kenaz 0.0.0-stage → 0.3.2

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

@@ -0,0 +1,231 @@
+# P3-2 Re-measure Report — reflex_reward grounding (TASK_1582)
+
+**Date:** 2026-06-27 · **Author:** Ansuz session · **Gate:** TIME window 2026-06-17..23 (passed)
+**Companion design:** `dev/PREDICTION_GROUNDING_DESIGN.md` §7.2 / §7.4
+**Verdict:** ❌ **STILL STRUCTURALLY UNMEASURABLE — `r` undefined. Real blocker is P3-3 (reward staging), not time.**
+
+---
+
+## 1. Purpose
+
+P3-2 is the hard gate of the reflex_reward grounding track: *a real `health_delta`-vs-commit-outcome
+correlation (r + n + CI) with symbol-based attribution must replace the structural argument before any
+reward change (P3-5).* The gate was a TIME gate — wait ~1–2 weeks from the P3-1 symbol-logging fix
+(7f51aceb, 2026-06-09) for symbol-populated turns to accrue, then re-run the Phase 2 correlation. The
+window (2026-06-17..23) has now fully passed (today 2026-06-27); no session ran it in-window. This report
+is the re-measure.
+
+## 2. Data
+
+Live source: `.kenaz/specialist/turn_feedback.jsonl` — 8671 turns, actively accruing (last write 2026-06-27).
+
+| Quantity | Value |
+|---|---|
+| Total turns | 8671 |
+| Turns with non-empty `resolved_symbols` (attributable) | **273** (vs 187 on 2026-06-13; +86 / 14d) |
+| First symbol-populated turn | 2026-06-10 20:31 |
+| Distinct `health_delta` values on attributable turns | **2** |
+
+## 3. Finding — the reward degeneracy (§7.2 fact #1) is UNCHANGED
+
+### 3.1 Attributable turns hold exactly two reward values, fully determined by tool class
+
+| `health_delta` | count | tools |
+|---|---|---|
+| −0.03 | 208 | Bash 166 + Read 42 |
+| +0.02 | 65 | Edit 45 + Write 20 |
+
+Within-tool-class variance = **0** (each class → one constant value). This is worse than Phase 2's
+within-type variance of 0.000016. A correlation between a 2-valued, tool-class-determined signal and any
+commit outcome **measures tool identity, not reward grounding** — `r` is degenerate/undefined, exactly the
+§7.2 fact #1 verdict.
+
+### 3.2 The reward variance and the attribution path are PROVABLY DISJOINT
+
+The reward *does* have variance across the full file (18 distinct `health_delta` values, dominated by the
++0.20 inscribe reward, plus 0.1 / 0.15 / 0.03 …). But:
+
+- **625 inscribe-reward (+0.20) turns — 0 of 625 have non-empty `resolved_symbols`.**
+
+`synapse_inscribe` writes a rune; it does not commit code, so it has no symbol→commit outcome to attribute.
+Every turn carrying reward variance lives in the empty-attribution set; every attributable turn lives in the
+2-valued set. The two sets do not intersect. **Therefore accrual cannot fix this** — waiting longer adds more
+2-valued code turns and more unattributable inscribe turns, never within-class variance.
+
+## 4. Reconciliation with the gate's optimism
+
+§7.4 predicted P3-2 would now have *"real within-type variance + attribution to produce an actual r."*
+Attribution arrived (#2 fixed: n=273; #3 partial: P3-4/TASK_1618 landed, `ARM_RUNE_REINFORCEMENT=false`),
+but the *within-type variance* never did, because it was never an accrual problem — it is a **reward-shape**
+problem. `health_delta` is a per-tool lookup table (Edit 0.10 − B-001 mirror 0.08 = 0.02; Bash/Read −0.03;
+inscribe 0.20). No amount of data gives a lookup table residual variance.
+
+## 5. Verdict & recommendation
+
+- **P3-2 = unmeasurable; `r` undefined.** Recorded here as the durable artifact the gate required. The
+  structural argument stands because the instrument is structurally unreadable, not under-powered.
+- **The mis-ordering is the lesson:** the plan placed P3-2 (re-measure) before P3-3 (reward staging). But
+  P3-2 cannot yield a number until P3-3 splits the flat per-tool reward into a base + outcome-conditional
+  component that *can* vary within a tool class. **P3-3 is the unmet prerequisite, not time.**
+- **Next:** stage P3-3 (reward staging) as its own task. P3-3 touches live reward weights
+  (`reflex_reward.js`) → fork-gated (Goodhart + scaffolding-asymmetry) + user sign-off + held-out A/B before
+  any live-weight change. P3-5 (grounded reward) stays gated on a *post-P3-3* P3-2 re-run.
+
+## 6. Method note (measure-first)
+
+This verdict was reached with ~6 cheap substring scans + one `synapse_recall`, not a dispatched correlation
+agent — because a correlation on a 2-valued, tool-class-determined input is degenerate by inspection. Running
+a full r+n+CI pipeline would have produced "undefined / degenerate" at higher cost. Measure-first caught the
+binding constraint (reward shape) before plumbing.
+
+---
+
+## 7. Addendum — 2026-07-02 · TASK_1683: graph-proximity join + revised acceptance
+
+### 7.1 Context
+
+TASK_1680 (P3-3a/b) landed reward staging and `reflex_reconcile.js`, which writes `outcome_component_shadow`
+to `.synapse/turn_outcome_shadow.jsonl`. The companion disjointness report
+(`dev/PHASE3_P3-2_POPULATION_DISJOINTNESS.md`) showed empirically that the original exact-symbol join yields
+**0 attributable turns** (tested against 117 verified predictions + 8927 real turns). This addendum records
+the same-file proximity fix (TASK_1683) and revises the P3-2 acceptance accordingly.
+
+### 7.2 Same-file proximity join (shadow-only)
+
+`reflex_reconcile.js` was widened (TASK_1683) to attribute surprise to turns via two join paths:
+
+| join_kind | predicate | weight |
+|---|---|---|
+| `exact` | `resolved_symbols` contains the exact `symbol_id` | 1.0 |
+| `same_file` | `resolved_symbols` contains any symbol sharing the `sym_<filehash>_` prefix | 0.5 |
+
+Exact takes priority over same_file for any given (turn, resolution) pair (no double-counting).
+All shadow rows now carry `join_kinds` (array of unique kinds present), `n_resolutions`, and
+`matched_symbols`. The weighted mean — `sum(surprise × weight) / sum(weight)` — is stored as
+`outcome_component_shadow`. No live-weight change; `turn_feedback.jsonl` is never rewritten.
+
+### 7.3 Test result (2026-07-02, synthetic fixture)
+
+Fixture: 117 verified predictions (real `symbol_id` + `surprise_magnitude`) → synthetic
+`prediction_resolution_log.jsonl`; real `turn_feedback.jsonl` (8927 turns, 302 with `resolved_symbols`).
+
+| Metric | Exact-only (baseline) | Same-file (TASK_1683) |
+|---|---|---|
+| turns_attributed | **0** | **27** |
+| shadow_rows_written | 0 | 27 |
+| join_kind breakdown | — | same_file: 27 / exact: 0 |
+| distinct `outcome_component_shadow` values | — | **3** (0.573, 0.829, 1.000) |
+
+The disjointness report estimated a ceiling of ~62 attributable turns (5 shared files × their turn-rows).
+The measured result is 27, below the ceiling, because the causal 14-day window excludes turns whose
+timestamps predate the predictions by more than 14 days — many of the 62-ceiling turns are from before the
+EFE predictions were recorded. The 3 distinct shadow values (vs 2 degenerate tool-class values in the
+original P3-2) confirm within-seam variance > 0.
+
+### 7.4 Revised P3-2 acceptance — underpowered-read protocol
+
+The original acceptance gate (`n ≥ 200 within-tool-class variance`) is **unachievable on current data**.
+Grounds: (a) the EFE prediction symbol population and per-turn `resolved_symbols` population are near-disjoint
+(0 exact-symbol overlap, 5 shared files), per `dev/PHASE3_P3-2_POPULATION_DISJOINTNESS.md`; (b) the same-file
+proximity join yields n=27 attributable turns under the 14-day causal window, far below 200.
+
+**Revised acceptance — underpowered-read protocol:**
+
+> P3-2 passes when a Pearson `r` is reported on the available attributable turns (current n ≤ ~27–62),
+> stratified by `join_kind`, with a 95% CI, explicitly flagged as **small-n / underpowered**. No minimum n
+> threshold applies. No auto-merge of any live reward change (`turn_feedback.jsonl`, `health_delta`) is
+> permitted on the basis of this correlation alone — the correlation is observational evidence only, not a
+> deployment gate. The correlation must be reported as:
+>
+>   `r = <value> (n = <n>, 95% CI [<lo>, <hi>], join_kind = same_file/exact, UNDERPOWERED)`
+>
+> The gate for P3-5 (live grounded reward) remains: P3-3c fork-gate (default-OFF) + A/B + user sign-off,
+> independent of this P3-2 correlation value.
+
+This protocol replaces the `n ≥ 200` gate. The n=27 result from the TASK_1683 fixture test is the
+**first measured baseline**; future sessions can re-run reconcile on accrued live data and report updated `r`.
+
+**Note on n=27 vs ~62 ceiling:** the shortfall is the 14-day causal window. Of the 62 optimistic ceiling
+turns (5 shared files), many have timestamps outside the 14d lookback relative to the prediction
+`predicted_at` timestamps. This is not a bug — the causal window is a correctness requirement, not a
+tunable dial. The n will grow as new turns accrue in the same files after predictions are recorded.
+
+---
+
+## 8. Addendum — 2026-08-03 · TASK_1684 requirement (A): `r` measured on REAL data
+
+### 8.1 What changed since §7
+
+§7.3's `n=27` was produced against a **synthetic** `prediction_resolution_log.jsonl` (117 fixture
+predictions). This section reports the first measurement on the **real** log, which now holds 65
+commit-resolved EFE predictions spanning 2026-07-04 → 2026-08-03.
+
+`.synapse/turn_outcome_shadow.jsonl` was found stale (last written 2026-07-24, 6 rows, all carrying a
+single `outcome_component_shadow` value). Re-running `reflex_reconcile.js --reset` over all 65
+resolutions yields **28 attributable turns**. Reading the stale 6 would have produced a
+degenerate-by-construction verdict that the full data does not support — the earlier partial state had
+zero predictor variance purely because it had processed one resolution cluster.
+
+> The `--reset` pass appends, so the sidecar briefly held 34 rows with 6 superseded `turn_id`
+> duplicates carrying *different* shadow values. It was deduplicated (keep-last;
+> `.bak-1684` retained). Any future analysis of this append-only sidecar **must** dedupe by
+> `turn_id` before joining — a naive read double-counts and mixes reconcile generations.
+
+### 8.2 The correlation
+
+```
+r = -0.0405   (n = 28, 95% CI [-0.4074, 0.3377], join_kind = same_file, UNDERPOWERED)
+```
+
+This satisfies the §7.4 reporting protocol in letter. **§5's verdict that `r` is "unmeasurable /
+undefined" no longer holds**: both axes carry variance (predictor `Sxx` = 1.75 over 5 distinct values;
+reward `Syy` = 4.6e-3). What §5 got right was the *structure*, not the computability.
+
+### 8.3 Three qualifiers that outrank the number
+
+**(a) 28 turns are not 28 observations.** They collapse into **5 distinct resolution clusters**
+(sizes 12 / 8 / 4 / 2 / 2). Kish effective n = **3.4**. Cluster-adjusted 95% CI = **[-0.964, +0.958]** —
+the entire admissible range of a correlation. The nominal CI is anticonservative; reporting it bare
+would ship a number that looks like evidence and is not.
+
+**(b) The reward axis is still the per-tool lookup table.** Across all 28 turns `health_delta` takes
+exactly two values — −0.03 (26 turns, Bash/Read) and +0.02 (2 turns, Edit/Write) — with
+**within-tool-class variance = 0**. So `r` correlates surprise against *tool identity*, which is the
+§3.1 degeneracy verbatim. P3-3a's base/outcome split exists in `reflex_reward.js`, but with
+`outcome_component = 0` the live reward has not moved off the lookup table.
+
+**(c) The entire between-class contrast rests on 2 turns** that share one predictor value
+(7.145e-2); predictor variance within the +0.02 class is 0.
+
+### 8.4 Decision — P3-3c fork answered NOT YET (user sign-off 2026-08-03)
+
+The fork gate defined by TASK_1684 requirement (C) is a **held-out A/B of staged vs flat reward**. At
+effective n = 3.4 across 5 clusters and 5 distinct outcome values, that A/B returns "no significant
+difference" for *every* possible Goodhart mapping. It is a structurally pinned signal, not a gate —
+there is no input that makes it say the other thing. Building (B) and running (C) would therefore
+manufacture the appearance of a passed gate.
+
+**Signed off: `outcome_component` is NOT activated.** Live `health_delta` and `turn_feedback.jsonl`
+remain unchanged. TASK_1684 is blocked on the upstream constraint below rather than accepted.
+
+### 8.5 The binding constraint is upstream (H3)
+
+Competing hypotheses for the P3-grounding stall, scored against this measurement:
+
+| Hypothesis | Verdict |
+|---|---|
+| H1 — insufficient accrual / needs time | **Refuted twice.** §3.2's disjointness argument, and now: 748 turns carry `resolved_symbols` and 65 predictions are resolved, yet the join yields 28 turns from 5 clusters. |
+| H2 — reward shape (the P3-3c activation) | **Necessary but insufficient.** Fixing reward shape leaves the gate at effective n = 3.4. |
+| H3 — **attribution population** | **Supported.** `exact` join is 0% and has never been non-zero; 100% of attributions are `same_file`, confined to 5 files. EFE predicts about symbols that turns do not touch. |
+
+H3 is the constraint that moves n. Until it moves, every downstream P3 gate is underpowered by
+construction, regardless of reward shape.
+
+### 8.6 Prerequisite risk carried forward
+
+`rune_6361a27e` (confidence 0.9, code-probed 2026-07-15, TASK_1748) records a verified failure mode
+directly in this path: when the graph loses CALLS edges (reindex window / KuzuDB eviction), four health
+sub-metrics independently saturate to 100 and inflate `overall_score`, while `compute_metric_trust` has
+no edge-sparsity signal and reads ~0.9 *exactly when the graph is least trustworthy*. Any future
+activation of `outcome_component` into live `health_delta` inherits this — the trust layer, not the
+score formulas, is the fix lever.

