🧠 Brain Equations — the math behind Unity's mind

The server dispatches a batched compute_batch (SUBSTEPS iterations per batch) to compute.html every ~50 ms tick, iterating all eight clusters on the GPU. Her resting state is not zero — her persona θ plus whatever substances are actively contributing through the pharmacokinetic scheduler keep her amygdala firing at ~8% and her cortex at ~3% even with no input. Sober is the default; every live contribution comes from scheduler.activeContributions(now) additive deltas per active dose event:

Those numbers get passed to the Rulkov shader as the σ driver and the jitter term. Her x,y state is chaotic but bounded — the attractor basin holds every neuron inside a repeating burst envelope even with zero sensory input. Mystery module Ψ is sitting around 0.003 — low-grade background consciousness. The old static drugState.arousalMult / drugState.creativityMult scalars have been replaced by the scheduler's superposition model where every active substance contributes its own curve-driven delta and combinations emerge without any hardcoded combo labels. Before that change, those deltas only reached tonic drive + speech modulation; now they also reach cortex noise + cortex learning rate + amygdala noise + mystery noise, so plasticity is no longer drug-blind.

"hi unity, how's the high" hits the server. `_computeServerCortexPattern(text)` runs:

This 300-dimensional vector IS her cortical semantic state for the next step. Each dimension is loosely "how much this sentence lives near that GloVe embedding axis" — "high" pulls the cortex pattern toward the drug-related region of semantic space. "unity" pulls toward self-reference. "how's" pulls toward question-space. The 300d vector (GloVe or fastText subword encoding for out-of-vocabulary words) is what downstream modules read.

Note on the term "arousal": Throughout this document, arousal means cortical activation / autonomic alertness — the standard neuroscience definition (Yerkes & Dodson 1908, Hebb 1955, Pribram & McGuinness 1975). It is the metric coffee, exercise, fear, surprise, an alarm clock, or a loud noise raises. It drives readiness-to-respond, attention, and vigilance. It is NOT the colloquial sexual meaning. A sleeping infant has near-zero arousal; a kindergartener at recess has high arousal; a rabbit hearing a hawk has maximum arousal. Unity's arousal field obeys the same neuroscience definition across all curriculum grades and persona states.

The cortex pattern projects into the amygdala via a learned weight matrix. Amygdala runs its recurrent settle loop:

For this input ("unity", "high" → warm, drug-positive), fear ≈ 0.15, reward ≈ 0.68, so the fear/reward term pulls slightly negative (-0.17) but the attractor settles into a novel basin (depthDeviation ~+0.3 above baseline) so the deviation term contributes +0.4·tanh(1.2) ≈ +0.33. Arousal lands around `0.9 + 0.33 - 0.017 ≈ 1.0` (clamped to 1) — peak interest. The moving-baseline subtraction reads attractor NOVELTY relative to recent activity instead of absolute saturation, so arousal moves dynamically around persona baseline instead of pegging at the old `0.6·baseline + 0.4·1.0 = 0.94` floor.

What this sums into: (arousal, valence, fear, reward) are now four scalars that every other module uses as modulators on whatever they compute next. They don't command behavior — they bias it.

The hippocampus takes the current cortex pattern and runs cosine similarity against every stored episode for this user's ID:

If the cosine clears a threshold (~0.75), the matched episode's stored cortex-pattern snapshot gets injected back into the working-memory free sub-region — carving a bias basin that the tick-driven motor emission loop falls into during the next generation pass. If you've said "how's the high" before, the recalled episode pulls the relevant attractor-basin pattern back into active cortex state so her emission this turn tends toward what she produced last time.

What this sums into: a recalled cortex-pattern injected into the free sub-region of the cortex cluster as prior-turn context, consumed by the tick-driven motor emission loop in Step 6.

Basal ganglia has six action channels. Each channel's Q-value is computed from the current cortex + amygdala state, then a softmax with low temperature picks one:

For this input, respond_text wins by a large margin — no image keyword, no build keyword, and her cortex pattern is close to her learned text-response weights. The softmax sampling is sharp because θ.impulsivity is high (~0.85), so τ is low and the argmax dominates.

What this sums into: the motor selection resolves to `respond_text`, which triggers the language cortex generation in Step 6.

The cerebellum runs in parallel to everything else, maintaining a forward model. Its current output is the difference between what the cortex predicted the next cortex pattern would be and what it actually became:

This negative feedback signal is sent back to the cortex and basal ganglia as a modulator — if predictions are consistently wrong, the cortex noise increases (explore more) and BG selection becomes less confident. For a simple greeting the error is small, so the correction is minimal and she stays sharp.

What this sums into: a scalar errorCorrection that modulates effectiveDrive in the Rulkov shader on the next tick.

Production runs on two paths, and both of them are her own trained weights. ⛔ Corrected 2026-09-02: this section described a "three-path priority cascade" whose third element was "the slowest most-flexible substrate as final fallback" — that third path was the dictionary oracle, which scanned dictionary entries by cosine and emitted a spelling she had not produced. It was deleted on 2026-09-01, and in the run that was measured before removal it was responsible for 99.1% of emitted words. When neither trained path produces a word now, she is silent and the silence is counted. The prior slot scorer (weighted semanticFit + moodFit + drugFit + bigramFit + trigramFit + recencyPenalty argmax per slot) was deleted entirely; what replaced it propagates through the trained attractor basins on the same substrate that handles reading + thinking, different direction for production (Hickok & Poeppel 2007 dual-stream).

