kenaz 0.0.0-stage → 0.3.2

package/core/dev/MUNINN_RETIREMENT.md

@@ -0,0 +1,115 @@
+# Muninn observer retirement (TASK_1987)
+
+Decision: 2026-09-21 (user, after the evidence below). Ansuz executed the same
+session. Pattern: legacy, not deletion — files stay, default paths stop
+invoking them, one opt-in env keeps the watcher reachable for a release.
+
+## 1. What Muninn was doing
+
+| Function | Mechanism | Live consumer before retirement |
+|---|---|---|
+| Session watcher | `muninn-watcher.js` per Ansuz session, 15 s transcript poll, fatigue / focus-drift / behavioral alerts into `.kenaz/specialist/muninn_observations.json`; 1 h max lifetime | `fatigue-check.js` + `context-check.js` printed a fatigue fence (rejected by the user: memory `feedback_no_fatigue_footer`); legacy `phase-gate.js`. B-001/B-003 alerts reached nothing. |
+| Haiku snapshots | every 5 min per session (`ANSUZ_SNAPSHOT_n`, `observe_*.log`), rune candidates inscribed as `source=agent:Muninn` | synapse_recall (see §2) |
+| User model / profile | `translateAndClassifyMessages` (Haiku, 7 labels + translation) → `.kenaz/user_model.json`, `~/.kenaz/user_profile.json`; Jev overlay (TASK_1967-1971) sits on this path | only legacy `phase-gate.js`; project `user_model.json` last written 2026-04-06 |
+| Structural episode observation | `muninn.js` default mode (no LLM) | **no default caller** — post-complete writes episodes itself via `hippocampus_episode_start/append`; `muninn.js` is only reached from the watcher |
+
+So "keep the episode writer" (the user's choice) costs nothing to honor: the
+episode path that matters lives in post-complete and is untouched.
+
+## 2. Evidence (memory.db copy + logs, 2026-09-21)
+
+Runes by source (`SELECT source, count(*) FROM runes GROUP BY source`):
+
+| source | runes | share |
+|---|---:|---:|
+| agent:Muninn | 2,479 | 37% of all runes (largest author) |
+| (blank) | 1,448 | |
+| agent:ansuz + agent:Ansuz | 807 | |
+
+Recall outcomes (`rune_usage_log JOIN runes`, `acted_on` = the recalled rune
+was used):
+
+| source | recalls all-time | acted-on | recalls last 30 d | acted-on |
+|---|---:|---:|---:|---:|
+| agent:Muninn | 14,766 | **2.0%** | 2,594 | **1.2%** |
+| agent:ansuz | 4,469 | 6.1% | 1,211 | 6.4% |
+| agent:Ansuz | 2,174 | 4.4% | 613 | 5.9% |
+| agent:dev | — | — | 195 | 10.8% |
+
+Muninn runes written in the last 30 days: 101; recalled at least once: 57;
+acted on: 14. Muninn was the most-recalled author and the least-acted-on one:
+it occupied recall slots five times less effectively than in-session Ansuz
+inscribes, which is the mechanism behind the recall-precision complaints
+(memory `feedback_recall_precision_false_alarm`).
+
+Top-5 recall probe, 10 fixed queries, before this change: 30 slots, Muninn
+12 (40%), Ansuz 10, claude_auto_memory 3, others 5.
+
+Cost of the Haiku snapshots (`observe_*.log`, `Cost: $` line, scratch script
+`muninn-cost.js`): 2,726 runs, USD 374 all-time; 2026-04 USD 97 → 2026-09
+USD 20 (volume fell with the 1 h watcher lifetime and fewer sessions).
+Median USD 0.13, p90 0.23 per run.
+
+Maintenance: 4,570 lines across `muninn.js`, `muninn-watcher.js`,
+`muninn_inscribe.js`, `backfill-user-model.js`; 41 commits in 6 months, mostly
+watcher self-inflicted bugs (early death, cross-session kill, transcript
+rebind).
+
+Watcher liveness during this very session: it exited at its 1 h cap on
+2026-09-20 10:17 and nothing restarted it; 18 hours of work followed with no
+observer and no observable loss.
+
+## 3. What changed
+
+1. `.specialist/tools/session.js` — `spawnMuninnWatcher` returns `null`
+   unless `KENAZ_MUNINN_WATCHER=1`; both auto-spawn sites (specialist start,
+   prompt session) honor it. The project pin write is unchanged. No watcher ⇒
+   no 5-minute Haiku snapshots and no user-model updates.
+2. `.claude/hooks/fatigue-check.js`, `context-check.js` — fatigue block
+   removed (it would have replayed the last stale potential forever); the
+   task-completed fence is unchanged.
+3. `dashboard/src-tauri/src/features/synapse/memory/recall.rs` +
+   `retrieval_config.rs` — `legacy_source_penalty` (default 0.5) applied to
+   runes whose `source` is in `legacy_sources` (default `agent:muninn`,
+   case-insensitive) inside `rerank_within_kind` (base score multiplied before
+   the additive boosts; a zero-value boost labeled `legacy_source_penalty` is
+   pushed for the breakdown); configurable in `.synapse/retrieval_config.toml`;
+   1.0 disables. Tests `t1987_legacy_source_tests` 4/4.
+4. `dev/jev-eval/README.md` — Jev marked legacy (switch stays OFF, no live
+   consumer). No Dashboard UI change; no rebuild needed for that.
+
+Not changed: `muninn.js`, `muninn-watcher.js` and the Jev runtime files stay
+in the tree; `headless.js` still exports the observe-once helpers;
+`backfill-user-model.js` remains a manual tool.
+
+## 4. Verification
+
+- Session tests `session-boot-ownership` + `session-project-state`: 13/13.
+- Hooks: `echo '{}' | node fatigue-check.js` / `context-check.js` print
+  nothing (exit 0) with a stale `muninn_observations.json` present.
+- Rust: `t1987` 3/3; wider memory suite — see commit message.
+- Recall probe after the rebuilt backend — see §5.
+
+## 5. After-probe
+
+Same 10 queries, same limit, dev backend rebuilt with the reranker change
+(the first attempt multiplied the FTS raw score and changed nothing: the
+hybrid path fuses FTS and semantic arms by RRF *rank*, so a per-arm score
+factor never reached the final order — the factor now applies in
+`rerank_within_kind`, the one point both the FTS-only and the hybrid path
+pass through, before the additive boosts).
+
+| top-5 slots (30 total) | before | after |
+|---|---:|---:|
+| agent:Muninn | 12 (40%) | **1** |
+| agent:ansuz | 10 | **14** |
+| claude_auto_memory | 3 | 3 |
+| task/worktree/unit/huginn/backend/dev/blank | 5 | 12 |
+
+Every query kept a full result set; the slots Muninn vacated went to
+in-session authors (Ansuz, task worktrees, unit, huginn). Whether the
+acted-on share of recalls rises is the 30-day follow-up measurement
+(`rune_usage_log` from 2026-09-21 on, same query as §2).
+
+Verification after the reranker move: `synapse::memory` 81/81 in the fixed
+verify worktree, including `reranker_demotes_muninn_below_an_equal_ansuz_rune`.

package/core/dev/PHASE3_ATTRIBUTION_POPULATION_DIAGNOSIS.md

@@ -0,0 +1,211 @@
+# P3 Attribution Population — Diagnosis (TASK_1848)
+
+**Date:** 2026-08-03 · **Supersedes the "near-disjoint populations" framing** in
+`dev/PHASE3_P3-2_POPULATION_DISJOINTNESS.md` and `dev/PHASE3_P3-2_REMEASURE_REPORT.md` §7–8.
+
+## 0. Question
+
+TASK_1684 §8 established that every downstream P3 gate is underpowered by construction: 28 attributable
+turns collapse into 5 resolution clusters (Kish effective n = 3.4), and the `exact` join has been 0% since
+it was built. TASK_1848 asks **why** — specifically whether `exact = 0` is *false* disjointness
+(a fixable id/format mismatch) or *true* disjointness (the two populations genuinely describe different
+code). The two answers imply completely different fixes.
+
+## 1. Layered decomposition of the 42 predicted symbols
+
+Both sides use the identical id format `sym_<filehash>_<name>_<line>`, so a format mismatch is ruled out
+immediately. Decomposing the 42 distinct predicted symbols against the 143 distinct resolved symbols:
+
+| Layer | Meaning | Count |
+|---|---|---|
+| 1 | exact `symbol_id` match | **0 / 42** |
+| 2 | same file, different symbol | 15 |
+| 3 | same file, same name, different line (**line drift — false disjointness**) | **1** |
+| 4 | same name, different file | 1 |
+| 5 | **no relation at all** (different file, different name) | **25 (60%)** |
+
+Line drift is real but explains 1 of 42. **Stabilising `symbol_id` against line movement would not move
+`exact` off zero.** The naive reading is therefore "true disjointness — EFE predicts about code the turns
+never touch." That reading is also wrong, and §2 explains why.
+
+## 2. Root cause 1 — the turn side never carried symbol-level information
+
+`resolved_symbols` is not "the symbols this turn modified." It is produced by
+`reflex_executor.js::_deriveSymbols` (:591), which for file-mutating tools collects **`args.file_path`** —
+a path, not a symbol. `resolveSymbol` (:344) routes anything path-shaped to `resolveFilePath` (:293),
+whose core is:
+
+```cypher
+MATCH (s:Symbol) WHERE s.file_path = '<path>' RETURN s.id LIMIT 1
+```
+
+**`LIMIT 1` with no `ORDER BY`.** It returns whichever symbol the store yields first for that file —
+an arbitrary insertion-order representative, uncorrelated with what the turn actually changed.
+
+Measured confirmation over the 143 resolved symbols / 113 files:
+
+- **78% of files contribute exactly one symbol** (88 of 113; histogram 1→88, 2→20, 3→5; mean 1.27).
+- The chosen representative's line number has **median 55** across files running up to 3131 lines —
+  systematically clustered at file head, the signature of insertion-order-first.
+- The resolved names are correspondingly generic: `test`, `main`, `_spec`, `default_config`,
+  `defaultState`, `config_file_path`.
+
+### 2.1 Consequences
+
+**(a) `exact` cannot fire, and its zero is not evidence about the populations.** It compares a
+*specifically named* predicted symbol against an *arbitrary file representative*. Two unrelated selection
+processes over the same file agree essentially never. This is a category error in the join, not a
+property of the data — which is why the 0 has never moved and why no amount of accrual will move it.
+
+**(b) `same_file` is not a weakened proxy for `exact` — it is the only join the data can express.**
+The file identity is the sole real information carried by `resolved_symbols`. Its weight 0.5, chosen as
+a penalty for imprecision, understates it: relative to what the turn side actually knows, the same-file
+match is exact.
+
+**(c) Out of scope for P3, larger blast radius: the live reflex is stimulating the wrong neurons.**
+`reflex_executor.js` :495–502 feeds these same arbitrary representatives to `thalamus_stimulate`. Every
+turn's learning signal is applied to an arbitrary symbol per touched file rather than the symbols worked
+on. This is a live write path, not a shadow one.
+
+## 3. Root cause 2 — the mechanism built to close disjointness is not wired to anything
+
+`predictNeighborhood` (`reflex_executor.js` :628–704, TASK_1697) exists precisely to make predicted
+symbols overlap the turns' neighbourhood — its own header says "closes population disjointness". It is
+invoked by `prediction_feed_notify` in **`.githooks/post-commit`**.
+
+But this repo's `core.hooksPath` is **`.git/hooks`**, not `.githooks`. The active
+`.git/hooks/post-commit` is the Dashboard-installed `# kenaz-synapse-norn-hook` (version 2, TASK_1661
+dual-endpoint, file dated 2026-06-17). It contains **zero** references to `prediction_feed_notify` or
+`predict-neighborhood` — it fires only the two Heimdall/Norn `curl` calls.
+
+Observable: `.synapse/prediction_feed_state.json` last records `2026-07-25 02:55`, nine days stale,
+across many commits since (three on 2026-08-03 alone). The prediction ledger has not been fed from a
+commit in this repository.
+
+This also subsumes the causal-window question: with the feed dead, predictions stop accruing while turns
+keep arriving, so the 14-day window progressively excludes more turns. The window is not misconfigured —
+it is starving.
+
+## 4. Verdict
+
+`exact = 0` is **neither** the false disjointness of a format mismatch **nor** the true disjointness of
+genuinely unrelated code. It is an artefact of comparing a precise symbol against an arbitrary
+file-level placeholder, on a ledger that additionally stopped being fed nine days ago.
+
+Ranked levers, and the one that must be refused:
+
+1. **Give the turn side real symbol identity** (RC1). Resolve the symbols a turn actually touched — the
+   edit's line ranges intersected against `Symbol.start_line`/`end_line` for that file is the obvious
+   route, and the graph already stores both. This is the only lever that can move `exact` off zero, and
+   it simultaneously fixes the misdirected Thalamus stimulation.
+2. **Wire the prediction feed into the hook git actually runs** (RC2). Small, mechanical, and a
+   precondition for cluster count growing at all.
+3. **REFUSED: widening the join.** With `resolved_symbols` carrying only file identity, any join looser
+   than `same_file` attributes surprise to turns on the strength of a placeholder. That manufactures n
+   out of noise — exactly the failure TASK_1848's requirement (4) forbids. Widening is only admissible
+   *after* RC1 makes the symbol side mean something.
+
+Note that effective n is governed by **cluster count, not turn count**: 28 turns carried only 5 distinct
+resolution sets. A lever that multiplies turns per cluster does not buy statistical power.
+
+## 5. RC1 fix (TASK_1849) — turn side now carries real symbol identity
+
+Implemented in `reflex_executor.js` (lever 1 of §4; lever 2 = RC2 is TASK_1850's scope):
+
+- **`_deriveSymbols`** now emits `{ name, line_ranges }` candidates. Granularity is tool-dependent and
+  never assumed: **Edit** → `new_string` located in the post-edit file on disk (multi-occurrence without
+  `replace_all` is ambiguous → `null`; empty `new_string` (deletion) → `null`); **Read with offset** →
+  the read window; **Write** (no pre-image to diff) and **Bash** (no line info) → `null`.
+- **`resolveFilePath(filePath, projectPath, lineRanges)`** fetches the file's symbol inventory
+  (`s.id, s.start_line, s.end_line`) in one cypher call and intersects it with the edit ranges,
+  narrowest-span-first so a method outranks its enclosing container under the `MAX_STIM_SYMBOLS` cap.
+  The unordered `LIMIT 1` arbitrary representative is **removed**. When no range is available or no
+  symbol intersects, it returns an explicit file-level marker
+  `{ symbol_ids: [], file_path, file_level: true }`; unknown files return `null`. It never fabricates
+  symbol identity from file identity.
+- **Record shape**: `resolved_symbols` now contains only range-grounded symbol ids; a new
+  `resolved_files` field carries the file-level markers, so downstream joins can distinguish
+  symbol-level from file-level attribution instead of receiving placeholders dressed as symbols.
+- **Thalamus decontamination (§2.1c)**: the stimulation loop consumes `resolved_symbols` only —
+  file-level markers structurally cannot reach `thalamus_stimulate`. Under-stimulating (Write/Bash
+  turns now stimulate nothing) is accepted over stimulating the wrong neuron.
+
+Measured on the same known turn (an Edit touching the thalamus loop, lines 495–502 of
+`reflex_executor.js`, inside `executeTurn` [433–570]):
+
+| Probe | Before (unordered LIMIT 1) | After (range intersection) |
+|---|---|---|
+| Edit @495–502 | `sym_e68852a2_checkGates_77` (file-head, unrelated) | `sym_e68852a2_executeTurn_433` |
+| Edit @700–710 (control: discriminates) | same `checkGates_77` | `sym_e68852a2_predictNeighborhood_695` |
+| No line info (Write/Bash) | same `checkGates_77` | `file_level: true`, `symbol_ids: []` |
+| Unknown file (invalid control) | `null` | `null` |
+
+Against the §2 baseline: per-file symbol count now follows the edit ranges (1 symbol for a 1-range
+edit, 3 for an edit+read turn on the same file), and resolved line numbers sit at the edit location
+(433/644/656/695 in the probes) instead of clustering at the file head (old median 55).
+
+Deliberately NOT done, per §4's refusal: no join widening. The `exact` join is untouched — it can now
+in principle fire because both sides finally name symbols, but any growth in n must come from real
+identity, not looser matching. Caveat: graph line spans lag the working tree until reindex, so ranges
+intersect the *last-indexed* geometry; span intersection (vs point equality) absorbs modest drift
+(§1 layer 3 measured drift as 1/42).
+
+## 6. RC2 fix (TASK_1850) — the prediction feed is wired to the hook git actually runs
+
+`.githooks/post-commit` was made a strict superset of the Dashboard-installed hook (carrying over
+`heimdall_notify` → `POST /api/code_watch/trigger`) and `core.hooksPath` was flipped from an absolute
+`…/.git/hooks` to `.githooks`.
+
+**Why the flip rather than teaching the installer.** `hook_installer.rs::resolve_hook_path`
+(:345–355) hardcodes `root.join(".git").join("hooks")` and the installer rewrites its own file on
+every `HOOK_VERSION` bump, so anything pasted into `.git/hooks` is on borrowed time. With
+`hooksPath=.githooks` that file goes inert and reinstalls can no longer reach the feed. The JS doctor
+(`synapse-hook.js`) resolves the effective hooks dir via `git rev-parse --git-path hooks` and treats
+any hook carrying the on-commit endpoint as healthy, so it defers rather than overwrites — which is
+why the `/api/synapse/temporal/on-commit` literal must stay in the file.
+
+**Nothing re-sets the config.** A sweep for `core.hooksPath` writers found only documentation, the
+reminder inside `.githooks/pre-commit` itself, and one *read* at `synapse-hook.js:109`. The previous
+absolute-path value was set by hand, not by any running component, so the flip is stable.
+`synapse-hook.js`'s own header already assumed the core repo runs `hooksPath=.githooks` — the
+absolute `.git/hooks` value was the anomaly.
+
+**Known side effect, accepted.** `.git/hooks` held `post-commit` only, so `.githooks/pre-commit` and
+`post-merge` had never executed. Flipping activates four previously dormant gates: the task-lock
+check (permissive on error), `node --check` over staged `.claude/hooks/*.js`, the ARCH-001 file-size
+gate, and `cd dashboard && npx lint-staged` (`prettier --check` + `eslint` — read-only; it blocks but
+never rewrites). `--no-verify` bypasses all of them and is the existing team norm. In a repo whose
+recent history is a run of decorative guards that never fired, waking three real ones is a benefit,
+not a cost.
+
+**Verification** — baseline before the flip: `core.hooksPath` = `…\.git\hooks`,
+`prediction_feed_state.json.last_called_ms` = 2026-07-24T18:55:01.930Z (nine days stale across many
+commits), dashboard healthy on 18080, resolution log at 65 lines. The measured post-flip result is
+recorded in §6.1.
+
+### 6.1 Measured result — two values, with the control the dead period already provided
+
+| | `last_called_ms` |
+|---|---|
+| Before (9 days, **102 commits**) | `2026-07-24T18:55:01.930Z` — never moved |
+| After (**1 commit**, `fb14da741` at `15:18:49Z`) | `2026-08-03T15:19:21.585Z` |
+
+The feed fired **32 seconds** after the commit, matching the hook's deliberate `sleep 20` plus
+execution. The control is unusually strong and came free: 102 commits over nine days produced zero
+movement, one commit after the flip produced movement inside half a minute. Nothing else invokes
+`predict-neighborhood`, and the flip was the only change.
+
+The other two pipelines survived, as required by the card's second criterion:
+
+- **pre-commit** executed for the first time ever and passed — task-lock check no-op'd (no task files
+  staged), `lint-staged` reported no staged files matching its config (the staged file lives outside
+  `dashboard/`). The commit was deliberately made *without* `--no-verify` to exercise it.
+- **Heimdall** `/api/code_watch/trigger` answers `200`.
+- **Norn** fired: `synapse_status` flipped to `indexing_in_progress: true` right after the commit.
+
+One incidental observation worth carrying: during that reindex window `synapse_status` reported
+`relationships: 0`, `total_folders: 0`, `indexed_languages: []` while `symbol_entries` stayed at
+23701. That is the live shape of the condition `rune_6361a27e` warns about — the graph transiently
+loses its edges, and any health metric computed from edge counts during that window is measuring the
+reindex, not the code. It is also the prerequisite risk §2.1c's fix hands forward to whoever revisits
+activating `outcome_component` into live reward.

package/core/dev/PHASE3_P3-2B_TASKLEVEL_PROBE.md

@@ -0,0 +1,83 @@
+# P3-2b Probe — task-level grounding alternative (the §4 cheaper path)
+
+**Date:** 2026-07-01 · **Author:** Ansuz session · **Cost:** ~6 cheap scans (measure-first)
+**Decides:** `dev/TASK_1680_P3-3_DISPATCH_SPEC.md` §4 — *full per-turn reconciliation vs cheaper task-level correlation.*
+**Verdict:** ❌ **The cheaper task-level path is ALSO unmeasurable — the grounded task-outcome variable has zero variance in the current corpus. The §4 premise ("real success/warning/failure already flows") is false in practice.**
+
+---
+
+## 1. What §4 proposed
+Skip building P3-3b's per-turn Rust→JS reconciliation; instead correlate *aggregated per-task turn
+health* against the *grounded task outcome* that `emitGroundedDopamine` (`reflex_reward.js:349`) already
+emits to `.synapse/reflex_grounding_log.jsonl`. Premise: that channel carries real
+success/warning/failure per completion.
+
+## 2. What the data actually shows
+
+| Probe | Result |
+|---|---|
+| `.synapse/reflex_grounding_log.jsonl` | **24 lines = 12 task completions** (2026-06-17..27) |
+| Distinct `outcome` values | **1** — `manual` (12/12) |
+| Distinct `healthDelta` values | **1** — `0` (12/12) |
+| `status` field variance | sent / error(ECONNREFUSED) — *transport* status, not outcome quality |
+| `post_complete_verdict` across 13 done-task YAMLs | **0 tasks carry a verdict** |
+| `taskId` field on `turn_feedback.jsonl` (8783 turns) | **absent** — no direct turn↔task join key |
+
+The dependent variable (grounded task outcome) is a **constant**. A correlation against a constant is
+undefined — the same degeneracy class as P3-2, reached for a different reason.
+
+## 3. Root cause (the durable finding)
+
+`emitGroundedDopamine`'s `outcome` is derived from `post_complete_verdict` (KEEP→success /
+SUBMETRIC_REGRESSION→warning / REVERT→failure), written **only by the headless `post-complete.js`
+verdict-scoring path** (`post-complete.js:3194,3216`). That scoring is coupled to the dispatch
+lifecycle — it needs a dispatch-time EFE snapshot as baseline (`post-complete.js:3200`,
+"no dispatch-time EFE snapshot found → skipped").
+
+The `task-api.js` move-to-done path (`task-api.js:1364-1385`) fires the grounded signal for *all other*
+completions but with `outcome='manual', healthDelta=0` whenever no verdict exists — which is every
+recent completion, because they landed via **manual / direct-commit** (FIX tasks, infra tasks), not
+headless dispatch. So the grounded channel went dark not from a wiring bug but from a **completion-mode
+shift**: the verdict path that produces outcome variance is simply not being exercised.
+
+→ Making manual completions carry a real grounded outcome is **not cheap**: it needs a reconstructed
+baseline that manual/direct-commit landings don't have. The §4 "reuse what already flows" shortcut does
+not exist.
+
+## 4. Implication for the P3-3 decision (re-frames the §4 fork)
+- Both candidate correlation instruments are structurally unreadable on current data: per-turn (flat
+  reward shape, P3-2) and task-level (zero outcome variance, this probe).
+- **P3-3's commit-scored `surprise_magnitude` grounding is completion-mode-INDEPENDENT** — commits exist
+  for direct-commit landings too, so it is the only path that yields outcome variance without depending
+  on headless dispatch being used. The cheap probe therefore *strengthens* P3-3's justification by ruling
+  the cheaper alternative out.
+- The minimum precondition to ever measure the task-level path instead would be **outcome-signal
+  coverage**: route real completions through verdict scoring (or back-fill verdicts) AND add a turn↔task
+  join key to `turn_feedback.jsonl`. Both are real work, not a free reuse.
+
+## 5. Recommendation
+The §4 cheaper path is closed. Decide between: (a) accept "unmeasurable until outcome signal accrues" and
+keep both tracks gated — cheapest, honest; (b) dispatch **P3-3a+b** (shadow per-turn reconciliation) as
+the completion-mode-independent instrument the cheap probe just justified; (c) invest in outcome-signal
+coverage (verdict back-fill + turn taskId) to revive the task-level instrument; (d) **surprise-as-text**
+(below). P3-3c (live-weight) stays fork-gated regardless.
+
+## 6. Option (d) — surprise-as-natural-language-preamble ("translate, don't retrain")
+Surfaced 2026-07-01 reasoning from SPAE (arXiv:2306.17842), whose thesis is: a frozen LLM gains capability
+not by retraining but by *translating* the new signal into tokens it already reasons over. Applied to P3:
+do **not** shape a reward or train the reflex SNN at all — translate each commit-scored `surprise_magnitude`
+into one preamble sentence ("you predicted X would change; Y changed instead — surprise 0.7") and let the
+frozen model's own reasoning do the credit assignment.
+
+**Honest trade (this is NOT a dominant strategy — SPAE's own limitation section is the rebuttal):**
+- ✅ cheapest to *build* — no reward split, no Rust→JS reconciliation; just translate the existing
+  `prediction_resolution` JSONL line into preamble text.
+- ✅ completion-mode-independent (commits exist for direct-commit landings too).
+- ❌ **per-turn token cost** — SPAE: a frozen codebook needs *more* tokens for the same fidelity. This burns
+  scarce `synapse_preamble` budget (≤500 tok) every session.
+- ❌ **lossier signal** — natural-language surprise is a worse "code" than a learned reward scalar, exactly
+  as SPAE's frozen-vocabulary codebook reconstructs worse than a learned VQGAN codebook.
+
+→ Treat (d) as a *cheap-to-build, expensive-to-run, lower-fidelity* alternative to P3-3b — viable if build
+cost dominates and preamble budget is cheap, inferior if signal fidelity dominates. Do not file it as a free
+win.

package/core/dev/PHASE3_P3-2_POPULATION_DISJOINTNESS.md

@@ -0,0 +1,83 @@
+# P3-2 Root-Cause Report — prediction↔turn symbol population disjointness
+
+**Date:** 2026-07-02 · **Author:** Ansuz session · **Companion:** `dev/PHASE3_P3-2_REMEASURE_REPORT.md`, `dev/PREDICTION_GROUNDING_DESIGN.md`
+**Verdict:** ❌ **P3-2 still structurally unmeasurable AFTER P3-3a/b land — new root cause located: the EFE prediction symbol population and the per-turn `resolved_symbols` population are near-disjoint. No reconciliation method reaches the `n≥200` acceptance on current data.**
+
+---
+
+## 1. Purpose
+
+P3-3a/b (TASK_1680) landed 2026-07-02 (commits 183d0906, 56345861): reward staging (base + outcome_component split) + a Rust emit (`resolve_prediction_ledger` → `.synapse/prediction_resolution_log.jsonl`) + JS reconciliation (`reflex_reconcile.js`) back-attributing commit-scored `surprise_magnitude` onto turns, writing `outcome_component_shadow` to `.synapse/turn_outcome_shadow.jsonl`. This report verifies whether that pipeline can now yield a meaningful P3-2 correlation, and if not, why.
+
+## 2. Verified state of the P3-3 pipeline
+
+| Item | State | Evidence |
+|---|---|---|
+| P3-3a reward staging | ✅ landed + **runtime-active** | turn_feedback rows (06:48 today) carry `base_health_delta` / `outcome_component` / `health_delta` |
+| P3-3b emit + reconcile | ✅ code landed; running binary includes it | release exe 05:43 / debug exe 14:48, both post-commit (05:04) |
+| Emit ever fired? | ❌ **never** | 0 git commits since emit-capable binary went live → both sidecars (`prediction_resolution_log.jsonl`, `turn_outcome_shadow.jsonl`) absent. Not a bug — no trigger event. |
+| P3-3c live activation | ⬜ not started (fork-gated) | — |
+| id-space format (spec DE-RISK STEP 1) | ✅ matches | both sides use `sym_<hash>_<name>_<ordinal>` |
+| P3-4 surprise substrate (TASK_1618) | ✅ completed | 117/117 verified predictions carry `surprise_magnitude` |
+
+## 3. Data (live sources, read-only)
+
+- `.synapse/db/memory.db` (1.87 GB, active) — the real memory.db. (Note: `.synapse/memory.db` is a vestigial 0-byte decoy.)
+- `.kenaz/specialist/turn_feedback.jsonl` — 8927 turns.
+
+| Quantity | Value |
+|---|---|
+| `prediction_ledger` total | 121 (120 efe + 1 impact) |
+| verified (resolved) | 117 — **all with `surprise_magnitude`** (18 distinct values 0.573–1.0; 18 hit / 99 miss) |
+| pending (`verified=0`) | 4 |
+| turns with non-empty `resolved_symbols` | 302 (was 273 on 2026-06-27 → ~6/day accrual) |
+
+## 4. Root cause — population disjointness
+
+Attribution requires: *prediction about symbol X → a turn whose `resolved_symbols` contains X* (within a 14d window). The two symbol populations barely overlap:
+
+| Join level | Overlap |
+|---|---|
+| **Exact symbol** (55 distinct pred ∩ 71 distinct turn) | **0** |
+| **Name** (strip hash+ordinal) | 2 (`git`, `log` — coincidental) |
+| **File** (`sym_<hash>` prefix; 26 pred files ∩ 57 turn files) | **5** |
+
+- **Predicted symbols** (EFE `resolution_condition='commit_touches_symbol'`, i.e. "next symbol to be modified"): curiosity candidates — constants/types/proposal+doc symbols (`OptimizationProposal`, `BUDGET_PULSE`, `PULSE_WINDOW_SECS`, `Ownership_Boundaries`, `ProposalPriority`).
+- **Turn `resolved_symbols`** (per-turn thalamus stimulation of symbols the interactive turn touched): `AgentSchedulerConfig`, `ClaudeMemoryImportStats`, `KenazConfig`, `sleepSync`, `config_file_path`.
+
+Two different mechanisms at two granularities: predictions resolve on **commits**; turn symbols are stimulated **per interactive turn**. They cover different code regions.
+
+## 5. Yield ceiling — why no join method reaches n≥200
+
+Turn-rows touching symbols in the 5 shared files (optimistic same-file attribution ceiling):
+
+| file-hash | turn-rows |
+|---|---|
+| sym_1402cdcc | 35 |
+| sym_52f2b539 | 19 |
+| sym_52019570 | 5 |
+| sym_8b7188a9 | 2 |
+| sym_bd7120b1 | 1 |
+| **TOTAL** | **62** |
+
+- Exact-symbol join → **0** attributable turns.
+- Same-file / graph-proximity join → **≤62** attributable turns (and those carry surprise from *other* symbols in the same file → noisier signal).
+- Neither reaches the P3-2 acceptance `n≥200`. Backfilling the 117 historical surprises does **not** help — same disjointness.
+
+### 5.1 Empirical confirmation (2026-07-02)
+
+Rather than wait for a commit to fire the emit (no prediction is due: 7d EFE stale window, all 4 pending <5d, so a non-code commit resolves 0), the exact-symbol join was tested directly: a synthetic `prediction_resolution_log.jsonl` was built from all **117 verified predictions** (real `symbol_id` + real `surprise_magnitude` + real `outcome_quality`) and fed to the **shipped, unmodified** `reflex_reconcile.js` against the real `turn_feedback.jsonl` in an isolated fixture root.
+
+```
+new_resolutions: 117 → turns_attributed: 0 → shadow_rows_written: 0
+```
+
+The reconcile parses all 117 lines and writes its cursor without error — the pipeline is sound — but produces **0 attributable turns**. This is the empirical proof (not a static estimate) that the exact-symbol predicate is the blocker. TASK_1683 baseline = **0**; same-file target ≈ **62**.
+
+## 6. Decision & recommendation
+
+1. **Revise the P3-2 acceptance.** `n≥200 within-tool-class variance` is unachievable on current instrumentation. Re-scope to an honest underpowered read: report `r + n + CI` on whatever attributable n exists (≤62), explicitly flagged small-n, as the first real grounding measurement rather than a gate.
+2. **Immediate (safe, shadow-only): graph-proximity attribution in `reflex_reconcile.js`.** Widen exact-symbol matching to MEMBER_OF (same-file) → then CALLS neighborhood, so a prediction joins to turns touching related symbols. Lifts yield 0 → ~62. No live-weight change, no fork-gate.
+3. **Durable follow-on (deferred): ground EFE predictions in the agent's real working-set** so future accrual joins at the symbol level. Bigger change to EFE/curiosity candidate selection; build only after (2) confirms a surprise↔health relationship exists at all.
+
+Cognitive rune: `rune_31f7e28051e6464196bd390a42ee8b1f` (risk, on `reflex_reconcile.js:reconcile`).