package/core/dev/PREDICTION_GROUNDING_DESIGN.md

@@ -0,0 +1,376 @@
+# Prediction-Error Grounding — Design (Norn-vs-Commit Falsification Loop)
+
+> Status: DESIGN / Phase 1 LANDED + runtime-verified; Phase 2 measure-first DONE; Phase 3 reframed. Authored by Ansuz, 2026-06-09 (autonomous session).
+> Origin: discussion "what a world that pushes back requires for AGI". The chosen first oracle is
+> **Norn-vs-commit**: the system already makes falsifiable predictions; git commits are an
+> independent, cheap, un-gameable oracle that arrives for free with every commit.
+
+## 1. Verified current state (ground-truthed via code investigation, not assertion)
+
+| Predictor | Emits score? | Persisted w/ ts+confidence? | Scored vs realized outcome? |
+|---|---|---|---|
+| Curiosity (next-edit target) | yes | **yes** — `curiosity_predictions` table | **yes, auto** — `verify_predictions()` from `process_commit()` (delta_graph.rs:173) |
+| Co-change | yes (on-read) | no (only delta tables) | no |
+| Impact (blast radius) | yes (on-demand) | no | no |
+| EFE candidate ranking | yes | no (transient) | no |
+| Reflex neurons | weights persisted | predictions no | no (STDP weights, no predict→outcome ledger) |
+| Prefrontal proposals | novelty claim | yes (proposals store) | no auto-scoring of "was this actually novel?" |
+
+**Key facts:**
+- Curiosity is the ONLY closed loop, and it is **coarse** (binary hit/miss, 24h miss window) and its
+  error signal is **discarded** — `MISS_DECAY_FACTOR=0.8` affects analytics only, never feeds back to
+  heat / thalamus / co-change matrix.
+- `apply_efe_feedback` (efe.rs:257-295) + thalamus feedback EXIST and learn from a `health_delta`, but
+  are **manual-only**: invoked only when something calls the `synapse_efe_feedback` MCP tool. Nothing
+  auto-fires it from a commit outcome. **Today an Opus session was that manual caller** — that is the
+  loop we are automating.
+- `accumulate_surprise` (efe.rs:366) is an existing surprise primitive, currently unused by a
+  commit-driven path.
+
+**Core claim verdict:** *"Norn makes falsifiable predictions but nothing scores them against realized
+commits to learn"* — CONFIRMED for EFE/co-change/reflex/impact; PARTIALLY REFUTED for curiosity (which
+scores but throws the signal away). The real gap = **no unified, automatic surprise→weight-update loop**.
+
+## 2. The design — Prediction Ledger + auto-feedback
+
+**Principle:** *A prediction is only knowledge once reality has had a chance to refute it.* Today the
+system inscribes runes that were asserted, never predicted-then-tested. The rejected "9% precision"
+proposal (survived weeks unfalsified) is the poster child.
+
+**Shape:**
+1. **Ledger** — one `prediction_ledger` table (generalizes `curiosity_predictions`): `prediction_type`,
+   `symbol_id`, `predicted_at`, `predicted_value`, `confidence`, `component_breakdown` (JSON),
+   `resolution_condition`, + outcome columns filled later (`outcome_*`, `surprise_magnitude`, `verified`,
+   `scored`).
+2. **Emit** — at compute time, EFE / curiosity / impact insert their prediction (Phase 1, behavior-neutral).
+3. **Resolve** — `process_commit()` generalizes `verify_predictions()` to score ALL open predictions
+   against the realized commit; compute `surprise = |predicted - realized|` (Phase 2).
+4. **Learn** — precision-weighted surprise auto-fires the EXISTING `apply_efe_feedback` /
+   `apply_thalamus_feedback` / curiosity-confidence / reflex-STDP updates. **Confidently-wrong = biggest
+   update.** (Phase 3.)
+
+## 3. Open forks (gate Phase 2/3 — need user decision)
+
+- **Fork A — Goodhart defense.** Rewarding "predictions that came true" teaches the system to make safe,
+  obvious predictions. Proposal: reward = **information-gain × survived-falsification** (i.e. the EFE
+  *epistemic* value), so confident+non-obvious+correct reinforces, confident+wrong punishes, uncertain is
+  cheap. Decision needed: bind reward to "confident & non-obvious & right", not merely "right".
+- **Fork B — Does substrate learning move the frozen core?** Calibrating rune/EFE/curiosity confidence
+  changes **what the next LLM session *notices*** (retrieval ordering, what surfaces in preamble) but
+  likely NOT **how it reasons**. Honest hypothesis: this raises *attention quality*, not *reasoning depth*.
+  Worth validating before investing in Phase 3 weight-update breadth.
+
+## 4. Phasing & risk
+
+- **Phase 1 (instrumentation, behavior-NEUTRAL, NOT fork-gated):** add `prediction_ledger` table + persist
+  EFE/impact predictions (curiosity already persists). No decision/weight path changes. Safe to build &
+  review independently. ← LANDED (TASK_1579, merged e7b99e50, runtime-verified — see §7).
+- **Phase 2 (scoring — MEASUREMENT-FIRST, per 2026-06-09 judgment):** before changing any reward, prove
+  whether the existing self-referential process-reward is actually harmful. Log each turn's
+  `health_delta` (from reflex_reward.js) into the ledger with a resolution_condition, then correlate it
+  against realized outcome (next commit touching the turn's symbols / build pass / whether a rewarded
+  rune was later recalled-and-acted-on). If process-reward ⊥ or anti-correlates with outcome → that is
+  the EVIDENCE to dampen (not an armchair worry). If it correlates → the prior was fine, just add
+  grounding on top. "Don't gate a human-approved live system on structural suspicion; instrument it
+  first." Also generalize `verify_predictions` to all prediction types + compute surprise. Read-mostly.
+  ← measure-first analysis DONE (TASK_1580 — see §7); result reframed Phase 3.
+- **Phase 3 (auto-feedback, fork-gated A+B):** wire surprise → existing feedback updaters from
+  `process_commit`. This is the only phase that changes runtime behavior; gate on user sign-off.
+
+**Files (per investigation):** schema.rs (table), efe.rs (emit + feedback), curiosity.rs (ledger reuse),
+delta_graph.rs (resolve in process_commit), pulse.rs (surprise surface).
+
+**Hazard note:** Rust changes against the live dashboard must be worktree-isolated (separate
+CARGO_TARGET_DIR) — see memory `feedback_live_dashboard_rust_dispatch`. Phase 3 must NOT auto-merge.
+
+## 5. MAJOR REFRAME (2026-06-09, after reading reflex_executor.js + reflex_reward.js)
+
+The earlier Explore investigation scoped only the Rust `synapse/` dir and MISSED the JS-side reflex
+loop in `.specialist/Ansuz/tools/`. Reading it changes the picture materially:
+
+**The efferent loop already exists and is LIVE.** `reflex_executor.js` (TASK_1125) runs every turn —
+gates already OPEN (approval flag + 500+ dry-run lines) — and AUTO-calls `synapse_efe_feedback` +
+`thalamus_stimulate` + optional inscribe. So the Explore verdict "apply_efe_feedback is manual-only"
+was WRONG: reflex_executor is the automatic caller. (rune_eeeff5be is a live artifact of it rewarding
+this very session.)
+
+**But the reward source is self-referential.** `reflex_reward.js:turn_health_delta` is a lookup table
+keyed on TOOL IDENTITY (synapse_inscribe=+0.20 max, pulse=+0.15, Edit=+0.10). The only reality contact
+is `_isError()` = did the tool call throw — NOT whether the action was correct. **Inscribing a false
+rune still earns +0.20.** This is the Goodhart failure mode (Fork A) ALREADY LIVE — and the
+operationalization of `feedback_label_ritual_displaces_perception`: the loop reinforces ritual
+compliance, not correctness. (rune_b819315a, risk, conf 5.)
+
+**The true architecture is a 3-arm sensorimotor loop:**
+- Afferent (Norn predictions) — half-built.
+- Efferent (reflex_executor → EFE/thalamus) — **fully built, LIVE**.
+- Reward (reflex_reward.js) — built but **self-referential = the broken leg**.
+
+**This reframes the whole project (and makes it more valuable + surgical):** we are NOT building a
+loop from scratch. We are **replacing the self-referential process-reward with a reality-grounded
+outcome signal** (commit-scored surprise) in an already-wired loop.
+- Fork A is RESOLVED — not a hazard to design against, it is the current live defect.
+- Fork B is RESOLVED — substrate learning DOES move the frozen core (loop is live), but currently
+  toward form over truth. Honest refinement of the earlier hypothesis: it changes what I notice AND
+  biases me toward tool-rituals.
+- **Revised Phase 3:** feed commit-scored surprise INTO `reflex_reward` as a grounded reward
+  component (replace/augment the lookup-table prior), instead of bolting on a new apply_efe_feedback
+  path. TASK_1579 (prediction_ledger) is unchanged and still the right Phase 1 — it is the afferent
+  record the grounded reward reads from.
+
+**Steelman (kept for honesty):** the process-reward is a defensible PRIOR when no outcome signal
+exists — the error floor (errors can't be averaged away) and mirror anti-patterns (penalize
+edit-without-pulse) are sound. The problem is there is no outcome CORRECTION, so the prior is all there
+is and compounds. The grounding work supplies the correction.
+
+**Open question now genuinely strategic (for user):** the self-referential reward loop is LIVE and
+reinforcing ritual on every turn. Given the scaffolding-asymmetry finding (labeled cognitive ops can
+HURT a strong core), is this loop net-positive right now, or should its reward be gated/dampened until
+the grounded component lands? This is a strategy decision, not an implementation detail.
+
+## 6. Cross-cutting requirements (user, 2026-06-09): TEST + FUTURE-ANSUZ FLUENCY
+
+These apply to EVERY phase, not as a separate phase.
+
+**R1 — Test for real, not just compile.** `cargo check` passing is necessary, not sufficient. Each
+phase's acceptance must include a RUNTIME proof:
+- Phase 1: trigger an actual EFE compute + an impact compute via the live dashboard MCP, then
+  `SELECT * FROM prediction_ledger` and confirm rows with correct type/value/confidence. (A unit test
+  is good; an end-to-end MCP-driven row is the real proof.)
+- Phase 2: run the correlation over real `turn_feedback.jsonl` + real commits and produce an actual
+  number with n — not a code path that "would" compute it.
+- Phase 3: A/B the grounded reward vs the process-reward on held-out turns before it touches live weights.
+
+**R2 — Future Ansuz must use this fluently — WITHOUT new ritual.** A capability no future session knows
+to use is dead. BUT fluency must NOT be bought with a new prompt-level checklist — the scaffolding-
+asymmetry finding shows labeled ceremony degrades a strong core (frame-lock). So fluency = **ambient
+availability in channels Ansuz already consumes**, not enforced ceremony:
+- The ledger's calibration output (am I well-calibrated? what did I confidently predict that reality
+  refuted?) must surface in `synapse_preamble` (read at every boot) — the same place hot zones / DDx
+  warnings already appear. One or two lines, only when there's signal.
+- If a query surface is useful, add ONE entry to the elixir/kernel `exo_cortex.tool_by_intent` map
+  (e.g. `calibration_check: "<tool> — where reality refuted my recent confident predictions"`) — a
+  pointer in the map I already scan, not a mandated step.
+- Document the capability + how/when to use it as a RUNE on the relevant symbol (after it exists, so
+  the description is accurate) — future-me recalls it on contact, the existing fluency channel.
+- Acceptance: a fresh Ansuz session, given only its normal boot (preamble + recall), should
+  surface and correctly invoke the calibration capability when relevant, with zero added checklist
+  lines in the elixir prompt. If it only works because a new ceremony step was added, R2 has FAILED.
+
+**Verification owner:** Ansuz main thread enforces R1 at each merge (runtime proof, not log-trust) and
+designs R2's surfacing as part of Phase 3 (when there is a real calibration signal to surface).
+
+---
+
+## 7. EXECUTION LOG + Phase 2 RESULT + revised Phase 3 (2026-06-09, Ansuz session)
+
+> This section records what was actually built/measured and how the plan changed. Earlier sections are
+> the original design; this is ground truth. (This file was untracked and got deleted by a
+> `task-api complete` auto-stash/checkout mid-session; reconstructed from context — if anything above
+> looks stale vs the runes, trust the runes: rune_e74a39be, rune_5c4a89a3, rune_4cc2bab8.)
+
+### 7.1 Phase 1 — LANDED + runtime-verified (TASK_1579, merged e7b99e50 → xyz951610)
+
+Implementation (purely additive, +175/−0, behavior-neutral; cargo check exit 0 in ~35s):
+- `schema.rs::migrate_prediction_ledger` — idempotent `CREATE TABLE IF NOT EXISTS` + 3 indexes, wired
+  into the `init_schema` migrate chain after `migrate_hebbian`. Lives in SQLite `memory.db` at
+  `./.synapse/db/memory.db` (NOT KuzuDB).
+- `efe.rs::persist_efe_predictions()` — called after `softmax_policy` in `compute_efe_with_budget`;
+  `prediction_type='efe'`, `predicted_value=action.efe`, `confidence=action.probability`, breakdown =
+  g_risk/g_ambiguity/g_novelty/g_salience/complexity_penalty, `resolution_condition='commit_touches_symbol'`.
+- `status.rs::persist_impact_prediction()` — called after BFS+cache in `impact_analysis`;
+  `prediction_type='impact'`, `predicted_value=total_impacted`, `confidence=1.0` (0.5 if `result.truncated`),
+  `resolution_condition='commit_touches_impacted_symbol'`.
+- Both inserts best-effort/non-blocking (open db, raw_query, swallow errors at debug, never propagate).
+
+R1 runtime proof: after restarting the dashboard on the new code, a live `synapse_efe(top_k=5)` +
+`synapse_impact(migrate_hebbian)` produced exactly 6 ledger rows — 5 `efe` (values/confidence matching
+the EFE output) + 1 `impact` (value=5.0, conf=1.0), all `verified=0 scored=0`.
+
+**Build gotcha (reusable):** a fresh git worktree fails `cargo` at `build.rs` with
+`resource path 'pty-server.exe' doesn't exist` — Tauri externalBin/resources (pty-server.exe +
+resources/onnx + resources/docs, ~14MB, gitignored) are absent from a clean checkout. Copy them from the
+main-repo `src-tauri/` into the worktree before `cargo check` will reach rustc.
+**Merge gotcha:** merging Rust into the live `tauri:dev` main repo triggers an auto-rebuild that drops
+the MCP backend ~65s — expected; the restart is what loads `migrate_prediction_ledger`.
+
+### 7.2 Phase 2 — measure-first RESULT: STRUCTURALLY UNMEASURABLE (TASK_1580)
+
+Report: `dev/PHASE2_CORRELATION_REPORT.md`. Analyzed 6498 real turns (60 days) + 934 commits. The
+decision rule (r≤0 → dampen / r>0 → keep+ground) **could not be applied** — not for lack of n, but
+because the instrument is degenerate. Three facts, independently verified (not just the sub-agent's claim):
+
+1. **`health_delta` is a near-deterministic function of TOOL IDENTITY**, not correctness: 84% of turns
+   are exactly two values (−0.03 read/bash, 0.02 edit = Edit 0.10 − B-001 mirror 0.08), 0.20 for inscribe.
+   Within-tool-type variance ≈ 0 (code-track variance 0.000016) → r undefined/meaningless (CODE r_pb=−0.004
+   CI[−0.11,+0.11] p=0.80 with 97.5% commit base-rate = double degeneracy; INSCRIBE delta=0.200 constant
+   for all 195, r undefined; acted-on outcome 5/195=2.6% with identical mean delta for Y=1 and Y=0).
+2. **`resolved_symbols` / `would_stim_symbols` EMPTY on all 6498 turns** → no turn→commit attribution
+   path. The designed symbol→commit-file outcome had nothing to match. (Root cause found + fixed — §7.3.)
+3. **`reinforcement_score = 0.0` on all 5486 runes** — the outcome-conditional feedback was never armed.
+
+The Goodhart risk is confirmed **structurally** (inscribe absorbs 174.5% of *net* reward mass with zero
+outcome grading), NOT as a measured negative correlation. The honest verdict resisted the narrative pull
+toward a dramatic anti-correlation — which is exactly what the measure-first mandate demanded.
+
+### 7.3 P3-1 prerequisite — symbol logging FIXED (committed 7f51aceb → xyz951610)
+
+Discovered while diagnosing Phase 2 fact #2. The hook `.claude/hooks/reflex-feedback.js` dropped tool
+input args at two lines: it collected tool_use blocks as `{id,name}` (discarding `block.input`) and
+built tool_calls as `{tool,result}` (no args). Both symbol derivers (`_deriveSymbols` /
+`_deriveWouldStimSymbols`) read `call.args||call.input` for file_path/symbol_id/command — so they were
+**starved, not buggy**. Fix: capture `block.input` and pass it as `args`. Verified end-to-end (`logTurn`
+on a sample turn now derives 3 symbols; was `[]`). Historical rows (pre-2026-06-09) remain symbol-less by
+this bug — do NOT read empty `resolved_symbols` in old rows as "turn touched nothing".
+
+### 7.4 Revised Phase 3 plan (gated)
+
+The original Phase 3 ("feed commit-scored surprise into reflex_reward") is correct in shape but had an
+**unknown hard prerequisite (P3-1, now done)** plus needs reward variance to even be gradeable. Ordered:
+
+- **P3-1 (DONE):** fix symbol logging so turns record what they touched. Attribution data accrues from
+  7f51aceb forward.
+- **P3-2 (re-measure, GATE):** once ~1–2 weeks of symbol-populated turns accumulate, RE-RUN the Phase 2
+  correlation. Only then is there real within-type variance + attribution to produce an actual r. This is
+  the gate: a real number replaces the structural argument. Candidate for a scheduled re-run.
+  - *Gate status 2026-06-11:* binary prerequisites ALL cleared — TASK_1606 symbol_id projection live
+    (verified post-restart), TASK_1607 MCP routing live, attribution wire runtime-proven (n=34
+    symbol-populated turns since 2026-06-10 20:31, thalamus stim 34/34 ok). Note: accrual began
+    pre-rebuild via the JS-side resolveSymbol fallback in reflex_executor.js (hook re-reads JS per
+    invocation; no restart needed). Remaining gate is TIME ONLY: re-run due ~2026-06-17..23 per the
+    1–2-week accrual window from 7f51aceb (2026-06-09).
+- **P3-3 (reward staging):** split the flat inscribe +0.20 into base + outcome-conditional so the reward
+  can discriminate (precondition for any measurable grounding effect).
+- **P3-4 (activate scoring):** generalize `verify_predictions` (delta_graph.rs) to resolve ALL
+  prediction_ledger types on `process_commit` + compute `surprise_magnitude`; arm `reinforcement_score`.
+  - *Status 2026-06-11: LANDED (TASK_1618, commits 6966a572 + 3e58e847 on xyz951610).*
+    `resolve_prediction_ledger` runs as Step 7 of process_commit: HIT/MISS per type (EFE 7d / Impact 3d
+    stale windows), normalized-error surprise `|p−a|/max(|p|,|a|,1)`, BEGIN/COMMIT, non-blocking.
+    ⚠️ **Rune arming GATED OFF** (`ARM_RUNE_REINFORCEMENT=false`): Phase 9 found recall.rs ALREADY
+    consumes reinforcement_score (FadeMem half-life ×(1+5·s) + EvolveMem-C ranking, TASK_1518) —
+    dormant only while scores are 0.0, so arming = live ranking change = P3-5's call. Gated rows keep
+    scored=0 for P3-5 replay. Runtime effect needs rebuild+restart. Caveat: the 5 unit tests compile
+    but were NEVER executed — crate-wide cargo-test loader failure 0xc0000139 (TASK_1619).
+- **P3-5 (grounded reward, fork-gated + user sign-off):** feed commit-scored surprise into reflex_reward
+  as a grounded component, replacing/augmenting the lookup-table prior. A/B vs process-reward on held-out
+  turns before it touches live weights (R1). Must NOT auto-merge.
+
+**Bottom line:** the efferent loop is live, the ledger substrate exists, symbols now log. The honest next
+milestone is **P3-2 re-measure**, not building grounding on an instrument we've proven can't yet be read.
+
+---
+
+## 8. SIBLING TRACK — Recall-Confidence Grounding (acted_on densification) (proposed 2026-06-14, Ansuz session)
+
+**Scope distinction (verified):** §1–7 ground the **reflex_reward** signal (Norn-vs-commit, SNN behavioural
+learning). This section is a *different* grounding loop: **rune confidence** self-calibration via
+`recall → acted_on → Heimdall Phase 5c boost` (+ FadeMem half-life, EvolveMem-C ranking). `acted_on` does
+not appear anywhere in §1–7 — this track was undesigned until now. They are siblings ("ground a signal in
+outcome instead of a prior"), not the same work. Cross-ref: TASK_1582 is the reflex_reward track; this is
+the memory-confidence track.
+
+**Motivation:** rune confidence partly runs open-loop on the inscribe-time prior. If `acted_on` is too
+sparse, "this knowledge proved useful" never feeds back, so confidence ≈ author's guess, not grounded utility.
+
+**Verified mechanism (how acted_on fires today):** `acted_on` is marked ~only when a rune is *recalled* and
+then, in the same window, *cited* via `related_rune_ids` on a subsequent `synapse_inscribe` (Heimdall Phase 5c).
+The dominant real path — recall → edit code → commit, no inscribe — NEVER marks it. Live evidence: in the
+2026-06-14 session an inscribe passing `related_rune_ids` returned `acted_on_marked: 0`, because the cited
+runes were inscribed (not recalled) that session, so there was no recall event to mark. Sigil:
+`Recall Decision Linkage` (recordRecall/recordActedOn in `.specialist/tools/memory-action-log.js`).
+
+**REVERSE PRESSURE — premise is NOT assumed, it is on trial (measure-first):**
+1. Prior lesson `recall_precision_false_alarm`: `acted_on ≠ precision`; a low acted_on-derived number was
+   previously judged an *artifact*, with the real gap being ColdArea/StaleOnly — explicit "don't open an
+   eng task on this number." 
+2. TASK_1580 discipline: a real number must replace the structural argument before any plumbing.
+   ⇒ "6% acted_on is a defect" is the hypothesis to falsify, not the premise.
+
+### Phase R0 — measure-first (GATE for everything below)
+- Operationalise what `acted_on` *should* mean ("this recall influenced an action").
+- Compute the **achievable ceiling**: of sessions that recall rune R, how many subsequently edit/commit R's
+  symbol? 6% is low relative to *what* denominator?
+- Test **causation**: do `acted_on=1` runes show measurably better downstream recall-hit / adoption than
+  `acted_on=0` runes (controlling for age/heat)? If confidence is NOT mis-calibrated by sparsity, STOP here.
+- Output: r + n + CI report, mirroring §7.2's format. Candidate for a scheduled run.
+
+### Phase R1 — widen capture (GATED on R0 showing real mis-calibration)
+- Mark `acted_on` on more action types, not just inscribe-citation: e.g. a recalled symbol that is
+  edited/committed in the same session auto-marks acted_on (no reliance on the agent remembering to cite).
+- Seam: `memory-action-log.js` (recordRecall/recordActedOn already exist) + commit hook + Heimdall Phase 5c.
+- Guard (Goodhart): widening capture must not make `acted_on` trivially saturate — define what does NOT count.
+
+### Phase R2 — confidence-update change (fork-gated + user sign-off)
+- Only then touch the confidence-update formula. A/B vs current on held-out runes. No auto-merge.
+
+### R0 RESULT (2026-06-14, Ansuz session) — NULL: premise falsified, track CLOSED
+
+Ran R0 against live `synapse_evolution_evaluate` (n=8975 recalls, authoritative):
+- `acted_on_rate = 5.58%` (501/8975) against a **documented structural ceiling of ~12%** (SYN-012
+  instrumentation: acted_on only fires when an agent passes `related_rune_ids` on inscribe). 5.58% is
+  ~47% of the achievable ceiling, NOT 6% of a possible 100%. The denominator question is answered: the
+  ceiling is ~12%, not 100%.
+- `failure_rate = 5.74%` (515/8975) — LOW / healthy. Dominant failure is **ColdArea 71%** (365; no rune
+  exists for the query) + StaleOnly 29% (150). Neither is confidence mis-calibration.
+- System self-diagnosis (`diagnosis_hint`): `high_failure_rate=false`; `low_acted_on_rate=true` but
+  annotated *"agents omit related_rune_ids, not a retrieval config problem."*
+
+**Verdict: the premise "5.58% acted_on is a defect" is FALSIFIED.** The low rate is instrumentation
+sparsity against a ~12% structural cap, not evidence of confidence mis-calibration. This reproduces the
+prior lesson `recall_precision_false_alarm` (acted_on ≠ precision; low values are artifacts). The
+causation sub-test (acted_on=1 vs =0 downstream adoption) was not needed — the structural cap + failure
+breakdown already determine the verdict; running SQL would not move it.
+
+**Decision: R1/R2 NOT pursued. Track closed.** If memory grounding is revisited, the real signal is
+`failure_rate`'s dominant component **ColdArea** = missing knowledge → a *coverage* track
+(`synapse_knowledge_gaps`: inscribe on high-heat zero-rune symbols), which is distinct from acted_on
+densification. The acted_on instrument is working as designed at ~half its structural ceiling.
+
+**Bottom line:** measure-first did its job — it caught a plausible-but-wrong lever (shared by both user
+and Ansuz) before any plumbing was built. The grounding priority that survives is the reflex_reward track
+(§1–7, gated on P3-2 re-measure ~2026-06-17..23), not this one.
+
+---
+
+## 9. TASK_1903 — Pure per-signal persistence + AUC re-measure (2026-09-21, re-scoped)
+
+**Context:** TASK_1903's requirements 1 & 2 (dev/TASK_1903_SIGNAL_AUC_MEASUREMENT.md) established that raw
+EFE (`predicted_value`) has no measurable relationship to `is_hit` (AUC 0.4784, CI spans 0.5), while the
+heat-dominated `g_risk` composite does (AUC 0.6725, CI excludes 0.5, p=0.0003). That report's own stated
+limitation: `g_risk`/`g_novelty` are FOLDED composites (`heat_val*1.5 + risk_rune_count + fire*0.5 +
+potential*0.2`, and `co_change_novelty + rune_recency_score + delta_presence_score` respectively) — the
+individual contribution of pure Heat, pure Co-change, or pure Recency cannot be attributed after the fact,
+because they were never persisted as their own columns. Re-deriving them retroactively from current engine
+state is invalid: Heat decays with a 12h half-life (`heat.rs` `HALF_LIFE_SECS`), so querying "current Heat"
+for a symbol predicted 80 days ago returns ~0 regardless of what happened at prediction time.
+
+**This card's scope (re-scoped 2026-09-21, measurement-only, no reward wiring):**
+
+1. **Persist the pure signals going forward.** `prediction_ledger` gained three additive columns via the
+   same idempotent `ALTER TABLE ... ADD COLUMN ... DEFAULT 0.0` pattern as the existing `rune_id` column
+   (`memory/schema.rs` `migrate_prediction_ledger`): `heat_raw`, `co_change_raw`, `recency_raw`. These are
+   the exact `heat_map` / `prediction_map` (co-change) / `recency_map` values `compute_efe_with_budget`
+   already computes per symbol — captured verbatim, BEFORE weighting/folding into `g_risk`/`g_novelty`, in
+   `persist_efe_predictions` (`efe.rs`). No new signal source, no re-derivation: the pure values already
+   existed in-memory at prediction time and simply weren't written down.
+2. **Read-only AUC report:** `dev/scripts/probe/prediction-signal-auc.js`. Uses Node's built-in
+   `node:sqlite` (no new dependency — checked package.json first, nothing else in the repo reads sqlite
+   from JS). Always copies the db (+ `-wal`/`-shm`) to a temp file before opening, and opens the copy
+   `readOnly: true` — the live `memory.db` is never opened for write. Computes Mann-Whitney AUC (average-
+   rank tie handling), bootstrap 95% CI, permutation p-value, and best single-threshold accuracy (including
+   the degenerate always-predict-majority-class floor) for every signal already in `component_breakdown`
+   plus the three new pure columns.
+3. **The pollution guard:** existing rows predicted before this migration landed default to `heat_raw =
+   0.0` etc. — that is "not measured", not "measured as zero". The report hard-codes a
+   `PURE_SIGNAL_CUTOVER` of 2026-09-21 and excludes any row predicted before it from the three pure-signal
+   evaluations (the pre-existing composite signals have no such gap and use full history). Verified live:
+   running the report against a copy of the production `memory.db` (770 rows now, up from 597 at the
+   original measurement) reproduces the folded signals within noise of the original report (raw EFE AUC
+   0.4758 vs 0.4784, `g_risk` AUC 0.6774 vs 0.6725) and correctly reports `n=0` for all three pure signals
+   — none exist yet, because this code had not been deployed to the running app at measurement time. This
+   is the expected state at landing, not a bug.
+4. **30-day re-measure gate (A4):** re-run `prediction-signal-auc.js` against production on or after
+   **2026-10-21**. Decision rule: if any pure signal reaches AUC ≥ 0.60 at n ≥ 300 post-cutover rows, the
+   grounding question (requirement 3 / option a/b/c from TASK_1903) reopens with real per-signal evidence
+   instead of the folded-composite proxy. Otherwise P3 grounding stays closed. No reward/health_delta/
+   thalamus/reflex wiring was touched by this card — it only records and measures.