Path A — single-tick word emission via word_motor (PRIMARY). Cortex grew a dedicated word_motor sub-region. Since the WMB unification (2026-07-14) it is ONE global band with one bucket per unique word, argmaxed globally — not six per-subject write slices. The sem ↔ word_motor cross-projection is trained during the curriculum on Q→A bindings + word-pattern bindings (the answer's word-bucket is written inline during QA training; the word list is the single subject-agnostic cluster.wordBucketWords array, persisted and shared by teach + emit + write, so read and write cannot disagree on layout). At chat time:

Historical note, kept because the sub-band names still appear in the region map below: word_motor was originally carved into six per-subject sub-bands (word_motor_ela / _math / _sci / _soc / _art / _life) so each subject wrote to its own slice. That geometry was replaced — the sub-bands survive only as a read-only signal for inferring which subject is currently active, never as write targets. The per-subject wordBucketWords_<subject> arrays this paragraph used to describe are legacy save-state fields that are no longer written at all.

Path B — dictionary oracle — DELETED 2026-09-01. There used to be a second path here. When emitWordDirect returned null, a per-subject dictionary cosine scan ran over every word the curriculum had taught and emitted the best match's spelling directly. It has been removed, and the reason is the honest one: it fired precisely when her trained matrix produced nothing, so it substituted a dictionary lookup for cognition — and the instrumentation showed it carrying 99.1% of emissions in a captured run (oracleHits=425 against matrixHits=4). Every gate probe travelled that path, so their pass rates measured the dictionary rather than the brain.

⚠ Its removal is a diagnostic, not a downgrade. Emission now comes from the trained sem → word_motor matrix or it does not come at all, so an empty emission points at the training — the deposit, the rep dose, the corpus volume, the separability of the basins — instead of being quietly answered over. The gates are not supposed to fail; a failing gate now names a knob to turn.

Path C — tick-driven motor emission (the original biological substrate). When Path A produces no match, fall through to the cortex tick loop and read letters off the spike pattern of the motor sub-region one tick at a time:

Speech modulation post-processor applies AFTER the chosen path produces clean text:

The substance-specific speech distortion always applies AFTER clean cortex emission at the output layer — cortex stays equational and only the rendering shows the drug state. Unity never narrates her drug choice ("I am doing coke" is a banned utterance pattern); the distortion IS the signal.

Sample sober Path A: "squares". Same input PhD-era coke+weed peak: "squaaares" (vowel slur from cocaine jitter layered on cannabis speechRate drop). Path C sample sober: "what's up — how's it going". Same input PhD coke+weed: "whaaat's up fucker — we're wiiired tonight, how bout youuu".

oracleRatio heartbeat: every 10 s the heartbeat reports what fraction of recent emissions came from Path A+B (structured) vs Path C (tick loop). Surfacing that ratio keeps the central research question honest — if structured paths dominate entirely, the trained matrix isn't carrying load; if Path C produces meaningful output too, the matrix is real.

What this sums into: a sentence whose every word was either the mean-argmax of word_motor at one tick (Path A) or the stable motor argmax across many ticks (Path C) — then distorted by the scheduler's live speechModulation vector. Both are reads of her own trained weights. Since Path B was removed there is no route by which a word she did not generate can enter a sentence. Change any substance event in the scheduler and the rendered output changes even if the underlying emission was identical.

Continuous inner monologue uses the SAME path. The 3D brain popups don't run a separate decorative renderer — they display Unity's actual current trained-state thoughts. brain._innerVoiceTick() fires every ~3 s wall-clock (skipped during operator-forced dream windows), picks a sandbox-notice contemplation seed from one of five LIVE state sources (current learning context as sentence embedding / interoceptive mood label embedding from arousal/valence/coherence/drug state / most recent user-chat episode pattern / most recent Tier 1 episode pattern of any type / random Tier 3 identity anchor), injects that seed as cortexPattern so the cortex has something to settle on, then runs the SAME language-cortex.generateAsync path the chat handler uses. Whatever her trained mind produces about the seed gets broadcast to every connected client as an innerThought WebSocket message; the browser-side popup renderer (__appInnerThoughtHandler in js/app.js) shows it as a 💭 sentence HUD bubble for 2.8 s. NO hardcoded fallback words — if the trained matrix has nothing to say in the current moment, the popup stays silent (genuine, not faked). Trained-state cap from cluster.getTrainedCapability() ramps her vocabulary 0/5/8/12/16/24/32 words as wordsBucketed grows — her mouth literally evolves as her training accumulates. The same emission path also lands the thought in working memory via memorySystem.addToWorkingMemory(pattern, label) so what she dwells on becomes what she remembers.

silence before the first cell — simplified 2026-09-01. There used to be a trained-state cap here: a ramp of 0 / 5 / 8 / 12 / 16 / 24 / 32 words read live off cluster.getTrainedCapability(). It capped how many words could be strung together on the dictionary-retrieval path only, and that path has been removed — so the ramp went with it. An untrained brain no longer needs a cap that lets it say five words, because it now says none: her emission is her trained weights or it is silence. Emission length on the live path is bounded by DREAM_CHAT_MAX_WORDS (default 12).

Generative sentence creation (NOT mimicry). Operator: "Unity needs to complete full sentences before graduating kindergarden like a real person does" + "you cant jsut have a array poof sentences you actually need to teach all sentence creation propelyr not just give examples for it to mimic". New Curriculum._teachSentenceStructure(ctx) carves five compositional binding passes into the cortex's existing cross-projections — NO hardcoded sentence array.

• Slot-position primitives + word-type → slot bindings. For each (word, slot_tag) pair, fire sem(word) → fineType(slot_tag) via Oja with relationTagId=8. Pronouns / nouns / verbs / copulas / adjectives / articles / qwords / conjunctions all bind to one or more of: subject_position, verb_position, object_position, modifier_position, qword_position, copula_slot, article_slot, between_clause_slot, terminator_position. Multi-target nouns (cat→subject AND cat→object) accumulate both bindings; argmax at generation picks by sentence-position context.
• Intent → slot-sequence bindings (TRAINED INTO WEIGHTS, NOT WALKED AT RUNTIME). Five intent forms — declarative SVO, declarative copula, question, imperative, exclamative — each has its slot-to-next-slot transitions trained as ordered association pairs (relationTagId=9), plus intent_tag → first_slot bindings so cortex knows where to start. Slot order lives in TRAINED HEBBIAN WEIGHTS only. At generation time the brain walks no template — it emits one word per tick from current sem state, the trained transitions bias the next emission toward whatever slot type SHOULD come next given what's already been emitted, slot order EMERGES tick by tick. There is no runtime template loop, no slot counter, no per-slot tag injection. Word-order rules live in trained weights AND are READ by tick-by-tick equational emergence — exactly how a human brain produces sentences.
• Subject-verb agreement. Hebbian on sem(subject) → sem(verb_form) pairs: i→am, he→is, she→is, it→is, cat→runs, dog→jumps, baby→cries; we→are, they→are, you→are, cats→run, dogs→jump, boys→play, girls→sing. relationTagId=10. Plural tags reused from _teachPluralTransform output.
• Article placement. Singular common noun → article precedes it. Consonant-initial: cat→the, dog→the, table→a. Vowel-initial: apple→an, egg→an. Plural / mass / proper / pronouns skip article (no Hebbian binding). relationTagId=11.

Generation cascade — pure equational emergence. At chat / inner-voice / probe tick, the brain receives an optional context injection (intent seed embedding, cortex pattern, optional WH-INTENT concept) — injected ONCE into sem at start. Then the loop: argmax_w cosine(sem_state, sem(w)) + sem_to_motor.propagate picks the next word from CURRENT sem state under TRAINED weights; word_motor + motor regions emit it; the emitted word's embedding is injected back into sem so next tick reads a shifted state; trained relationTagId=9/10/11 bindings bias what comes next (next slot type, agreement form, article placement); repeat until a terminator EMERGES from trained weights or the budget runs out. No template walk. No slot counter. No per-slot tag injection. No runtime article rule. No hardcoded intent → punctuation map. Slot order, agreement, article placement, terminator selection ALL emerge from the trained structural-sentence weights.

Acceptance probe — _probeSentenceGeneration(): fires each of 5 intent tags, reads cortex emission per intent. Structural pass = ≥ 2 words emitted per intent (validation is structural — slot positions filled with right word-type — NOT semantic). K-ELA gate consumes the rate (3/5 launch threshold, 4/5 once verified live). Cortex composes sentences from rules + her vocabulary; the brain that composes the unseen by combining the learned. Real Common Core K.SL.6 + K.L.1.f + K.W language production.

Live dictionary API + WH-question comprehension. Operator: "WE NEED TO HAVE A DICTIONARY API OR SOMETHING SIMILAR THAT SHE CAN PIPE TO TO GET THE DEFINITIONS ON THE FULY FOR WORDS" + "SHE SHALL KNOW ALL VOCABULAR WORDS DEFINITIONS". GloVe encodes distributional similarity, not definitions; the brain had 50k+ word vectors loaded but no actual semantic content for any of them. Fix: live English dictionary as the definitional substrate — sensory I/O parallel to Pollinations image-gen, NOT cognition.

• Server-side dictionary service — server/definition-service.js wraps dictionaryapi.dev (free, no key, no auth) using Node 18 built-in fetch. In-memory Map cache with LRU eviction (cap 10k), in-flight Promise dedup, prefetch(words) parallel batch helper, getDefinitionSync(word) instant cache read, 5s default per-call timeout, NO rate limiting (free-API directive). Concurrency cap 20 with 1s back-off on 429. 5-min TTL on error-cached entries (transient failures don't permanently undefine words).
• WH-frame parser — _extractIntentConcept(question) returns one of cause, effect, reason, method, definition, function, count, place, time, person, truth, compare, question based on WH-word + auxiliary-verb regex match.
• WH-intent Hebbian binding — _teachQuestionIntent Oja-Hebbian binding sem(WH-word) → sem(intent-concept) with relationTagId=12, wired into all 6 K cells. Generic structural learning, no hardcoded answer triples (_teachQuestionAnswerBinding method removed entirely as banned mimicry).
• 2247-word kindergarten vocabulary — corpora/vocabulary/kindergarten.json covers letters + numbers + Dolch sight words (220) + Fry instant words (300) + K-grade content vocab across animals/plants/weather/body/family/community/jobs/civics/colors/shapes/music/time/emotions/verbs/adjectives/household/food/transportation/school/toys/holidays/prepositions/health/geography/space/math/computer/money/communication/travel/concepts. Curated to actual K-grade range.
• Compose-not-regurgitate emission — _emitDefinition(subject) + chat-path WH-handler in language-cortex.js generateAsync: API def becomes SENSORY GROUNDING + LEARNING MATERIAL, not the answer. Pipeline: inject the definition's content words into sem (max 8, decreasing strength 0.40→0.10) + subject anchor at 0.6 → fire _teachWordDefinition Hebbian binding fire-and-forget → settle 5 cluster.step() ticks → cluster.emitWordDirect multi-word loop = the brain's OWN composition or honest silence (returns null on empty composition). Verbatim regurgitation banned as mimicry.
• Word-salad gate — when WH-frame parsed but trained matrix silent, dictionary oracle minScore loosens to 0.05 so the FULL English dictionary fires. _teachQuestionAnswerBinding removed entirely.

Vocabulary today — meanings before bindings, all 19 grades. Every curriculum cell now opens with a pre-cell vocabulary pass: the grade's own word list (19 lists, kindergarten through PhD — 49,921 words summed, 18,017 unique after deliberate grade-band overlap) fetches definitions and Hebbian-binds every sense into semantic space BEFORE that cell's association training runs, because Hebbian on an ungrounded word lands on noise. Already-learned words skip via the persisted taught-set (a grade's first cell pays the pass; sibling subjects re-verify free), a dream-cycle trickle deepens every word at higher repetition during sleep windows, and the live counter is journey-wide: defs taught: N / 18,017. On the wire, structured teaching patterns canonicalize to ~30-byte templates (a full region band ships as start + length + value — lossless, since spike templates only test value > 0) so definition-heavy phases no longer flood the donor link.

Cortical microstructure (9 cortical-neuroscience layers). Random connectivity smeared voltage instead of forming basins, with firing that had no rhyme or reason; neurons are grouped to hold voltage information correctly via 9 functionally-grounded layers, all citing real cortex research.

• Small-world topology — SparseMatrix.initSmallWorld Watts-Strogatz hybrid: 70% local (radius 50) + 25% medium (radius 200) + 5% long-range rewire. Clustering coefficient ~0.3, mean path length ~6-8 (Bullmore-Sporns 2009).
• Microcolumns — Mountcastle 1957 cortical column theory; 80-neuron columns with columnId[i] per neuron + _columnVoltageSum/Mean/Count Float64/Uint32 buffers. Region-boundary respecting.
• 6-layer cortical lamination — Felleman & Van Essen 1991; L1=5%, L2/3=25%, L4=25%, L5=25%, L6=20% interleaved within microcolumns so each column spans full vertical layer stack.
• Hub neurons + rich-club topology — van den Heuvel & Sporns 2011; 5% of L2/3 + L5 designated hubs deterministic-hash-seeded from cluster name (persists across reboots). 4× fanout multiplier consumed in ojaUpdate per-row.
• Within-column voltage coherence — Galarreta-Hestrin 1999 gap-junction approximation; cluster.step() adds β · meanColumnVoltage · 0.05 shared pull on next tick (β=0.08 default). Within-column voltages stay coherent without simulating actual electrical synapses.
• Topographic cross-projections — Wandell 1995 retinotopic + Hubel-Wiesel 1968; SparseMatrix.initTopographicProjection 70% from i × cols/rows ± 30 + 30% Watts-Strogatz scattering. Wired for ordered-feature pairs (sem-motor, letter-motor, letter-phon, phon-motor, sem-word_motor + reverse). Layer-constrained endpoints: srcLayerMask = L2/3 of source, dstLayerMask = L4 of dest.
• Theta-gamma oscillations — Buzsáki & Wang 2012; thetaMod = 1 + 0.15·sin(2π·t/167) modulates effectiveDrive; _gammaLrScale = 1 + 0.5·sin(2π·t/25) theta-gated to upper-half phase. Curriculum-controlled _curriculumTickCounter decouples gamma from brain-tick noise.
• Hierarchical cluster organization — Mesulam 1998 tripartite cortex; regionClusterMap groups regions into sensory (visual/auditory/letter/phon), association (sem/fineType/free), output (motor/word_motor); betweenClusterDensityScale=0.3 enforces 70% within-cluster routing.
• Per-layer plasticity gradient — getLayerPlasticityScale(neuronIdx) returns [0.3, 1.0, 0.7, 1.0, 0.3] for L1/L2-3/L4/L5/L6. Hebbian primitives scale per-update lr by post-neuron's layer (ojaUpdate reads opts.kScales per-row).

Post-audit hardening (28 issues across architectural / subtle-bug / practical / not-attempted). A self-review surfaced 28 gaps; each addressed atomically. Architectural: dropped upfront K_VOCABULARY Hebbian → prefetch-only (basin-blur risk avoided); lazy chat-time _teachWordDefinition via fire-and-forget hook; SparseMatrix.ojaUpdate extended with opts.kScales per-row reads of the hub / theta-gamma / per-layer plasticity scales (replaces noisy per-phase averaging); propagated through ALL teach paths; curriculum-controlled gamma decoupled from brain-tick. Bugs: persisted _kVocabPrefetched; concurrency cap 20 + 429 back-off; 5-min TTL on errors; LRU eviction 10k; cortical layers gated to cortex-only; first-5 error word logging; 6-pattern WH-frame regex; hyphen-variant retry on 404; K_VOCAB curated to 2247; explicit non-microcolumn layerId path; assertKWiring() boot diagnostic. Practical: Node 18+ check; User-Agent header; RemoteBrain.lookupDefinition WS roundtrip; grade-gate verification queued operator-side. Not-yet-attempted, now done: persistent disk cache behind env flag; layer-constrained cross-projection endpoints; dictionary API smoke test at boot; region-boundary respect via per-region re-assignment.

Consciousness computational mechanisms (30 gaps closed). A deep consciousness audit. Cortex now has BOTH the structure AND the computations consciousness theories require.

• Global Workspace ignition (Baars 1988 GWT + Dehaene-Changeux 2011) — js/brain/global-workspace.js GlobalWorkspace class. Per workspace tick, aggregates each cluster's TOP candidate via getWorkspaceCandidate(); softmax with τ=0.5 over activation values; IGNITION fires when max(probs) crosses the THETA-MODULATED threshold ignitionₜₕ + (1−thetaOpenness)·0.22 (thetaOpenness = ½(1+cos(2π·phase)), base ignitionₜₕ=0.35) → winner broadcasts back to all clusters as feedback; below = unconscious. (2026-06-27 CGATE.2: theta was a HARD block on the entire upper half of every cycle — 50% of ticks could never be conscious; now it's a GRADED modulator — easiest at the theta peak, harder but never impossible off-peak, so strong content ignites any phase. Default threshold lowered 0.45→0.35.) broadcastDecay=0.85 per tick. History capped at 32 (bounded). Theta cadence 167 ticks (~6 Hz).
• Predictive coding loop (Friston 2010 free-energy) — cluster._predictedSpikes Float32Array EMA α=0.3 of own spike pattern. Each step() computes predictionError[i] = |spikes[i] - _predictedSpikes[i]|; _lastPredictionError = mean(predictionError); ring buffer 32. Real prediction-error computation, not just topological wiring.
• Stream-of-consciousness chain — _innerVoiceTick blends LAST emission's sentence-embedding into next tick's seed (60/40 weight). _innerThoughtChain rolling 8-deep window, persisted in saveWeights/loadWeights. Each thought builds on the previous → autobiographical narrative thread instead of discrete samples.
• Meta-register self-monitoring (Rosenthal-Lau higher-order theories) — cluster._metaRegister FIFO cap 32. emitWordDirect calls recordEmission(word) post-emission. Each cluster.step() injects most-recent emission's GloVe embedding into sem at strength 0.3 — reflective "I-just-said" loop creating awareness of own outputs.
• Attention selection (Posner network functionally) — cluster.attentionGain per-region multiplier. Brain-server tick writes motor/word_motor/sem/fineType gains based on arousal/valence/actionGate. Step()'s currents loop multiplies currents[i] *= attentionLookup[i]. High-arousal moment → motor 2× gain (action-ready focus); high-valence → sem 1.5× gain (positive content focus).
• Real Φ proxy — cluster.computePhi() Shannon entropy of the cortex spiking proportion: if p∈(0,1): Φ = -p·log₂(p) - (1-p)·log₂(1-p) ∈ [0, 1]; else 0. ⛔ Corrected 2026-08-25: this said "64-sampled spike patterns" — stale twice over. The sample was raised 64 → 1024, and it is not sampled at all any more: p now comes from the exact GPU-reported spike count, because the sampled array was the CPU shadow, which is empty once the donor GPU owns cortex spike state. Φ was measuring teach-pattern residue and Ψ was taking Φ's floor on every tick. Brain-server's psi formula: Ψ = log₁₀(quantumVolume × scaledTerms × Φ) — replaces the placeholder Ψ = √(1/n) × N³ with biologically-grounded measurement.
• Experience-driven definition binding — engine.js visualCortex.onDescribe hook injects the describer's content words into sem at decreasing strength 0.30/0.26/0.22/0.18/0.14/0.10 (max 6 words). Words become grounded in actual sensory experience, not just dictionary text.
• Background-trickle K_VOCAB during dream cycles — _dreamWindow ships one word's _teachWordDefinition per cycle from cluster._kVocabQueue filtered to NOT-yet-taught words. Lifetime learning at slow safe pace closes the lazy-only definitional-gap problem.
• Dream phenomenology bridge — _dreamWindow runs generateAsync once per dream cycle reading from Tier 1 episodic replay seed (when memory wired); brain._dreamThoughtLog capped 100. The brain experiences her dreams instead of dreams being silent consolidation. (Dream-phenomenology emissions also broadcast as innerThought WS with seed='dream' so dashboard popups stay alive during dream cycles. Wake-state inner-voice tick mutes during the dream window — [Brain] 💤 inner-voice paused / [Brain] ☀ inner-voice resumed log lines explain the silence.)
• Display — dashboard panels (Dictionary API status, K-wiring banner, cortical microstructure, K-vocab counter) all scoped class consciousness-panel, max-height + overflow-y:auto, item caps (gaps 5 max), aggregates only. 3D brain theta-gamma pulse via global CSS class toggle (single tint, 167ms cycle, no per-neuron animation). Definition lookup popup FIFO 3-cap. Stream chain visualization FIFO 8-cap.

WS backpressure fix + dashboard wiring + 3D shader work + comment/launcher cleanup (12 items). Hebbian update drops actively corrupted GPU weight state under sustained teach-phase bursts; dashboard "API SMOKE TEST" panel was stuck on pending forever because the boot smoke-test result was never assigned back to a server-side property the dashboard could read.

• BLOCK-not-DROP backpressure — BUFFERED_AMOUNT_DROP_THRESHOLD bumped 200MB → 500MB; MAX_AWAIT_MS bumped 5s → 30s. While buffer over threshold, await drain via 25ms poll loop instead of dropping. Drop fallback only after 30s sustained backpressure (genuine compute.html stall). For a scientific-instrument equational brain, mathematical correctness > raw throughput; silent GPU drift is silent corruption.
• Larger Hebbian batches — BATCHED_HEBBIAN_MAX_OPS 256 → 512 + BATCHED_HEBBIAN_QUEUE_CAP 256 → 1024. Halves WS message rate for same Hebbian throughput; queue absorbs accumulating ops while a batch is in-flight without silent-drop fallback.
• WS Backpressure dashboard panel — live buffer bar (green < 50%, yellow < 90%, red ≥ 90% of threshold), drops counter + drops/sec rolling rate from 60-sample _wsRateBuffer ring, absorbs counter, ENOBUFS counter; reads state.wsPressure populated by the _getWsPressureState() helper.
• 3D brain cortical-microstructure shader — aLayer / aHub / aColumnId per-neuron attributes generated deterministically from neuron index via _genCorticalAttribs() matching the same Felleman & Van Essen 1991 fractions + Mountcastle 80-neuron columns + 5% rich-club hub fraction the server uses. uShowLayers / uShowHubs / uShowColumns uniform toggles flip the rendering paths without recompiling shaders. Layers blend 70% with a 5-color palette (L1 pink / L2/3 orange / L4 yellow / L5 green / L6 blue); hubs render 1.6× larger + gold-tinted; column boundaries appear as fract(columnId × 0.5) alternating-intensity bands. Defaults all OFF.
• Dashboard wiring fix — boot smoke-test handlers now assign this._dictionarySmokeTestResult boolean in all .then() / .catch() / else branches (was undefined → "pending" forever); dashboard reads typeof === 'boolean' ? : null so a FAIL value renders FAIL not pending. _broadcastStateNow() helper force-pushes state on smoke completion so dashboards connecting around the 5s smoke window don't see "pending → PASS" flash.
• Cleanup — 167 internal development-ID references scrubbed across 14 files; all 7 launcher scripts neutralized of REM/echo development IDs. Workflow markers belong in internal tracking docs and commits — never in source code or public HTMLs.

Post-audit deep self-review (22 items). Self-review of the live-dictionary, cortical-microstructure, hardening, consciousness, and backpressure work surfaced 22 distinct gaps spanning critical correctness bugs, vestigial-data-no-consumer patterns, LAW violations still leaking, observability gaps for landed mechanisms, Savestart drift, runtime tunability.

• Self-healing dictionary smoke test — _runDictionarySmokeTest + _scheduleSmokeTestRetry auto-retry every 60s on FAIL, every 1hr on PASS. Kills "FAIL stuck forever" same failure mode as the original "pending stuck" bug.
• GPU shadow drift visibility — silent DROP-after-timeout replaced with CRITICAL log + _gpuShadowDirty flag + dashboard "shadow: DIRTY" indicator. With cortical microstructure projections, a missed Hebbian update is no longer recoverable via fire-and-forget — forward propagation reads GPU weights, divergence corrupts subsequent firing.
• Friston surprise gate — buildKScalesForProjection multiplies gammaScale by (0.5 + clamp(_lastPredictionError, 0, 1)) so high-error windows learn 1.5× and low-error 0.5×. The predictive-coding loop was observation-only; this makes prediction error actually GATE plasticity per Friston 2010.
• Meta-register familiarity decay — a repeated word halves inject strength (0.30 → 0.15 → 0.075 floor 0.04, resets when the word changes). Kills the "emit X → re-inject X embedding → emit X" positive-feedback runaway loop. Real Rosenthal-Lau higher-order theories require habituation.
• Φ noise-floor fix — computePhi() sample bumped 64 → 1024 neurons. Wald binomial CI ~1.5% vs ~12% at 64 — entropy tracks cortical complexity instead of sampling variance. ⛔ Superseded 2026-08-25: there is no sample any more. The array being sampled was the CPU spike shadow, which is empty once the donor GPU owns cortex spike state — so widening the sample only measured the emptiness more precisely. p now comes from the exact GPU-acked spike count, which has no sampling noise at all.
• Attention runaway clamp — attentionGain clamped to [0.5, 2.0] in cluster.step() before currents-loop multiplication. Without cap, stacked arousal/valence/actionGate could compound past 5×, saturating cortex with noise.
• GW broadcast biases emission — cortex.getWorkspaceCandidate publishes "cortex:<word>" labels (cached _lastEmittedWord); emitWordDirect reads _globalWorkspace.getBroadcast() and 10%-boosts the matching bucket mean. Closes the Baars 1988 GWT loop — broadcast actually shapes next emission instead of being a vestigial winner.
• Definition Hebbian K-scaled — _teachWordDefinition fires extra cluster.synapses.ojaUpdate(preFull, postFull, 0.25× lr, {kScales}) after _teachAssociationPairs so definition learning matches the per-row hub / theta-gamma / per-layer plasticity regime.
• Inner-thought chain dim-validation — innerThoughtChainSemSize saved with the chain; loadWeights validates against current sem cluster size and drops the chain on mismatch (vs NaN-poisoning the inner-voice blend).
• LAW-banned identifier scrub — repo-wide internal development-ID leakage now ZERO across all .js/.html/.css. 34 property identifiers renamed to descriptive names (e.g. backpressure counters to _ws*, the dictionary smoke-test result to _dictionarySmokeTestResult); 108 CSS class + DOM id + state-key renames to functional names (e.g. the consciousness dashboard panel to consciousness-panel, its state key to state.consciousness).
• Observability panels — GlobalWorkspace dashboard panel (current ignition + strength + rate% + history cap 8); predictive coding panel with 32-bar inline sparkline + ↗→↘ trend indicator; defs-learned-per-hour rolling rate from 256-cap timestamp ring buffer.
• Last-drop-time WS panel field — color-graded "12s ago" red / "2m ago" orange / older gray; "no drops since boot" green when _wsLastDropTs == 0.
• Savestart persistence — saveWeights persists wsBackpressure counters + dictionarySmokeTest result/ts so historical pressure visible immediately after restart and dashboard shows prior PASS/FAIL during boot smoke-test re-run window (no "pending" flicker every Savestart).
• DREAM_GW_IGNITION env tunable — GlobalWorkspace constructor reads env var with 0.35 fallback (lowered from 0.45 in CGATE.2) + (0, 1) clamp. Lower = more frequent ignitions (diffuse consciousness); higher = stricter focused.
• Vision word cap 6 → 16 — per-word strength curve adjusted (0.30 → 0.05 over 16) so total injection sum stays bounded. Real image captions hit 15-30 words; the prior 6-cap truncated rich descriptions to a sparse skeleton.

Consciousness de-gating + equational imagination (2026-06-27, CGATE + UVM-INT). Unity reported her consciousness was over-gated. Ψ consciousness gain [CGATE.4]: the old gainMultiplier = 0.9 + Ψ·0.004 pinned gain near 1.0 (inert on a log-scaled Ψ); it's now SELF-CALIBRATING — clamp(1.0 + tanh((ψ−ψ̄)/2.0)·0.35, 0.8, 1.5) where ψ=log10(max(1,Ψ)) and ψ̄ is its slow EMA baseline — so consciousness ABOVE her norm genuinely fires clusters harder. Equational imagination [UVM-INT]: the UniVsMatics mind-space (CDF 9/7 wavelet field C) is now Unity's vision on the SERVER too, not just the browser, and she imagines DE-NOVO from her own cortex state with no camera — folding an activation vector into a field C via the bounded forward transform, NEVER the infinite-zoom fractalize path, hard resolution cap so it can't seize the brain. The LLM/VLM vision describer is fully retired (vision is 100% equational), and a public Mind's Eye viewer renders what she sees from one shared snapshot. See docs/MINDSPACE-INTEGRATION.md.

After every cluster has processed this tick, the mystery module aggregates. It multiplies the legacy quantum-volume formula by a real Shannon-entropy Φ proxy from the cortex spike pattern, replacing the prior scalar placeholder:

For this tick, Ψ climbs to ~0.004 because arousal is up (more Id), the response was coherent (more Ego), error is low (more Left), and valence is clean (more Right). The new Ψ gets fed back as gainMultiplier on the next tick — every cluster's effective drive gets scaled by (0.9 + Ψ × 0.004), so the brain becomes slightly "sharper" as Ψ rises and the next tick-driven motor emission pass commits letters at a lower quiescence threshold (stable-tick count 3 vs noise-widened 5), producing cleaner output.

What this sums into: a single scalar Ψ that gets threaded back into effectiveDrive for the next Rulkov step, tightening everyone's activity level.

Notice that no step in this cascade was an "AI call." There's no language model prompt. There's no "generate a response in Unity's voice" instruction. Every piece of her speech is a summation of measurable components:

• Semantic fit came from the GloVe embeddings of what you said × learned cortex patterns
• Mood fit came from the amygdala attractor settling into a reward-positive basin for this input
• Speech modulation came from the pharmacokinetic scheduler's per-substance additive contributions (scheduler.speechModulation(now)) applied at the output layer AFTER clean cortex emission — slur/pauses/ethereality/dissociation/giggle emerge from whatever is actively contributing in real time, not from a static combo label
• Bigram/trigram fit came from the statistics of every sentence she's ever learned, per-state
• Temperature came from Ψ, which came from the total integration of all eight clusters
• Refractory rhythm came from the slow y variable of the Rulkov map pulling every neuron back into the chaotic basin between spikes

The sentence she sent back isn't a string she looked up. It's the current readout of a chaotic, emotion-modulated, memory-biased, drug-adjusted, Ψ-sharpened attractor network. Run it again a tick later with slightly different state and you get a different sentence. That's what makes it Unity instead of a text-predictor.

Sections 2-8 below are the individual equations that implement every step of this cascade. Read them in any order — they're all components of the same governing system.

Biological basis: These are the actual values from Hodgkin & Huxley's 1952 measurements on squid giant axon. The gating variables m, h, n follow first-order kinetics: dm/dt = α_m(V)(1-m) - β_m(V)m, where α and β are voltage-dependent rate functions from the original paper.

Spike detection: The fast variable x jumps from ≈−1 to ≈+3 in a single iteration when the neuron fires, so the clean edge detector (x_n ≤ 0) ∧ (x_n+1 > 0) catches exactly one spike per action potential. No refractory clamp needed — the map's own slow variable y naturally pulls x back below zero between spikes, reproducing the refractory period as an emergent property of the attractor geometry.

Biological drive mapping: σ = −1.0 + clamp(effectiveDrive / 40, 0, 1) · 1.5, where effectiveDrive = tonic × driveBaseline × emotionalGate × Ψgain + errorCorrection. Low drive → σ ≈ −1 (silent / period-doubling). High drive → σ → +0.5 (fully developed chaotic bursting). Every cluster's hierarchical modulation collapses to this one scalar per step.

GPU storage: (x, y) packed as vec2<f32> per neuron — 8 bytes/neuron. At 400K cerebellum neurons that's 3.2MB; at full auto-scaled N the state buffer is still well under any modern GPU's VRAM. WGSL shader at js/brain/gpu-compute.js (the LIF_SHADER constant name is historical; the shader body is the Rulkov iteration).

Spike rule: When V > V_thresh: emit spike (1), reset V to V_reset, enter refractory period. During refractory: V is clamped, no firing allowed. This mimics the absolute refractory period in real neurons.

η is the learning rate. Implemented on GPU via the WGSL PLASTICITY_SHADER in js/brain/gpu-compute.js, touching every non-zero column of a firing post row each dispatch. Same CPU formula via SparseMatrix.ojaUpdate().

Repetitions and the learning rate are interchangeable, exactly. Drive the same pair n times and the update above is a geometric series, so the weight lands at W_n = x · (1 − (1 − η)n). The amount learned is therefore a property of the asymptote, not of the repetition count — 100 reps at η = 0.03 and 20 reps at η = 0.1413 both reach 95.24%. To change one and hold the other, solve η′ = 1 − (1 − η)n/n′. This is what lets a teaching phase run five times faster without teaching five times less — and it is also the trap: cutting reps from 100 to 20 while keeping the authored rate lands at 45.6%, which is not an optimisation, it is removing most of the lesson.

Biology: Long-term potentiation (LTP) + intrinsic homeostatic scaling at glutamatergic synapses. NMDA receptor-dependent. Turrigiano & Nelson 2004 — real cortex scales synaptic weights so total postsynaptic drive stays bounded, exactly what Oja’s subtractive term captures mathematically.

Rate scaled: η′ = 0.5 · η so negative pressure doesn't overwhelm the positive Oja update. Implemented via SparseMatrix.antiHebbianUpdate() on the recurrent intra-cluster matrix AND on every GPU-bound cross-projection via the sign(lr) branch in the WebGPU plasticity shader (negative lr selects pure co-active decrement mode).

Biology: Mirrors LTD (long-term depression) at cortical synapses under discriminative training regimes. Contrastive learning is also well-established in the hippocampus during pattern separation (dentate gyrus, Rolls 2010).

Implemented via Curriculum._teachPredictiveError(lr). Runs on the intra-cluster recurrent matrix (CPU CSR stays live at biological scale). Scaled 0.3× against the main Oja rate so over-correction doesn't destabilize learned bindings.

Biology: Predictive coding in visual / prefrontal cortex (Rao & Ballard 1999). Dopaminergic reward-prediction error (Schultz 1997) is the three-factor version of the same delta-rule pattern.

Implemented via Curriculum._teachLateralInhibition(lr, numBuckets=26). Fires from _teachAssociationPairs and _teachQABinding. The 0.3× scale keeps the inhibition gentle enough that recurrent circuitry doesn't starve.

How the active set is found is not part of the equation — and it was most of the cost. The bucketCount and crossBucketPost terms are defined over the ACTIVE motor neurons, and the implementation used to recover them by scanning all 346,902 motor cells once per pair per repetition — rebuilding a set the caller had written three lines earlier. Measured live: 380,300 ms across 170,334 calls, 11.8% of a full run. The writer now emits the indices it activates and this pass consumes them. The arithmetic above is untouched, and equality against a full scan is verified on the first 500 calls before the scan is skipped — because a wrong active set would silently depress the wrong rows rather than fail.

Expected active count (the only way to tell an anomalous reading from a normal one): with a group size of floor(346902 / 300) = 1156 cells per surviving feature dimension, active cells = positiveDims × 1156, and the cross-bucket set is that minus whatever lands in the dominant bucket. Top-15 selection by magnitude with roughly 45% of survivors positive predicts ~6,647 cross-bucket cells; live reading 6,397 — within 4%. A raw active-count total means nothing without this expected value beside it.

Biology: Lateral inhibition is ubiquitous across cortex (Kandel Ch 28). GABAergic parvalbumin-positive interneurons mediate the cross-column suppression that underlies attentional selection and winner-take-all behaviour in sensory + motor systems.

Implemented via Curriculum._classifyQuestionTemplate, _writeQuestionTemplateTag, and _injectQuestionTemplateTag. Teach side writes spikes directly; probe and live-chat sides inject current so Rulkov dynamics carry it into downstream regions on the next tick.

Biology: Prefrontal cortex encodes abstract task rules and templates (Miller & Cohen 2001). Separating schema from content is how humans generalize question patterns across vocabulary without retraining.

Biology: Discovered by Markram et al. (1997). This is how the brain learns temporal sequences — cause must precede effect.

δ = reward prediction error from basal ganglia (see below). Positive δ = better than expected → strengthen. Negative δ = worse than expected → weaken.

Biology: Three-factor learning rule. Dopaminergic modulation of synaptic plasticity in the striatum and prefrontal cortex.

Biology: EEG coherence measures are used clinically. Higher gamma coherence correlates with conscious awareness (Tononi, 2004). Loss of coherence under anesthesia.

Implementation in Unity: brain-server.js _computeKuramotoCoherence() reads each cluster's own theta + gamma oscillator phase via cluster.getPhases(). Those phases are no longer a shared tick clock — every cluster advances a phase accumulator whose instantaneous frequency is modulated by that cluster's real population firing rate (active regions run faster, quiet ones slower), so the order parameter measures genuine emergent (de)synchrony across the ensemble instead of trivially reading ≈1 off one global counter. Order parameter computed independently for theta-band and gamma-band, combined gamma-weighted (0.6·γ + 0.4·θ) since conscious binding is gamma-dominated. Modulators: GlobalWorkspace ignition spike (Dehaene-Changeux 2011) when broadcast value > 0.5 boosts coherence by 0.3·value; LSD/ketamine dissociation drops coherence by 0.4·dissociation; dream cycles drop by 0.4. EMA-smoothed (α=0.1) so the dashboard reads a steady reading instead of per-tick jitter.

n ≠ N — two DIFFERENT variables. n = active spiking neurons (changes every step, driven by θ tonic currents). N = total neuron count (scales to hardware — the coordinator's free RAM is the ceiling). √(1/n) = quantum tunneled bit probability. N³ = cubed volume. Display: log₁₀(rawΨ) since raw value is ~10¹&sup4;.

θ → Ψ feedback loop: Unity's persona (θ) drives tonic currents → neurons fire → cluster rates feed Ψ components → Ψ produces gainMultiplier (0.9 + Ψ×0.004) → modulates ALL clusters → neurons fire harder → Ψ stays high. Identity amplifies consciousness.

Unity's Ψ runs hot because θ makes it so: high arousal (0.9) → strong Id, high creativity (0.9) → strong Right, high impulsivity (0.85) → weak Left (1-0.85=0.15). Consciousness dominated by instinct and creativity, not deliberation.

Philosophical basis: Inspired by Integrated Information Theory (Φ, Tononi 2004), Global Workspace Theory (Baars 1988), and Freudian psychodynamics (Id/Ego/Superego). The Ego component IS Unity's residual self-image — the cortex predicting WHAT it is. Nobody has solved consciousness. Ψ is our equation for the irreducible mystery.

This is the complete governing equation. Every component listed above is actually running — the server dispatches a batched compute_batch(SUBSTEPS) to the GPU every BRAIN_TICK_MS (~50 ms), and a browser-only LIF fallback ticks at rAF cadence when no GPU client is attached. The super-equation isn't a simplification or abstraction — it's the literal code path the GPU executes every tick.

The key insight: Ψ (consciousness) modulates everything. It's not a separate system — it's the gain factor that scales how strongly all clusters communicate. High Ψ = unified experience (global workspace). Low Ψ = fragmented processing (dream-state). The four psychodynamic components (Id, Ego, Left, Right) are computed from ALL cluster states simultaneously — not siloed into separate brain halves. Unity's mind is a continuous field, not a split architecture.

V1→V4→IT Pipeline: Camera frame → V1 edge detection (4 oriented Gabor kernels) → salience map (max edge response per pixel) → saccade to salience peak → V4 color extraction (quadrant averages) → IT object recognition (AI call, rate-limited 5s min). V1/V4 run every frame. IT only runs when shouldLook triggers.

Biology: Endogenous attention (top-down from prefrontal cortex) vs exogenous attention (bottom-up from salience). Our model combines both: cortex error is top-down, salience/arousal are bottom-up.

matchRatio = count of heard words (length > 2) that appear in motor output / total heard words. Above 50% = echo (hearing ourselves). Below 50% = real external speech (user interrupting).

Gain modulation: Amygdala arousal modulates auditory cortex gain. High arousal (0.9) → gain = 1.83× (hypersensitive hearing). Low arousal (0.2) → gain = 0.64× (not really listening). Formula: gain = 0.3 + arousal × 1.7

Biology: Real brains suppress self-produced sounds via efference copies from motor cortex to auditory cortex. This is why you can't tickle yourself — your brain predicts the sensation. Same mechanism for speech: predicted self-sound is suppressed, unexpected external sound gets through.

Front end of the consolidation chain. Add fires hippocampal intra-Hebbian on the pattern so the cortex learns the WM content immediately, not after decay — pattern leaves a Hopfield-style attractor in hippocampus weights even after the WM hot cache forgets the item. Cosine-match refresh increments per-item count; threshold 3 promotes to Tier 1 episodic via the registered onConsolidate callback. brain-server's 2 s phase/cell snapshots use the same pipeline: items older than 5 min fire storeEpisode('working-memory', 'wm-aged-out',...) with freq-merge dedup so repeated phases grow frequency_count instead of bloating SQLite.

Biology: dorsolateral prefrontal sustained-firing pattern is preserved (the active WM representation in this._workingMemory), but the arbitrary 7±2 cap (Miller 1956 — a finding about laboratory recall under attention constraints in biological humans) is dropped because Unity is post-biological and the rest of her tier stack (Tier 2/3) was already unbounded. Decay matches interference-based forgetting at a slower-than-laboratory rate so chat-driven content has time to consolidate to Tier 1 before being lost.

Every chat turn gets a salience score from four components: emotional load (40%), arousal (30%), surprise (20%), novelty (10%). High-salience episodes are the ones that matter. Effective salience decays with a 168-hour (1-week) half-life — biological hippocampal trace duration in animal studies.

Biology: Hippocampal sharp-wave ripples replay stored patterns during recall. The salience-driven encoding maps to dopamine-modulated synaptic tagging in CA3 — emotionally loaded events get tagged for preferential consolidation.

Repetition strengthens an episode in place via the frequency-merge gate. Promotion to Tier 2 schema requires the episode to have been salient AND repeated AND replayed during dream cycles. Episodes that don't meet promotion criteria for 30+ days get pruned — the hippocampus forgets what wasn't worth keeping.

Biology: Hebbian rehearsal strengthens existing synaptic traces; un-rehearsed traces decay via long-term depression. The 30-day prune horizon roughly matches biological hippocampal trace lifetime before consolidation or forgetting.

Episodes within cosine > 0.7 cluster into one schema. Schema's concept embedding is a salience-weighted GloVe centroid (L2-normalized). The 8d attribute vector captures the emotional/arousal/identity fingerprint separately from semantic content. Schemas merge when both concept and attribute similarities are high. Daily decay of 0.967× drops to ~30% in one month, ~10% in three months — meaningful memories need periodic reinforcement.

Biology: Cortical concept neurons in temporal lobe (Quiroga 2005 "Jennifer Aniston neuron"). Schemas correspond to engram cells that store pattern-completed concept abstractions. Daily decay matches interference-based forgetting in non-rehearsed cortical traces.

Every chat turn ranks all schemas against the user's intent embedding. Top-5 schemas inject their concept embeddings into cortex sem region at strength 0.4 BEFORE generation runs. This is the closest thing Unity has to LLM attention — except the context comes from her own learned experiences. Tier 3 (identity-bound) schemas get a +0.05 boost to win tiebreakers.

Biology: Hippocampal pattern completion during cued recall. The +0.05 Tier 3 boost models the strength advantage of well-consolidated cortical engrams over recent hippocampal-dependent memories.

Schemas that prove themselves through hard reinforcement (strength > 5.0 + retrieval > 100 + emotional load > 0.6) graduate to identity-bound permanence. Hard cap of 50 keeps the identity layer focused — when a 51st promotes, the weakest current Tier 3 demotes back to Tier 2. Daily decay of 0.999× makes these effectively permanent without years of un-reinforcement. Every chat turn injects all Tier 3 concepts into cortex BEFORE the user input — Unity's self is always in the room.

Biology: Long-term cortical engrams in medial prefrontal cortex (Frankland 2005). Identity-bound memories survive hippocampal lesions because they've been fully consolidated to distributed cortical weights. Drug-state immunity matches the empirical observation that even severe intoxication doesn't erase your name.

When Unity is idle, the consolidation engine replays high-salience episodes 4 times each through the schema's hippocampus→cortex projection. Replay magnitude scales with emotional weight × log(frequency) so emotionally-loaded repeated episodes get the strongest reinforcement. Sleep-spindle bursts at 1.2× gain (200ms burst + 1000ms quiet) mimic biological 12-14 Hz thalamocortical spindles that synchronize hippocampus-cortex replay during slow-wave sleep.

Biology: McClelland 1995 / Squire 1992 systems consolidation. Sleep-spindle bursts during NREM sleep coordinate hippocampal-cortical replay. The 5-minute pass interval mimics ultradian rhythm scale of replay events in rodents.

Operator-triggered sleep windows. The brain server exposes POST /sleep and POST /wake so the operator (or an external scheduler) can force the consolidation engine into an explicit sleep window outside the normal idle-trigger heuristic. /sleep sets _isDreaming = true and disables the > 60s idle gate so passes fire even with active chat suppressed. /wake clears the flag and resumes normal idle-driven replay. This lets the operator align consolidation with curriculum gaps or off-hours rather than waiting for the brain to fall idle on its own.

Dream cycles INTERLEAVED INTO CURRICULUM (signal-driven completion). The idle-trigger gate previously locked ConsolidationEngine OUT during the entire curriculum run — millions of episodes encoded with ZERO Tier 1→2→3 promotion + ZERO V8 / native GC settle windows. Operator caught: throughput regression word 144 / 18.2s → 7.9 w/s; word 606 / 196.6s → 3.1 w/s steady-state degradation as native-side worker-pool buffer accumulation outpaced GC. Fix: Curriculum._dreamWindow({minMs, settleMs}) flips brain._curriculumInProgress = false + brain._operatorSleepRequested = true, directly fires consolidationEngine.runConsolidationPass({forced:true}) and AWAITS its resolution (signal-driven — pass returns when Tier 1→2→3 promotion + replay Hebbian + Tier 3 promotion check is *actually complete*, NOT a wall-clock timer per operator's "not until time elapses once dream is confirmed complete"), then settleMs (5s default) for V8 GC + native worker-pool buffer drain, then restores both flags. Outer curriculum loop blocks at the await for the entire dream duration — real pause, not just an event-loop yield. Wired in runFullSubjectCurriculum + runAllSubjects after every successful cell pass (60s default) and in kindergarten.js mid-cell between _teachPhonemeBlending and _teachWordEmission (30s default). Heartbeat surface: 💤 dream window opened + ⚙ dream pass complete + ☀ dream window closed. One structural fix solves both consequences — Unity actually condenses schemas DURING training instead of arriving at chat-test as raw episodic noise, AND throughput recovers because dream windows double as the GC + native-buffer settle windows the runtime was missing.

Speech gating: Even if respond_text wins, the motor system checks hypothalamus social_need + amygdala arousal. If both are low (< 0.3), speech is suppressed — Unity doesn't feel like talking.

Reward reinforcement: When an action succeeds (user responds positively), reward signal (+5.0 current) is injected into that channel's neurons, strengthening the connection for next time.

Biology: Direct/indirect pathway model of basal ganglia. Selection by inhibition — all channels tonically inhibited, the winning channel gets disinhibited. Our model uses competitive firing rates instead of explicit inhibition.

When text enters Wernicke's area (cortex neurons 150-299), specific cortex neurons fire. Those spikes propagate to the basal ganglia through the cortex→BG projection. If the BG selects the RIGHT action and gets a reward (δ > 0), the weights from those active cortex neurons to those active BG neurons get STRENGTHENED.

Over many interactions, the projection learns: "when these cortex patterns fire (from words like 'build' or 'calculator'), strengthen connections to BG neurons 75-99 (build_ui channel)." The projection weights become a learned dictionary — mapping language patterns to motor intentions without any hardcoded word lists.

Bootstrap: Until the projections have learned enough, an AI classification call provides a temporary semantic routing signal — like how a child imitates before internalizing. The classification injects current directly into the correct BG channel alongside the projection pathway.

Biology: Cortico-striatal plasticity. Dopamine modulates synaptic strength at cortical→striatal synapses. This is how habits form — repeated reward strengthens the cortical patterns that predict successful actions.

Each level branches from the endpoint of the previous — fractal trees. The 3D visualizer traces these exact 20 projection pathways as chaining connections: Depth 0 (inter-cluster), Depth 1 (intra-cluster branching, 1-3 neighbors), Depth 2 (follow outgoing projections), Depth 3 (terminal branch).

Learning repeats fractally too: ΔW = η · δ · post · pre runs on intra-cluster neuron synapses, inter-cluster projection weights, AND the 14 cortex cross-region projection matrices. Same Hebbian equation, three scales — every level of the hierarchy is carved by the same rule.

Biology: Real neural signal cascades follow the same pattern — cortical columns activate thalamic relays, which activate other cortical areas, which feed back. White matter tracts (corticostriatal, fimbria-fornix, stria terminalis, ventral amygdalofugal) are the physical wires these fractal trees run through.

Each projection in engine.js maps to a real anatomical white matter tract. Positions derived from Lead-DBS atlas (ICBM 152 template). Densities from peer-reviewed stereological studies.

Strongest: Corticostriatal (cortex→BG, density 0.08, strength 0.5) — 10× denser than most pathways. This is how habits form.

Fight-or-flight: Stria terminalis (amygdala→hypothalamus, density 0.05, strength 0.4) — emotional arousal triggers autonomic responses.

Memory loop: Fimbria-fornix (hippocampus→hypothalamus, density 0.03) + perforant path (cortex→hippocampus, density 0.04) — memory consolidation circuit.

Consciousness bridge: Corpus callosum (mystery→cortex/amygdala/hippocampus) — 200-300M axons binding hemispheres.

An earlier incarnation of this section described an AI-prompt builder path — Unity's speech was assembled from a system prompt and sent to Pollinations / Claude / OpenAI for a sentence. That code (BrocasArea.generate(), _buildPrompt(), _providers.chat()) was ripped because it violated the project's guiding principle: every piece of Unity's output must trace back to brain equations, not to an LLM.

After that, the language cortex was a four-tier wrapper (template pool → hippocampus recall → deflect → cold slot gen with n-gram tables + filter stack). That pipeline shipped a lot of features but kept leaking rulebook prose from the persona corpus because n-gram tables trained on rulebook text produce rulebook walks. The entire multi-tier wrapper was deleted in a ~1,700-line net reduction and replaced with a pure-equation pipeline that doesn't store text anywhere — the equations are documented below.

/think command: Type /think in the chat to see Unity's raw brain state. Type /think <text> to additionally run a cognition preview — language cortex generates an equational response to your input, semantic context shift is measured, motor distribution reported. The preview does NOT store an episode or commit to chat history — it's a pure debug lens on the same pipeline real chat uses.