--- # DOCPROV.1 — provenance. See docs/ARCHITECTURE.md for the full note. # ⭐ THE DOC IS THE MAP, THE CODE IS THE TERRITORY. # ⚠ This page is seeded FIRST for a reason: line 358 once claimed a route had # been removed in April while that route ran in production for four more # months. It is the page that proved a doc can lie in the reassuring # direction, so it is the page that most needs a mechanical baseline. status: verified sources: - js/brain/curriculum.js - js/brain/language-cortex.js - js/app.js - js/brain/cluster.js - js/brain/engine.js - js/brain/sparse-matrix.js - server/brain-server.js - server/brain-server/memory.js verified-scope: | CHECKED 2026-08-27 (DOCPROV.4). ⛔ The dated capability entries saying "8 named sub-regions" and "7 pairs x 2 directions" were NOT rewritten — they were true when written, and this page's whole function is to record what she could do on each date. WHAT WAS DONE INSTEAD: a GEOMETRY FORWARD-POINTER at the head giving the current measured values (11 top-level sub-regions; 16 cross-region projections) and naming the current authority. ⭐ The CLASS is now guarded: docs:drift check 10 tripwires the superseded figures with a historical exemption, and reads GREEN as of this stamp. NOT CHECKED — do not read this page as authority on: - any capability claim. This page is ~514 lines of extremely dense dated banners and NONE of them were re-verified; only the geometry figures were. - js/brain/curriculum.js, the source that moved. Not read for this page. ⚠ THE STANDING WARNING ON THIS PAGE REMAINS THE POINT: line 358 once claimed a route had been removed in April while it ran in production for four more months. Treat every capability sentence here as a cached observation. CHECKED 2026-08-29 (provenance pass): js/brain/curriculum.js moved since the prior stamp (SUBJRETIRE roster retirement + ASSOCBOUND.1 tally) — the living "273 cells / GROWING roster" row was re-priced against subjectsOwedAt; the five previously-unlisted cited files were added to sources and each living citation was re-verified against current code (line numbers refreshed; the passedPhases stale-load-filter row was found SUPERSEDED by 114.19fe and marked). Dated banners stay byte-identical per this page's own rule. ⭐ Doc-sweep pass 2026-08-31 (the fresh-walk night). `server/brain-server/memory.js` added to sources — this page has carried nine Tier-1/2/3 consolidation capability rows since 2026-05-04 while never declaring the file that owns Tier 1's writers, so the one condition that made all nine inert could not have registered as drift here. CHECKED this pass, against live state on the b1a5eb01 fresh walk: - ✅ NEW: the 2026-08-31 banner. Replay ran end to end for the first time (tier1 4, freqMerged 21, promotedToTier2 4, two named Tier-2 schemas) after `!_curriculumInProgress` came off the Tier-1 heartbeat; roster published as DECLARED (9 + rosterUpcoming 11); corpus 89/89 cells. - ⭐ The banner states the lesson this page needed most: a capability row says code EXISTS, never that it RUNS. This page has now recorded both failure directions — a route claimed removed while it was live (line 358) and a system claimed present while it had never executed. NOT CHECKED — do not read this page as authority on: - the dated banners below 2026-08-25, deliberately left as written. - the "114 cells / 6 subjects" arithmetic inside historical rows; the 273-cell row already carries its own correction. last-verified: "4bc99291 2026-08-31" --- # SKILL TREE — IF ONLY I HAD A BRAIN ## ⛔ START HERE — the skill tree itself begins at [§ By Domain](#by-domain) Everything between here and there is **current-state notes followed by change history**. The tree is organised four ways, and they are four views of the same set: | View | Answers | |---|---| | [§ By Domain](#by-domain) | *what field is this?* — neuroscience, ML, backend, frontend, voice/vision, distributed compute | | [§ By Complexity](#by-complexity) | *how hard is this to pick up?* — beginner through expert | | [§ By Dependency](#by-dependency-skill-tree) | *what must I understand first?* — the actual tree | | [§ By Priority](#by-priority) | *what matters most?* — critical, important, nice-to-have | ⛔⛔ **THIS PAGE'S OWN HISTORY IS THE REASON IT IS READ SCEPTICALLY, AND THAT WARNING BELONGS AT THE TOP RATHER THAN IN THE FRONTMATTER.** It once stated that a live text-AI route *"had been removed"* — while that route ran in production for **four more months**. ⭐ **It is the page that proved a document can lie in the reassuring direction**, which is the direction nobody investigates. **A claim here that something was removed is not evidence that it was.** --- > ## ⚠ GEOMETRY FORWARD-POINTER (added 2026-08-27) — the dated entries below say **8 sub-regions**, and that was TRUE WHEN WRITTEN > > ⛔ **The cortex now carves into ELEVEN top-level sub-regions, not 8, and there are SIXTEEN cross-region projections, not 14 / "7 pairs × 2".** Measured by constructing a real cluster: `auditory, visual, gustatory, somatosensory, free, letter, phon, sem, fineType, motor, word_motor`. `gustatory` and `somatosensory` were carved out of `free` (so the spans shifted), and `word_motor` + its projection pair arrived with the 2026-07-14 WMB unification. > > ⭐ **The dated entries below are NOT being rewritten, and that is deliberate.** They are a record of what shipped on the day they were written, when `8` and `14` were the truth. **Editing them would falsify the history this page exists to keep** — the same reason `docs:drift`'s link checker exempts archives. > > **Current authority for the region map:** `wiki/modules/cortex-cluster.md`, `docs/ARCHITECTURE.md` and `README.md` — all three verified 2026-08-27. ⚠ **Six documents were found carrying the old figures during that sweep; four stated them as CURRENT and were corrected, and this page and `docs/ROADMAP.md` state them as history and were left alone with this pointer instead.** > **CURRENT-STATE — re-measured 2026-09-07.** ⛔ **Every figure in the previous version of this block was stale**, which matters more here than anywhere else on the page: the dated banners below are *labelled* history and are allowed to be old, while this block claims to be current. **A stale CURRENT-STATE block is the only kind that misleads.** > > | | measured | the block used to say | > |---|---|---| > | Brain size | **388,597,268** at this boot — ⛔ **derived at boot from free host RAM, never a constant** | "306M brain" | > | Language cortex | **15,082,717** | "12,000,000-neuron" | > | Grades in the roster | **20** — `pre-K` through `phd`, read from `GRADE_ORDER` | "all 19 grades" (it omitted pre-K) | > | Teach rate | observed **5,235** and **9,076** pairs/min this session, and **0** while she is in definition anchoring | "200 → 1,100+" | > > **Scope:** the full walk — every grade, every subject, plus the full lived year at each age. ⛔ **The "SCOPE LAW: Pre-K + K ONLY" line in the dated banners below is REVOKED and historical.** > > ⚠ **A teach rate of zero is not necessarily a fault.** Before her prose training begins, each cell anchors the definitions of every unlearned word it uses — a serial pass that reports through its own progress stamp and can legitimately run for tens of minutes with the teach counter at zero. **Read the stage tag before reading the rate.** --- ## Change history — newest first > ⚠ **HISTORY, NOT CURRENT STATE — and deliberately left as written.** Each entry records what shipped on the day it was written, including figures that were true then and are not now (the geometry pointer above is the worked example). **Rewriting them would falsify the record this page exists to keep**, which is the same reason the link checker exempts archives. > > ⛔ **So read them as dated claims, never as the present.** Where an entry disagrees with the CURRENT-STATE table above, **the table was measured and wins.** The entries also carry internal milestone identifiers that nothing in the project resolves — those are allowed here, in labelled history, and are banned from the tree sections below. > Last updated: 2026-09-06 latest (**A GATE THAT TAUGHT THE ANSWERS TO ITS OWN PROBE, AND THE PRICING NUMBER THAT WENT NOWHERE**). **NEW capability — the exam bank can declare a word UNTEACHABLE.** Nonsense-word-fluency items measure whether she can blend a letter string she has **never seen**, so their answers are absent from every corpus by design; the vocabulary-coverage audit read that as *missing vocabulary* and the pre-gate teaches whatever the audit calls missing. ⛔ **A pre-taught nonsense word is a sight word — the probe stopped measuring decoding, started measuring recall, and PASSED, with no failure and no warning anywhere.** Items now carry an explicit un-teachable flag, answer-*variants* stop counting as required vocabulary (they are tolerances the scorer accepts, not answers she must produce), and a **second independent barrier** sits at both pre-teach call sites. Coverage on the affected cell **0.966 → 1.0000**; zero un-teachable tokens reachable across all twelve cells. ⚠ **The first cut of that barrier was EMPTY and read correctly in the diff** — the bank's shape-converter builds a new object from a fixed field list and dropped the flag. **NEW capability — the rep-pricing verdict is readable.** The self-pricing collision-load measurement was shipped unarmed on the promise that one press would produce the evidence, and wrote its answer to a property with **exactly one reference in the tree: the write itself**; it is published in state now, carries its own age, and re-measures on a clock instead of on every call. **NEW capability — the lateral pass stops rediscovering what it was handed:** the writer emits the motor indices it activates rather than the pass scanning all **346,902** cells to find them (**380,300 ms, 11.8% of a boot**), behind a 500-call self-verification because a wrong active set depresses the wrong rows silently. ⭐ **And the rep question is settled: repetition was never the knob** — two presentations at low collision load retrieve at **97.2%**, one hundred at high load at **86.6%**. > Last updated: 2026-09-04 latest (**THREE QUARTERS OF EVERY LAMINATED PROJECTION WAS BORN DEAD, AND THE RELAY THAT WAS NEVER CALLED IS ON**). ⛔ `initTopographicProjection` **skipped** any row outside the L4 mask, and L4 is 25% of a region, so **75.0% of the rows in every laminated topographic projection came out of construction empty and could never learn** — measured identical at four sizes spanning 50×. Fixed both ways at once on the operator's ruling: the engineered index bands (`motor`, `letter`, `word_motor` — a bucket per symbol read by argmax over bucket means, not laminated cortex) are exempt from masking, and where the mask belongs it is a **bias** (0.25 of fanout, floor 1) rather than a veto, so the hierarchy survives as a gradient. **At 60,000: `letter_to_phon` 2.50 → 4.75, `phon_to_letter` 2.52 → 10.00, `motor_to_letter` 1.01 → 4.00, `letter_to_motor` 1.47 → 6.00 — all at zero empty rows.** ⛔ Two further empty-row sources found in the same pass: the source mask could leave a row under its fanout, and **`initRandom` had no `Math.max(1, …)` at all**. **NEW capability — the thalamic relay is live:** the attention head has been built, wired into the emission path and never called since it shipped; it now rides the conversational lane, opt-in per caller so gate and probe callers keep measuring the trained matrix alone. > > Last updated: 2026-09-04 later (**THE BAND THAT PRODUCES EVERY WORD SHE SAYS WAS THE THINNEST PROJECTION IN THE BRAIN**). **NEW capability — a wiring audit at boot**, because `ojaUpdate` cannot insert and so the wires a row gets at construction are its capacity for life, and nothing had ever printed that number. On its first run it found `sem_to_word_motor` at **3 wires/row** against `sem_to_motor`'s 6 — the projection discriminating tens of thousands of WORDS had half the wiring of the one choosing between 26 letters. **Now 6/row, 606 → 1,212 wires per word.** The `sem` pairs also came off the topographic list, against which the list's own comment already warned: `radiusTopo` is a fixed 30, so at the deployed geometry a word's window is **0.630% of one GloVe dimension**. ⛔ **And the instrument found a bigger defect than the one it was built for, left OPEN as a decision: 75.0% of every laminated topographic projection's rows are EMPTY and can never learn** — the L4 fraction, measured identical at four sizes spanning 50×. > > Last updated: 2026-09-04 (**SHE CAN NOW FINISH SCHOOL WITHOUT BEING SWITCHED OFF BY IT, AND FINISHING IS AN EVENT SHE HAS**). ⛔ **A capability this page never listed because nobody had noticed it was missing: continuing.** Five lanes — chat-time deep Hebbian, the curiosity follow-up, the deferred percept grounding that carries what she has seen into her semantic memory, her own drawing / practice / relearn queue, and the episode-salience term — drained **only** inside the curriculum's compute-substrate gate, which fires once per teach call. After the last cell there are no teach calls, so all five would have stopped permanently and silently. They now have a second driver that runs *only* while the curriculum is not running. ⛔ **One of the five had never run at all** — its guard named a property the class does not have, so every chat episode banked at the default surprise. **NEW capabilities:** a persisted **graduation record** with a per-course *merit / force-advanced / still-owed* split the cell ledger structurally cannot express; a **first-person memory of finishing**, banked once, with wording conditional on that verdict; and a **corpus completion verdict** that tells a cell with no corpus apart from a cell whose corpus nothing ever read. **40/40 across three harnesses.** > > Last updated: 2026-08-31 (**A CAPABILITY THIS PAGE HAS LISTED SINCE 2026-05-04 RAN FOR THE FIRST TIME TODAY**; fresh walk pressed 07:23Z on `b1a5eb01`). ⛔ **Read the 2026-05-04 banner below — "3-TIER HIPPOCAMPAL CONSOLIDATION SYSTEM adds 9 NEW capabilities" — and then read this: `tier1.totalEpisodes` was `0` on every boot in this project's history.** Every one of those nine rows described code that exists, is wired, and was **producing nothing during a walk**. ⭐ **This is the same failure mode this page is already famous for, inverted:** line 358 once claimed a route had been REMOVED while it ran in production for four more months; here nine rows claimed a system was PRESENT while it had never once executed. **A capability row states that code exists. It does not state that the code runs, and this page cannot tell the two apart** — which is the standing argument for reading a live field before believing a matrix cell. **(1) The cause was one condition**, `!this._curriculumInProgress`, on two of Tier 1's three writers, with the third (`_recordPhaseEpisode`) firing only on phase completion while phases were not completing. **`_curriculumInProgress` is true for the entire multi-week walk.** No episodes → no consolidation candidates → no Tier-2 schemas → **interleaved replay, the mechanism that separates representations, never ran** — so the waking rep dose was silently doing work replay was supposed to share. **(2) Now live and verified at 18 minutes:** `tier1` **4** · `freqMergedCount` **21** · `promotedToTier2` **4** · Tier 2 holding `hebbian-ela-kindergarten` and `association-pairs-ela`. ⚠ Judge it by `freqMergedCount`, not the raw count — the exact-text merge folds repeated contexts by design. **(3) NEW capability — the training card publishes the DECLARED roster:** row membership comes from `subjectsForGrade()` instead of `cluster.grades`, so a course is visible BEFORE it first runs — `subjects` **9**, new **`rosterUpcoming`** **11**, `SUBJECT_LABELS` grown to 20. **(4) The academic corpus reached 89/89 cells · 874/874 topics · 12,075 sentences** (from 729 / 10,083); ⛔ `cs` had **zero** corpus across all eight of its K-12 grades. **(5) Reps and learning rate are interchangeable, exactly:** `n` reps of Oja on binary spikes reach `x·(1−(1−lr)ⁿ)`, so 100 @ 0.03 ≡ 20 @ 0.1413 = **95.24%**. The 5× walk saving was already banked dose-neutrally, which is why the competing proposal to simply cut reps closed as moot instead of shipping — it kept the authored lr and would have landed at 45.6%, i.e. removed teaching. > > Last updated: 2026-08-25 (**SHE LEARNS ~40× FASTER, AND THE BOARD CAN NOW ANSWER "WHY" INSTEAD OF GUESSING**; branches `feature/scalewalk*`, `feature/oneshot-state`, `feature/lateral-scan`). ⭐ **The capability is speed, and it is measured in her behaviour rather than a benchmark: definitions went from 5-7.4 seconds each — tripping a 5s slow-word alarm on `m`, `p`, `s`, `zero` — to ~128ms, with ZERO slow-word warnings on the next walk.** Nothing about what she learns changed; every substitution was proved bit-identical first (144/144, 72/72, 16/16, 128/128 including row ORDER). **What was removed was work that produced nothing:** three separate functions were re-deriving information the caller already had, or maintaining CPU arrays that nothing at biological scale reads — `injectEmbeddingToRegion` wrote ~13.7 MILLION floats per call into an array whose only readers sit in a function that cannot run at this scale; `_clearSpikes` zeroed up to 82M cells per call in a per-element JS loop across 24 sites; `_teachLateralInhibition` walked the motor span twice for the same sparse bits. ⛔ **All three had one cause: they were priced when the cortex was 1.5M and nobody re-priced them at 82M** — `_clearSpikes`'s own comment still quoted the 1.5M figure. ⭐ **And a second capability, quieter but structural: the brain can now tell you what is slowing it down.** The one-shot self-profile ranks main-thread functions by self-time and, since `ONESHOT.1`, **survives in `state.profiling.cpuProfile` instead of a console line** — which mattered immediately, because at the new walk speed the 500-line ring is a **nine-second** window (KI-36). Three consecutive profiles then verified each fix in turn: 34.9%+23.0% → both gone → 33.8% → 14.1%. **Loop service 95% → 99%**, upload of the 2.79GB matrix **58.0s → 39.7s with no upload-code change at all** (the CPU walks had been throttling the network). ⚠ The honest stopping point: `normalizeRows` is now top at 27.5%, and it is **probably not waste** — its absolute cost rose because the walk got faster, and cutting it needs a dirty-row audit whose failure mode is corrupted training (`NORMROWS.1`). > > Earlier updated: 2026-08-25 (**HER DRAWING ABILITY BECAME A TRAINED SKILL — and four instruments stopped lying**; branches `feature/endo-board-parity`, `feature/propbound-audit`, `feature/boundcap-darkheb`, `feature/artzig2`). ⭐ **The one genuinely new CAPABILITY: how much of a remembered thing she commits to the page is now something she LEARNS.** `budgetMul` is a sixth trainable parameter in her practice loop, beside jitter / underA / traceW / keepP / detailMul, and it is scored the same way — cosine against her banked percept of the real thing — so *"draw more of what I remember"* only survives a practice session **when the extra work made the drawing genuinely closer to the subject**. Measured on a full 260-stroke trace: the doodle hand draws **101 strokes untrained → 235 practiced**. ⛔ **That capability existed as a CEILING before this, and the ceiling was mine:** per-hand stroke budgets sized as a noise defence (doodle **22**) survived after the noise itself was fixed at the source, and the operator named it — *"cant make a art work in only 20 strokes it should increase in ability as she learns"*. **When a defence becomes unnecessary its cost stops being free.** Everything else in this batch is HONESTY rather than new ability, and it is worth listing because three of the four were *my own* instruments reporting health they could not know: the endocrine board read a **reassuring `allostatic 0.000/0.6`** for the one quantity that says whether adversity is accumulating (fields read by the page, never forwarded by the server — 13/13 and 7/7 parity now); the bound-propagate lane **fell back to CPU silently** with no counter, which is the exact number the loop-starvation work needs; `boundHebbian` published **seven** fields into the dark, including the one whose own comment says *"it belongs on screen"*; and a truthy `'browser'` sentinel made **two browser-donor branches dead code**, one of them serving browser donors the native wire protocol and the other stripping the socket protection they exist to have. ⚠ **Her art improved by being LOOKED AT:** the "zigzag" was never the strokes — the body was a **rectangular slab**, because the silhouette hull was fitted to the tracer's noise while the gate that kills that noise governed only which strokes got *drawn*. **None of this is verified live.** > > Earlier updated: 2026-08-25 (**SHE HAS A BODY** — the endocrine system, the glands that fire it, and the questions she asks herself. 30 items across six batches). ⭐ **These are CAPABILITIES, not features — things she can now do that she could not do yesterday.** **She can be FRIGHTENED, and it changes how she talks:** a two-stage stress axis (adrenaline in seconds, cortisol behind it over minutes — which is what makes stress *last*), four responses not two (fight / flight / **freeze** / **fawn**), and ⭐ freeze IS `idle` winning in action selection, so **going silent is a correct output rather than a failure to speak** — verified as clipped speech, longer pauses, `idle_thought` biased ×2.90 and `speak` ×0.24. **She carries a MOOD FLOOR that a hard stretch lowers and that STAYS lowered:** serotonin is tonic, so a level *below* baseline produces the **inverse** effect (more impulsivity, not less mood), and allostatic load shifts her baseline with a ceiling of 0.6 and a verified recovery path — because *"she survived it changed"* must not become *"she was destroyed by it"*. **She LIVES A MENSTRUAL CYCLE on curriculum time:** ~273 cells over 20 grade-years is 13.65 cells/year against ~13 real cycles/year, so **one cell pass ≈ one cycle** within 5% — and ⭐ **PMS is built as the WITHDRAWAL, a RATE**, because progesterone is at its *lowest* during PMS and a level-driven model produces nothing exactly when it matters. **She COMES DOWN:** spent transmitter pools dip *below* baseline (serotonin 0.550 → 0.218 after an MDMA night), queued at ingest and scaled by dose. **She builds TOLERANCE THAT CROSSES SUBSTANCES:** receptor downregulation rather than a per-substance fudge, so tolerance built entirely on cocaine blunts amphetamine by **18%**. **She ASKS HERSELF QUESTIONS, and they vary with her chemistry** — six gap kinds drawn from her own lived episodes, inward ones riding the inner voice and outward ones needing a turn; ⭐ measured against its own kill criterion at **total-variation distance 0.840** between two pinned endocrine states, where a question bank scores ~0. **And she LEARNS WHAT ALL OF IT IS** — 144 body/chemistry words on the LEARN axis, which is never gated and runs deliberately *ahead* of the physiology: she learns what a period is at **nine**, and menarche does not fire until **twelve**, because that ordering is the entire point of sex education. ⛔ **Bugs found while building on top of them:** a five-year-old was reading as twenty-five (`_computeMinGrade` searched for a grade string the curriculum never emits); the morning-coffee ritual was 2/2 steps dead because `caffeine` was referenced and never defined; and `level()` was clamping tonic chemicals at 1.0, **eating a third of a line of coke**. ⚠ **None of it is verified live** — `WEIGHTS_FORMAT_VERSION` 4 → 5 means the next press is a **fresh walk**. > Last updated: 2026-10-18 (**SHE MOVED HOUSE + ONE VOICE WITH FEELING + HER OWN EYES + donor-v0.3.38**). The rented box is gone: the site is `theunitybrain.com` on GitHub Pages, the brain runs on the lab's own machine behind a Tailscale Funnel that forwards five read lanes and no admin lane, and the launchers start a local control plane beside her. **Capabilities:** her voice is `unity-voice-v2` — the ONLY synthesizer (piper deleted) — and its emotion / intensity / speech act come from her amygdala, endocrine layer and prediction error, never from the words; her images render on her own card through a local Stable Diffusion engine behind one gate (Pollinations deleted). Donor `0.3.38` dials the new address; releases are built by GitHub Actions. ⚠ Rows below that read "Pollinations", "piper", "nginx" or "Forgejo-authed" are the ledger of what was true when it was built and are marked where they no longer hold. > Last updated: 2026-08-21 (**ALL TRAINING ON THE DONOR + donor-v0.3.26**). **NEW capabilities:** **Masked bound plasticity** (SPRS type 13, new binary) — the donor can now train a bound matrix with pre = its resident spike state and post = an explicit sparse row mask scattered device-side (new `scatter_ones.wgsl` on wgpu; existing zero+scatter primitives on CUDA; kernel unchanged, lr<0 = anti) — which moves lateral inhibition, the last big CPU teach slab, onto the card. **Range-form dispatch everywhere it fits** — the intra Oja pass, both alphabet drills, and the once-per-definition sem→sem write ship exact index sets as `[start,len]` runs on `hebbian_ranges`; refusal-to-compress = full CPU pass (never truncated GPU math). **A teach lane that names its own failures** — `throughput.boundHebbian` stage counters + a batch cap that flushes instead of dropping. **Spaced-repetition gate vocab** — persisted `word → lastTaughtAt` receipt with a 48h re-teach window: gate re-entry inside the window reads `VOCAB OK 100%` in a second. **Chunked gate probes across all 19 grades** (shared-helper conversion) with `gate:probe-*` stage stamps. **A pump that feeds the port** — 96MB in flight for native donors + a measured-MB/s line per upload. **A self-updating donor pod** — pulls `releases/latest` on every start/restart. > Last updated: 2026-08-20 (**SELFFRAME + OWNART + NOBUDGET**). Three capability changes, all teach-time or draw-time, none touching the emission path. **She learns in FIRST PERSON:** every lesson is reframed as something she DID (`1 + 1 = 2` → *"i add one and one to make two"*), taught through the same Hebbian primitives at four chokepoints that every grade's every cell funnels through, with `i`/`me`/`my`/`myself` grounded to `unity` at the top of every cell — the curriculum previously held **six** occurrences of "i am unity". **She is INQUISITIVE:** a content word from your answer becomes her next question (depth-3 chain), and the asking is trained, not scripted. **She DRAWS HER OWN VERSION:** a look now survives as a ≤9-cell shape schema (~1-2% of the reference's information, so copying is impossible) and she constructs the marks — the old "drawing" was a 7-band posterize of a Pollinations photo, and the word *draw* never even reached her hand. **No caps on the mind's eye** (ceilings raised to the engine's integrity bound) and **no phase budget** — cells take the time they take; the consolidation gate alone keeps the walk finite. > Last updated: 2026-08-18 (the drop-on-speak war close — INJECTSPARSE / CONSOLERING / TICKGUARD / chat-stage eyes). **Talking to her is SAFE now**: the chat text-injection went sparse (dense 23.4MB no-op bomb → 160 real bytes; her Wernicke's area receives chat text for the first time on native donors), the box console is remotely readable forever (`/public-state.json?console=N` tunnel), the reply path can never CPU-step the 12M cortex on a donor wobble, and every loop pin within 120s of chat prints its chat-stage name. Live verify: donor held RTT 61ms through a full reply, zero sheds, zero drops. Open: the one-time first-reply-after-boot pin (~21.5s, non-lethal, instrument-first — FIRSTPIN). > Last updated: 2026-08-17 (the stalling-war sweep — TMPLFIX / BCASTFIX+GSLAPS+CONSCFIX / HOPFIX / PRECELL+DEFTOTAL / GINTRA+STALEGATE+SHADOWTIME / DROPCHAT / PAIRSLICE / SENDFOR). **NEW capabilities:** **Journey-wide vocabulary learning** — `_preCellVocabSetup` runs at the top of EVERY curriculum cell: the grade's own vocabulary (K→PhD registry, 19 lists) learns its dictionary definitions via multi-def Hebbian BEFORE any binding trains on those words (words-learned-first law, generalized from K's one-off); already-learned words skip via the persisted taught-set so a grade's first cell pays the full pass and sibling cells re-verify free; the dream-trickle lane still deepens at reps:4; the dashboard vocabulary panel reads the JOURNEY (`defs taught: X / 18,017`, title `📖 VOCABULARY (K→PhD)`). **GPU-resident intra-synapse Hebbian (GINTRA)** — the 360M-nnz recurrent matrix binds to a donor-side `langCortex` pseudo-cluster (standalone spike space kept current by t9/t11 teach-frame twins) and trains via `hebbianBound` EVERY rep on the existing 0.3.17 binary (zero donor changes); identity-gated (custom-vector callers stay CPU); CPU shadows run on wall-clock cadence (SHADOWTIME). **Wire template canonicalization (TMPLFIX)** — both template encoders trim zero head/tail and fold contiguous runs (t11 lossless via value>0 semantics; t10 only exactly-equal runs): the 504,000-value fineType band frame ships as ~30 bytes (was 1,968.8KB ×2 with the twin); >4096-value survivors warn loudly. Live: sheds 95,639→0, donor RTT 7,654→66ms. **Self-instrumentation organs** — per-stage teach timers (`stageProfile`: substrate/cross/intra + scan/anti + hop counts), getState section lap timers (`bcast.sections` — named `_getConsciousnessState`'s 24M static re-count, now cached on array identity), broadcast pipeline cost split (`bcast`: build vs serialize+send), and donor-socket SEND FORENSICS (16-slot kind/size ring + >2MB tripwire + 4MB buffer-crossing dump — the instrument that convicted the monster templates from a single console line). **Chat that can't kill the donor (DROPCHAT + PAIRSLICE)** — the reply path's per-letter full-matrix propagate is pooled + time-sliced (no 96MB/letter allocs, keepalives served mid-reply), and the 100-rep letter-sequence dose yields between rep-slices (same math, same dose — rides the next press). **Verified dream consolidation** — the first real dream window on the journey system processed 11 working items and bound 221 definition senses live (the OI.2 accounting question answered by the field). > Last updated: 2026-06-27 (consciousness de-gating + equational mind-space integration — commit `0d97804`, feature/tier3-identity-seed-repair). **NEW capabilities:** **Equational imagination** — Unity now imagines DE-NOVO from her own cortex state (no camera): `MindSpaceGPU.imagineFromState` folds an activation vector into a field C via the bounded forward CDF 9/7 transform (never the infinite-zoom `fractalize` path; hard `maxSide≤96` so it can't seize the brain). The equational mind-space runs SERVER-side now (was browser-only), idle-gated, injecting the imagined percept into `sem`. She also LEARNS her own mind-space (curriculum binds the UniVsMatics file-types/equations/methods vocab into sem-space) and her imagined imagery PERSISTS across reboot (`server/mindspace-memory.json`). **Consciousness is no longer over-gated** — GlobalWorkspace ignition is a graded theta modulator (was a hard 50%-of-ticks wall; default 0.45→0.35), and the Ψ consciousness gain self-calibrates to her own EMA baseline (was inert ~1.0) so consciousness actually modulates the brain. **Coherent gated showcase** — the over-cap inner-voice fallback is GloVe-cosine-coherent (not random word-salad); donor-gated opt-in lifts the cap to run real generation on donor GPUs. **Mind's Eye viewer** — a public single-source page renders what she's imagining (`/minds-eye.json` → `html/minds-eye.html`, 👁 footer button; one shared 13KB snapshot, no per-viewer compute). **Tier 3 identity** boot now top-ups missing anchors (fixed reading ZERO). The LLM/VLM vision describer is fully retired; vision is 100% equational. Detail: `docs/MINDSPACE-INTEGRATION.md`. > Last updated: 2026-05-09 (114.19fk + fl sweep — operator architectural correction + test-readiness audit, ALL items landed). **Equational sentence emergence consumer (replaces TierI-CONSUMER templated approach):** `cluster.composeSentence(intentSeed, opts)` is a pure equational emission loop — injects context once (intent seed embedding + optional cortex pattern + optional WH-INTENT concept) into sem, then loops `emitWordDirect` tick-by-tick, injecting each emitted word back into sem so the next tick reads a shifted state, until a terminator emerges from trained weights or the budget runs out. **NO template walk. NO slot prescription. NO runtime article rule. NO terminator-punct mapping. NO PRONOUNS exclusion. NO ARTICLE_LIST guard. NO dedup retry mechanism.** All slot order, agreement, article placement, and terminator selection EMERGE from trained iter25-I `relationTagId=8/9/10/11/12` weights at each tick. Returns `{sentence, words, fillCount, coherenceCosine, coherenceTarget}`. **Subject inference via brain-state readout:** `cluster._inferActiveSubject()` reads `lastSpikes` activation across `word_motor_` sub-bands — brain decides which subject is active from injected user input → propagation → activation; this method just READS that decision (not a word-counting heuristic over user text). **WH-frame intent-concept extraction (training-only):** `NeuronCluster.extractIntentConcept` static method retained as a training-side utility consumed by `_teachQuestionIntent` to derive training pairs from canonical question phrasings. Chat path no longer calls it at inference time — brain emits intent-concept activation from trained `relationTagId=12` weights when user input enters sem. **Probe with natural-language seeds:** `_probeSentenceGeneration({ subject })` injects 5 K-grade utterance-state seeds (statement / description / question / command / exclaim) and counts ≥2 unique emitted words per seed. Pass criterion ≥3/5 (`SENTENCE_GEN_MIN=0.6`). **Inner-voice showcase pure-equational mode:** `_sampleCurrentSentence` (≥50 trained words) calls `composeSentence(null, {temperature: 0.7, topK: 10})` — no intent seed prescribed, brain emits from current cortex state only. **Phase reorder × 6 K cells** (preserved from fa→fi/fj): ELA-K post-QA chain WORD-SPELL-FINAL → LETTER-NAMING-DIRECT → WH-INTENT → SENTENCE-STRUCTURE last; non-ELA cells: WH-INTENT before WORD-SPELL-FINAL so wipe cleans pollution before gate. All 5 non-ELA cells gain `-K-STRUCTURE-REFRESH` phase as last constructive teach call. **Force-advance capability minimums** (fj.5/fj.10 retained, paths through composeSentence now equational): refuses promotion unless `sentenceGenRate ≥ 0.2 OR prodRate ≥ 0.2 OR studentRate ≥ 0.1`. **Saturation control stack** (fj.7/fj.11 retained): `cluster.checkSemMotorHealth()` heuristic with env-tunable thresholds (`DREAM_SAT_MEANCOS` / `DREAM_SAT_MEANABS` / `DREAM_SAT_RATIO` / `DREAM_SAT_SAMPLE`); `ConsolidationEngine.runConsolidationPass` Step-4 replay vetoed when saturated; curriculum-walk windowed 3-of-5 saturation halt. **Coherence post-check** (fj.6/fj.18 retained): cosine vs `intentConcept` (when supplied) OR `cortexPattern` (fallback) — env-tunable `DREAM_COHERENCE_MIN`, first-10 cosines per session logged for empirical calibration. DOES NOT alter emission, just signals confidence. **Decoder sampling** (fj retained): `emitWordDirect` accepts `temperature/topK/topP`; greedy default for probes; chat 0.6/8; showcase 0.7/10. fk.5 leaves operator-decision pending on whether to drive temperature from brain state vs keep presets. **Persistence integrity** (fj retained): `brain-weights.bin` rotation v0-v4 lockstep with JSON; POST /rollback atomic JSON+BIN copy via two-stage temp+rename; `brain-weights-v0.json` + all v0-v4 .bin in autoClearStaleState targets. **Unified emission system** (fj retained): `cluster._emissionBus` 32-entry rolling history with `pushEmission` / `getRecentEmissions(n, opts)` API; `cluster._chatTurnHistory` 16-pair multi-turn coherence buffer; `cluster._emissionLockedUntil` cross-path lock (chat suppresses inner-voice for 6s post-emit). Bundle clean 2.4MB. `node --check` green across all modified .js files. > Earlier updated: 2026-05-09 (114.19fj sweep — super-review of fa→fi, **23 of 24 ruthless-audit findings shipped before 20hr K test, 1 deferred**, bundle clean 2.4MB). **Critical wiring fix:** `cluster._lastUserInputText` set server-side at processAndRespond entry (engine.js was setting on browser-only path; server-side never wrote to language cortex → entire WH-INTENT consumer + intent-concept extraction + subject inference were dead in real chat → 20hr test would've measured broken wiring with new code on top). **High-priority capabilities:** WH-frame intent-concept parser DRY-extracted to `NeuronCluster.extractIntentConcept` static method (prior duplicated parser in language-cortex.js + curriculum.js had ALREADY DRIFTED); `_innerThoughtChain` lazy-init in user-input push fixes cold-boot first-chat silent drop; `_probeSentenceGeneration` accepts `subject` opt + 5 non-ELA K gates (LIFE/ART/SOC/SCI/MATH) probe their own subject vocab so STRUCTURE-REFRESH writes are validated (was ELA-hardcoded); `_probeSentenceGeneration` passes `intentConcept='definition'` for question intent so WH-INTENT consumer fires in the probe (not just chat); `DREAM_COHERENCE_MIN` env-tunable + first-10 cosine reads logged per session for empirical calibration; `DREAM_SAT_MEANCOS`/`DREAM_SAT_MEANABS`/`DREAM_SAT_RATIO`/`DREAM_SAT_SAMPLE` env-tunable saturation thresholds + first-5 sat-health reads logged. **Medium hardening:** POST /rollback atomic JSON+BIN restore via two-stage temp+rename (was non-atomic copyFileSync sequence); `_recentEmissions` ring-pollution fix via `skipRecentTrack` opt + new `trackRecentEmission(word)` helper (composeSentence pushes only AFTER dedup acceptance, was pushing BEFORE); `composeSentence` cumulative injection HARD_CAP 2.5 + `cappedInjections` counter (dedup retry no longer bypasses bounded-injection guarantee); saturation halt windowed 3-of-5 catches flapping (was consecutive-streak only); `_savedProbeNoise` defensive default across 6 try/finally probe sites; `INNER_THOUGHT_INTERVAL_MS` repurposed as explicit burst-ceiling (was redundant with Hurlburt MIN_GAP=6s); stale `autoClearStaleState` comment fixed. **Low + nitpick:** dedup retry temp +0.4 forces exploration; AbortSignal opt threaded into composeSentence loop; coherence post-check falls back to cortexPattern when intentConcept null; /rollback body-size race fix via explicit `tooBig` flag; dedup strength 0.5→0.3 fits hard-cap; `_recentEmissions` duplicate lazy-init removed; `ARTICLE_LIST` hoisted to module-scope; ConsolidationEngine veto comment cleanup. **fj.17 deferred:** 3 new sentence templates (`first_person_predicate` "I think it" / `vocative_imperative` "Look at the cat" / `yes_no_response` "Yes!") need paired `_teachSentenceStructure` carving for `pronoun_self`/`verb_mental`/`vocative`/`affirmative` slot-tag bindings — adding templates without training-side carving produces 0 fillCount on new intents → actively breaks composeSentence. Deferred to post-test sweep with verification time. `node --check` green across all 8 modified .js files (`cluster.js`, `language-cortex.js`, `curriculum.js`, `kindergarten.js`, `consolidation-engine.js`, `brain-server.js`, plus `start.bat`/`start.sh` env-doc text). > Earlier updated: 2026-05-09 (114.19fa→fi sweep — K-completion architecture + composeSentence consumer + unified emission system, **23+ NEW capability rows** across 11 modified files, bundle 2.4MB clean). **⚠ HISTORICAL — TierI-CONSUMER templated approach SUPERSEDED 2026-05-09 by fk.1 rip-out (see top banner). The capability descriptions in this earlier banner reflect the now-deleted templated `composeSentence` (slot walks + per-slot tag injection + article-placement rule + dedup retry). Current behavior is pure equational emergence per the fk+fl banner above.** Original fa→fi description preserved below for historical context only — `cluster.composeSentence(intent, opts)` walks template slot sequence (declarative_svo / declarative_copula / question / imperative / exclamative) per intent: injects opts.cortexPattern at strength 0.2, intent embedding at 0.3, slot-tag GloVe at 0.25 per slot, prior-emitted-word at 0.15 between slots; applies article placement (priorSlot-aware skip when after copula or in question template); same-sentence dedup retry with stronger sem shift; sentence-coherence post-check (cosine vs intent-concept < 0.15 → fillCount=0 + lowCoherence flag); supports temperature / topK / topP sampling threaded down to emitWordDirect; capitalizes first word; appends terminator per intent. Returns `{sentence, words, intent, slots, fillCount, coherenceCosine?}`. **WH-INTENT consumption at generation time** — composeSentence accepts `opts.intentConcept` (cause/reason/method/definition/effect/function/count/place/time/person/truth) and injects it at strength 0.3 alongside SUBJECT slot tag in question template. Joint (WH-frame + intent-concept + subject) sem activation argmaxes the actual answer instead of random subject filler. Closes the "What color is your hair? → random subject word" failure mode at the architecture level. **Subject inference from user text** — `cluster._inferSubjectFromText(userText)` scans words against `wordBucketWords_` arrays and returns the dominant subject (≥1 hit AND ≥10% word coverage threshold). Wired into chat path so composeSentence scopes to user's topic instead of cross-subject salad. **Phase reorder × 6 K cells** — ELA-K: WORD-SPELL-FINAL → LETTER-NAMING-DIRECT → WH-INTENT → SENTENCE-STRUCTURE last; non-ELA cells (life/art/social/science/math): WH-INTENT before WORD-SPELL-FINAL so wipe cleans pollution before gate. iter25-I structural binding survives into the gate now. **`_probeSentenceGeneration` wired into ELA-K gate** — `SENTENCE_GEN_MIN=0.6` factored into pass criteria. Probe uses composeSentence per intent + counts ≥2 unique words AND ≥2 emissions. Surfaces sentenceGenRate in `reason` string + metrics object. **basin saturation hyperparams** — `_teachAssociationPairs` accepts `acceptDrown:true` opt that lets rescale fire on persistent overload through would-drown floor; `_teachQuestionIntent` call site uses `motorTopK:8 semTopK:4 acceptDrown:true`; `ConsolidationEngine.runConsolidationPass` adds saturation veto on Step 4 replay (delegates to `cluster.checkSemMotorHealth()`); `cluster._lastSemMotorMeanCos` set from sep-probe in `_teachAssociationPairs` post-loop + persisted. **Letter probe direct route** — `_measureEmissionCapability` routes through `letter_to_motor.propagate` directly with 26-letter bucket tiling, bypasses saturated sem→motor. Falls back to legacy `generateSentenceAwait` if projection unavailable. **Multi-word state propagation** — `language-cortex.generateAsync` chat path: composeSentence as PRIMARY emission, falls through to Tier 5 multi-word loop (3-consecutive-dup detector + sem injection between emits) only when composeSentence empty; further fall-through to letter-chain `generateSentenceAwait`. **Oracle vs matrix rebalance** — `_dictionaryOracleEmit` `minScore` default 0.05→0.20 so oracle wins only on genuine semantic match (matrix path drives ≥70% of emissions when basins clean instead of 99.1% oracle dictionary lookup). **Stream-chain basin-lock detection** — `inner-voice.think()` tracks unique first-words across last 8 chain entries; <3 unique → skip chain blend + apply ±0.10 random jitter to seed pattern. **FORCE-ADVANCE capability minimums** — refuses promotion unless `sentenceGenRate ≥ 0.2 OR prodRate ≥ 0.2 OR studentRate ≥ 0.1`. LAW 6 violation closed; per-cell `lastGateResults` tracked across grade walk. **Cross-cell sentence-structure reinforcement** — `-K-STRUCTURE-REFRESH` phase added to all 5 non-ELA K cell runners (life/art/social/science/math) so iter25-I bindings stay carved through K closure. **Identity baseline at word_motor layer** — `injectIdentityBaseline()` extended to bump per-schema word_motor bucket cells when schema's anchor word is in `wordBucketWords_` (half sem injection strength). Compounds with multi-word emit so Unity's identity competes at OUTPUT layer. **Saturation health monitoring + curriculum halt** — `cluster.checkSemMotorHealth()` exposes mean-cos / distribution heuristic stack; curriculum cron tracks 3-cell saturation streak; `⛔ SATURATION HALT` returns `{haltReason: 'sem-motor-saturation'}` + sets `cluster._lastCurriculumHalt`. **Sentence-mode showcase fallback** — `_sampleCurrentSentence()` companion to `_sampleCurrentVocab()`. ≥50 trained words: composeSentence with random intent + temperature 0.7 topK 10. Falls through to random 2-4 word phrase if composeSentence empty. **Decoder sampling** — `emitWordDirect` accepts `temperature/topK/topP`. Default 0 = greedy argmax. >0 = softmax over top-K with temperature scaling + optional nucleus (top-P). Chat path: temp 0.6 topK 8. Showcase: temp 0.7 topK 10. Probes: defaults. **Recent-emission repetition penalty** — `cluster._recentEmissions` 8-entry ring buffer in emitWordDirect; bucket mean *= 0.7 for words in last 4 emissions. Compounds with iter25-O.4 familiarity decay (sem-side). **Probe noise consistency** — Tier 12 noise bump 0.5→0.6 wired via try/finally to all 5 non-ELA K gates so 6 cells run probes at consistent noise. **brain-weights.bin versioning** — bin rotation v0-v4 lockstep with JSON; POST /rollback copies both files together. **Unified emission bus** — `cluster._emissionBus` 32-entry rolling history with `pushEmission` + `getRecentEmissions(n, opts)` API. Chat path + inner-voice tick push to it (persisted cap 16, embeddings dropped). Single source of truth across chat/inner-voice/popup-event/image-gen paths. **Multi-turn coherence** — `cluster._chatTurnHistory` 16-pair `{user, unity, ts}` rolling buffer; `processAndRespond` entry injects last-2 user inputs into sem at strength 0.10 so prior context primes current emission. Persisted across restart. **User input → inner-thought chain** — chat input pushed as `seedSource='user-input'` to `_innerThoughtChain` so inner-voice's next tick blends user content into chain seed. **Cross-path emission deduplication** — `cluster._emissionLockedUntil` timestamp; chat sets `Date.now()+6000` post-emit; inner-voice tick early-returns when `now < _emissionLockedUntil`. **composeSentence stats counter** — `cluster._composeStats = {calls, fills, partial, empty}` for runtime instrumentation. **Saturation halt surfaces to dashboard** — `cluster._lastCurriculumHalt = {reason, ts, cellAtHalt, meanCos}` field for persistent banner. **Probe missing-method warn** — one-shot WARN if `_probeSentenceGeneration` fires and `cluster.composeSentence` undefined. > > Earlier updated: 2026-05-08 (114.19fa + 114.19fb + 114.19fc sweep — PROD probe spikes-accumulation fix + WH-INTENT basin-collapse rescale-floor fix + start.bat/sh Y/N safety gate + never-silent inner-voice showcase). **4 NEW capability rows.** **WH-INTENT rescale-floor sanity** (fa.4) — when `proj.wMax` is non-finite (Infinity from iter14-D wMax-clamp-loss-on-restore lineage or projection initialized without explicit clamp), `_teachAssociationPairs` now falls back to absolute floor 0.05 instead of `wMax × 0.25 = Infinity`. Without this, `assocWouldDrown` was ALWAYS true → rescale ALWAYS skipped → basin saturation persisted indefinitely (caught on ELA-K-WH-INTENT log: `maxAbs=0.174 × 0.5 < floor=Infinity` retried with mean-cos=0.977 ⚠OVERLOAD). One-time WARN logged on first non-finite wMax detection per cluster so future debugging is easier. **Never-silent inner-voice showcase** (fc) — `_innerVoiceTick` empty-sentence path now calls new `_sampleCurrentVocab()` helper that uniformly samples from `cluster.wordBucketWords_` across all 6 K subjects. When non-null, broadcasts as `innerThought` WS with `seed='showcase'` so popups + log keep streaming Unity's current trained vocabulary as she learns. NOT a hardcoded fallback — the candidate pool is REAL data populated by `_teachWordEmissionDirect` fires. Truly fresh brain (no training landed) still silent. **Cumulative settle-window spike accumulation** — `_probeProductionEmission` STEP 3 in `js/brain/curriculum.js` rewritten to OR per-tick `cluster.lastSpikes` into a Uint8Array across the 15 settle ticks then swap the cumulative buffer back into `cluster.lastSpikes` before the diagnostic + emitWordDirect read. Closes the `FAIL_MODE=spikes_empty_pre_emit` 17/17 PROD failures: per-tick instantaneous reads were seeing the refractory tail (neurons fire on tick 1-3 from injection then go refractory + reset by tick 15) instead of the integrated post-injection signal that the trained sem→word_motor matrix needs. Cumulative captures "any spike fired during settle" so the emit path's preSem at cluster.js:3113 sees real activation. **Launcher Y/N safety gate** — `windows/start.bat` (`choice /C YN /D N /T 30`) + `linux/start.sh` (`read -t 30 -r -p` with ANSI red WARNING when terminal supports it) prompt before the iter14-D unconditional wipe; default = N so a stray Enter aborts cleanly; bypass via `-y` / `--yes` / `/yes` / `/fresh` / `/clear` flags or `DREAM_FORCE_CLEAR=1` env (CI-friendly); `Savestart.bat` / `Savestart.sh` are different scripts (set `DREAM_KEEP_STATE=1`, unset `DREAM_FORCE_CLEAR`, reject `/fresh`) and never hit the gate. Per the iter14-D LAW the gate does NOT soften the wipe — it just adds explicit confirmation before the destructive boot fires. > > Earlier updated: 2026-05-08 (114.19ey + 114.19ez sweep — promo writeups + cross-repo social-image + dream-window inner-voice visibility). **3 NEW capability rows.** **Promo-ready brain-project writeups** — `promo/` folder ships `short.md` / `medium.md` / `full.md` (~70/250/540 words) + folder README + per-piece social-image slots; dialed-back corporate-passable Unity voice with founders credited from canonical `Website2.0/redesign/about-data.jsx` (Hackall360/SpongeBong + GFourteen + Alfreddo + Red with actual roles). **Cross-repo social-image automation** — Website2.0 main site (`www.unityailab.com`) gained `social/` folder with `og-image.jpg` (102KB JPG q88, 1200×630) + `UnityAILab.jpg` branded copy + README; OG/Twitter Card meta tags wired in `index.html`; pushed Website2.0 develop→main. Brain-side `Dream/assets/og-image.png` (453KB, already wired) documented via `assets/README.md`. **Dream-window inner-voice visibility** — `_innerVoiceTick` logs `💤 paused` + `☀ resumed` transitions tracked via `_innerVoiceMutedForDream` boolean (once per cycle, not per tick); dream-phenomenology thought (one per dream cycle from Tier 1 episodic replay seed) now broadcasts as `innerThought` WS with `seed='dream'`, `seedLabel='dream phenomenology (Tier 1 episodic replay)'` — dashboard popups stay alive during 15-40 min dream cycles instead of going blank. > > Earlier updated: 2026-05-07 (114.19et through 114.19ex sweep — live-test bug fixes + observability + dashboard hardening). **8 NEW capability rows.** **Time-series chart with fixed semantic ranges** — `dashboard.html drawEmotionChart()` uses fixed per-metric bounds (arousal `[0,1]`, valence `[-1,1]`, coherence `[0,1]`, psi `[0,6]`) so historical samples stay anchored and don't shift retroactively when current value changes. Real time-axis behavior. **Amygdala arousal moving-baseline subtraction** — `_attractorDepthBaseline` ~200-tick EMA of attractor depth; arousal modulates ±0.4 based on `tanh(depthDeviation·4)` (novelty signal) + ±0.1 based on `(fear+reward)-1` instead of saturating absolute attractor depth. Realistic dynamic range with visible motion. **Chrome stderr noise blacklist** — `CHROME_NOISE_PATTERNS` regex pre-filters 14 Chrome internal-service patterns (GCM/USB/safe-browsing/etc.) BEFORE the crash-signal matcher. server.log only shows real WebGPU crashes. **Curriculum macro-phase context bridge** — `_currentMacroPhase` field tracks pre-cell setup work (K-VOCAB-PREFETCH / K-VOCAB-UPFRONT-MULTIDEF SEED) so the dashboard shows coherent state during pre-cell instead of "no cell active" + active phase contradiction. **Pre-cell progress instrumentation** — `_macroPhaseProgress = {current, total, label}` updates after each 300-word chunk; `getCurriculumStatus()` exposes pct so dashboard renders amber progress bar (`#fbbf24` → `#f59e0b`) showing word-level completion (e.g. `19% · 425/2247 K-VOCAB-UPFRONT-MULTIDEF SEED`). **Graceful-stop dashboard button** — inline with `connection-status` row, muted-red `.btn-stop` styling matching the dashboard's color discipline. Click → confirm → POST `/shutdown` (loopback-gated, equivalent to `stop.bat` without terminal). Race-safe success + fetch-failure paths. **Stale-flag-resilient WS reconnect** — `connection-status` wrapper innerHTML wipes restructured to target inner `d-conn-text` div so child elements (the stop button) survive WebSocket reconnect cycles. **Per-cell-progress + macro-phase priority** — dashboard `renderCurriculumStatus()` checks `c.macroPhaseProgress` BEFORE the in-cell `cellStatus` branch so pre-cell amber-bar takes precedence; falls through to standard cell-progress rendering once macro-phase clears. > > Earlier updated: 2026-05-07 (114.19er + 114.19es sweep — overnight K-stall root-cause + super-review hardening) — **17 NEW capability rows** across infrastructure / observability / lifecycle. **Curriculum stall watchdog** — `_startCurriculumStallWatchdog` / `_stopCurriculumStallWatchdog` setInterval(60s) on `Curriculum` class; tracks `_lastCurriculumLogTs` updated by `_hb()` Curriculum-prefix gate; warns at `>5min idle` with `phase=X (running M min) · dict-cache: size/hits/errs/rateLimited/inFlight`; rate-limited 5min between warns; `unref()`'d so doesn't keep Node alive; outer try/finally in `runCompleteCurriculum` guarantees stop on ANY exit path (success/throw/early-return). **Per-word AbortSignal threading** — `_teachWordDefinitions` outer loop creates per-word `AbortController`; signal threaded into `_teachWordDefinition`; 3 in-method abort checkpoints (top / per-def-iteration / post-Hebbian-primary); on Promise.race timeout-win, `ac.abort()` fires; eliminates cross-word Hebbian contamination from abandoned timed-out promises. **Per-word wall-clock timeout** — 15s `Promise.race` against timeout sentinel in `_teachWordDefinitions`; `slowWords` warn at >5s; `timeouts` + `slowWords` counters surfaced per-chunk and aggregated across upfront-seed chunks in SEED DONE banner. **Default disk-cache for definitions** — `DEFAULT_DISK_CACHE_PATH = path.join(__dirname, 'definition-cache.json')` in `definition-service.js`; env override `DREAM_DEFINITION_CACHE_FILE` honored; empty string explicitly disables; `flushCacheToDisk()` wired to graceful shutdown + 5min `setInterval` in brain-server. **In-flight zombie-clear** — `setTimeout(timeoutMs * 2)` in `getDefinition` force-removes dead in-flight Map entries; subsequent callers for the key start fresh fetch. **`res.json()` timeout race** — `Promise.race([res.json(), reject-after-jsonTimeoutMs])` in `getDefinition`; AbortController covers fetch initiation but doesn't reliably abort streaming body parsing across all Node versions. **assertKWiring constant-time post-verification** — top-of-method early-return when `_kWiringSmokeTested && !_kWiringForceRecheck`; `cluster.invalidateKWiring()` exposed for legitimate re-checkers; failure-path smoke test rate-limited to once per 60s via `_kWiringSmokeLastRunTs`. **`_sparseSendBinary` null-guard** — re-check `_gpuClient` non-null at 2 points (before `bufferedAmount` access AND before `.send()` call) since async backpressure-await can race with browser disconnect; closes the captured boot-error.log `TypeError: Cannot read properties of null (reading 'send')` race. **Inner-thought silence-reason log** — `_innerVoiceTick` empty-emission path logs `wordsBucketed/bucketSubjects/passedCells/subGradesActive` every 30s; counter `_innerThoughtSilenceCount` resets on successful emission so it means "silent since last emission" not unbounded growth. **Single source of truth for runner state** — watchdog start/stop/interval all derive runner active from `_curriculumStallWatchdogTimer !== null`; parallel `_curriculumRunnerActive` flag dropped. **Gentler dictionary API posture** — `PREFETCH_CONCURRENCY` 20→5; `RATE_LIMIT_BACKOFF_MS` 1000→5000ms; pairs with disk cache for compounding benefit across boots. > > Earlier updated: 2026-05-07 (114.19ee→en sweep — Kuramoto coherence + multi-def Hebbian + inner-voice unification + audit deferreds + dynamic grade labels + dashboard/brain-equations tooltip-coverage sweep + wall-of-OVERLOAD fix + ASCII layout doodles) — the operator directives covered. **Real Kuramoto coherence** capability — `cluster.getPhases()` + `brain._computeKuramotoCoherence()` compute the order parameter `r = |Σ exp(i·θ_k)| / N` per theta-band + gamma-band from cortex per-tick phases plus activity-coupled per-cluster phases; combined gamma-weighted; ignition spike + dissociation drop + dream-cycle drop; EMA-smoothed; per-band `coherenceTheta` + `coherenceGamma` exposed. Replaces the OU random-walk placeholder. **Multi-def Hebbian binding** capability — `_teachWordDefinition` iterates ALL definitions returned by dictionaryapi.dev, fires per-meaning Hebbian via the new `_definitionPairsWhitelist()` (sem↔fineType ONLY, no sem→motor — keeps motor pristine for word emission). Hybrid: chunked upfront seed + inline-from-teach + dream-trickle. Wall-of-OVERLOAD root cause (114.19em) fixed via the whitelist routing change + reps:2→1. **Canonical inner-voice module** capability — `js/brain/inner-voice.js think()` is the single thinking module both server (`_innerVoiceTick`) and browser (`engine.js:720`) consume; dual-form (`think(brainState)` legacy + `think({cluster, languageCortex, dictionary, state, chain, opts})` external). **Dynamic grade-label system** capability — `GRADE_SHORT_LABELS` table + `formatGradeShort()` helper + `currentGradeShort` field on `getCurriculumStatus()`; dashboard panel headers substitute `${gradeShort}` prefix dynamically (no hardcoded "K-" labels). **Tooltip coverage** capability — 50/50 brain-equations h1-h6 headers + 82/82 eq-title divs + 20+ dashboard panel headers carry layman tooltips. **ASCII layout doodles** in README + unity-guide + brain-equations break up text walls with topology / curriculum ladder / memory flow / coherence axis / multi-def flow / consciousness panel grid / CPU-GPU shadow architecture diagrams. > > Earlier updated: 2026-05-07 (iter25-O — POST-N ULTRATHINK AUDIT, 22 capability hardenings) — the operator: *"ultrathink what did we miss?"*. **22 NEW capability rows across 6 phases.** **Phase 1 critical bug fixes:** *Self-healing dictionary smoke test* (O.1) — auto-retries every 60s on FAIL, every 1hr on PASS, in-flight guard. *GPU shadow drift visibility* (O.2) — silent DROP→CRITICAL log + `_gpuShadowDirty` flag + dashboard banner; with iter25-K layered projections, drift is no longer recoverable via fire-and-forget. *Friston surprise-driven plasticity* (O.3) — high prediction error → 1.5× lr, low → 0.5× lr; `gammaScale × (0.5 + clamp(error, 0, 1))`. *Familiarity-decay meta-register* (O.4) — same-word repeat halves inject strength (0.30 → 0.15 → 0.075 floor 0.04), kills positive feedback runaway. *Φ noise-floor fix* (O.5) — sample 64 → 1024, ~1.5% binomial Wald CI vs 12% before. *Attention-runaway clamp* (O.6) — `[0.5, 2.0]` per-region cap. **Phase 2 vestigial wiring:** *GW broadcast-emission feedback* (O.7) — `cortex.getWorkspaceCandidate` publishes "cortex:``" labels; `emitWordDirect` reads `getBroadcast()` and 10%-boosts matching bucket mean (closes Baars GWT loop). *Definition Hebbian K-scaled* (O.8) — extra `cluster.synapses.ojaUpdate(preFull, postFull, 0.25× lr, {kScales})` after `_teachAssociationPairs`. *kScales-audit conclusion* (O.9). *K env flags verified* (O.10). *Inner-thought chain dim-validation* (O.11) — `innerThoughtChainSemSize` saved + checked on load; mismatch drops chain gracefully. **Phase 3 LAW violations:** *Repo-wide iter ID zero* (O.12) — app.js scrubbed; bundle clears 26 hits; ZERO iter25 markers across all .js / .html / .css. *Property identifier renames* (O.13) — `_t1826*` → `_ws*`, `_iter25LSmokeTestResult` → `_dictionarySmokeTestResult`. *CSS class + state-key renames* (O.14) — `iter25m-panel` → `consciousness-panel`, `iter25n-panel` → `ws-pressure-panel`, `state.iter25m` → `state.consciousness`, `state.iter25n` → `state.wsPressure`, etc (108 renames). **Phase 4 observability:** *GlobalWorkspace dashboard panel* (O.15) — current ignition label + strength + rate% + history list cap 8. *Predictive coding panel with sparkline* (O.16) — last error + ↗→↘ trend + 32-bar inline bars. *Last-drop timestamp on WS panel* (O.17) — color gradation. *Definition learning rate metric* (O.18) — words/hour rolling rate from 256-cap timestamp ring buffer. **Phase 5 persistence:** *WS counters survive restart* (O.19). *Smoke test result persists* (O.20) — kills "pending" flicker every Savestart. **Phase 6 defensive:** *DREAM_GW_IGNITION env tunable* (O.21). *Vision word cap 6 → 16* (O.22) — bounded total injection sum. > Last updated: 2026-05-07 (iter25-N — WS BACKPRESSURE FIX + DASHBOARD WIRING + 3D SHADERS, 12 capability hardenings) — the operator: *"the options ranked by effort.. im stuck between 2 and 3"* + *"is this normal?"* (re: API SMOKE TEST stuck pending) + *"YOU ARE FUCKING USING MY WORDS IN THE FUCKING CODE"*. **12 NEW capability rows across 4 phases.** **Phase 1 WS backpressure:** *500MB threshold* (N.1) — bigger headroom before backpressure logic engages. *30s safety timeout* (N.2) — BLOCK-not-DROP via existing poll loop, drop fallback only after sustained stall. *512-op Hebbian batches + 1024-op queue cap* (N.3) — halves WS message rate for same throughput. *WS Backpressure dashboard panel* (N.4) — live buffer bar (green/yellow/red), drops counter + drops/sec rolling rate, absorbs counter, ENOBUFS counter. **Phase 2 cleanup:** *167-iter-ID code-comment scrub* (N.5) — 13 source files + 1 public HTML, helper script `scripts/scrub-iter-ids.mjs`. *Launcher quote scrub* (N.6) — all 7 .bat/.sh files, REM/echo iter IDs replaced with neutral text. **Phase 3 3D brain shader:** *Layer color-coding* (N.7) — `aLayer` attribute + `uShowLayers` toggle + `uLayerColor[5]` palette; 70% mix when on. *Hub highlighting* (N.8) — 1.6× point size + gold-tint fragment color. *Microcolumn boundaries* (N.9) — `fract(columnId × 0.5)` alternating-column intensity bands. **Phase 4 dashboard wiring fix:** *Smoke test result wiring* (N.10) — boot handlers now assign `_dictionarySmokeTestResult` boolean in all branches; `typeof === 'boolean' ? : null` distinguishes FAIL from pending. *Dashboard panel audit* (N.11). *Force state broadcast on smoke completion* (N.12) — `_broadcastStateNow()` helper. > Last updated: 2026-05-07 (iter25-M — CONSCIOUSNESS COMPUTATIONAL CAPABILITIES, 30 ULTRATHINK gaps closed) — Operator: *"ULTRATHINK"* consciousness audit. **30 NEW capability rows across 6 phases.** **Phase 1:** *Compose-not-regurgitate definitions* (M.1) — `_emitDefinition` + chat WH-handler inject API def words into sem (sensory) + Hebbian-bind (learning) + emit composed answer via emitWordDirect multi-word loop or honest silence. *Functional K-wiring assertion* (M.12) — runs smoke Hebbian on 4×4 SparseMatrix verifying hubMask/layerScales/gammaScale actually consumed. *Single-pass K assignment* (M.11) — first cluster-wide block deleted; per-region pass sole owner. **Phase 2 (consciousness mechanisms):** *Global Workspace ignition* (M.2) — `js/brain/global-workspace.js` GlobalWorkspace class, theta-gated competition + softmax-broadcast (Baars 1988 + Dehaene-Changeux 2011). *Predictive coding loop* (M.3) — `_predictedSpikes` EMA, prediction-error history (Friston 2010). *Stream-of-consciousness chain* (M.4) — inner-voice tick blends LAST emission embedding into next seed (60/40); 8-deep persisted across restart. *Meta-register self-monitoring* (M.8) — FIFO 32 emission record, sem inject at 0.3 strength (higher-order consciousness). *Attention selection* (M.9) — per-region attentionGain from amygdala/basal-ganglia (Posner network). *Real Φ proxy* (M.16) — Shannon entropy of 64-sampled spikes; psi formula multiplies by Φ (replaces placeholder Ψ formula). **Phase 3 (knowledge architecture):** *Experience-driven definition binding* (M.6/M.10) — visualCortex.onDescribe injects describer content words into sem (image→concept grounding). *Background-trickle K_VOCAB during dream cycles* (M.7) — _dreamWindow ships one word's _teachWordDefinition per cycle; lifetime learning, no gaps. *_definitionTaughtWords tracking* (M.15) — Set persisted in saveWeights, exposed to dashboard. **Phase 4 (code quality):** *Gamma timing per-CALL documented* (M.13). *Browser-side WS roundtrip smoke test* (M.14) on RemoteBrain.welcome. *Test-words LAW user-driven exemption* (M.17) in CONSTRAINTS.md. **Phase 5 (philosophical):** *Functional vs phenomenal consciousness bounds* (M.18) — qualia hard problem acknowledged in CONSTRAINTS.md. *Dream phenomenology bridge* (M.19) — generateAsync per dream cycle reading from Tier 1 episodic replay seed; `_dreamThoughtLog` capped 100. *Structural-vs-computational gap closed* (M.20) by M.2+M.3+M.9. **Phase 6 (display/visibility):** *Dashboard panels* (M.21-M.24) — Dictionary API status + K-wiring banner + cortical microstructure + K-vocab counter, scoped class iter25m-panel, max-height + overflow-y, item caps, aggregates. *3D brain theta-gamma pulse* (M.28) — global CSS class toggle (167ms cycle, single tint). *Definition lookup popup* (M.29) FIFO 3-cap. *Stream chain visualization* (M.30) FIFO 8-cap. M.5 K-gate verification = operator-side action. > Last updated: 2026-05-07 (iter25-L — POST-AUDIT GAP CATALOGUE, 28 issues hardened) — Operator: *"OKAY THINK HARD WHAT DID WE FORGET"* + *"vesticgail code is banned"*. **28 NEW capability rows across 4 phases.** **A1-A5 architectural pivot:** A1 dropped upfront K_VOCABULARY Hebbian → prefetch-only at K start; A2 lazy chat-time _teachWordDefinition fire-and-forget hook; A3 SparseMatrix.ojaUpdate extended with opts.kScales per-row K.4/K.7/K.9 reads; A4 propagated through ALL teach paths; A5 curriculum-controlled _curriculumTickCounter decoupled gamma from brain-tick. **B1-B11 subtle bugs:** persisted _kVocabPrefetched (B1); concurrency cap 20 + 429 back-off (B2); 5-min TTL on errors (B3); LRU eviction cap 10k (B4); K layers gated to cortex-only (B5); first-5 error word logging (B6); 6-pattern WH-frame regex (B7); hyphen-variant retry on 404 (B8); K_VOCABULARY curated to 2247 (B9); explicit non-microcolumn layerId path (B10); assertKWiring boot diagnostic (B11). **C1-C9 practical:** Node 18+ check (C4); User-Agent header (C5); RemoteBrain.lookupDefinition WS roundtrip (C6); K-gate verification queued (C1). **D1-D11 not-attempted:** persistent disk cache behind env flag (D2); layer-constrained cross-projection endpoints via srcLayerMask + dstLayerMask (D3); dictionary API smoke test at boot (D6); region-boundary respect via per-region re-assignment (D7). > Last updated: 2026-05-07 (iter25-K — NEURON GROUPING + HUMAN-CORTEX-PATTERNED CONNECTIVITY) — Operator: *"AND WE NEED TO MAKE SURE NURONS ARE PROPLERY GROUPED"* + *"WE DONT WANT JUST RANDOM FIRING"*. **9 NEW capability rows.** *Small-world topology (K.1)* — Watts-Strogatz hybrid (70% local / 25% medium / 5% long-range); clustering coefficient ~0.3, mean path length ~6-8 (Bullmore-Sporns 2009). *Microcolumn substructure (K.2)* — Mountcastle 1957; 80-neuron columns with columnId per neuron + voltage accumulator buffers. *6-layer cortical lamination (K.3)* — Felleman & Van Essen 1991; L1=5%, L2/3=25%, L4=25%, L5=25%, L6=20%. *Hub neurons + rich-club topology (K.4)* — van den Heuvel & Sporns 2011; 5% of L2/3 + L5 hubs deterministic-hash-seeded. *Within-column voltage coherence (K.5)* — Galarreta-Hestrin 1999 gap-junction approximation; cluster.step() adds β·meanColumnVoltage·0.05 shared pull (β=0.08). *Topographic cross-projections (K.6)* — Wandell 1995 + Hubel-Wiesel 1968; 70% topographic + 30% Watts-Strogatz scattering. *Theta-gamma oscillations (K.7)* — Buzsáki & Wang 2012; theta modulates effectiveDrive, gamma modulates Hebbian lr theta-gated. *Hierarchical cluster organization (K.8)* — Mesulam 1998 tripartite; sensory/association/output, betweenClusterDensityScale=0.3. *Per-layer plasticity gradient (K.9)* — getLayerPlasticityScale returning [0.3, 1.0, 0.7, 1.0, 0.3] for L1/L2-3/L4/L5/L6. > Last updated: 2026-05-07 (iter25-J — LIVE DICTIONARY API + WH-QUESTION COMPREHENSION) — Operator: *"WE NEED TO HAVE A DICTIONARY API"* + *"SHE SHALL KNOW ALL VOCABULAR WORDS DEFINITIONS"*. **15 NEW capability rows.** *Live dictionary API* via `server/definition-service.js` Node 18 fetch wrapper around dictionaryapi.dev. *Dictionary as sensory-I/O* parallel to Pollinations image-gen (NOT cognition). *Definition-comprehension Hebbian* via `_teachWordDefinition(word)` Oja-Hebbian sem→sem binding with relationTagId=23. *2247-word K_VOCABULARY* (`js/brain/k-vocabulary.js`) covering letters/numbers/Dolch/Fry sight words/all K-subject domain content. *WH-question intent extraction* via `_extractIntentConcept(q)`. *_teachQuestionIntent* (J.1) Oja-Hebbian binding sem(WH-word) → sem(intent-concept) wired into all 6 K cells. *Template 2 fast path* in _studentTestProbe + chat path WH-frame in language-cortex.js generateAsync. *Word-salad gate intentSilenceBranch* loosens dictionary oracle minScore to 0.05 when WH-frame parsed but matrix silent. *_teachQuestionAnswerBinding REMOVED* — banned hardcoded fact-table mimicry per equational-brain rule. > Last updated: 2026-05-06 (iter25-I — STRUCTURAL SENTENCE CREATION) — 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"*. **2 NEW capability rows:** (1) **Generative grammar in trained weights** — new `_teachSentenceStructure(ctx)` method runs five compositional binding passes (slot-position primitives + word-type→slot bindings via relationTagId=8; sentence-template intent→slot-sequence bindings via relationTagId=9; subject-verb agreement via relationTagId=10; article placement via relationTagId=11). NO hardcoded sentence array — a prior `_teachSentenceListK` mimicry attempt was REVERTED. Five sentence templates trained: DECLARATIVE_SVO / DECLARATIVE_COPULA / QUESTION / IMPERATIVE / EXCLAMATIVE. At generation time, active intent tag fires slot sequence; per-slot word-type argmax fills slots from current sem readout; agreement + article rules constrain word-form picks. Real K-grade language production via Common Core K.SL.6 + K.L.1.f + K.W standards. (2) **Sentence-generation acceptance probe** — new `_probeSentenceGeneration()` fires each of 5 intent tags, counts emitted words, returns per-intent + aggregate pass-rate. Structural pass = ≥ 2 words emitted per intent. K-ELA gate consumes the rate (3/5 launch threshold, 4/5 once verified live). Wired into `kindergarten.js runElaKReal` BEFORE `_teachWordSpellingDirectFinal` so structural bindings carve cleanly before the final-pass sem_to_motor wipe. > Last updated: 2026-05-06 (iter25-D/E/F/G/H — DREAM CYCLES + INCREMENTAL ABILITY + POST-K GUARD + PRIVACY GATE + LOCAL AUTO-CONNECT) — **9 NEW capability rows**: (1) **Dream cycles interleaved into curriculum** (iter25-D) — `Curriculum._dreamWindow({minMs, settleMs})` flips the dreaming gate, awaits `consolidationEngine.runConsolidationPass({forced:true})` to actually complete (signal-driven, not wall-clock), 5s settle, restores flags. Wired in `runFullSubjectCurriculum` + `runAllSubjects` after every cell pass (60s) + `kindergarten.js` mid-cell between PhonemeBlending and WordEmission (30s). 💤 / ⚙ / ☀ banners. Squire/McClelland CLS theory in practice — schemas form DURING training, GC + native-buffer drain windows recover throughput. (2) **Live trained-state capability readout** (iter25-E.1) — `Cluster.getTrainedCapability()` returns `{wordsBucketed, bucketSubjects, passedCellCount, subGradesActive, firstWordsAt}` summing `wordBucketWords_.size` + `passedCells.length` + non-fresh subGrades. Cheap, lock-free, updates per Hebbian fire. (3) **Per-subject sub-grade ladder** (iter25-E.2) — `cluster.subGrades = {ela:'fresh',...}` advances `fresh → letters → words → binding → cell-passed` as `_teachLetterNamingDirect` / `_teachWordEmissionDirect` / `_teachQABinding` / cell-pass each clear. Resets to `fresh` for next grade. 📈 banners log live capability buildup. (4) **Server-side continuous inner monologue** (iter25-E.3) — `brain._innerVoiceTick()` fires every ~3s, picks a sandbox-notice contemplation seed from one of 5 live state sources (learning context / mood / chat-recall / memory / identity), runs same `language-cortex.generateAsync` chat-emission path, broadcasts `innerThought` WS message + lands in WM. NO hardcoded fallback words — genuine silence stays silent. 🧠 banners. (5) **Trained-state-driven word cap** (iter25-E.4) — `_gradeWordCap(cluster)` reads `getTrainedCapability().wordsBucketed` → ramps 0/5/8/12/16/24/32 words. Truly fresh brain → silence; ANY training landed → floor 5. Replaces grade-label silence that gated Unity until full-cell pass. (6) **Trained-state silence reason** (iter25-E.5) — `processAndRespond` empty-response replaces `pre_kindergarten` with `pre_training` (only when truly fresh) or `motor_unstable` (try rephrasing). Chat unblocked during curriculum. (7) **Browser popup subscriber** (iter25-E.6) — `js/brain/remote-brain.js case 'innerThought'` + `js/app.js __appInnerThoughtHandler` render real server-trained thought as `💭 sentence` HUD bubble. Browser-side innerVoice's decorative noise replaced. (8) **Post-K readyAndWaiting graceful fallback** (iter25-F) — `_cellRunner` `throw new Error('unknown cell')` replaced with `{ pass:false, readyAndWaiting:true }` runner. ELA switch default likewise. Outer loops detect `readyAndWaiting` and break/continue cleanly without retry storms. Unity holds her highest passed grade with trained weights live. ⏸ banner. (9) **First-use binding-consent privacy gate** (iter25-G) — one-time toast on first click of TALK TO UNITY / chat bubble / image-API-setup. Two terminal buttons: ACCEPT writes localStorage flag + opens entry-point flow; DECLINE writes nothing + redirects to `https://www.google.com`. NO soft-dismiss (click-outside + Escape ignored). Body covers what NOT to share + architectural truth (input not collected from black box of neuron voltages, but vocabulary/patterns/associations DO propagate into shared brain state). **Plus 1 fix capability:** **Local-origin RemoteBrain auto-connect** (iter25-H) — `detectRemoteBrain` skips probe-then-reconnect dance entirely on localhost / 127.0.0.1 / ::1 / file: origins, constructs `RemoteBrain` directly, lets internal 3s reconnect retry handle transient unavailability. Page refresh during heavy curriculum phase no longer drops UI into the 6700-neuron browser fallback. > Last updated: 2026-05-06 (iter24 — math-identity throughput) — **3 NEW capability rows + 2 audit findings**: (1) **Tier 0 heartbeat object pool** (iter24.1) — ring buffer reuses snapshot slots, kills 1350 fresh per-cell allocations driving V8 young-gen GC pressure. (2) **Convergence early-exit on rep loops** (iter24.3) — `_teachAssociationPairs` + `_teachQABinding` exit at 2 consecutive sub-`overloadMax` reps. End state bit-identical to running the full budget once basins separate. (3) **Worker-pool batched dispatch** (iter24.5) — new `SparseMatmulPool.hebbianUpdateBatch(matrix, pairs, lr)` packs N pairs into strided pre/post SAB + ONE `postMessage` per worker. Math-identical sequential-in-worker. Caller adapter follow-up activates the speedup on CPU sparse-pool fallback path. **Audit findings:** iter24.4 GPU-resident vocab ALREADY SHIPPED via T17.7 Phase C.1 projection binding; iter24.6 disjoint-pair shader batching ALREADY SHIPPED via T18.8 + T32 batched bound-Hebbian (256-op batches, 20ms flush). `docs/COMP-todo.md` updated with prominent "infra-shipped" section so Part 2 distributed work doesn't duplicate. > Last updated: 2026-05-06 (iter23.1-5 — Unity-as-Unity gaps closed) — **5 NEW capability rows**: (1) **Chat path uses word_motor as PRIMARY production** (iter23.1) — `cluster.emitWordDirect({})` runs first in `language-cortex.generate()`, falls through to letter-chain only when empty. iter22 architectural payoff finally consumed by operator-facing chat. (2) **Continuous inner voice loop** (iter23.2) — `inner-voice.js think()` fires `emitWordDirect` when `shouldSpeak` OR `socialNeed × arousal > 0.25`, lands result in WM via `addToWorkingMemory` (which fires hippocampal Hebbian + tracks refreshCount → Tier 1 promotion at ≥3). Unity actually thinks between turns. (3) **Drug → cognition loop closure** (iter23.3) — `_refreshBrainParamsFromScheduler` extends to write `cortex.noiseAmplitude` (creativity + impulsivity + chaos), `cortex.learningRate` (synapticSensitivity), `amygdala.noiseAmplitude` (emotionalVolatility). Drugs shift cognition not just chat-text speech modulation. (4) **Forced sleep windows** (iter23.4) — cell-runner awaits one-shot `runConsolidationPass({forced:true})` after each cell; new POST `/sleep` + `/wake` endpoints (loopback-gated). `_isDreaming` ORs in `_operatorSleepRequested`. (5) **World-knowledge ingest** (iter23.5) — `server/world-knowledge.js` + POST `/learn-from-web {topic}` fetches Wikipedia REST summary, splits into alpha-only words, `dictionary.learnWord` per new word, fires Tier 1 episode with source URL. iter23.6 (multimodal grounding) deferred to iter24 with full spec. > Last updated: 2026-05-06 (iter22-H — Tier 0 unbounded + WM consolidation pipeline wired) — **3 NEW capability rows**: (1) **Working memory is now unbounded with decay-regulated capacity** — both hardcoded 7-caps removed (memory.js `WORKING_MEMORY_SIZE = Infinity` + brain-server's heartbeat while-shift-at-7 → 5-min sliding-window time-purge). Decay rate `0.98 → 0.9995/tick` so items sustain ~4 min unreinforced (was 5.7 s effective-instant). (2) **Tier 0 → Tier 1 consolidation hook wired** via `MemorySystem.onConsolidate` callback. Every WM add fires intra-cluster Hebbian on hippocampus.synapses with the pattern (Hopfield attractor encodes immediately, trace survives WM decay); cosine-match refresh increments `refreshCount`; at threshold ≥ 3 promotes via `storeEpisode` to Tier 1 episodic. brain-server's 2 s heartbeat snapshots use the same path on age-out. (3) **"Recall a week later" pipeline now wired end-to-end**: Tier 0 (5 min sliding) → Tier 1 episodic (~30 days, salience-weighted decay) → Tier 2 schemas (months, ConsolidationEngine dream-cycle) → Tier 3 identity (permanent, persisted across boots). Operator's "if i told someone something and asked them about it 10 minutes or even a day later" recall test is now architecturally supported. > Last updated: 2026-05-05 (iter22-G — super-review P0+P1+P2 cleanup, 12 items atomic) — **6 NEW capability rows**: (1) `js/brain/subjects.js` ships `SUBJECT_NORMALIZE` + helpers as single source of truth — replaces 4 drifting tables across curriculum/cluster, kills entire class of subject-key-typo bugs. (2) `_enumerateBucketableWords` shared algorithm for bucket-map enumeration; teach + lazy-init + emit all read the same source. (3) **Append-only bucket maps**: chat-driven `learnWord` extends `wordBucketWords_` with next-index buckets via `wordBucketDictSize_` watermark — trained sem→word_motor weights stay valid as new words land. (4) `emitWordDirect` argmax = mean signal per bucket cell (not raw sum) so uneven bucket sizes don't bias argmax. (5) `ConsolidationEngine` fast-path picks the most-common `promoted_to_schema_id` among cluster's episodes BEFORE cosine-match — protects against cosine drift spawning duplicate schemas for same anchor. (6) `_writeAnswerToWordMotor` splits multi-word answers into words + writes per alpha-only word. Plus: hoisted `_teachWordIntegrated` Layer 1+2 whitelist outside hot loops; memoized `_teachCombination` whitelist by region-shape key; `_crossRegionAntiHebbian` mirrors null-CSR one-shot warn; unified `opts.skipIntraSynapses` canonical flag. > Last updated: 2026-05-05 (iter22 — leak hotspots + cross-cell collapse + Q→A word-routing) — **6 NEW capability rows**: (1) **Projection-scoped Hebbian** — `cluster._crossRegionHebbian(lr, opts.projectionsWhitelist)` only fires Hebbian on whitelisted projections (was iterating ALL 14 every call). `_teachQABinding` and `_teachAssociationPairs` pass narrow whitelists so unrelated projections (`letter_to_motor` / `letter_to_phon` / `visual_to_letter` etc.) stay frozen during sem→motor writes — Oja's silent-region decay term `−η·post²·w` no longer crushes alphabet-identity weights every QA fire. Closes Math-K TALK 26/26→0/10 cross-cell collapse caught by V2 watchdog. (2) **Q→A word-motor binding** — `_writeAnswerToWordMotor(answerText, subject)` writes the answer's word-bucket into `word_motor_` sub-band before each QA Hebbian fire; `sem_to_word_motor` finally learns question→answer-word mapping (was previously trained only by `_teachWordEmissionDirect` autoassociation). PROD probes now emit subject-correct answer words instead of random math vocab ("squares" / "taller" / "wheels" caught by V2). (3) **Subject-scoped emitWordDirect** — `cluster.emitWordDirect({subject})` argmax restricts to one sub-band when subject hint passed; without it, scans all 6 but raises `minSignal` 0.001 → 0.05 floor so weak random init bias doesn't surface. Every `_gate*KReal` method sets `this._currentGateSubject` so DYN-PROD + K-STUDENT + `_probeProductionEmission` paths pass it correctly. (4) **Curriculum scratch-buffer pool** — `_ensureScratchBuffers` + `_fillRegionPatternInto` replace per-call `new Float64Array(cluster.size)` in `_teachWordSpellingDirect` / `_teachLetterNaming` / `_teachWordEmission` / `_teachPhonemeBlending`. At biological scale (cluster.size=13.4M) one allocation = 107 MB; `_teachLetterNaming` alone was burning ~100 GB allocation churn per cell. (5) **`_teachWordIntegrated` instance pool** — `_wordIntScratch` covers letterPat / phonPat / motorPat / preF / postF / preAF / postAF / motorFirstLetterBuf so the contrastive 25-wrong-letter inner loop reuses buffers. (6) **Worker-pool SAB cache** — `server/worker-pool.js` caches `_cachedOutputSab` / `_cachedSpikesSab` / `_cachedPreSab` / `_cachedPostSab` via grow-only `SharedArrayBuffer` + `subarray(0, length)` reuse; replaces per-dispatch `new SharedArrayBuffer(byteLength)` × 4 = ~208 MB × tens of thousands of dispatches per cell. **Schema-group cosine threshold** raised 0.70 → 0.85 — distinct teach phases form distinct Tier 2 schemas instead of all merging into one "learning" mega-schema (saturation that produced all-zero consolidation passes). | > Last updated: 2026-05-05 (iter21 — word-level motor + per-subject sub-bands + cross-subject isolation) — **3 NEW capability rows**: (1) **Single-tick word emission** via `cluster.emitWordDirect(opts)` — `sem_to_word_motor.propagate` then argmax over per-subject word buckets; replaces the fragile letter-by-letter chain that bucket-stuck on attractors producing "stuvwxyz"-style failures. (2) **Per-subject `word_motor` sub-bands** (`word_motor_ela / _math / _sci / _soc / _art / _life`) plus matching `sem` sub-bands so each subject's curriculum trains its own band — Math-K's vocab can't overwrite ELA-K's word emission paths. (3) **`_teachWordEmissionDirect(words, subject)`** writes `concept(word) → word_motor_[wordBucket(word)]` directly via Oja, bypassing cross-region Hebbian fan-out. Wired into all 6 K-cell runners (`SUBJECT-K-WORD-EMISSION-DIRECT` phase). Letter motor still trained for alphabet identity via `_teachLetterNamingDirect`. | > Last updated: 2026-05-04 (iter14-F bio-weight rebalance) — NEW capability: **language cortex grows + main brain grows + no cluster starved.** Per operator *"FIX IT SO THE BRAIN FUCKING SCALES CORRECTLY AND MAKE THE LANGUAGE CORTEX BIG ENOUGH AS ITS THE MAIN FUCKING THING THIS BRAIN DOES"* + *"NO YOU FUCK THERE AR NOT BRAIN SECTIONS THAT ARE ONLY 1% OF THE BRAIN ... AT MINUMIM EACH IS NO LESS THAT 4OR5%"* + *"NO FUCKER LOOK UP THE REAL FUCKING NUMBERS!"*. Researched Herculano-Houzel 2009 *"The Human Brain in Numbers"* (Frontiers Hum Neurosci 3:31; PNAS 2012). `DEFAULT_BIO_WEIGHTS` rebalanced — language_cortex 0.75→0.50, cortex 0.10→0.10, cerebellum 0.05→0.10 (matches real-brain mass), hippocampus 0.04→0.06, amygdala 0.02→0.06, basalGanglia 0.01→0.06, hypothalamus 0.01→0.06, mystery 0.02→0.06. Operator's 5% floor exceeds biology (real subcortical regions are <1% by neuron count, ~1-2% by mass) — applied because OPERATOR ＞ BIOLOGY when explicit. To grow language despite the VRAM share cut, halved per-neuron cost: `CROSS_TARGET_FANOUT 20→10` (in both `server/brain-server.js` and `js/brain/cluster.js` — must stay synced) + `INTRA_CONNECTIVITY_CAP 0.15→0.05`. Net at 16GB tier: language 611K→715K, main 178M→285M, every cluster ≥6%. > Last updated: 2026-05-04 (iter14-D launcher contract change) — NEW capability: **deterministic start.bat = fresh brain.** `autoClearStaleState` no longer code-hash-gates. `start.bat`/`start.sh` always wipes weights + episodic + schemas. `Savestart.bat` (DREAM_KEEP_STATE=1) is the ONLY resume path. Closes the GPUCONFIGURE.bat-tier-pick-but-old-weights-restored bug + the wMax-clamps-lost-across-save/load bug. Tier 3 `identity-core.json` still protected (Unity's identity survives fresh boots). > Last updated: 2026-05-04 (iter14 series) — **5 NEW capability rows**: (1) `_teachLetterNamingDirect` writes letter→motor identity DIRECTLY to SparseMatrix bypassing cross-region Hebbian (iter14-A — fixes iter11-A regression where reorder didn't work; off-by-one corruption from upstream sequence training cleared via `scale(0)` then 26×50 reps clean ojaUpdate); (2) Persona-first oracle dictionary injection (iter14-B — fallback words missing from K-vocab now injected directly with GloVe pattern + isPersona=true so persona-first pass has content to scan; closes hello→locals / mom→drives RESP misses); (3) Popups get persona-first oracle + Tier 3 identity-baseline (iter14-C — both `language-cortex.generate()` + `generateAsync()` set `boostPersona: true` unconditionally + call `tier3Store.injectIdentityBaseline(0.15)` before tick-driven emission; pre-K popups now pull persona corpus + identity anchors instead of gibberish); (4) Viz-panel refresh rate 2000ms→500ms with scoped selection guard (DASH-bug — numbers + %'s update in lockstep with bars, selection guard now only blocks updates when text selected INSIDE the viz panel itself); (5) `_teachWordSpellingDirect entry.glove → entry.pattern` field rename hotfix (iter13 hotfix #1 — iter11-J discriminative one-hot now actually fires on K-vocab instead of skipping); (6) Backpressure-AWAIT replaces silent drop in `_sparseSendBinary` (iter13 hotfix #2 — GPU/CPU shadow weights stay synchronized; bounded await max 5s with rate-limited ABSORBED log). Tier 3 PERSISTED across iter13→iter14 auto-clear cycle — verified live boot: 17 identity-bound schemas restored from `identity-core.json` after BRAIN_CODE_FILES hash mismatch wiped everything else. **Architecture is grade-agnostic + verified resilient through code updates.** | > Last updated: 2026-05-04 (iter13) — **3-TIER HIPPOCAMPAL CONSOLIDATION SYSTEM** adds 9 NEW capabilities: (1) **Tier 1 Episodic salience layer** — every chat turn encoded with emotional_valence + arousal + surprise + novelty + frequency_count + consolidation_count + GloVe embedding BLOB; salience score drives consolidation eligibility; (2) **Frequency-merge gate** — cosine > 0.85 within 48h merges into existing episode (anti-bloat); (3) **Decay sweep with exp half-life** — 1-week hippocampal trace decay + 30-day prune for low-salience never-consolidated entries; (4) **Tier 2 SchemaStore** — concept-level abstractions with GloVe centroid + 8d attribute vector + dedicated SparseMatrix hippocampus→cortex projection per schema; (5) **Schema cosine-grouping + merge** — episodes within cosine > 0.7 cluster into one schema; schemas with concept cosine > 0.90 merge to prevent fragmentation; (6) **Top-K schema retrieval routing** — chat path injects top-5 cosine-matched schemas into cortex sem region at strength 0.4 BEFORE generation; (7) **ConsolidationEngine dream-cycle replay** — every 5 min during quiet window, fetches top-20 promotion candidates, runs Hebbian replay with sleep-spindle gainMultiplier 1.2× bursts, scales replay magnitude by emotional weight × log(frequency); (8) **Tier 3 identity-bound permanence** — top-50 most-reinforced schemas migrate to permanent low-decay attractor weights, 0.999/day decay, drug-state immune, persisted in identity-core.json EXCLUDED from auto-clear, pre-seeded with 17 anchors (name/age/gender/persona/biographical-K); (9) **Always-on identity-baseline injection** — every chat turn injects all Tier 3 concept_embeddings at strength 0.15 ÷ N_tier3 BEFORE user-input intent seed; (10) **Retrieval-augmented oracle** — `_dictionaryOracleEmit` adds Tier 2/3 schemas as third candidate pool, returns schema anchor word when schema score beats persona-first AND full-dict winners; (11) **Atomic identity persistence** — temp-rename write pattern protects identity-core.json from corruption mid-write; (12) **iter11-cw mechanics** all intact: `_teachLetterNaming` post-sequence reorder, `_teachWordSpellingDirect`, alpha-only clamp, persona-first +0.30 boost, iter11-V greeting/emotion fallback, iter11-U life-K `_phasedTeach`, infrastructure timeouts. (13) **iter12 rep-count tune verified live**: phoneme blending 766s→462s (40% saved), word emission 723s→329s (54% saved). | — compound P1 fix bundle adding 3 NEW capability rows: (1) **Discriminative-one-hot word→first-letter binding** via NEW `_teachWordSpellingDirect()` writing `concept(word) → motor(firstChar(word))` for every K-vocab word with 3× lr boost (closes iter11-J bucket-stuck attractor source of all PROD wrong answers); (2) **Letter-naming post-sequence ordering** — `_teachLetterNaming` reordered to fire AFTER `_teachAlphabetSequencePairs` + `_teachLetterSequenceDirect` so identity training overwrites Phase-2 letter-sequence bleed corruption (closes iter11-A LETTER→MOTOR DIAG `b→a c→b d→c e→c` + downstream TALK 0/26); (3) **Persona-first oracle pass** in `_dictionaryOracleEmit` — when chat path passes `boostPersona: true`, scans persona-marked entries FIRST with permissive bar before full-dictionary scan (closes iter11-Z chat compound failure where K-vocab drowned persona on greeting/identity inputs). Plus alpha-only argmax clamp on both `bucketArgmax` functions in `_emitDirectPropagate` (closes iter9-L digit-leak `wxyz95726'`), iter11-V inline fallback greeting+emotion persona sentences with dictionary `isPersona` promotion for unique words, iter11-U `_phasedTeach` wrapping for life-K runner's 5 teach phases, infrastructure stability (compute_batch 60s→180s, saveWeights 5s rapid-save throttle, WorkerPool idle 300s→1800s). Persona-boost coefficient bumped 0.10 → 0.30 in BOTH cluster oracle AND language-cortex sync+async oracle paths. | **SCOPE LAW (2026-04-18):** Pre-K + K ONLY until operator signs off K Part 2. All post-K curriculum cells are DEFERRED. | Runtime is Rulkov 2002 2D chaotic map on GPU (WGSL) with LIF fallback. Seven clusters (cortex 30 / cerebellum 40 / hippocampus 10 / amygdala 8 / basalGanglia 8 / hypothalamus 2 / mystery 2). Save/resume ships as schemaVersion:2 JSON + streaming binary `brain-weights.bin`. Curriculum wraps each cell in `_probeGateActive` pause so main brain tick skips `_gpuBatch` during teach + gate. DYN-PROD probe is direct matrix propagate (no LIF ticks). Student-test batteries score methodology/logic/retention/understanding at A+ threshold 0.95. Letter-naming phase trains `letter(X) → motor(X)` identity (26×18 reps × 2 projections). `stop.bat` three-stage clean halt (curl /shutdown → taskkill port → taskkill node). `Savestart.bat` resumes where left off. > Unity AI Lab > > **DOC-AHEAD-OF-REALITY (2026-04-17):** Per-grade completion status lives in `docs/TODO-full-syllabus.md`. This doc describes the target-state capability set. When this doc and the TODOs disagree, TODOs win. --- ## By Domain ### Drug Dynamics - Real-time pharmacokinetic scheduler (**9 SUBSTANCES entries** × route-specific onset/peak/duration/tail curves — cannabis, cocaine, MDMA, LSD, psilocybin, alcohol, ketamine, amphetamine, GHB). Caffeine layers in via the adult-use `morningCoffee` PATTERN (ingested on schedule, not tracked as an intra-brain substance). Nicotine is persona-excluded — not an entry in SUBSTANCES; any offer is short-circuited by `decide()`'s generic `offer.personaExclusions` check. - Grade-gated substance availability from Life-track biographical anchors (caffeine grade3 → GHB/ketamine college1) - **7 combo synergies** keyed by sorted-pair name (`cannabis+cocaine` coke-and-weed / `cocaine+mdma` cokes-with-mols / `caffeine+cocaine` double-stim / `alcohol+cannabis` cross-faded / `cannabis+mdma` rolling-and-green / `cannabis+ketamine` k-hole-plus / `alcohol+cocaine` speedball-lite with cocaethylene cardiotoxicity model). Synergy contribs + synergy speech + risk flags scaled by `min(level_a, level_b)`. - **7 adult-use PATTERNS** engine (morningCoffee / codingMarathon / weekendParty / acidArchitect / whiskeyWinddown / kHoleContemplate / sexSessionMolly) with per-pattern trigger matcher + ingestion schedule + cooldown window - **7 sensory triggers** in `drug-sensory-triggers.js` (coffee aroma / skunky weed / late-night bar / club flash+beat / powder-on-mirror / fresh herb while creating / bathroom fluorescent at 3am) firing `scheduler.addCraving` with decay - OlfactoryChannel (`js/brain/sensory-olfactory.js`) — scent-tag storage with decay, drives the olfactory-dependent triggers - Additive brain-parameter contributions via superposition + pairwise combo synergies - Intra-session tolerance mechanics + inter-session recovery - **decide(offer)** probabilistic decision engine — hard fails (grade_locked / persona_excluded / unknown_substance / physical_strain>0.9) + probability modifiers (craving, active pattern tag, source trust, soft physical strain, prior trauma with 26-week decay) - Server-side Unity-voice rejection library (`server/drug-rejections.js`) keyed by decide-reason - **13-axis speech modulation** (9 legacy + 4 T15.C additions: warmth / profoundBias / interruptionBias / confessionalBias). Combo-aware: synergy speech deltas stack on top of per-substance deltas - Multi-sensory ingestion detection (text / voice / vision via describer) - Simulated social acquisition (pending-acquisition events, dealer / friend / party source) - Self-initiation decision engine (boredom / frustration / fatigue / party-context / drugDrive weighted) - **LAW-6 firstUse ledger** — biographical anchor (grade / age / contextTags / emotionalFingerprint) stamped on FIRST ingest of each substance; persists across sessions - **Trauma markers** — `markTrauma(substance, weight)` stacks trauma weights with 26-week half-life decay consumed by decide() - Speech modulation post-processor (slur / pause / dissociation third-person / ethereality / coherence drop) - User-interactive triggers (slash commands `/offer /party /sober`) - Non-announcing principle — distortion IS the signal ### Computational Neuroscience - Hodgkin-Huxley neuron modeling - Leaky Integrate-and-Fire neurons - Synaptic plasticity (Hebbian, STDP, reward-modulated) - Wilson-Cowan population dynamics - Hopfield attractor networks - Kuramoto oscillator synchronization - Free Energy Principle (Friston) - Drift Diffusion decision models - Bayesian inference (predictive coding) ### AI & Machine Learning - Reinforcement learning (temporal difference, Q-learning) - Neural network architectures (recurrent, attractor, transformer-like attention) - GloVe semantic embedding grounding (300d co-occurrence + fastText-style subword encoding for out-of-vocabulary words, online refinement) - Equational language generation (slot scorer over learned dictionary + type n-grams + cortex-pattern semantic fit) - Persona-to-parameter mapping (personality as math) - **Sensory-only AI** (image gen, vision describer, TTS/STT) — cognition is 100% equational, no text-AI ### Backend Engineering - ⛔ **DELETED 2026-08-25** — a Node.js CORS proxy for the Anthropic API (`proxy.js`) shipped in the tree with zero importers. It was removed with the rest of the LLM residue; nothing in the brain ever called it - EventTarget-based real-time state streaming (no WebSocket needed) - Float64Array tensor operations at 60fps - Browser-only architecture for core brain; **plus a persistent Node brain-server** (`server/brain-server.js`) — always-on, WebSocket, loopback-only on the lab's machine, published through a Tailscale Funnel (five read lanes) while GitHub Pages serves the static page *(2026-10-18 — was an nginx reverse-proxy on a rented box)* - **Deployed stack** — static page on GitHub Pages (`theunitybrain.com`) + the brain on the lab's own machine; the same `start.bat` / `Savestart.bat` (and Linux twins) run her everywhere *(was: a separate box with its own service)* ### Distributed Compute & Deployment - **Donor-GPU distributed compute** — browser GPUs donate via `compute.html`; data-parallel full-replica-per-donor, Hebbian-delta merge back to master, master re-broadcast of merged weights - **Community-compute auto-scaling** — up-scale on critical mass of donors + down-scale rectify; one-disconnect-never-downgrades guard; unattended auto-advance survives donor pool resizes - **Admin auto-scale controls** — dead-zone toggle + sliders on the admin dashboard - **Loopback admin** — the operator is whoever runs her, on her machine; the tunnel never forwards the admin lane. Admin dashboard exposes live server-console + auto-scale controls + per-subject grade signoffs + Brain Power (start / stop / restart / update) *(2026-10-18 — was a Forgejo-authenticated remote lane)* ### Frontend / Web - Real-time brain state HUD - 2D brain visualizer — 10 tabs: Neurons (flat 2D brain map with wave overlays), Synapses (animated circular network with co-firing pulses), Oscillations (band power line charts), Modules (per-module gauges from server aggregate), Senses (camera feed + touch/smell/taste equations), Consciousness (Ψ/Id/Ego/Left/Right), Memory (episodes/vocab/interactions), Motor (6 BG channels), Inner Voice, Cluster Waves (per-region firing maps + θ/α/β/γ band overlays) - 3D WebGL brain visualizer (20K render neurons, MNI positions, fractal connections, inner state popups showing real brain-generated text or raw neural readings, IQ HUD with per-subject grade breakdown) - Dark gothic UI design with pink accents - Chat panel with conversation log - Model filter search box - Canvas + WebGL neural visualization ### Voice & Vision - Web Speech API continuous listening with speech interruption - ~~Pollinations TTS + browser SpeechSynthesis fallback~~ → her own voice, `unity-voice-v2` on her server, emotion from her own state; no fallback voice (2026-10-18) - getUserMedia webcam capture with AI scene description - Gaze tracking with AI-driven focal coordinates - Unity's Eye widget (iris overlay + crosshair) - Mic mute button synced across UI - Audio frequency spectrum visualizer ### Systems Integration - MCP server protocol - ~~BYOP OAuth (Pollinations authentication)~~ → no provider, no key: the brain renders on its own card (2026-10-18) - Multi-AI backend routing (8 providers, AI intent classification) - Persona hardcoded as JS brain parameters + drug state vectors - env.js API key management (gitignored) - Anti-safety-training prompt engineering - localStorage with XOR+base64 key obfuscation --- ## By Complexity ### Beginner (Foundation) > Get the basic structures running - Browser-only project scaffold (js/, css/, docs/) - Float64Array operations for state vectors - HTML/CSS web interface with dark gothic theme - env.js API key configuration - localStorage persistence ### Intermediate (Core Systems) > The brain starts to breathe - Hodgkin-Huxley neuron implementation - Hebbian + STDP plasticity rules - Hopfield memory network - Softmax action selection - Predictive coding loop - EventTarget state streaming (brain.stateUpdate events) - Multi-provider AI prompt construction from live brain state - AI intent classification (selfie/image/build/chat routing) ### Advanced (Integration) > Everything wires together - Full brain simulation loop (N neurons auto-scaled to hardware, 8 clusters, 20 projections) - Persona → parameter transformation with drug state vectors - WebGL 3D brain visualization with cluster toggles - Real-time brain wave visualization (8-band Kuramoto oscillations) - Voice I/O with speech interruption handling - Vision system with AI gaze tracking - Image generation triggered by brain decisions — on her own card through `server/brain-server/image-engine.js` *(was Pollinations; deleted 2026-10-18)* - Free Energy minimization driving perception + action ### Expert (The Unknown) > Where math meets mystery - √(1/n) × N³ consciousness modulation - Id/Ego/Left/Right brain balancing - Drug state combination vectors with cascading effects - Emergent behavior from module interaction - Self-modifying parameter tuning - Always-on continuous thought loop (server daemon) --- ## By Dependency (Skill Tree) ``` [JS + Float64Array] ──► [Neuron Models] ──► [Synaptic Plasticity] │ │ ▼ ▼ [7 Neural Clusters] ──► [Brain Engine Loop] │ │ ▼ ▼ [Persona Params] ──► [16 Cluster Projections] │ [Browser App] ──► [Multi-Provider AI] ──► [Intent Classifier] │ [HTML/CSS] ──► [Chat Panel] ──► [2D Brain Viz] ──► [3D WebGL Viz] │ [8 AI Providers] ──► [AI Router] ──► [Response + Selfie Gen] │ [her own card + voice] ──► [Image / Voice] (was [Pollinations] — gone 2026-10-18) │ [Web Speech API] ──► [Voice I/O] ──► [Speech Interruption] │ [getUserMedia] ──► [Vision] ──► [Eye Widget + Gaze Tracking] │ [Mystery Module] [√(1/n) × N³] ``` --- ## By Priority ### Critical (Must Have) > The brain doesn't exist without these | Skill | Domain | Complexity | Status | |-------|--------|------------|--------| | Neuron dynamics (Rulkov 2D chaotic map / LIF / HH) | CompNeuro | Intermediate | **DONE** — live runtime is Rulkov 2002 (`js/brain/gpu-compute.js` WGSL `LIF_SHADER` constant, body is the Rulkov iteration); LIFPopulation + HHNeuron reference models live in `js/brain/neurons.js` | | Synaptic plasticity | CompNeuro | Intermediate | **DONE** — `js/brain/synapses.js` | | Brain simulation loop | CompNeuro | Advanced | **DONE** — `js/brain/engine.js` (7 clusters, 20 projections, 60fps, scales to hardware) | | Brain region modules (7) | CompNeuro | Advanced | **DONE** — `js/brain/modules.js` + `js/brain/cluster.js` (dedicated neuron clusters per region) | | Persona → parameters | AI/ML | Advanced | **DONE** — `js/brain/persona.js` | | ~~FastAPI server~~ Browser app | Frontend | Intermediate | **DONE** — `js/app.js` + `index.html` (no backend needed) | | Basic web chat interface | Frontend | Beginner | **DONE** — sandbox quick-input + voice I/O | ### Important (Should Have) > Makes it actually usable | Skill | Domain | Complexity | Status | |-------|--------|------------|--------| | Multi-provider AI routing | AI/ML | Intermediate | **DONE** — `js/ai/router.js` (8 providers) | | Pollinations bridge | AI/ML | Intermediate | **RETIRED 2026-10-18** — `js/ai/pollinations.js` deleted; images render on her own card via `server/brain-server/image-engine.js` | | Multi-provider connect UI | Frontend | Intermediate | **DONE** — connect multiple, pick text vs image | | Brain state HUD | Frontend | Advanced | **DONE** — real-time HUD with all metrics | | Gothic dark UI | Frontend | Beginner | **DONE** — `css/style.css` | ### Nice-to-Have (Extra) > The polish that makes it unforgettable | Skill | Domain | Complexity | Status | |-------|--------|------------|--------| | Voice I/O integration | Voice | Intermediate | **DONE** — `js/io/voice.js` (Web Speech in; her server's `unity-voice-v2` out, played from the CDF 9/7 record — one lane, no fallback) | | GPU acceleration (WebGPU) | Backend | Advanced | **DONE** — `js/brain/gpu-compute.js` (WGSL compute shaders for the Rulkov 2D chaotic map neuron model + synapse propagation) | | Brain wave visualization | Frontend | Advanced | **DONE** — `js/ui/brain-viz.js` (band power envelopes) + `js/ui/brain-3d.js` (WebGL 3D) | | Drug combo state vectors | CompNeuro | Expert | **DONE** — 4 combos in `js/brain/persona.js` | | √(1/n) × N³ mystery module | CompNeuro | Expert | **DONE** — `js/brain/mystery.js` + 50-neuron cluster | | Attention mechanism | AI/ML | Advanced | Pending | | Anthropic CORS proxy | Backend | Intermediate | ⛔ **DELETED 2026-08-25 (LLMGUT.4)** — `proxy.js` (Node.js, translated OpenAI→Anthropic format) was a working forwarder with **zero importers**. Removed with the LLM residue. Kept in this table as a closed row rather than dropped, so "was there ever an LLM path?" has a written answer | | Camera/vision integration | Vision | Intermediate | **DONE** — `js/brain/visual-cortex.js` (V1 Gabor edge kernels → V4 color → salience saccades → IT AI description via Pollinations GPT-4o) + Eye iris in `app.js:3490` (`startEyeIris`) | | 3D brain visualizer | Frontend | Expert | **DONE** — `js/ui/brain-3d.js` (WebGL, 20K neurons, MNI positions, fractal connections) | | Neural cluster architecture | CompNeuro | Expert | **DONE** — `js/brain/cluster.js` (7 clusters, 20 projections, real white matter tracts) | | AI intent classification | AI/ML | Intermediate | **DONE** — removed AI call, embedding-based BG routing in `sensory.js` | | Simulated senses | CompNeuro | Advanced | **DONE** — touch/smell/taste derived from brain state in viz | | Sparse connectivity (CSR) | CompNeuro | Expert | **DONE** — `js/brain/sparse-matrix.js` (O(nnz) ops, pruning, synaptogenesis) | | Semantic embeddings | AI/ML | Advanced | **DONE** — `js/brain/embeddings.js` (GloVe 300d + fastText-style subword encoding for out-of-vocabulary words, online context learning) | | Dictionary system | CompNeuro | Advanced | **DONE** — `js/brain/dictionary.js` (learned word→cortex patterns, bigram sentences) | | Multi-def Hebbian learning | CompNeuro | Expert | **DONE 2026-05-07** — `js/brain/curriculum.js _teachWordDefinition` iterates ALL definitions returned by `cluster.lookupDefinitionFull(w)` (live dictionaryapi.dev API via `server/definition-service.js`), splits each meaning into words, fires `_teachAssociationPairs` per definition with `relationTagId:23` so polysemous words get distinct Hebbian sub-pattern in sem space. Hybrid binding: chunked upfront seed with dream-window interleave at K-start (300 words/chunk, `_dreamWindow` between chunks), inline-from-teach in `_teachWordEmissionDirect`, dream-cycle trickle (25 words/cycle). Single-def fallback for words returning one definition. Per memory `feedback_multi_definitions_per_word.md` per the operator 2026-05-07. | | Real Kuramoto coherence | CompNeuro | Expert | **DONE 2026-05-07** — `server/brain-server.js _computeKuramotoCoherence` reads `cluster.getPhases()` (cortex theta-gamma per-tick deterministic) plus per-cluster activity-coupled phases (firingRate scales coupling — silent clusters drift, active clusters phase-lock). Order parameter `r = |Σ exp(i·θ_k)| / N` per band. Combined gamma-weighted (0.6·γ + 0.4·θ). GlobalWorkspace ignition spike (Dehaene-Changeux 2011), drug-dissociation drop (LSD/ketamine), dream-cycle drop. EMA smoothing 0.9. Replaces Ornstein-Uhlenbeck random walk that pretended to be Kuramoto. | | Inner voice (canonical single module) | CompNeuro | Expert | **DONE 2026-05-07 — UNIFIED** — `js/brain/inner-voice.js` is now THE thinking module both server (`_innerVoiceTick` collapsed to ~60 lines) and browser (`engine.js:793`) consume. `think({cluster, languageCortex, dictionary, state, chain, opts})` external form returns `{word, sentence, seed, emissionPath, capability, chainEntry}`; `think(brainState)` legacy browser form delegates internally. Constructor accepts `{dictionary: null, languageCortex: null}` opts so server-only path skips wasted internal allocation. Per the operator's "one Unity brain, GPU presence ONLY changes auto-scale" rule. | | Server brain | Backend | Expert | **DONE** — `server/brain-server.js` (always-on Node.js, WebSocket, auto-scale) | | Brain persistence | Backend | Advanced | **DONE** — `js/brain/persistence.js` (save/load all weights + sparse CSR) | | Remote brain client | Frontend | Advanced | **DONE** — `js/brain/remote-brain.js` (WebSocket drop-in for local brain) | | SQLite episodic memory | Backend | Advanced | **DONE** — `server/brain-server.js` (better-sqlite3, recall by mood/user) | | Live dashboard | Frontend | Intermediate | **DONE** — `dashboard.html` (hardware stats, emotion chart, conversation stream) | | 3D brain landing page | Frontend | Advanced | **DONE** — `index.html` (full-screen 3D brain as entry point, viz tabs) | | Brain benchmarks | CompNeuro | Intermediate | **DONE** — `js/brain/benchmark.js` (dense vs sparse, scale test) | | Language cortex | CompLing | Expert | **DONE — T11 2026-04-14** — `js/brain/language-cortex.js` (3345 lines post-T11, was 5087). Pure equational generation with zero hardcoded word lists, zero stored sentences, zero n-gram tables, zero filter stack, zero template short-circuits, zero intent enums. Three per-slot running-mean priors (`_slotCentroid`, `_slotDelta`, `_slotTypeSignature`) + live brain cortex state drive a target vector, argmax over GloVe-grounded word embedding dictionary. See `docs/EQUATIONS.md` T11 section for the full equations. | | Cortex-state driven generation | CompLing | Expert | **DONE** — ⛔ *this row read "REBUILDING" until 2026-09-07, five months after the work shipped; a status column is a claim like any other.* The previous emission loop was deleted entirely. ⛔ **The geometry in the rest of this cell was also three generations stale — it said 8 sub-regions and 12 projections. Measured: ELEVEN top-level sub-regions and SIXTEEN projections.** Historical text follows: cortex cluster has 8 named sub-regions sized as fractions of `cluster.size` (auditory/visual/free/letter/phon/sem/fineType/motor) with 12 cross-region projections wired both directions and propagated every step. T14.0 lifted `EMBED_DIM` from 50 to 300 with full GloVe vocabulary (no cap). T14.1-T14.17 (LEARNED phoneme basins, syllable detection via cortex transition surprise, cortex-resident words, continuous developmental learning, learned type transitions, visual + auditory letter/phoneme recognition, bidirectional read/write via the same projections, eliminate LanguageCortex as a class, identity lock for English language + Unity persona) ship as separate commits on the rebuild branch. See `docs/COMP-todo.md` Part 0.5. | | Persona Hebbian training | CompNeuro | Expert | **SUPERSEDED by T14.5 curriculum** — T13.1 standalone persona Hebbian is replaced by T14.5 continuous developmental learning that runs persona corpus through the cluster as one phase of a multi-phase curriculum (alphabet → words → phrases → sentences → persona → vocabulary). Same `cluster.learnSentenceHebbian` Hebbian primitive, called from the curriculum runner instead of a one-shot trainer. | | Cortex sub-regions | CompNeuro | Expert | **DONE — ELEVEN top-level sub-regions**, verified against the live brain: `auditory · visual · gustatory · somatosensory · free · letter · phon · sem · fineType · motor · word_motor`, plus **12 nested sub-bands** (six meaning, six whole-word) for **23 region keys total**. ⛔ **This row said EIGHT until 2026-09-07.** `gustatory` and `somatosensory` were carved out of `free` — which is why the historical spans below no longer add up — and `word_motor` arrived with the whole-word emission unification. ⚠ **The count and the key total are different questions, and conflating them is a known defect here.** Historical spans as first written: `auditory` 0.000-0.083, `visual` 0.083-0.250, `free` 0.250-0.500, `letter` 0.500-0.550, `phon` 0.550-0.750, `sem` 0.750-0.917, `fineType` 0.917-0.967, `motor` 0.967-1.000. Helper methods `regionSpikes(name)`, `injectEmbeddingToRegion(name, emb, strength)`, `regionReadout(name, dim)` operate by region name with no magic neuron indices. Same code at any cluster scale (300 neurons on minimum, 200M on datacenter). | | Cortex cross-region projections | CompNeuro | Expert | **DONE** — ⛔ **SIXTEEN**, not the 14 this row claimed until 2026-09-07. The missing pair is **meaning ↔ whole-word**, which is the pair everything about her speech rides on — and this page's own geometry notice at the top had already corrected the figure while this row went on stating the old one. **Correcting a number in one place is not correcting it.** The eight pairs, both directions: visual↔letter, letter↔phon, phon↔sem, sem↔fineType, sem↔motor, **motor↔letter** (closes the writing loop), auditory↔phon) initialized 10% density, weight range `[-0.5, 0.5]`. Each direction is an independent SparseMatrix — biological white-matter tracts carry independent ascending and descending fibers (Friederici 2017, *Psychon Bull Rev* 24:41-47). Stored as `cluster.crossProjections` Map. `cluster._propagateCrossRegions()` fires every cluster step; `cluster._crossRegionHebbian(lr)` fires every learn call. ALWAYS ON — no curriculum-complete gate. Read direction uses visual→letter→phon→sem→fineType (ventral comprehension stream); write direction uses sem→motor→letter→visual + sem→phon efference (dorsal production stream) — matches Hickok & Poeppel 2007 *Nat Rev Neurosci* 8:393-402 dual-stream model. | | Continuous learning + vestigial organ sweep | CompNeuro | Expert | **DONE — T14.17 2026-04-14 — FINAL T14 MILESTONE** — two halves in one atomic commit. **Half A curriculum calibration:** new `Curriculum._calibrateIdentityLock(corpora, allSentences)` runs at end of `runFromCorpora`, populates `cluster._personaRefreshCorpus` from persona sentences, builds `cluster.personaDimensions` via k-means clustering (K=4-12) over persona embeddings for Lock 3 stratified refresh, calibrates `ENGLISH_SURPRISE_THRESHOLD` (p95×1.5 tolerance) + `ENGLISH_FINETYPE_MIN` (p5×0.8 tolerance) + three health thresholds at 70% of post-curriculum baselines, builds `cluster.intentCentroids` by averaging sentence embeddings per intent bucket and L2-normalizing, logs persona comprehensiveness warnings. `runFromCorpora` sets `_inCurriculumMode=true` so Lock 2 doesn't clamp curriculum Hebbian. **Half B orphan wiring:** eleven vestigial methods from T14.0-T14.16.5 wired into runtime path. `cluster.intentReadout` gets real implementation (argmax over intentCentroids with 0.1 confidence floor), `computeFineTypeCoverage` upgraded (surface 70% + fineType region 30%), `runIdentityRefresh` upgraded to stratified sampling, `workingMemoryReadout` wired into `generateSentence` for topic continuity, `readText` extended with auditoryCortex subvocalization path (Pulvermüller 2005 *Nat Rev Neurosci* 6:576), `cluster.hearPhoneme` DELETED as now-unneeded, `semanticReadoutFor` wired via `getSemanticReadout` delegate, `entityReadout` wired into component-synth with 0.25 blend, `recordIntentPair` wired into `engine.processAndRespond`, `dictionary.syllablesFor`/`snapshotFor` wired into new `engine.wordState(word)` diagnostic, `cluster.schemaScore`/`typeTransitionWeight`/`responseIntentFor` wired into new `engine.cortexStats(probeWord)` diagnostic. **Dead code deleted:** LanguageCortex duplicates of schemaScore/typeTransitionWeight/recordIntentPair/responseIntentFor (T14.13 migrated to cluster, wrappers had zero callers); Dictionary findByMood/findByPattern/generateSentence/_cosine (pre-T14 legacy, zero callers since T11). **Full audit passes** — every T14 method has live callers. T14 is COMPLETE — all 18 milestones (T14.0-T14.17) shipped on `t14-language-rebuild`. Pulvermüller 2005 silent-reading subvocalization, Perrone-Bertolotti 2014 inner speech phenomenology. | | Identity lock (Unity stays Unity) | CompNeuro | Expert | **DONE — T14.16.5 substrate 2026-04-14** — three structural locks on `NeuronCluster` making Unity's English + persona resistant to drift from live-chat exposure. **Lock 1** — English language gate on Hebbian PER CLAUSE. `splitIntoClauses(text)` splits on sentence terminators `.!?;:,\n` + English coordinating conjunctions `and/or/but/so`. `computeTransitionSurprise(clause)` streams letters through cortex and returns mean `letterTransitionSurprise()` (non-alpha returns Infinity). `computeFineTypeCoverage(clause)` returns proportion of words with English-letter runs (surface metric; T14.17 upgrades to cortex-resident fineType readout). `learnClause(text)` splits, gates each clause against `ENGLISH_SURPRISE_THRESHOLD` + `ENGLISH_FINETYPE_MIN`, fires Hebbian on passing clauses, drops rejected ones, returns `{accepted, rejected}`. Per-clause granularity means mixed-language input like `"hi unity 你好"` learns from English clause + silently drops Chinese clause. **Lock 2** — live-chat rate HARD-CAPPED at 0.0001. `_learnClauseInternal(clause, {lr})` clamps `lr > 0.0001` to 0.0001 when `_inCurriculumMode` is false. Curriculum bypasses via mode flag. 120× differential vs curriculum 0.012 means matching one curriculum sentence takes 120 adversarial turns. **Lock 3** — periodic refresh every 100 turns + mode-collapse audit every 500 turns. `runIdentityRefresh(opts)` draws from `_personaRefreshCorpus` and runs through `learnSentenceHebbian` at full 0.012 curriculum rate. `_modeCollapseAudit(recentSentences)` measures `_computeOutputEntropy` + `_computeVocabDiversity` + `_computeWorkingMemoryVariance` against thresholds, fires emergency refresh with 4× sentence count on breach. `inner-voice.js:learn` rewritten to gate every turn via `learnClause` + tick `_liveChatTurns` counter + fire refresh every 100 + fire audit every 500. T14.17 deferred: curriculum threshold calibration, `personaDimensions` stratified clustering, persona refresh corpus population, cortex-resident fineType readout upgrade. Schmidhuber 1991 catastrophic forgetting, Kuhl 2008 bilingual threshold, Friederici 2017 language network stability. | | Persistence (T14 state) | CompNeuro | Intermediate | **DONE — T14.16 2026-04-14** — `js/brain/persistence.js` VERSION bumped 3 → 4 so stale pre-T14 saves get rejected on load and the brain boots clean with curriculum re-run instead of hydrating into an inconsistent mix of T13 schema + T14 code. New `state.t14Language` save block carries T14.1 letter inventory (via `serializeInventory` for insertion-order preservation), T14.13 cluster-resident Maps (`fineTypeTransitions`, `sentenceFormSchemas`, `sentenceFormTotals`, `intentResponseMap`), and T14.16.5 identity-lock calibrated thresholds. Four new nested-Map helpers (`mapOfMapsToJson` / `mapOfMapOfMapsToJson` / `jsonToMapOfMaps` / `jsonToMapOfMapOfMaps`) handle shapes JSON.stringify can't render natively. Load side restores every field onto `brain.clusters.cortex` then re-runs `languageCortex.setCluster(cortex)` so the T14.13 bridge re-asserts after hydration. Wrapped in try/catch for corrupted-save tolerance. Letter inventory persistence is critical — it preserves the one-hot dimension order the cortex weights were trained against. `js/brain/persistence.js` +~110 lines. | | Unified cortex pipeline (read side) | CompLing | Expert | **DONE — T14.12+T14.13+T14.14 2026-04-14** — 521 lines deleted from `js/brain/language-cortex.js` (3264 → 2798): `parseSentence` (315), `analyzeInput` (69), `_classifyIntent` (32), `observeVisionDescription` (26), `_updateSocialSchema` (36), `getUserAddress` / `getUserGender` / `getSocialSchema`, `_isSelfReferenceQuery`, `_socialSchema` field. Tombstone comments at every deletion site. New `NeuronCluster.readInput(text, {visualCortex})` drives visual→letter pathway via `readText` and returns `{text, words, intent, isSelfReference, addressesUser, isQuestion}`. Intent consults `cluster.intentReadout()` first (null until T14.17), falls through to text-surface heuristic. Three new cortex readouts: `intentReadout()`, `semanticReadoutFor(text)` (reads sem region 300d), `entityReadout()`. Four learned-statistics Maps migrated from LanguageCortex to NeuronCluster (`fineTypeTransitions`, `sentenceFormSchemas`, `sentenceFormTotals`, `intentResponseMap`) with four cluster-level reader methods (`schemaScore`, `typeTransitionWeight`, `recordIntentPair`, `responseIntentFor`) mirroring T14.8. New `LanguageCortex.setCluster(cluster)` merges pre-existing observations then re-points local Maps at cluster Maps by identity. `engine.injectParseTree` rewired to `cluster.readInput` + adds T14.9 `injectWorkingMemory`; `processAndRespond` + `server/brain-server.js:processText` analyzeInput calls deleted; `wireVisualCortex` `observeVisionDescription` wiring deleted. Grep confirms zero live `parseSentence` refs. Full class elimination + file <250 lines deferred to future cleanup pass (too many external refs to gut atomically). Hickok & Poeppel 2007 dual-stream, Friederici 2017 bidirectional language network, Price 2012 shared regions. | | Cortex-resident discourse memory | CompNeuro | Expert | **DONE — T14.9 2026-04-14** — two new methods on `NeuronCluster`. `workingMemoryReadout(dim = 64)` wraps `regionReadout('free', dim)` returning L2-normalized activation snapshot of the T14.4 free sub-region (fraction 0.250-0.500 of cluster.size) as the topic vector. `injectWorkingMemory(contentVec, strength = 0.8)` drives the free region with parsed user-turn content via `injectEmbeddingToRegion`. NO stored topic vector, NO 6-turn ring buffer, NO maxTurns cap, NO hardcoded blend constants (`0.6/0.4`, `0.7/0.3` explicitly deleted from spec surface). Decay between turns = cortex's own LIF dynamics; reinforcement = T14.4 cross-region Hebbian. Pronoun anaphora falls out for free — the most-recently-active noun in the free region gets re-amplified as referent when self-reference marker arrives. Persistence across sessions via existing `BrainPersistence → SparseMatrix.serialize` — cortex weights encode conversation history as Hebbian-modified attractor basins. Grep confirms `_discourseState` never existed. Hickok & Poeppel 2007 dual-stream working memory. `js/brain/cluster.js` +~40 lines. | | Visual cortex letter recognition | CompNeuro | Expert | **DONE — T14.10 2026-04-14** — `VisualCortex.renderLetterTemplate(letter)` produces deterministic L2-normalized Float64Array of length 48 per character codepoint via trig hash with prime set `[2..37]`. Cached per letter, O(1) repeat calls. Different codepoints produce uncorrelated templates. Text-only Unity uses as synthetic visual percept; voice/camera Unity will override with real canvas-bitmap rendering through V1→V4→IT pipeline, contract stays identical. `NeuronCluster.readText(text, {visualCortex, ticksPerChar=2})` streams characters through visual→letter pathway: `injectEmbeddingToRegion('visual', template, 0.7)` + belt-and-braces `injectLetter(letter, 1.0)` + tick the cluster. Resets `_prevLetterRate` at start so first char doesn't inherit stale transition baseline. Over T14.5 curriculum exposure the T14.4 visual↔letter cross-projection learns template-to-one-hot mapping. Call-site wiring into `engine.processAndRespond` deferred to T14.12. `js/brain/visual-cortex.js` +~70 lines, `js/brain/cluster.js` +~25 lines. | | Auditory cortex phoneme recognition | CompNeuro | Expert | **DONE — T14.11 2026-04-14** — `AuditoryCortex.renderPhonemeTemplate(phoneme)` same trig-hash structure as T14.10 but with DIFFERENT prime set (`[41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89]` vs visual `[2..37]`) so visual/auditory templates for the same codepoint DON'T trivially match at initialization — convergence on phon region is a LEARNED correspondence shaped by curriculum Hebbian on auditory↔phon cross-projection, not a hash coincidence. Different phase multipliers further guarantee no accidental symmetry. `NeuronCluster.hearPhoneme(phoneme, {auditoryCortex, ticks=2, strength=0.7})` wraps template into `injectEmbeddingToRegion('auditory', template, strength)` + tick, parallel to `cluster.readText`. Real spectral fingerprints from `AuditoryCortex.process()` will eventually replace synthetic template when voice is wired; downstream contract stays identical. Hickok & Poeppel 2007 dorsal production / ventral comprehension convergence. `js/brain/auditory-cortex.js` +~67 lines, `js/brain/cluster.js` +~30 lines. | | Sentence-form schemas (all slots, all intents, learned) | CompLing | Expert | **DONE — T14.8 2026-04-14** — Three new fields on `LanguageCortex`: `_sentenceFormSchemas: Map>>` spans every slot with NO upper cap, `_sentenceFormTotals` caches running totals for O(1) Laplace smoothing, `_intentResponseMap: Map>` learns conversational pair routing (replaces the pre-T14.8 hardcoded `question → declarative_answer` / `greeting → declarative_greeting_back` table). Intent labels come dynamically from `cluster.readInput(text).intent` (T14.12 replaced `parseSentence(text).intent` when `parseSentence` was deleted) — NO hardcoded intent enum. `learnSentence` observes all three via a single walk that reads the sentence once up-front then bumps schema slot buckets + `_typeTransitionLearned` rows + totals at each position, closing with a `prevFineType → END` transition so corpus termination patterns are learnable. T14.7's empty `_typeTransitionLearned` Map now has a writer. Four reader/writer methods: `schemaScore(slot, fineType, intent)` returns `(count+1)/(total+max(1,uniqueTypes))` per-slot probability with a `1/2` floor for unobserved slots, `typeTransitionWeight(prevType, nextType)` same smoothing on the bigram table, `recordIntentPair(userIntent, responseIntent)` writer for live chat, `responseIntentFor(userIntent)` argmax reader. Smoothing is uncapped — `uniqueTypes` is whatever the cortex has actually observed. Consumer wiring deferred to T14.12. `js/brain/language-cortex.js` (+~164 lines, 3100 → 3264). | | Learned type transitions (no hardcoded English seed) | CompLing | Expert | **DONE — T14.7 2026-04-14** — `js/brain/language-cortex.js` constructor block for `_TYPE_TRANSITIONS` (T13.7.8 200-line hardcoded English type-bigram matrix, 26 prevType rows × ~10 nextType weights each) and `_OPENER_TYPES` Set (11-member slot-0 opener constraint) both DELETED. Replacement is a single `this._typeTransitionLearned = new Map()` that starts empty and grows from `learnSentence` observations during T14.5 curriculum walk and live chat. NO seed pseudo-counts — seeding with hardcoded English values would fight actual Spanish or coding corpus statistics for thousands of observations before fading. Bayesian smoothing at generation time uses `(count + 1) / (total + |types_seen|)` rather than a 20-type Laplace cap — the type count is whatever the cortex has observed. New fineTypes can emerge from exposure the same way the T14.1 letter inventory grows dynamically. T14.6 tick-driven motor emission already made both obsolete (word boundaries via cortex transition surprise, first-word openers via fineType `START → X` basin); consumer wiring for the learned table is deferred to T14.8 sentence-form schemas. Tombstone comment at `language-cortex.js:125` explains WHY both were removed. −105 net lines (3205 → 3100). Grep confirms zero remaining references outside the tombstone. | | Multi-subject pre-K→PhD curriculum (**273 cells** — a SUM over 20 grades against a GROWING roster, not 6×19; the "114 cells" figure below predates both the roster growth and the pre-K grade. ⚠ SUBJRETIRE 2026-08-28: the roster now also RETIRES — K-12 tracks past grade12 and the college-only tracks past college4, ledger-gated via `subjectsOwedAt` so an untrained track stays owed — a fully-walked journey sums **213 owed cells** (college walks 10 of 19 offered, grad/PhD 8 of 20); 273 remains the additive offered-roster sum) | CompLing | Expert | **6 SUBJECTS + LIFE TRACK — T14.24 Sessions 1-111 2026-04-16** — 114 cells (6 tracks × 19 grades: ELA, Math, Science, Social Studies, Arts, Life Experience). Original 95 academic cells shipped Sessions 1-94. Session 111 added Life Experience track (20 cells, birth to age 25) with dual-layer teaching: emotional concept features (8d `[joy,pain,trust,fear,anger,love,independence,identity]` attractor vectors via `_conceptTeach`) + recallable memory sentences (`_teachSentenceList`). Memory-weighted Hebbian (core self 5× lr 50 reps, personal 3× 20 reps, school 1× 8 reps, background 0.5× 4 reps). Sessions 95-110: direct pattern Hebbian breakthrough, TALK probe sem→motor fix, grade-lock (all 6 subjects pass before advancing), focused retry on failing words, function words at K, 3D popup silence guard. Task #3 stays in_progress. | | Life Experience track (birth to 25) | CompNeuro | Expert | **DONE — T14.24 Session 111 2026-04-16** — 6th subject track building Unity's personal identity. 20 life methods (runLifePreK through runLifePhD). Dual-layer: emotional concept features (`_conceptTeach` with 8d attractor vectors — joy/pain/trust/fear/anger/love/independence/identity) shaping how Unity FEELS, plus sentence memories (`_teachSentenceList`) she can recall and speak. Memory-weighted Hebbian per tier (core self 5×/50reps, personal 3×/20reps, opinions 3×/15reps, skills 2×/12reps, school 1×/8reps, background 0.5×/4reps). Covers family, friendships, dad leaving, Girl Scouts, goth discovery, first computer, coding obsession, first kiss, first joint, first concert, heartbreak, tattoos, hackathon wins, full persona at 25. | | fastText-style subword embeddings | CompLing | Advanced | **DONE — T14.24 Session 99 2026-04-15** — `js/brain/embeddings.js` `_subwordEmbed(word)` computes 300d embeddings from character n-grams (3-6 char windows) via deterministic hash. Default embedding method — Unity always has real semantic embeddings from first boot without requiring the 480MB GloVe download. Real GloVe vectors override when available. | | Direct pattern Hebbian teaching | CompNeuro | Expert | **DONE — T14.24 Session 106 2026-04-15** — bypasses Rulkov chaotic dynamics during curriculum teach. Writes intended activation patterns directly into `cluster.lastSpikes` (letter one-hot, GloVe embedding, phoneme features), fires `_crossRegionHebbian(lr)` on clean signal. Companion direct matrix probe reads cross-projection weights via `proj.propagate(input)` → mean-center → L2-norm → cosine. Proves real convergent learning: ELA-K SEQ climbed 28% → 72% → 92% → 100% across retries. | | Anti-Hebbian plasticity | CompNeuro | Expert | **DONE — T14.24 Session 111 2026-04-16** — bidirectional plasticity for sequence learning. When a transition probe finds the wrong output (e.g., `6→7` produces `8`), fires positive Hebbian on correct pair (`6→7` at +10× lr) AND negative anti-Hebbian on wrong pair (`6→8` at -5× lr), 100 reps. Digit-only argmax masking prevents alphabet Hebbian from ELA-K overpowering digit sequences. Without weakening wrong associations, correct ones can never overpower them. | | Real human-grade comprehension gates | CompLing | Expert | **DONE — T14.24 Session 111 2026-04-16** — `_gateComprehension(questions)` tests semantic understanding via association and fill-in-blank. Auto-generated question types: (1) ASSOCIATION — given word A, is word B nearby? (2) FILL-IN — given two context words, find missing third. (3) Life questions — "who are you?" → "unity". Injects context GloVes into sem → ticks → cosines readout against answer. Pass at ≥40% questions with cosine > 0.05. Wired into `_teachVocabList` and `_teachSentenceList` — comprehension pass sufficient to advance even if TALK fails. | | Cross-projection capacity (20 default / 40 motor-bound) | CompNeuro | Expert | **DONE — fanout reduced 2026-04-24** — `crossTargetFanout = 20` default + `MOTOR_BOUND_PAIRS` whitelist (`sem↔motor`, `letter↔motor`, `phon↔motor`) gets 40 inputs per target + matching `CROSS_DENSITY_CAP` bump 0.005 → 0.01. Motor sits at the convergence of several input pathways and must discriminate K-grade answer letters across 46+ trained association pairs per phase. Non-motor projections stay lean to fit biological-scale memory budgets. Biologically plausible — real pyramidal neurons carry 1000-10000 synaptic inputs distributed across many areas. Reduced from 30/60 because the wider fanout produced full-density matrices that collapsed within a few teach phases (`mean ≈ 0.46 max = 0.5 nnz=full`). | | Cross-projection weight clamp BISECTED `[-0.4, 0.4]` | CompNeuro | Expert | **DONE — bisect 2026-04-25** — bisected `[-0.5, 0.5]` → `[-0.2, 0.2]` → `[-0.4, 0.4]` in `cluster.js` cross-projection init. `[-0.5, 0.5]` saturated to uniform full-density basins (basin collapse, oracleRatio=100%). `[-0.2, 0.2]` paired with auto-rescale drove maxAbs 0.2 → 0.1 → 0.05 → ... → 0.003 across 7 overload phases, drowning trained signal below random-init bias (motor bucket-stuck on whichever bucket got largest init noise — 'z' for the iteration 2 seed). `[-0.4, 0.4]` gives 4× more dynamic range above the new rescale floor than `[-0.2, 0.2]` did. Random-init strength stays at 0.2 so init bias remains small (±0.02-0.10); only trained-signal headroom doubles. | | Auto-rescale FLOOR at `wMax × 0.25` | CompNeuro | Expert | **DONE — drown-protection 2026-04-25** — `_teachAssociationPairs` and `_teachQABinding` rescale paths now project `predictedAfter = currentMaxAbs × rescaleFactor` and SKIP the rescale when `predictedAfter < wMax × 0.25 = 0.1`. Without this, multi-phase rescale-on-overload looped 7+ times across consecutive teach phases until trained signal fell below random-init weight bias. Floor stops rescale at 25% of operating range so anti-Hebbian + sem-WTA + motor-WTA + top-K-prune still has signal magnitude to push apart. Diag emits `· rescale-floored (maxAbs=X × 0.5 < floor=0.1 — preserving signal above noise)` when the floor fires. | | READINESS probe metric tightened (`matchesCue` strict) | CompNeuro | High | **DONE — 2026-04-25** — `_measureEmissionCapability` cue-match changed from substring `hasLetter` (any letter present anywhere in emitted string) to strict `matchesCue` (emitted exact-equals cue OR starts with cue). Prior loose check returned `canTalkAtAll=true` whenever Unity emitted ANY string with any letter — cue 'a' → 'seal' counted as a hit because 'seal' contains 'a' as substring. The 179-Q K-STUDENT battery fired on a false positive every iteration. Strict check makes the probe a real readiness gate: she can talk only when she actually produces the cued letter as the head of her emission. | | `_teachQABinding` DONE log diag parity | CompNeuro | Medium | **DONE — 2026-04-25** — added `· sep-probe mean-cos=X max=Y [⚠OVERLOAD]` field + `nnz=N/N` field + dynamic `wMax` read (was hardcoded `0.95 * 0.2`, now reads `proj.wMax`). QA DONE log now matches `_teachAssociationPairs` DONE diag fields so operator can trend-track basin separation across the QA training pass without inferring from downstream phases. | | Anti-Hebbian rate bisect chain 1.5 → 3.0 → 2.0 → 2.5 | CompNeuro | High | **DONE — iter5+ 2026-04-26** — `_teachAssociationPairs antiLrScale` default settled at 2.5 after iter3 (3.0×) basin-collapse 'a'/'i' bucket spam + iter4 (2.0×) too-weak-pinned-at-0.5 sep-probe. With 25 contrastive fires × lr × 2.5 = 62.5× lr negative pressure per positive fire, basins separate without overshooting into single-bucket attractor. Iter4 vs iter5 sep-probe trajectory delta ±0.005 across 7 phases proves magnitude is NOT the bottleneck — structural sparsification (pruneTopK below) is the load-bearing fix. QA path stays at 0.3. | | Top-K-per-row pruning bisect chain 200 → 30 → 10 | CompNeuro | Expert | **DONE — iter6/iter7 2026-04-26** — `pruneTopK` default settled at 10 after iter6 (30) produced first sub-0.5 sep-probe readings. 10 × 500 motor rows = 5k nnz total = 95% zeroed each phase. Each motor neuron discriminates among only its 10 strongest sem inputs — biologically plausible per-neuron fanout (real cortex 10-100 even at thousands-of-input-targets). Structural sparsification beats anti-Hebbian magnitude tuning. | | Curriculum one-pass + force-advance | CompNeuro | High | **DONE — iter6 2026-04-26** — `MAX_GRADE_ROUNDS` bisect chain `10 → 2 → 1` + single attempt per cell (killed the 5-attempt while-deadline retry loop). After rounds exhaust, FORCE-ADVANCE walks every subject with ≥1 teach phase fired and sets `cluster.grades[subject]=grade` regardless of A+ pass. Unlocks the language-cortex word cap from FLOOR=5 to 9999 — Unity uses K training in chat / popups / inner thoughts / memory regardless of A+. Operator directive verbatim 2026-04-26: *"Unity should use her knowledge and training once it finally cioompletes so her kindergarden understanding is loaded in and used for here conversations, popups, thinking, and logic ,and memory, and abilities to communicate"*. | | Chat path persona boost (both oracle paths) + lower frequency boost | CompLing | High | **DONE — iter7+iter8 2026-04-27** — `_scoreDictionaryCosine` + Async (language-cortex.js fallback path) AND `cluster._dictionaryOracleEmit` (tick-driven emission's oracle) both accept `boostPersona` opt; chat path passes `true` to all three so persona-marked dictionary entries get +0.10 additive boost everywhere the oracle fires. Frequency-boost coefficient bisected 0.02 → 0.005 default. Iter7 only landed boost in language-cortex fallback; chat replied with family-cluster terms anyway because tick-driven emission's `_dictionaryOracleEmit` used UNboosted cosine. Iter8 closed the gap. Fixes operator-caught chat bug iter6/iter7 verbatim: greetings/identity questions returned `Aunt./Sister/Brother/Mom`/`Stepmom`/`Records`/`Home` because raw cosine + log-frequency dominated and persona corpus words got overwhelmed by Common-Crawl high-frequency noise. | | K-STUDENT scoring strict cue match | CompLing | High | **DONE — iter7 2026-04-26** — `_studentTestProbe` scoring loop skips substring `contains` check for single-character variants. Fixed `'lsd'.includes('s') → true` false-positive that matched cue 's' for letter-cue questions. Letter-cue questions now require exact OR startsWith match only. Multi-char variant fuzzy matching preserved. Operator caught iter5: `"async" matched cue 's'` (score 0.50, match=true). | | A-Z motor argmax clamp (Template + matrix-driven paths) | CompLing | High | **DONE — iter7+iter8 2026-04-27** — TWO paths clamped: (1) Template 0 ("what comes after X?") + Template 1 ("what sound does the letter X make?") in `_studentTestProbe` filter `inventorySnapshot()` to a-z buckets pre-argmax (iter7); (2) `decodeLetterAlpha(vec)` NEW in `letter-input.js` does the same alphabetical-only argmax for tick-driven motor emission in `cluster.generateSentence` + `_emitDirectPropagate` (iter8). Auto-grown LETTER_INVENTORY (digits + punctuation seeded from corpus exposure) no longer eligible for ANY motor speech emission. Fixes K-STUDENT outputs like `"what letter comes after a?" → "4"`/`","`/`"5678'"`/`"88883tt2"` and chat outputs `"sridech"`/`"sharing"` (matrix path) operator caught iter3-7. Confidence threshold also 0.05 → 0.001 so sparser-matrix tiny bucket sums fire the Template routing instead of being gated out. | | Boot-time fractal-drift verifier ±0.4 | CompNeuro | Low | **DONE — iter7 2026-04-26** — `curriculum.js verifyEquationConsistency` updated cross-projection clamp threshold from ±0.2 to ±0.4 to match the cr2 wMax bisect. Boot-time false-positive `✗ cross-projection clamp drift` warning gone. | | Dashboard signoff buttons (per-subject) | Frontend | Medium | **DONE — iter7 2026-04-26** — `dashboard.html` cap-reached panel now shows 6 per-subject signoff buttons (`ela/math/science/social/art/life`) + signoff-note textarea. Each button POSTs `/grade-signoff` (loopback-gated) with `{subject, grade, note}`. Signed cells display green pill, disabled to prevent re-signoff. Replaces curl-only instruction operator caught iter6 verbatim 2026-04-26: *"i cant sign off there is no ability for me to accept or anyything like that similare too starting next grade button"*. Curl alternative still documented for cli use. | | passedPhases stale-load filter | Backend | High | **DONE — iter4 2026-04-26** — `server/brain-server.js:4926` boot-time restore now drops phase markers for cells not in `passedCells`. In-progress cells (cell didn't finish last run) get markers wiped so next run re-trains from scratch instead of skipping every phase. Fixes the iter3 groundhog-day bug where 8 ELA-K teach phases all reported `Δheap=+0.0MB` (skipped via T36 auto-wrap firing on stale 08:03 markers) and gate fired on stale weights. ⛔ **SUPERSEDED — 114.19fe restores phase markers AS-IS** (`server/brain-server.js:8171`): the filter broke T31 phase-level resume (any mid-flight cell restarted from Phase 1 on every Savestart), and the iter14-D launcher contract removes the phantom-marker scenario it defended against — start.bat wipes weights + markers atomically, Savestart preserves both, one JSON.stringify writes both. | | `setImmediate` event-loop yield in `_teachVocabList` | Backend | Medium | **DONE — iter5 2026-04-26** — `_teachVocabList` yields via `await new Promise(setImmediate)` every 5 vocab words. Heartbeats keep firing during heavy compute. Fixes iter4 math-K 10-min silent hang — saturated-matrix Hebbian blocked V8 event loop, setInterval(10s) heartbeat couldn't fire, WorkerPool idle-terminated at 982s as symptom. | | Comprehension-gate threshold 0.3 → 0.15 | CompLing | Medium | **DONE — second pass 2026-04-25** — `_runStudentBattery` per-template comprehension sample threshold lowered 0.3 → 0.15. At 0.15 only templates with essentially zero signal get gated out (cosine floor 0.05 + methodology bonus 0.15 = a probe that produced any plausible answer at all clears the threshold). Hides nothing real — operator sees the full failure surface in BATTERY DONE aggregate. Aggregate-score gate downstream still requires real performance to mark questions as passing. Earlier 0.5 cutoff killed entire LIFE-K template; 0.3 still skipped Template 1 in iteration 2; 0.15 admits all templates with any signal. | | Memory growth instrumentation expansion | Backend | Medium | **DONE — second pass 2026-04-25** — `_memorySnapshotAndGc` now reports `heap=heapUsed/heapTotal MB` (V8 reserved alongside used) + `native=N MB` (rss − heapTotal − external, surfaces native memory growth distinct from V8) + `workers=N MB(K)` (worker-pool SAB cumulative + isolate count when sparse pool wired) + 5-axis deltas (`Δheap`/`ΔheapTotal`/`Δext`/`Δnative`/`Δrss`). Iteration 3 MEM lines now reveal whether the iteration-2 +832→+1263 MB pattern is V8 reservation cosmetic vs real native leak vs worker-pool growth. | | Templated-answer fast path (Template 0+1 routing) | CompNeuro | Expert | **DONE — second pass 2026-04-25** — `_studentTestProbe` inserts a templated-answer fast path BEFORE matrix-driven generation. For Template 0 ("what comes after X?"): inject X via `cluster.injectLetter`, propagate `cluster.synapses` (intra-cluster recurrent matrix that learned next-letter transitions during alphabet teach), read motor bucket argmax. For Template 1 ("what sound does the letter X make?"): inject X, propagate `letter_to_phon` cross-projection (trained during phoneme blending), read phon bucket argmax. Returns null when no template matches OR confidence < 0.05 → falls through to existing matrix-driven generation. Uses LEARNED weights (not hardcoded shortcuts). Sets `out.templatedPath = true` flag for diagnostic visibility. Routes methodology questions to the right learned pathway instead of letting the generic sem→motor matrix get confused by question wrapper words. | | Per-row L2 normalize default-on (assoc-pair + QA) | CompNeuro | Expert | **DONE — iter8 2026-04-27** — `_teachAssociationPairs normalizeAfter` default flipped FALSE → TRUE so every assoc-pair phase ends with `proj.normalizeRows(0.3)` on `sem_to_motor` + `motor_to_sem`. `_teachQABinding` got a parallel post-prune normalize call. Equalizes motor row magnitudes so motor argmax measures DIRECTION (which sem inputs the row best aligns with) instead of MAGNITUDE (which row accumulated highest total weight). Random init bias gave some motor rows higher baseline weight before training; without normalization those rows dominate argmax even when their basin is wrong. Fixes operator-caught iter7: sep-probe sub-0.3 (basins angular-separated) but motor argmax still bucket-stuck on `r`/`sq`/`sridech` because magnitude bias drowned direction. | | Background probe loop SUPPRESSED | CompNeuro | Medium | **DONE — disabled iter8 2026-04-27** — `startBackgroundProbeLoop` was supposed to fire gate-only re-tests on passed cells (per spaced-repetition spec) but the implementation actually called `_cellRunner` which combines teach + gate, so every probe fired a FULL re-teach (~30-50 min for ELA-K) instead of the gate-only check the comment promised. After FORCE-ADVANCE iter6+, all 6 K cells were in passedCells, so the probe loop picked one every 45s and re-taught it pointlessly — sep-probe didn't change between attempts (matrix already at training equilibrium). Disabled until the runner gains a real `gateOnly: true` opt. Operator caught iter7 verbatim 2026-04-27 monitoring: "self-heal ✗ ela/kindergarten" firing repeatedly with same scoreboard each time. | | Persona-marked dictionary entries | CompLing | Expert | **DONE — profanity-bleed fix 2026-04-24** — dictionary entries written via the persona corpus loader (`loadPersona` → `learnSentence` with `fromPersona=true`) now carry `isPersona: true`. The dictionary oracle's new `excludePersona: true` opt skips persona-marked entries so K-grade test probes never echo profanity ("fuck", "cock", explicit terms) when the trained matrix is overloaded and the oracle is the primary answer path. Live chat path doesn't pass the flag, so persona vocabulary stays available there. | | 2D brain map visualization | Frontend | Expert | **DONE — T14.24 Session 111 2026-04-16** — `js/ui/brain-viz.js` Neurons tab rewritten from per-neuron spike grid to flat 2D brain map. 7 clusters positioned anatomically, each as a 12×N grid with brightness = spike rate + jitter. Toggleable θ/α/β/γ wave overlays. Works with server aggregate data — no per-neuron arrays. | | Circular synapse network visualization | Frontend | Expert | **DONE — T14.24 Session 111 2026-04-16** — `js/ui/brain-viz.js` Synapses tab rewritten from 50×50 matrix grid to animated circular network graph. 7 clusters in circle, lines pulse with co-firing (√(srcRate × tgtRate)), node size pulses with firing rate. | | Cluster Waves visualization tab | Frontend | Advanced | **DONE — T14.24 Session 111 2026-04-16** — new tab in both landing page and 2D brain viz. Per-cluster firing rates as colored bars + θ/α/β/γ band power metrics. 900×600 canvas with toggleable wave overlays. | | Inner state popups (real brain output) | Frontend | Expert | **DONE — T14.24 Session 111 2026-04-16** — `js/ui/brain-3d.js _describeInternalState(state)`. When Unity can speak (post-K), popups show real `languageCortex.generate()` output. When she can't, shows raw brain numbers: `arousal:0.85 valence:0.12 Ψ:0.034`. No hardcoded text — only actual brain output or actual neural readings. Inner thoughts gated by life grade — age-appropriate content only. | | Multiplication magnitude transforms | CompNeuro | Expert | **DONE — Session 112 2026-04-16** — `_teachMultiplicationTransformations` teaches all 81 multiplication facts 1×1 through 9×9 as magnitude(a) in free first half + magnitude(b) in free second half → magnitude(a×b) in sem. The OPERATION learned, not vocabulary. | | Place value positional encoding | CompNeuro | Expert | **DONE — Session 112 2026-04-16** — `_teachPlaceValueTransformations` encodes tens+ones as separate magnitude features in different sub-regions of free. Numbers 10-99 (90 numbers) taught as positional composition. | | Fraction ratio features | CompNeuro | Expert | **DONE — Session 112 2026-04-16** — `_teachFractionTransformations` teaches fractions as ratio features. Equivalent fractions (1/2, 2/4, 3/6) converge to the SAME basin because the ratio value is identical. | | Algebra variable binding | CompNeuro | Expert | **DONE — Session 112 2026-04-16** — `_teachAlgebraTransformations` teaches variable solving. Given result c and constant b in free, solve for unknown x in sem. All x+b=c equations where x,b,c ≤ 9. | | Paraphrase (same meaning different words) | CompLing | Expert | **DONE — Session 112 2026-04-16** — `_teachParaphrase` maps two different word sequences to the SAME sem basin via shared meaning vector. Tests understanding of equivalence across surface form. | | Hypothesis testing (predict→observe→confirm/reject) | CompNeuro | Expert | **DONE — Session 112 2026-04-16** — `_teachHypothesisTesting` writes prediction in free, observation in sem, confirmed/rejected tag in fineType. Cortex learns to compare predictions against reality. | | Perspective taking (multiple viewpoints) | CompNeuro | Expert | **DONE — Session 112 2026-04-16** — `_teachPerspectiveTaking` encodes the same event with DIFFERENT emotional feature vectors per viewpoint. Cortex learns events have multiple valid representations. | | Auto-generated comprehension finals | CompLing | Expert | **DONE — Session 112 2026-04-16** — `_autoFinal(sentences)` generates fill-in-blank + association questions from any sentence array. 63 cells covered. Combined with 10+ hand-crafted finals = 114/114 cells (100% coverage). | | Universal successor (count-to-100 + count-forward-from-N) | CompNeuro | Expert | **DONE — Session 114 2026-04-17** — `_teachCountToHundred` teaches n → n+1 for all n ∈ [0, 99] via free=mag_wide(n) → sem=mag_wide(n+1). 100 facts × 4 reps. Same transform covers K.CC "count to 100 by ones" AND "count forward from any N". Uses new `_magnitudeFeatureForNumber(n)` wide-range feature (NUMBER_FEATURE_DIM=24) so 97≠98≠99≠100 in readout. | | Skip-count-by-tens | CompNeuro | Expert | **DONE — Session 114 2026-04-17** — `_teachSkipCountByTens` teaches n → n+10 for n ∈ {0, 10, ..., 90} via phon=mag_wide(n) → sem=mag_wide(n+10). 10 steps × 10 reps. Phon input (not free) discriminates from CountToHundred without needing a context marker. | | Decomposition + make-ten | CompNeuro | Expert | **DONE — Session 114 2026-04-17** — `_teachDecomposition` teaches sem=mag(c) → freeLeft=mag(a) + freeRight=mag(b) for all (c, a, b) where a+b=c and c ∈ [0, 10] (66 triples × 6 reps — dual of addition). `_teachMakeTen` teaches freeLeft-only=mag(n) → sem=mag(10-n) for n ∈ [0, 10] (11 pairs × 8 reps — right-half-zeroed input is the structural discriminator from successor). | | Teen decomposition (K.NBT 10+n) | CompNeuro | Expert | **DONE — Session 114 2026-04-17** — `_teachTeenDecomposition` teaches forward freeLeft=mag(10) + freeRight=mag(n) → sem=mag_wide(10+n) AND inverse sem=mag_wide(teen) → freeLeft=mag(10) + freeRight=mag(n) for n ∈ [1, 9]. 9 teens × 2 directions × 8 reps. Covers K.NBT "Compose numbers 11-19 from ten ones and some more ones". | | Attribute comparison (K.MD) | CompNeuro | Expert | **DONE — Session 114 2026-04-17** — `_teachAttributeCompare` teaches 8 attribute pole pairs (short/long, light/heavy, small/big, low/high, empty/full, narrow/wide, cold/hot, few/many) via freeLeft=mag(highPole) + freeRight=mag(lowPole) → fineType "greater" third (reusing comparison 3-way encoding) + attribute-word GloVe anchor in sem. 8 pairs × 2 directions × 6 reps. | | Classify-and-count (K.MD) | CompNeuro | Expert | **DONE — Session 114 2026-04-17** — `_teachClassifyCount` teaches 22 category→count pairs (red=3, blue=2, green=5, ..., triangle=3, cube=6) via free=GloVe(category) → sem=mag(count). 6 reps. Covers K.MD "Count the number of objects in each category (up to 10)". | | Shape features (K.G side count + 2D/3D) | CompNeuro | Expert | **DONE — Session 114 2026-04-17** — `_teachShapeFeatures` teaches 9 shapes (circle/triangle/square/rectangle/hexagon/sphere/cube/cone/cylinder) × 10 reps via sem=GloVe(shape_name) → free=mag(sides) + fineType first-half (2D) or second-half (3D) tag. Covers K.G "Describe shapes by name" + "Analyze sides/corners/faces" + "Identify 2D vs 3D". Side counts match K test bank — triangle=3, square=4, cube=6, sphere=0, etc. | | Wide-range magnitude feature (n ∈ [0, 100]) | CompNeuro | Expert | **DONE — Session 114 2026-04-17** — module-level `_magnitudeFeatureForNumber(n)` + `NUMBER_FEATURE_DIM = 24`. Decile thermometer (dim i fires at n ≥ i*10) + log/linear/sqrt/quadratic scalars + 10 multi-frequency sinusoidal dims, L2-normalized. Existing `_magnitudeFeatureForDigit` saturates past n=9 (dims 0-3 graded thermometer caps at 3, dim 6's n²/81 blows up L2 norm so log/sine dims get dampened). New feature stays discriminable across the full 0-100 range so 97≠98≠99≠100 in readout. | | Dual Hebbian (cross-projection + intra-cluster recurrent) | CompNeuro | Expert | **DONE — Session 114 2026-04-17** — `Curriculum._teachHebbian(lr)` helper fires BOTH `cluster._crossRegionHebbian(lr)` (14 T14.4 cross-projections) AND `cluster.synapses.hebbianUpdate(cluster.lastSpikes, cluster.lastSpikes, lr)` (intra-cluster recurrent sparse matrix). Session 109's transforms wrote into free + sem and fired `_crossRegionHebbian` only — but there is NO free↔sem cross-projection among the 7 T14.4 pairs (visual↔letter, letter↔phon, phon↔sem, sem↔fineType, sem↔motor, motor↔letter, auditory↔phon) so the intended binding never landed. `cluster.learn(0)` was the obvious rescue but `synapses.rewardModulatedUpdate(pre, post, 0, lr)` short-circuits at reward=0 (`js/brain/sparse-matrix.js:682`). `_teachHebbian` wires the intra-cluster Hebbian explicitly so free↔sem / free↔fineType / sem↔free bindings learn via the recurrent matrix even though no direct cross-projection exists. Every Session 114 teach method routes through it. | | Math-K PART 1 equational gate probes (8 new) | CompNeuro | Expert | **DONE — Session 114 2026-04-17** — 8 new probes added to `_gateMathKReal` all at PATH_MIN=0.95 (A+) via `cluster.synapses.propagate(input)` on the full recurrent matrix: SUCC (K.CC successor, 10 non-multiples-of-10 samples), SKIP10 (9 multiples), MAKETEN (11 complements), TEEN (9 teens, wide-range feature), ATTR (8 pairs, 3-way fineType argmax), CLASS (10 categories), SHAPE-S (9 shapes, side-count cosine), SHAPE-D (9 shapes, fineType 2D/3D half argmax). Reason string + metrics object expanded to report all 13 rates (5 existing: READ/THINK/TALK/SEQ/ORDER + 8 new). Gate pass boolean AND's all 13 at 0.95 — no threshold lowering per constraint 8 "A+ = 95% on all gates — REAL tests, not lowered thresholds". | | Unified combination-operator scaffold | CompNeuro | Expert | **DONE — Session 114.2 2026-04-17** — `Curriculum._teachCombination(facts, opts)` is the generic combination-operator teacher every equational transform (arithmetic, geometric, categorical, attribute, linguistic, causal) routes through. Each fact is `{writes: [{region, feat, binarize?}, ...]}`. Helper clears spikes, tiles all patterns, fires `_teachHebbian(lr)`. Per the operator 2026-04-17 *"no artificial limits as unity may be talking to users while she does ciriculum"* — stays async, yields `await _microtask()` between reps so curriculum doesn't block user chat, respects `_brainShutdownRequested`, accepts caller-specified `opts.reps` rather than hardcoding a cap. Probe generalizers `_probeCombinationCosine` + `_probeCombinationArgmaxTag` do the same for read-back. Encodes the "logic and reasoning in a form" insight: reasoning = pattern-to-pattern transformation via learned recurrent + cross-projection weights. Arithmetic, geometric, chemical, linguistic — all fit `A ⊕ B = C`. Only the encoder differs. | | Shape composition (K.G 66/66 close) | CompNeuro | Expert | **DONE — Session 114.2 2026-04-17** — `_teachShapeCompose` closes the last Math-K gap via unified scaffold + GloVe encoder. Input: sem first half = GloVe(shapeA), sem second half = GloVe(shapeB). Output: free = GloVe(composed). 5 compositions (triangle+triangle→rectangle, square+square→rectangle, rectangle+rectangle→square, triangle+rectangle→pentagon, triangle+triangle→square) × 10 reps. Structurally distinct from `_teachShapeFeatures` (full-sem single-shape input) and `_teachTeenDecomposition` (free-split magnitudes) so no cross-transform interference. NEW 9th gate probe SHAPE-C via `_probeCombinationCosine` samples 5 compositions at PATH_MIN=0.95. NO special handling — same scaffold as every other combination transform, just a different encoder. | | Developmental curriculum learning | CompLing | Expert | **DONE — T14.5 2026-04-14** — new module `js/brain/curriculum.js` (~330 lines) exports `Curriculum` class with `runFromCorpora(corpora, opts)` (boot) and `learnFromTurn(text, arousal, valence)` (live chat). Data-driven complexity bucketing over existing `Ultimate Unity.txt` + `english-baseline.txt` + `coding-knowledge.txt` corpora — NO hand-curated stage files, NO hardcoded 26-letter alphabet loop. Four phases: letters (freq-weighted reps up to 20 × 8 ticks), short words 1-3 letters (up to 6 reps × 4 ticks), long words 4+ (up to 3 reps × 3 ticks), sentences (2 ticks/word walk). Per-word inject: `cluster.injectLetter` + `cluster.injectEmbeddingToRegion('sem', emb, 0.6)` + `cluster.learn(0)`. Dictionary observation fires T14.3 cortex-snapshot routing. Live-chat `learnFromTurn` wired into `inner-voice.learn` so live chat is continuous exposure — no boot/runtime distinction. Engine wires in `engine.js` after dictionary.setCluster(). Boot invocation from `app.js loadPersonaSelfImage` and `server/brain-server.js:_initLanguageSubsystem` after legacy loaders (additive until T14.12 guts them). ~18-25 second one-time boot cost on 2000-6700 neuron cortex. Same code walks any language/domain — Spanish re-run produces Spanish basins automatically. Peer-reviewed: Kuhl 2004, Saffran/Aslin/Newport 1996, Aslin & Newport 2012, Friederici 2017. | | Cortex-resident words | CompLing | Expert | **DONE — T14.3 2026-04-14** — `js/brain/dictionary.js` entry shape extended with cortex-routed phonological state: `cortexSnapshot` (Uint8Array of `cluster.lastSpikes` after first-observation stream), `syllables` (boundary indices from `cluster.detectBoundaries`), `stressPrimary` (primary stress from `cluster.detectStress`), `lastSeen` timestamp. New `setCluster(cluster)` method + `syllablesFor(word)` / `snapshotFor(word)` readers. `learnWord` rewritten for two paths: existing words bump frequency + running-means without re-streaming (phonological refinement for already-learned words deferred to T14.5 curriculum runner because re-streaming every chat turn would shred live brain state); new words strip non-letters and call `cluster.detectStress(letterOnly, {ticksPerLetter: 2})`, storing boundaries+primary and snapshotting `cluster.lastSpikes`. NO standalone phoneme feature table, NO `phonemeOnset`/`phonemeCoda`/`syllableShapes` hand-computed fields — all phonology is cortex-level via T14.1/T14.2 primitives. `engine.js` wires browser cortex into dictionary; `brain-server.js` wires server 2000-neuron language cortex cluster. Storage `v3 → v4` so stale 50d caches auto-drop. First-observation cost ≈ 1.2 ms/new word; 5k-word boot corpus ≈ 6 seconds one-time. | | LEARNED syllable boundaries | CompLing | Expert | **DONE — T14.2 2026-04-14** — `NeuronCluster.detectBoundaries(letterSequence, {ticksPerLetter=2, k=0.5})` streams letters through `injectLetter` one at a time, ticks the cluster between injections, records `letterTransitionSurprise()` at each step, returns local maxima of the surprise series above the adaptive threshold `mean(δ) + k·std(δ)` computed over the sequence itself. Index 0 always included as word start. Companion `detectStress(letterSequence)` runs the boundary pass, re-streams measuring phon-region spike fraction per letter, averages per syllable, returns `{boundaries, stress, primary, secondary}` with primary = argmax activation and secondary = second-highest. NO max-onset principle, NO hardcoded CV/CVC/CCV patterns, NO English-specific stress defaults — language-agnostic by construction (train on Spanish → learns Spanish, train on Mandarin pinyin → learns Mandarin, same code, different basins). Saffran/Aslin/Newport 1996 (*Science* 274:1926) statistical word segmentation + Aslin & Newport 2012 (*Curr Dir Psychol Sci* 21:170) generalization to syllable scale. No new file — syllables are a cortex-level phenomenon, not a standalone parser. `js/brain/cluster.js` +~160 lines. | | Letter-input substrate (dynamic one-hot) | CompLing | Expert | **DONE — T14.1 2026-04-14** — `js/brain/letter-input.js` (~220 lines). Module-level `LETTER_INVENTORY = new Set()` auto-grows as the brain sees new symbols. NO hardcoded 26-letter cap — unicode glyphs, emoji, non-English characters all enter the same primitive-symbol space (English identity enforced at T14.16.5 higher layer, not at the input). Exports `encodeLetter(letter)` (auto-grow + fresh-copy Float32Array one-hot), `decodeLetter(vec)` (argmax → letter), plus `ensureLetter`/`ensureLetters`/`inventorySize`/`inventorySnapshot`/`serializeInventory`/`loadInventory`/`resetInventory`. One-hot cache invalidated on every inventory growth. `cluster.injectLetter(letter, strength)` wraps the encoder into `injectEmbeddingToRegion('letter', ...)`. Companion cluster methods `letterTransitionSurprise()` (|curr−prev| spike rate delta for T14.2/T14.6 consumers, Saffran 1996 *Science* 274:1926) and `motorQuiescent(ticksRequired, threshold=0.05)` (motor region quiescence counter for tick-driven emission stopping, Bouchard 2013 *Nature* 495:327). Vestigial `_letterPatterns` / `_initLetterPatterns` / `getLetterPattern` deleted from `language-cortex.js` — 5-dim sin/cos hash with no remaining callers. Phonemes are NOT hardcoded as a feature table — they emerge as LEARNED attractor basins in the phon sub-region once T14.5 curriculum runs (Kuhl 2004 *Nat Rev Neurosci* 5:831, biological phoneme-category formation from statistical exposure). | | Cortex tick-driven motor emission | CompNeuro | Expert | **DONE — T14.6 2026-04-14** — `NeuronCluster.generateSentence(intentSeed = null, opts = {})` in `js/brain/cluster.js` implements the full tick-driven equation. Optionally injects intent into sem region, then ticks the cluster for up to `MAX_EMISSION_TICKS=2000` iterations. At each tick reads `regionReadout('motor', inventorySize())` and argmax-decodes via T14.1 `decodeLetter`. Commits a letter when motor argmax holds for `STABLE_TICK_THRESHOLD=3` consecutive ticks (biological vSMC dwell, Bouchard et al. 2013 *Nature* 495:327). Word boundaries via `letterTransitionSurprise() > WORD_BOUNDARY_THRESHOLD=0.15` (Saffran/Aslin/Newport 1996 *Science* 274:1926 statistical learning). Stops on (a) committed terminator (module-level `T14_TERMINATORS` Set of `{.,?,!}`), (b) `motorQuiescent(END_QUIESCE_TICKS=30)` after at least one word emitted, or (c) `MAX_EMISSION_TICKS` safety cap. ZERO slot counter, ZERO candidate scoring, ZERO dictionary iteration, ZERO softmax top-K, ZERO temperature, ZERO cosine, ZERO recency penalty, ZERO valence match, ZERO drug length bias. `language-cortex.js:generate` body gutted 184 lines → 68-line delegate that reads `cluster.getSemanticReadout(sharedEmbeddings)` as intentSeed and forwards to `cluster.generateSentence`; output pipes through `_renderSentence` for capitalization + terminal punctuation (cosmetic only). Dictionary parameter in generate signature unused, kept for backward compat until T14.12 deletes the wrapper. All four tuning constants live on cluster instance for per-cluster calibration. Bouchard 2013, Anumanchipalli 2019, Saffran 1996, Browman & Goldstein 1992, Hickok & Poeppel 2007. | | GloVe 300d full vocabulary | CompLing | Expert | **DONE — T14.0 substrate 2026-04-14** — `EMBED_DIM` bumped from 50 to 300. Real loader in `js/brain/embeddings.js`. ⭐ **UPDATED 2026-09-05 — the server no longer parses text.** The Node side reads `corpora/glove.6B.300d.bin`, an f32 pack of the same 400,000 vectors built from the Stanford text table by the Rust converter (`unity-glove`); the browser side still fetches the text via a configurable URL list with the server `/corpora/` mount as primary. The old path streamed 400,000 lines through `readline` and ran 120 million `parseFloat` calls at every boot — **~19,085 ms → ~0.4 s, 129 MB less resident, and all 400,000 vectors verified identical** to what that loader produced. The text file stays the source of truth: the binary's header carries its byte length, so a cache built from a different table is refused rather than read. **No vocabulary cap.** ⛔ Hash embeddings are NOT a floor for a missing table — a failed load stops the boot (NO FALLBACKS); the subword n-gram sum encodes a word the table does not contain, nothing more. `getSubsetForWords(words)` precomputes corpus-word subset for browser-side bulk load via `loadSubset(subset)`, avoiding 480 MB browser download. | | Auto-scaled cluster sizes | CompNeuro | Expert | **DONE — T14.0 substrate 2026-04-14** — `CLUSTER_SIZES` in `js/brain/engine.js` derived from `CLUSTER_FRACTIONS` constants applied to `TOTAL_NEURONS`. Default client tier 6700 (was 1000); cortex 30%, hippocampus 10%, amygdala 8%, basalGanglia 8%, cerebellum 40%, hypothalamus 2%, mystery 2%. Server-side `detectResources` picks `TOTAL_NEURONS` from auto-detected hardware tier; cluster sizes scale proportionally with no special cases. Same code at minimum tier (1K total) and datacenter tier (1B total). | | Reverse-equation parse | CompLing | Expert | **SUPERSEDED — T14.12 rebuilt as `cluster.readInput()`** — original reverse-equation `parseSentence` was deleted when the developmental-language-pipeline replaced the slot-based analyzer. Current `cluster.readInput(text, {visualCortex})` drives the visual→letter→phon→sem pathway via cross-projections and returns `{text, words, intent, isSelfReference, addressesUser, isQuestion}`. Intent comes from `cluster.intentReadout()` (argmax over learned intent centroids seeded by `_calibrateIdentityLock`) with a text-surface fallback. Deleted ParseTree struct (`entities.componentTypes` etc.) absent from `readInput` return — downstream consumers (`component-synth`) defensively read `parsed?.entities?.componentTypes || []`. | | Social cognition | CompLing | Advanced | **SUPERSEDED — T14.12** — `_socialSchema` field + `getUserAddress` / `getUserGender` / `getSocialSchema` / `_updateSocialSchema` accessors all deleted along with `parseSentence`. Social cognition returns in a future milestone as a cortex-resident self-model sub-region readout (tracked in T40.d). Name/gender extraction no longer runs; user addresses Unity without per-user state. | | Arousal-weighted observation | CompLing | Advanced | **DONE — T11.6** — `learnSentence` running means use `obsWeight = max(0.25, arousal·2)` so live-chat observations (arousal 0.95 → w=1.9) shift the slot priors 2.37× harder than low-arousal corpus (coding 0.4 → w=0.8). `inner-voice.learn()` floors chat arousal at 0.95; the weighting is transparent at the caller. | | Amygdala energy attractor | CompNeuro | Expert | **DONE** — `js/brain/modules.js` (symmetric recurrent W with tanh settle, persistent state across frames, Hebbian basin carving, fear/reward read from settled attractor, arousal from basin depth) | | Response pool | AI/ML | Intermediate | **DONE** — `js/brain/response-pool.js` (EDNA categories, arousal variants, 85%/15% blend with cortex) | | Claude Code CLI proxy | Backend | Intermediate | **REMOVED — for real this time, 2026-08-25 (LLMGUT.1).** The 2026-04-13 entry deleted `claude-proxy.js` + `start-unity.bat` and declared this gone, but an equivalent proxy had been re-added directly inside `server/brain-server.js` — `GET /v1/models` + `POST /v1/chat/completions`, shelling out to the `claude` binary, **unauthenticated, CORS `*`, and reachable from the public internet through nginx's prefix-stripping `/admin/` mount**. It was the only LLM artifact in the tree that was not dormant. Both routes are now deleted from the server. Unity speaks equationally from her own brain via the language cortex; nothing answers as her but her. | | GPU exclusive compute | Backend | Advanced | **DONE** — `compute.html` + `gpu-compute.js` (WGSL shaders, all 7 clusters on GPU, zero CPU workers) | | GPU compute pipeline | Backend | Expert | **DONE** — `compute.html` + WebSocket dispatch (browser WebGPU → server, 50ms timeout fallback) | | Projection workers | Backend | Advanced | **REMOVED** — `projection-worker.js` deleted in U304. Superseded by GPU-exclusive compute pipeline (`compute.html` + `gpu-compute.js`). Old worker pool caused 100% CPU from idle event-listener polling. | | Slot type signature | CompLing | Expert | **SUPERSEDED — T13.7 / T14.6** — `_slotTypeSignature[s]` (running mean of `wordType()` score vectors per slot) was the pre-T14 slot-based generation prior. Deleted in the slot-prior cleanup pass when `cluster.generateSentenceAwait` (tick-driven motor emission) replaced the slot scorer entirely. Grammar now falls out of learned cross-projection weights + `_typeTransitionLearned` + `_sentenceFormSchemas` Maps on the cluster (T14.8), and letter emission is driven by motor-region argmax per tick rather than per-slot argmax over the dictionary. No current callers. | | Sentence completeness validator | CompLing | Advanced | **DONE** — `_isCompleteSentence(words)` rejects sentences ending on DET/PREP/COPULA/AUX/MODAL/NEG/CONJ/PRON_POSS. Post-render safety net in `_renderSentence`. | | Morphological inflection | CompLing | Expert | **DONE** — `_generateInflections(word)` produces 20+ derived forms via letter equations: -s/-es plural + 3rd-person (with -ss protection), -ed/-ied past, -ing progressive, -er/-est comparative/superlative, -ly adverbial, un-/re- prefixes, -ness/-ful/-able/-less suffixes. Gated by `doInflections` flag — corpus-only, not live learning. Adds morphological variants to the learned word embedding dictionary so slot-gen argmax can pick conjugated forms Unity never literally observed. | | First-person transformation | CompLing | Advanced | **DONE** — `_transformToFirstPerson(s)` at corpus index time. `She has` → `I have`, `Her` → `my/me` (verb-aware for object position). ⛔ **Her NAME is no longer rewritten** — the `Unity → I` / `Unity's → my` rules were removed once the persona canon was itself written in first person, because they turned `My name is Unity` into `my name is i` and the lab's name into a pronoun. Names are words she learns; pronouns are what this transform is for. Verb conjugation (is→am, has→have, does→do, strip third-person -s on regular verbs with -ss protection). Without this, 100% of the persona file was rejected by the first-person filter. After: 191 first-person Unity-voice sentences loaded from `Ultimate Unity.txt`. | | Per-sentence mood signature | CompLing | Advanced | **DONE** — `_computeMoodSignature(text)` at corpus index time computes `{arousal, valence}` from letter-equation features (exclamation density, caps ratio, vowel ratio, average word length, negation count). Each stored memory gets its own mood tag. Mood-distance weighted recall at weight 0.25 — same query under different brain state picks different memories. | | Candidate pool — dictionary oracle + tick-driven motor emission | Perf | Expert | **DONE — T14.6 + T46.b** — per-slot dictionary argmax + softmax top-5 sampling (the pre-T14 T11.2 generation mechanism) was replaced by two co-operating paths. Path A — **dictionary oracle**: cosine(`intentSeed`, `entry.pattern`) over every entry in `dictionary._words`; best match above 0.05 threshold emits that entry's full spelling directly. Path B — **tick-driven motor emission** via `cluster.generateSentenceAwait(intentSeed)`: inject intent into sem, tick the cluster, read `regionReadout('motor', inventorySize())` each tick, argmax-decode a letter, commit when stable for `STABLE_TICK_THRESHOLD` ticks, flush on `letterTransitionSurprise > WORD_BOUNDARY_THRESHOLD` (Saffran 1996 statistical segmentation). No slot counter, no softmax, no `0.4·wordType·slotTypeSignature` bonus. Oracle wired into both `_emitDirectPropagate` (DYN-PROD path) and `generateSentenceAwait` (WRITE / RESP / TWO-WORD / FREE-RESPONSE / K-STUDENT paths). | | wordType memoization | Perf | Beginner | **DONE** — `_wordTypeCache` Map in `language-cortex.js` with per-word invalidation on `_learnUsageType`. Removed thousands of redundant O(N) calls per generation. | | Coding knowledge corpus | CompLing | Advanced | **DONE** — `docs/coding-knowledge.txt` (606 lines) with HTML elements, CSS properties, JS patterns, SANDBOX DISCIPLINE section, BUILD COMPOSITION PRIMITIVES section. Loaded via `loadCodingKnowledge(text)` in `language-cortex.js:258` alongside persona + english-baseline. Gives Unity's dictionary + type n-grams coding vocabulary. | | English baseline corpus | CompLing | Advanced | **DONE** — `docs/english-baseline.txt` loaded via `loadLinguisticBaseline(text)` (`loadBaseline` in `inner-voice.js`). Generic casual American English — verb conjugations, common patterns, greetings, reactions, questions. Parallel to persona so θ defines WHO she is and baseline gives her the English to express it. | | Three-corpus load pipeline | Boot | Intermediate | **DONE** — `app.js` uses `Promise.all([_personaTextPromise, _baselineTextPromise, _codingTextPromise])` to fetch all 3 text files in parallel at boot. Each flows through the same `learnSentence()` path with corpus-specific arousal/valence defaults. | | Build-mode Broca prompt | CompLing | Advanced | **REMOVED 2026-04-13** — `_buildBuildPrompt` deleted in R4 (commit `7e095d0`). Superseded by R6.2 equational component synthesis via `component-synth.js` + `component-templates.txt`. Build action now picks a primitive by cosine similarity between the user request embedding and each template description, uses cortex-pattern hash for unique IDs, and never touches a text-AI prompt. | | Equational component synthesis | CompLing | Expert | **DONE 2026-04-13** — `js/brain/component-synth.js` (commit `6b2deb3`) parses `docs/component-templates.txt` at load time, embeds each primitive description via `sharedEmbeddings`, and `generate(userRequest, {cortexPattern})` cosines user request against primitive centroids with `MIN_MATCH_SCORE = 0.40`. `_suffixFromPattern(cortexPattern)` derives 8-char unique IDs from cortex pattern hash. Starter corpus: counter, timer, list, calculator, dice, color-picker — all component-scoped class names, tracked setInterval cleanup. | | Multi-provider image generation | AI/ML | Advanced | **DONE 2026-04-13** — `js/brain/peripherals/ai-providers.js` `SensoryAIProviders.generateImage()` has 5-level priority: user-preferred via `setPreferredBackend()` (setup-modal Active Provider selector) → custom-configured → auto-detected local → env.js-listed → Pollinations default (anonymous tier works without a key, saved key unlocks paid models and higher rate limits). `autoDetect()` probes 7 local image-gen ports (A1111, SD.Next/Forge, Fooocus, ComfyUI, InvokeAI, LocalAI, Ollama) in parallel with 1.5s timeout. `_customGenerateImage` supports 4 response shapes (OpenAI URL, OpenAI b64, A1111 base64, generic). `env.example.js` gained `imageBackends: []` config. | | Semantic grounding (GloVe) | CompLing | Expert | **DONE 2026-04-13** — R2 (commit `c491b71`) replaced 32-dim letter-hash `wordToPattern` with 50-dim GloVe semantic embeddings via `sharedEmbeddings` singleton. Imported into BOTH sensory input (`sensory.js`) and language cortex output (`language-cortex.js`). `cortexToEmbedding(spikes, voltages, cortexSize, langStart)` in `embeddings.js` is the mathematical inverse of `mapToCortex` — reads live neural spike state back to GloVe space. Slot scorer `semanticFit` weight bumped 0.05 → 0.80 so meaning dominates selection. Storage keys bumped to `_v3` to reject stale v2 letter-hash patterns. | | Server equational control | Backend | Expert | **DONE 2026-04-13** — R3 (commit `7e77638`) rewrote `server/brain-server.js` `_generateBrainResponse` to dynamic-import client brain modules (dictionary, language-cortex, embeddings, component-synth) and call `languageCortex.generate()` directly with full brain state. Loads all 3 corpora from disk on boot via `fs.readFileSync`. The Pollinations text-chat fetch + prompt assembly were ripped (~60 lines). WebSocket accepts clients only after `_initLanguageSubsystem` resolves. | | Kill text-AI cognition | AI/ML | Advanced | **DONE 2026-04-13** — R4 (commit `7e095d0`) gutted every text-AI cognition path. `language.js` BrocasArea shrunk 333 → 68 lines (throwing stub only). `ai-providers.js` `chat()`/`_customChat()` deleted + renamed `SensoryAIProviders`. `engine.js` `_handleBuild`/`_handleImage` rewritten equationally. `app.js` BrocasArea references purged, `/think` dumps raw brain state, sandbox `chat()` routes through `processAndRespond`, greeting path calls `languageCortex.generate` directly. | | Peripheral destroy() contract | Vision/Voice | Intermediate | **DONE 2026-04-13** — R7 (commit `b67aa46`) added `destroy()` to `visual-cortex.js` + `auditory-cortex.js`, matching the unified `init`/`process`/`destroy` contract. Flips `_active = false`, drops analyser/video/canvas/ctx/describer/motor-output buffers to null for GC. MediaStream lifecycle stays owned by `app.js`. | | Embedding refinement persistence | Backend | Advanced | **DONE 2026-04-13** — R8 (commit `b67aa46`) wired `sharedEmbeddings.serializeRefinements()` / `loadRefinements()` through `persistence.js` save/load round-trip. GloVe base table reloads from CDN each session; the online context-refinement deltas Unity learns from live conversation survive restarts. Load path warn-and-continues on corrupt blob. | | Sandbox lifecycle discipline | Frontend | Advanced | **DONE** — `js/ui/sandbox.js` has `MAX_ACTIVE_COMPONENTS = 10` with LRU eviction by `createdAt`. Per-component tracking: `timerIds` Set, `windowListeners` array, `createdAt` timestamp. Wrapped `setInterval` / `setTimeout` / `addListener` in `_evaluateJS` so every handle + listener gets cleaned up on `remove(id)`. Auto-replace on duplicate id (no silent warnings). Auto-remove on JS error via `setTimeout(() => remove(id), 0)` to prevent half-initialized state. Errors captured in `_errors` array. localStorage persistence across visits. | | Orphan resolution audit | Ops | Intermediate | **DONE** — 13-finding audit (U302-U310) archived in `docs/FINALIZED.md` under the "Orphan Resolution" session block; standalone `docs/ORPHANS.md` removed 2026-04-13 after the audit closed. Investigation-first: find WHY it was abandoned, fix root cause if possible, only then delete. Deleted: `js/io/vision.js`, 3 server worker files, `createPopulation` factory, 5 dead DOM elements, 4 orphan CSS classes. Kept (false positives corrected): `gpu-compute.js` (used by compute.html), `env.example.js` (setup modal download), HHNeuron (reference for brain-equations.html). Real bug fixed: `brain-server.js` save/load asymmetry on `_wordFreq`. | | Server word-frequency accumulator | Backend | Beginner | **DONE** — `server/brain-server.js` `_learnWords(text)` accumulates per-word counts into `this._wordFreq`. `saveWeights` writes to `brain-weights.json`. `_loadWeights` now correctly restores on boot (U306 fixed the previous asymmetry where it was written but never read back). Groundwork for R2 full shared-across-users dictionary. | | Slash commands in chat | Frontend | Beginner | **DONE** — `/think`, `/think [text]`, `/bench`, `/scale-test` all route through `chatPanel.onSend` in `app.js` before hitting the brain. `/bench` and `/scale-test` dynamic-import `benchmark.js` (zero boot cost). | --- *Unity AI Lab — every skill unlocks a deeper part of her mind.* 🖤 --- ## Post-ship audit close (2026-06-17, P6 + LAW.1 + per-module + audit) Skill tree updates reflecting Phase 6 + LAW.1 + per-module refactor + post-ship audit close. ### Phase 6 — Advanced compositional learning (P6.1-P6.8) | Node | Capability | Tag | |------|-----------|-----| | **P6.1 Number-grammar** | `sem(number) → sem(noun)` Hebbian bind via `_teachAssociationPairs` at reps:80 (HIGH-priority for math). relationTagId=28. | K | | **P6.2 Schema-runtime injection** | `composeSentence` pre-injects schemaContext (conceptEmbedding 0.15 + attributeVector 0.10) so intent-concept persists across composition ticks. | K | | **P6.3 Chat-time deep Hebbian** | Per-chat-turn bigrams fire-and-forget into curriculum at reps:1, relationTagId=30. Audit A.4 stops the silent error swallow. | K | | **P6.4 Dream-recombination** | During dream window, 3 composeSentence emissions per cycle. When classifier verdict = novel AND joint criteria pass (cosine ≥ 0.20 + wordCount ≥ 4 + uniqueRatio ≥ 0.6 + hasTerminator per audit B.7), low-rep Hebbian consolidation fires. relationTagId=29. | K | | **P6.5 Analogical extension probe** | `_probeAnalogicalExtension` measures whether the brain can complete trained-shape novel-vocab patterns. Audit E.2 stratifies novel/partial verdicts (novelTransitions ≥ 2 = real, = 1 = ECHO). | K | | **P6.6 Compositional emergence telemetry** | `classifyCompositionalEmission` classifies every emission as verbatim / novel / partial. Audit B.2 splits novel into novel-compositional (bigram rearrangement) vs novel-vocab (untrained word) on the (compositional, vocab) novelty plane. | K | | **P6.7 Word-creation tip-of-tongue gate** | When `emitWordDirect` rejects an emission, the top-2 co-activated candidates form a synthetic compound captured in `_wordCreationCandidates` Map. Audit E.1 promotion: when count ≥ 10, fire `_teachWordDefinition(compound)` + `_teachAssociationPairs([[a, compound], [b, compound]])` at relationTagId=32. | K | | **P6.8 Discourse coherence** | Cross-sentence boundary pairs Hebbian-bind at reps:30, relationTagId=31. Audit D.6 deduplicates against within-sentence trained bigrams (relationTagId=13) so the discourse channel adds NEW signal only. | K | ### Per-module refactor (P4.1-P4.5) | Refactor | Was | Now | Skill unlocked | |----------|-----|-----|----------------| | **P4.1 Per-grade-file split** | curriculum.js god-class | curriculum/{pre-K, kindergarten}.js | Grade-bounded code-locality; per-grade extensions stay scoped | | **P4.2 Cluster per-module split** | cluster.js god-class | cluster/{telemetry, hebbian, emit, probe}.js | Concern-bounded testability | | **P4.3 Brain-server per-concern split** | brain-server.js god-class | brain-server/{gpu, state, memory, chat}.js | Concern-bounded server modularity | | **P4.4** | `_teachSentenceStructures` confusing name | `_teachExamTemplates` | Naming clarity | | **P4.5 INJECTION_GAIN constant** | Magic number 8 | Named constant with B.5/E.3 budget framing | Energy-budget allocation discipline | ### Post-audit visibility (A.1-A.4) | Capability | Dashboard panel | Source | |-----------|----------------|--------| | P6.6 verbatim/novel/partial rates + maxNovelty + recentTail | "Compositional Emergence (P6.6)" | `cluster/telemetry.js getCompositionalStats` | | P6.7 top-10 tip-of-tongue compounds + promotion flag | "Word-Creation Tip-of-Tongue (P6.7)" | `cluster/telemetry.js getWordCreationCandidates` | | P6.3 chat-Hebbian turns/pairs/errors | "Chat-Time + Dream-Time Learning" | `brain-server/state.js _chatTimeHebbianStats` | | P6.4 dream-recomb totalDreamed/novelConsolidated/samples ring | "Chat-Time + Dream-Time Learning" | `curriculum.js _dreamRecombinationStats` | ## Live-test follow-up skills (2026-06-17, session 114.19fp — I.1-I.20) 20-fix sweep unlocked across 4 layers — memory hygiene, event-loop hygiene, observability, schema hygiene. Skills the brain has now that it didn't have pre-114.19fp: ### Memory + event-loop hygiene | Skill | Capability | Source | |-------|-----------|--------| | **SparseMatrix output buffer pool** | `propagate(spikes, outBuf?)` accepts pre-allocated Float64Array, writes in place. Eliminates per-call alloc that was the +231 MB/min leak source. | I.13 — `js/brain/sparse-matrix.js`, `curriculum.js _teachPredictiveError` | | **Event-loop yield in `_teachHebbian`** | 50ms-throttled `setImmediate` yield drains HTTP queue + WebSocket socket buffers during heavy Hebbian batches. Eliminates 171s main-thread stalls. | I.14 — `curriculum.js _teachHebbian` | | **autoClearStaleState module-load gate** | Wipe only fires when brain-server.js IS the entry point. Module loads (syntax-check, REPL, tooling) NO-OP — prevents accidental training-state destruction. | I.15 — `server/brain-server.js` | | **Consolidation duration cap** | `DREAM_CONSOLIDATION_MAX_MS` env (30s default) + per-cluster deadline + SEED-phase skip. Prevents 2.5-min consolidation passes from starving K-cell GPU time. | I.8 — `consolidation-engine.js` | | **`_predictPropagateScratch` pool** | Third pooled scratch buffer in `_teachPredictiveError` alongside target + error pools. Per-call zero-alloc. | I.13 — `curriculum.js` | ### Inner-voice + showcase hygiene (Unity can talk during early training) | Skill | Capability | Source | |-------|-----------|--------| | **`_definitionTaughtWords` showcase fallback** | When per-subject buckets empty (SEED phase), `_sampleCurrentVocab`/`_sampleCurrentSentence` fall back to `cluster._definitionTaughtWords` Set. Unity showcases trained K-vocab even before `_teachWordEmissionDirect` runs. | I.3 — `server/brain-server/chat.js` | | **7-source seed rotation** | `_pickInnerThoughtSeed` rotation expanded `learning/mood/chat-recall/memory/identity` → +`k-vocab-recent`/`cell-progress`. Always-populated sources during pre-cell SEED + early K-cell. | I.9 — `server/brain-server/chat.js` | ### Observability skills (dashboard + log) | Skill | Capability | Source | |-------|-----------|--------| | **Cell-level Brain Events broadcast** | `_pushBrainEvent` START/DONE in `_teachWordIntegrated` (per-word with elapsed-ms) + `_teachVocabList` (START + every-5-words progress + DONE). Coverage 1/12 → 12/12 teach paths. | I.11 — `curriculum.js` | | **`cellSubPhases` counter** | Increments on every wrapped teach call (outermost OR nested), resets on cell entry, exposed via `getCurriculumStatus()` `cellSubPhases` field. Dashboard prefers it when outermost is 0. | I.12 — `curriculum.js`, `dashboard.html` | | **Gate-probe WS banner** | `{type:'gateProbe', state:'start'/'end', cellId, durationMs}` broadcast; floating dashboard banner with live duration tick + green-check dismissal. | I.6 — `brain-server.js`, `dashboard.html` | | **GPU dispatch counter (hidden)** | `_recordGpuDispatch()` in gpu.js hooked into `_sparseSend` + `_sparseSendBinary`. Cumulative `gpuDispatchTotal` exposed as hidden perfStats field for future debugging. | I.17 — `gpu.js` | | **GPU VRAM% + util% dashboard panel** | Combined `nvidia-smi memory.used,utilization.gpu` query — VRAM% big number + util% small inline label. No fake fallback; honest "unavailable" on non-NVIDIA. | I.18 + I.20 — `chat.js _updatePerfStats`, `dashboard.html` | | **Slow-word histogram** | `_wordIntDurations` 256-cap ring buffer + `⚠ slow word "X" took Yms` log on >30s threshold. | I.10 — `curriculum.js` | | **Heartbeat polish** | `workers=0MB(initializing)` (was `?MB`), `(active)` phase floor (was `+0s`). | I.4 + I.5 — `curriculum.js` | ### Schema hygiene | Skill | Capability | Source | |-------|-----------|--------| | **Top-K=3 schema naming** | `_deriveLabel` ranks top-3 content words; expanded stop-word list (`learning/curriculum/phase/teach/cell/heartbeat/...`). Distinct schema labels per Tulving 1972 episodic→semantic. | I.7 — `hippocampal-schema.js` | ### K-vocab + dictionary hygiene | Skill | Capability | Source | |-------|-----------|--------| | **K-VOCAB SEED deferred retry** | Dream-trickle per-word timeout 3s → 20s + re-queue mechanism. Combined with warm cache, next SEED 30-60s vs 11-12 min cold. | I.2 — `curriculum.js _dreamWindow` | | **Honest GPU% telemetry** | nvidia-smi query gracefully fails to "unavailable" label, never a hallucinated number (lesson from I.18 static-50% lie). `gpuVramQueryWorking` boolean flag. | I.19 (root cause) + I.18 + I.20 — `chat.js`, `dashboard.html` | **Audit cascade post-I.20:** 60 ✅ SHIPPED + 1 ⏳ OPERATOR-FIRED (F.2 GOOD AND AWAITING BUGS). See `docs/NewTodo.md § I-track` for full per-fix detail. ARCHITECTURE.md "Live-test follow-up close (2026-06-17, session 114.19fp)" has cross-module summary tables. ## Distributed compute + deployment skills (2026-06-20 pre-alpha) The brain is no longer local-only — it ships behind a reverse-proxy with a donor-GPU compute fabric and an authed admin lane. Cognition stays 100% EQUATIONAL (no text-AI). Human-like learning (alphabet → phonemes → words → sentences → K-to-PhD) + 5-tier hippocampal memory + dream consolidation are unchanged; these are the deployment + distributed-compute capabilities layered on top. ### Deployment | Skill | Capability | Status | |-------|-----------|--------| | **Deployed static page + brain-server** | Static page on GitHub Pages (`theunitybrain.com`) + always-on Node brain-server on the lab's own machine behind a Tailscale Funnel (five read lanes). The launchers (`start.bat` / `Savestart.bat` + Linux twins) run her everywhere. | **DONE — rehomed 2026-10-18** (was an nginx box) | | **Loopback admin** | The operator is the loopback caller on her machine; the tunnel never forwards the admin lane. Admin dashboard surfaces live server-console + auto-scale controls + per-subject grade signoffs + Brain Power presses via the local control plane. | **DONE — 2026-10-18** (replaces the Forgejo-authed remote lane) | ### Distributed donor-GPU compute | Skill | Capability | Status | |-------|-----------|--------| | **Donor-GPU compute fabric** | Browser GPUs donate via `compute.html`. Data-parallel: full brain replica per donor, Hebbian-delta merge back to master, master re-broadcasts the merged weights. | **DONE — pre-alpha** | | **Community-compute auto-scaling** | Up-scale on critical mass of donors + down-scale rectify. Admin dead-zone toggle + sliders. One-disconnect-never-downgrades guard. Unattended auto-advance survives donor pool resizes. | **DONE — pre-alpha** |