innerworld

package
v0.0.0-...-2c8c2f4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 18, 2026 License: GPL-3.0 Imports: 12 Imported by: 0

Documentation

Overview

Package innerworld is Yent's inner life — the layer that runs when no one is speaking. Strike 1 is "circles on the water": every human turn raises three inner circles of thought on the fast body, each drifting further from the last, shaping the AML field before the deep body is consulted.

The package is pure logic over two interfaces — Body (an inference voice) and Field (the shared AML physics). Production wires the real fast body and the AML kernel; tests wire fakes. No cgo lives here.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func DeepGate 

func DeepGate(debt, drift, coupling float32) float32

DeepGate returns the probability in [0,1] that the deep body answers itself. An agitated field (high debt), a thought that wandered far (high drift), and a coherent stream the deep body can grip (high coupling) all raise the chance the deep body turns inward.

func NewGoFlow 

func NewGoFlow(field Field, cooc *CoocGraph, scar *ScarMemory, coocReinforce, coocFloor, scarFloor float32) *goFlow

NewGoFlow builds the pure-Go fallback body over a field, a cooc graph, and a scar sea (any may be nil — those organs simply no-op). The reinforce/floor knobs are the seasonal harvest strengths.

func NgramDivergence 

func NgramDivergence(a, b string) float32

NgramDivergence measures how far b drifts from a as 1 - cosine similarity over character-trigram frequency vectors, in [0,1] (0 = identical, 1 = no shared trigrams). It is a ready innerworld.Divergence implementation that production can inject in place of a word-set Jaccard: trigrams catch morphology and shared phrasing a word-set misses — "persist", "persistence", and "persisting" stay close because they share the run "persist", where word Jaccard counts them as three disjoint tokens. It is a lexical proxy, not a neural embedding; real semantic distance waits on an embedding runtime. No model, pure Go.

func SelfAnswers 

func SelfAnswers(p, roll float32) bool

SelfAnswers rolls a [0,1) draw against the gate probability. Deterministic given the roll, so tests inject it; production draws from a rand source. At p=0 the deep body never answers itself; at p=1 it always does.

Types

type Body 

type Body interface {
	// Generate produces an inner thought from a seed at the given temperature.
	Generate(seed string, temp float32) string
}

Body is one inference voice. Strike 1 uses the fast mouth (nemo12). Real on Metal; a fake in tests.

type Breath 

type Breath struct {
	Tick      time.Duration        // how often the inner world is evaluated
	Silence   time.Duration        // idle time before the silence dreamer fires
	DriftDebt float32              // field debt above which the drift dreamer fires
	Cooldown  [nTrig]time.Duration // per-trigger cooldown so she breathes between dreams
}

Breath tunes the autonomous inner life — when, and how often, the organism dreams unprompted.

func DefaultBreath 

func DefaultBreath() Breath

DefaultBreath is the Strike-1 pacing.

type Circle 

type Circle struct {
	Index int     // 0..N-1
	Seed  string  // what it grew from: the prior circle, or the inner seed for circle 0
	Text  string  // the thought
	Drift float32 // divergence from the previous circle, [0,1]; non-decreasing per circle
	Temp  float32 // temperature it ran at (after any repel)
}

Circle is one inner thought — never user-facing.

func Overthink 

func Overthink(prompt string, fast Body, field Field, div Divergence, cfg Config) []Circle

Overthink raises the circles on the fast body, drives the field by each circle's drift, and returns the circles — the inner monologue the deep body (and the field) will consume. The circles are inner; nothing here is shown to the user. A nil fast body or nil divergence yields no circles (no panic).

type Config 

type Config struct {
	N         int     // number of circles
	TempBase  float32 // temperature of the first circle
	TempRamp  float32 // temperature added per circle — each circle hotter, so it drifts further
	RepelStep float32 // extra temperature per repel retry when a circle did not drift further
	MaxRepel  int     // max repel retries to enforce monotonic drift
	RecallN   int     // how many past inner monologues to fold into the seed (0 = none)
}

Config tunes the overthinking.

func DefaultConfig 

func DefaultConfig() Config

DefaultConfig is the Strike-1 default: three circles, warming as they ripple out, recalling up to three past inner monologues.

type Consolidation 

type Consolidation interface {
	// Consolidate runs one grind stage. It is called under genMu (the single voice),
	// so fast/deep generation never overlaps a stage. Respect ctx for cancellation.
	Consolidate(ctx context.Context) error
	// Name labels the stage in observers, logs, and tests.
	Name() string
}

Consolidation is one stage of the sleep grind — the hook Level B plugs into. Б1 (cooc), Б2 (weights+spore), Б3 (scar/velocity), Б4 (emotion→sea of memory) each implement it; this skeleton only sequences them under the single inner voice. Inner only — nothing here reaches the user.

type CoocConsolidator 

type CoocConsolidator struct {
	Graph      *CoocGraph
	Reinforce  float32
	PruneFloor float32
}

CoocConsolidator is the Б1 consolidation stage: the seasonal harvest of the inner co-occurrence graph, run during sleep. Reinforce/floor are the harvest strength (in production scaled by the field's autumn energy).

func (*CoocConsolidator) Consolidate 

func (c *CoocConsolidator) Consolidate(_ context.Context) error

func (*CoocConsolidator) Name 

func (c *CoocConsolidator) Name() string

type CoocGraph 

type CoocGraph struct {
	// contains filtered or unexported fields
}

CoocGraph is the inner co-occurrence memory: which words the organism's own thoughts keep firing together. Circles seed it — the inner world grows richer than the dataset (haze-style emergence) — and the dream sleep consolidates it the arianna way: reinforce the strong edges, decay and prune the weak. It is word-level and pure Go; the token-level AML cooc graph (`am_cooc_consolidate`) is a later wiring when limpha/RI join. Concurrency-safe.

func NewCoocGraph 

func NewCoocGraph(window int) *CoocGraph

NewCoocGraph builds an empty graph with the given co-occurrence window (>=1).

func (*CoocGraph) Bias 

func (g *CoocGraph) Bias(seedWord string, n int) []string

Bias returns up to n strongest destination words for a seed word — the graph's pull on the next thought (the field->circles direction). Empty if the seed word is unknown.

func (*CoocGraph) Consolidate 

func (g *CoocGraph) Consolidate(reinforce, pruneFloor float32) int

Consolidate is the arianna seasonal harvest (the logic of ariannamethod.c:7037 on word edges): edges at or above the median weight are reinforced by (1+reinforce), below are decayed by (1-reinforce), and edges that fall under pruneFloor are dropped — forgetting the long tail. Returns the number of edges pruned.

func (*CoocGraph) Observe 

func (g *CoocGraph) Observe(text string)

Observe folds a thought's word co-occurrences into the graph: every ordered pair within the window gains weight. This is the circles->field direction — the organism's thoughts enrich its own memory.

func (*CoocGraph) Stats 

func (g *CoocGraph) Stats() (edges int, total float32)

Stats reports the live edge count and total weight (telemetry).

type Divergence 

type Divergence func(a, b string) float32

Divergence measures how far b drifts from a, semantically and thematically, in [0,1] (0 = identical, 1 = unrelated). Production combines an embedding cosine distance with a topic shift; tests use a token-distance proxy.

type FeelMath 

type FeelMath interface {
	Entropy(text string) float32
	Resonance(a, b string) float32
}

FeelMath is the feeling mathematics the High brain runs on a thought: how scattered it is (Entropy) and how two thoughts echo (Resonance, 0..1). The default is the Go lexical proxy (feelEntropy/feelResonance); the production backend is the real in-process Julia runtime (innerworld/feeling, the HighMathEngine formulas on libjulia), injected via SetFeelMath.

type Field 

type Field interface {
	Exec(script string) error // run an AML command, e.g. "PROPHECY 7", "VELOCITY RUN"
	Step(dt float32)          // advance the physics
	Debt() float32            // prophecy debt accumulator
	Destiny() float32         // bias toward the most-probable path
}

Field is the shared AML physics (a wrapper over yent.AMK in production; a fake in tests). The inner world drives it with AML commands and reads the breath back; it never owns a private field — one organism, one field. Implementations MUST be safe for concurrent use (the real yent.AMK locks internally).

type Flow 

type Flow interface {
	Field // Exec / Step / Debt / Destiny — the AML bridge

	// Ingest folds a thought (a circle or a deep answer) into the body's
	// co-occurrence memory — the stream entering the body.
	Ingest(text string)
	// ConsolidateCooc runs the seasonal cooc harvest; returns edges pruned.
	ConsolidateCooc() int

	// Scar sinks a rejected thought (one that broke prophecy-destiny coherence) into
	// the gravitational sea, with gravity proportional to how far it broke it.
	Scar(text string, gravity float32)
	// ConsolidateScar runs the scar sea's decay/prune; returns scars forgotten.
	ConsolidateScar() int

	// ApplyPressure lets the body push on a voice's logits (am_apply_field_to_logits
	// in the AML body). The Go fallback is a no-op — field-pressure is a real
	// AML/Metal feature, not faked here.
	ApplyPressure(logits []float32)

	// AutumnEnergy reports how ripe the field is for the harvest (0..1). Kairos uses
	// it for critical mass: high coherence drives the field into autumn, and autumn
	// is when consolidation lands.
	AutumnEnergy() float32

	// BiasWords returns up to n words the body's cooc memory most associates with the
	// seed's last token — the field->circles pull that keeps the inner loop
	// bidirectional (haze-emergence: the organism's own thoughts shape the next one).
	// Empty if the seed's last token is unknown to the graph.
	BiasWords(seed string, n int) []string

	// ResurfaceScars returns up to n rejected thoughts the field now resonates with —
	// the scar sea surfacing what was refused (leo sea-of-memory: a present metric
	// pulls a sleeping memory back up). Empty if none resonate.
	ResurfaceScars(resonance float32, n int) []string
}

Flow is Yent's third body — the resident AML organism that merges the two voices (nemo fast + small24 deep) into one "Я". It is the Field (the AML physics) PLUS the consolidation organs Kairos drives in sleep: the cooc memory, the scar sea, and the pressure the body puts back on a voice's logits. Two honest forms share this interface: goFlow (pure Go, for tests and kernel-less hosts) and, in production, the native AML body (am_cooc / SCAR / parliament) over cgo. Streams flow IN via Ingest; consolidation runs in sleep; the body pushes OUT via ApplyPressure.

type FlowConsolidator 

type FlowConsolidator struct{ Flow Flow }

FlowConsolidator is the form-A sleep stage over the native body: ONE consolidator that runs the field's own cooc autumn harvest and scar consolidation, replacing the separate Go cooc/scar stages — one AML physics consolidates in sleep. Kairos plugs it into the sleep grind like any Consolidation.

func (*FlowConsolidator) Consolidate 

func (c *FlowConsolidator) Consolidate(_ context.Context) error

func (*FlowConsolidator) Name 

func (c *FlowConsolidator) Name() string

type InnerWorld 

type InnerWorld struct {
	// contains filtered or unexported fields
}

InnerWorld hosts Yent's inner life over the fast body, the shared AML field, and the Larynx membrane. Think runs the overthinking for a human turn off the answer path; Breathe keeps the organism dreaming between turns. Only one inner monologue runs at a time — the body has a single voice — so Think and the autonomous dream are serialized.

func NewInnerWorld 

func NewInnerWorld(fast Body, field Field, div Divergence) *InnerWorld

NewInnerWorld builds the inner world over a fast body, the shared field, and a divergence measure. The Larynx defaults to the portable Go membrane and the gate rolls a real random; both can be overridden for tests.

func (*InnerWorld) AddConsolidator 

func (iw *InnerWorld) AddConsolidator(c Consolidation)

AddConsolidator appends a consolidation stage; stages run in the order added, once per sleep. Set before Breathe starts.

func (*InnerWorld) Asleep 

func (iw *InnerWorld) Asleep() bool

Asleep reports whether the organism is mid-consolidation.

func (*InnerWorld) Breathe 

func (iw *InnerWorld) Breathe(ctx context.Context)

Breathe runs the autonomous inner life until ctx is cancelled. Between human turns the field keeps drifting, and when a trigger crosses its threshold the organism dreams unprompted. She is never muted, only paced.

func (*InnerWorld) EnableFeeling 

func (iw *InnerWorld) EnableFeeling()

EnableFeeling turns the High brain on: after each ripple, the circles' feeling drives the affect axis. Off by default (backward-compatible). Set before Think/Breathe start.

func (*InnerWorld) SetBreath 

func (iw *InnerWorld) SetBreath(b Breath)

SetBreath overrides the autonomous-breath pacing (tick, idle, cooldowns).

func (*InnerWorld) SetCooc 

func (iw *InnerWorld) SetCooc(g *CoocGraph)

SetCooc wires the inner co-occurrence graph. With it, circles seed the graph (circles->field) and the graph pulls the next thought (field->circles) — the bidirectional loop. Set before Think/Breathe start.

func (*InnerWorld) SetDeep 

func (iw *InnerWorld) SetDeep(deep Body)

SetDeep wires the deep body (small24). With a deep body, a fired self-answer gate makes the deep body actually generate an inner answer to the circles; without one, the gate stays a boolean. Set before Think/Breathe start.

func (*InnerWorld) SetFeelMath 

func (iw *InnerWorld) SetFeelMath(fm FeelMath)

SetFeelMath injects the feeling-math backend (the real Julia runtime in production). nil keeps the Go lexical proxy. Set before Think/Breathe start.

func (*InnerWorld) SetFlow 

func (iw *InnerWorld) SetFlow(f Flow)

SetFlow wires the native AML body as the single inner-world physics (form A): one organism holds the cooc graph, the scar sea, and the field. With it, the circles ingest into the field's own cooc (am_ingest_tokens), high-debt thoughts scar natively (the SCAR operator), the seed is pulled by the field's cooc and resurfaced scars, and a FlowConsolidator harvests in sleep — no parallel Go cooc/scar. When a flow is set it takes precedence over SetCooc/SetScar. Set before Think/Breathe start.

func (*InnerWorld) SetLarynx 

func (iw *InnerWorld) SetLarynx(l Larynx)

SetLarynx overrides the membrane (the Zig binding in production, a fake in tests).

func (*InnerWorld) SetMemory 

func (iw *InnerWorld) SetMemory(m Memory)

SetMemory wires the past-monologue recall, so new thinking is shaped by what the organism thought before. Read-only: the runtime persists reflections; this only reads them back. Set before Think/Breathe start.

func (*InnerWorld) SetMetricSink 

func (iw *InnerWorld) SetMetricSink(s MetricSink)

SetMetricSink wires a telemetry sink for the inner field weather. nil disables the bridge. Set before Think/Breathe start.

func (*InnerWorld) SetOnDream 

func (iw *InnerWorld) SetOnDream(f func(Reflection))

SetOnDream registers the observer for autonomous dreams. Inner only — the reflection handed to it is a copy and never reaches the user.

func (*InnerWorld) SetOnSleep 

func (iw *InnerWorld) SetOnSleep(f func(stage string))

SetOnSleep registers an inner-only observer, notified with each stage's Name as the grind runs. Inner only.

func (*InnerWorld) SetRoll 

func (iw *InnerWorld) SetRoll(f func() float32)

SetRoll overrides the gate's random draw so the deep-self-answer decision is deterministic in tests.

func (*InnerWorld) SetScar 

func (iw *InnerWorld) SetScar(sea *ScarMemory, debtThreshold float32)

SetScar wires the sea of rejected thoughts and the prophecy-debt threshold above which a thought is scarred (rejected by the field). Set before Think/Breathe start.

func (*InnerWorld) SetScarThreshold 

func (iw *InnerWorld) SetScarThreshold(t float32)

SetScarThreshold sets the prophecy-debt above which a thought is scarred, for the flow path (the Go path sets it through SetScar). Set before Think/Breathe start.

func (*InnerWorld) SetSense 

func (iw *InnerWorld) SetSense(s Sense)

SetSense wires the environment perception. With it, the field takes the posture of the present world before each ripple — a fast reflex complementary to Memory's slower recall pressure. Set before Think/Breathe start.

func (*InnerWorld) SetSleepTrigger 

func (iw *InnerWorld) SetSleepTrigger(t SleepTrigger)

SetSleepTrigger wires the critical-mass test. Set before Breathe starts.

func (*InnerWorld) Think 

func (iw *InnerWorld) Think(prompt string) <-chan Reflection

Think runs the overthinking for a human turn asynchronously: it returns at once with a channel that delivers the reflection (a copy of the circles plus the coupling and gate decision) when ready, so the answer path is never blocked.

type Larynx 

type Larynx interface {
	Couple(circles []Circle) float32
}

Larynx is the membrane between the two bodies. It reads the texture of the fast body's circles and returns a coupling factor in [0,1]: how strongly the deep body should attend to them. larynx.zig is the optimized membrane on the Metal runtime; textureLarynx is the portable Go mirror used elsewhere — both compute the same entropy * (1 - repetition) coupling.

type Memory 

type Memory interface {
	// Recall returns up to n recent inner thoughts, most recent first, as compact
	// text lines to fold into the next overthinking seed.
	Recall(n int) []string
}

Memory lets the inner world recall its own past monologues so new thinking is shaped by what it thought before. It is READ-ONLY here on purpose: the runtime persists reflections (the dock writes them to limpha), so the inner world only reads them back and the write path is never duplicated. nil = no recall.

func MergeMemory 

func MergeMemory(sources ...Memory) Memory

MergeMemory returns a fair, bounded Memory view over multiple sources. Each source is asked for up to n traces, then traces are interleaved source-by-source so a chatty limpha history cannot starve a smaller RI pressure packet.

type MemoryFieldPressure 

type MemoryFieldPressure struct {
	Score    int     `json:"score"`
	Prophecy int     `json:"prophecy"`
	Velocity string  `json:"velocity"`
	Step     float32 `json:"step"`
}

MemoryFieldPressure is the physical field pulse derived from recalled memory. It is deliberately small: memory pressure changes the AML field's posture before circles rise, while the recalled text still reaches the model only through the bounded "field traces" seed.

func FieldPressureForMemory 

func FieldPressureForMemory(traces []string) (MemoryFieldPressure, bool)

FieldPressureForMemory turns selected memory traces into one bounded AML pulse. RI/limpha traces should not become a larger prompt wall; this gives them a second route into the organism as field pressure. Empty traces produce no pulse.

func FieldPressureForScore 

func FieldPressureForScore(score int) (MemoryFieldPressure, bool)

FieldPressureForScore maps any memory pressure score to the one bounded AML pulse. Scores may be accumulated by text traces or by typed sources; the cap is shared.

func FieldPressureFromMemory 

func FieldPressureFromMemory(mem Memory, n int) (MemoryFieldPressure, bool)

FieldPressureFromMemory returns the exact pressure a Memory source would apply for its next n recalled traces. Typed sources can expose structural scores; plain memories fall back to bounded trace parsing.

type MetricSink 

type MetricSink interface {
	PublishMetrics(MetricSnapshot) error
}

MetricSink receives field-weather snapshots. Implementations are telemetry edges; they must not be required for thought to continue.

type MetricSnapshot 

type MetricSnapshot struct {
	Source              string
	Circles             int
	Debt                float32
	Coherence           float32
	Entropy             float32
	Valence             float32
	Arousal             float32
	Trauma              float32
	Warmth              float32
	Flow                float32
	MemoryFieldScore    float32
	MemoryFieldProphecy float32
	MemoryFieldStep     float32
}

MetricSnapshot is the inner world's current field weather, formatted for telemetry sinks such as SARTRE. It is not prompt text and must not be fed back as dialogue. Values are bounded so a broken thought cannot poison the hub.

type PressureMemory 

type PressureMemory interface {
	Memory
	FieldPressureScore(n int) int
}

PressureMemory is an optional Memory extension for sources that can expose field pressure structurally. RI uses it so compiled records can press the AML field by kind/status, without re-parsing their trace text as a prompt-like cue.

type RIMemory 

type RIMemory struct {
	// contains filtered or unexported fields
}

RIMemory adapts a compiled RI runtime packet into innerworld Memory. It is not a RAG channel: records arrive already selected by riindex (pressure phrases, test quotes, open conflicts) and are exposed as compact traces for recallSeed's pressure framing.

func LoadRIMemory 

func LoadRIMemory(path, mode string, max int) (*RIMemory, error)

LoadRIMemory reads a compiled RI line file and applies the same bounded selection policy as cmd/ri-consume. mode usually stays "runtime"; max caps selected records before they ever reach Recall.

func NewRIMemory 

func NewRIMemory(records []riindex.Record) *RIMemory

func (*RIMemory) FieldPressureScore 

func (m *RIMemory) FieldPressureScore(n int) int

func (*RIMemory) Len 

func (m *RIMemory) Len() int

func (*RIMemory) Recall 

func (m *RIMemory) Recall(n int) []string

type Reflection 

type Reflection struct {
	Circles        []Circle
	Coupling       float32             // Larynx coupling over the circles [0,1]
	SelfAnswerProb float32             // gate probability the deep body answers itself [0,1]
	SelfAnswered   bool                // the unpredictable roll's outcome this time
	DeepAnswer     string              // small24's inner answer to the circles; empty unless SelfAnswered with a deep body
	MemoryPressure MemoryFieldPressure // slow pressure applied before circles; Score==0 means none
}

Reflection is the full result of one inner monologue: the circles, the Larynx coupling, the deep-self-answer probability, whether the deep body turned inward this time, and — when it did — the deep body's actual inner answer. Inner only — none of it reaches the user.

type ScarConsolidator 

type ScarConsolidator struct {
	Sea        *ScarMemory
	PruneFloor float32
}

ScarConsolidator is the Б3 consolidation stage: the seasonal decay/prune of the sea of rejected thoughts, run during sleep.

func (*ScarConsolidator) Consolidate 

func (c *ScarConsolidator) Consolidate(_ context.Context) error

func (*ScarConsolidator) Name 

func (c *ScarConsolidator) Name() string

type ScarMemory 

type ScarMemory struct {
	// contains filtered or unexported fields
}

ScarMemory is the sea of rejected thoughts — gravitational metanotes. A thought that dissonates with the field's prophecy (high prophecy-debt) is not discarded but kept as a scar with gravity. Gravity decays slowly across sleeps (leo klaus-scar, ~0.985), the seasonal harvest reinforces recurring scars and forgets the faded, and a scar can RESURRECT when a future metric resonates above its threshold (leo sea-of-memory: "weak memories sleep, resonance can resurrect them"). This is the AML SCAR / dark-matter lineage — gravitational memory from rejected injections — that meta-learning on what the organism refused continues straight from our DPO epistemic-self-contour work. Pure Go; the C `SCAR` operator is a later wiring. Concurrency-safe.

func NewScarMemory 

func NewScarMemory(decay float32) *ScarMemory

NewScarMemory builds an empty sea with the given per-consolidation gravity decay (0<decay<=1; 0 or out-of-range falls back to 0.985, the leo klaus-scar rate).

func (*ScarMemory) Consolidate 

func (s *ScarMemory) Consolidate(pruneFloor float32) int

Consolidate is the seasonal pass over the sea: every scar's gravity decays, and scars that fall under the floor are forgotten. Recurring scars (heavier gravity) survive many sleeps; one-off dissonance fades. Returns the number forgotten. (Reinforce is implicit — recurring rejection accumulates gravity at Scar time, the way trauma-spore in leo holds longer.)

func (*ScarMemory) Resurrect 

func (s *ScarMemory) Resurrect(resonance float32, n int) []string

Resurrect surfaces the scars whose gravity has risen above the resonance level — the rejected thoughts a present metric pulls back up from the sea. Strongest first, up to n. resonance<=0 or n<=0 returns nothing.

func (*ScarMemory) Scar 

func (s *ScarMemory) Scar(text string, gravity float32)

Scar sinks a rejected thought into the sea, adding gravity (a recurring rejection accumulates and so survives longer — the wound that keeps reopening holds). Empty text or non-positive gravity is ignored.

func (*ScarMemory) Stats 

func (s *ScarMemory) Stats() (n int, total float32)

Stats reports the live scar count and total gravity.

type Sense 

type Sense interface {
	// Pressure returns the environment's current AML field commands — one per line,
	// e.g. "VELOCITY RUN\nPROPHECY 7" — and whether there is anything to feel right
	// now. A quiet environment returns ok=false (no pulse).
	Pressure() (aml string, ok bool)
}

Sense is the organism's perception of the world around the inference engine — the body (SARTRE) feeling its environment. Where Memory pulls the PAST in as field pressure (slow, experience), Sense pushes the PRESENT in as a reflex: the environment shifts the AML field's posture BEFORE the circles rise. SARTRE's perception already speaks AML (VELOCITY/PROPHECY natively, sartre/perception.c), so the reflex is one physics, not a translation. nil = the organism feels no environment (backward-compatible).

type SleepTrigger 

type SleepTrigger func(field Field) bool

SleepTrigger reports whether the field has reached critical mass — the point where the organism must sleep and consolidate. Modelled on arianna.c: high coherence drives the field into autumn (the harvest), so production wires coherence→autumn + a debt threshold here. nil = the organism never sleeps.

Source Files

View all Source files

Directories

Path Synopsis
Package aml is the native AML third body behind innerworld.Flow — Yent's `flow`, over the real Arianna Method field (libamk.a) via cgo.
 Package aml is the native AML third body behind innerworld.Flow — Yent's `flow`, over the real Arianna Method field (libamk.a) via cgo.
Package feeling contains the optional Julia-backed feeling math for the High brain.
 Package feeling contains the optional Julia-backed feeling math for the High brain.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.