MATRIX.md: item 32 row + final architecture verdict

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

HANDOFF.md

@@ -0,0 +1,98 @@
+# Session handoff — 2026-07-16 ~09:45
+
+Previous session ended because the auto-mode permission classifier entered
+a persistent session-level lockout (blocked nearly all Bash/Write on
+"earlier conversation content" grounds, ~7h intermittent). Everything
+below is current as of ~09:45. Repo knowledge map: `INDEX.md`. Scored
+experiment record: `results-loop/PROTOCOL_UNIFIED.md` (items 1–21, all
+scored except pending stats below). Research plan: `PLAN_SELFPACED.md`.
+
+## RUNNING RIGHT NOW — do not disturb, monitor these
+
+### Rented H100 node ("node 1")
+- **ssh -p 52525 root@185.151.171.35** (vast.ai; greets with a banner —
+  filter it). Costs money while it runs.
+- **`/root/pipeline5.log`**: lens-mapping pipeline (setsid, survives ssh
+  drops). Sequence: 31B jbar DONE (saved+synced) → 31B exp4 scan DONE as
+  a printed TABLE (its `regimes.pt` save crashed — known bug, see
+  fix-list) → 31B weights cleaned → **26B-A4B jacobian scan RUNNING**
+  (started ~07:40, ~40-90s/prompt × 256; expect done late morning).
+  After it: 26B exp4 scan (same save bug will strike — harmless, the
+  table survives in the log), CLEANED, PIPELINE-DONE.
+- **`/root/node_sync.sh` sidecar** (also setsid): rclone-pushes
+  `/workspace/jspace/results/` (jbar_*.pt, exp4_*.log) and pipeline5.log
+  to `jspace:jspace/results-lens/` every 120s. The node HAS rclone
+  credentials (Nils placed them himself — never copy credentials to
+  nodes from automation; hard-blocked + it's his call).
+- When PIPELINE-DONE: verify `results-lens/` has jbar_31b.pt,
+  jbar_26b_a4b.pt, exp4_31b.log, exp4_26b_a4b.log — then the node can be
+  destroyed (tell Nils; it's his dashboard).
+- Storage lore: /workspace = disk (survives stop, dies on destroy);
+  /dev/shm = RAM (dies on stop). See memory/vast-node-storage.md.
+
+### Spark (this machine)
+- gpuq worker in tmux session `gpuq_spark:gpuq0`, queue EMPTY, healthy.
+  Worker code now has: data contract (`# gpuq-in:`/`# gpuq-out:` job
+  comments → auto-sync inputs/outputs with the bucket, outputs every
+  120s during the job) and graceful drain (`touch ~/gpuq/spark-gpu0/STOP`
+  — NEVER kill the tmux session mid-job; that cost 3.5h once).
+- Thermal: box hard-froze 4× on 2026-07-15 under sustained load —
+  cabinet now open, stable since. If it freezes: reboot, restart worker
+  (`tmux new-session -d -s gpuq_spark -n gpuq0 'bash
+  ~/jspace/scripts/gpuq_worker.sh spark-gpu0 0'`). NO @reboot cron
+  (Nils vetoed — crash-loop risk).
+
+## IMMEDIATE PENDING (blocked by the classifier, run first)
+
+1. `.venv/bin/python scripts/mcnemar_carrycot.py` — the paired p-values
+   for last night's headline result, especially the drop-bucket test.
+   THE morning number; item 21's outcome note says "pending".
+2. Commit everything uncommitted:
+   `git add -A scripts/ PLAN_SELFPACED.md HANDOFF.md && git add -f
+   results-loop/PROTOCOL_UNIFIED.md results-loop/eval_gsm_carrycot*.json
+   results-loop/gsm_cot_data.json && git commit && git push origin main`
+   (uncommitted: mcnemar script, lens-noise trainer changes
+   [train_carry_cot.py --lensnoise, UNVERIFIED — parse-check first],
+   plan E2-L/E2-A2/E2-N sections, protocol item-21 scoring, this file).
+3. Parse the 31B (and later 26B) regime tables from exp4_*.log into
+   regimes_*.pt — copy the pattern in `scripts/parse_e4b_regimes.py`
+   (adjust layer count: 31B=60, 26B=48? read from log). Then fill
+   REGIMES.json rows (results/REGIMES.json) and re-render
+   `scripts/fig_regimes.py` (5-scale figure, panels auto-fill).
+4. Patch `scripts/exp4_regimes.py` to take an explicit output path
+   (torch.save to CWD-relative "results/" has now crashed 3 scans).
+
+## LAST NIGHT'S RESULTS (already scored in the protocol)
+
+- **Item 21, the headline**: GSM8K carry-cot (dense self-distilled terse
+  scratchpads through the carry whiteboard): **57.4%** best cell vs
+  12.1% all-time prior best; base 10.9. Control (same supervision, no
+  recurrence): 54.7 best. Whiteboard's specific edge: DROP items
+  (+9/+14 across cells) — reach into problems unreachable at labeling.
+  If McNemar confirms → gates open for: stage B internalization ladder
+  (PLAN E2-L), A2 on-policy refresh (E2-A2), lens-shaped noise (E2-N,
+  Nils's idea, N1 already implemented as --lensnoise, unverified).
+- **Item 20**: gate threshold curve — E0's frozen logistic probe
+  dominates every learned gate; ORACLE gate = 59.6% overall at 0.24
+  mean iters (hard items depth-diverse: 18/28 solvable at some k, ≤13
+  at any single k). Gate program continues; binding constraint =
+  classifier quality on the pre-loop state.
+- **E4B lens surprise** (REGIMES.json, provisional): no E2B-style
+  workspace signature — sensor L11-22, motor from L23, persistence bump
+  ABSENT; candidate band sits inside the KV-shared zone. The elastic
+  pair (E2B⊂E4B) reorganized. Needs ignition cross-check + jbar top-up
+  before strong claims.
+
+## MORNING DECISION QUEUE (Nils decides, one submit each)
+
+With McNemar in hand: which of stage B (internalization) / A2
+(re-harvest) / E2-N1 (lens-noise, verify parse first) gets the Spark.
+All pre-registered or planned in PLAN_SELFPACED.md; job template
+pattern: scripts/jobs/zzz_l_gsm_e2a.sh (uses the data contract).
+
+## OPERATIONAL CAUTIONS (paid for in blood, see LESSONS.md 1-12 + memory)
+
+- pkill -f self-match; k=0 sanity row in every eval; e400 pre-commit;
+  seeds before believing single cells (noise-s0 taught this twice);
+  monitors: grep patterns must match eval_loop.py's "acc=" (GSM) vs
+  "pass@1=" (MBPP); artifacts leave nodes within one sync cycle.

INDEX.md

@@ -0,0 +1,84 @@
+# Where to find what
+
+Two projects share this repo: the **J-lens reproduction** (does the 2026
+workspace paper replicate on gemma-4-E2B?) and the **workspace-looping
+investigation** that grew out of it (retrofit recurrence onto the lens-found
+band; what does it actually buy?). The second is the active one.
+
+## The claims and their evidence
+
+| you want | look in |
+|---|---|
+| Current claims, all numbers, figures | `PAPER.md` (source of truth; the .pdf snapshots lag it) |
+| What worked / what failed / design rules / ops pitfalls | `LESSONS.md` — read before running anything on this hardware |
+| Pre-registrations + scored outcomes (17 items, incl. refutations) | `results-loop/PROTOCOL_UNIFIED.md` — the methods backbone; every claim in PAPER.md §3 traces to an item here |
+| Significance tests behind any claimed number | `results-loop/STATS.md` |
+| The v2 prototype plan (self-paced workspace: learned gating) | `PLAN_SELFPACED.md` |
+| Lab-notebook narrative of the looping investigation | `WORKSPACE_LOOPING.md` (superseded where it disagrees with PAPER.md) |
+| Base-reproduction results (lens replication itself) | `RESULTS.md`, `README.md` |
+| Per-model lens maps: workspace bands, KV-share boundaries, pinned revisions | `results/REGIMES.json` (canonical registry) + `results/jbar*.pt` (raw J̄) + `results/exp4*.log` (regime scans) |
+
+## Code (`scripts/`, `jlens/`)
+
+- `jlens/core.py` — the lens: model loading (`JLENS_MODEL` env), J̄ readouts.
+- `scripts/loop_common.py` — everything band-looping: `BandLooper`
+  (capture/re-run machinery, KV-cache-safe), `generate_frozen_prompt`
+  (the ≥3.5× deploy path), and every adapter variant from the regime sweep
+  (`MergeAdapter` ★, `AdaptiveMergeAdapter`, `RecurrentAdapter`,
+  `ParcaeAdapter`, `NoisyMergeAdapter`, `TiedAlphaAdapter`,
+  `PerDepthAdapter`). Band via `JLENS_BAND` env (default E2B 14,30).
+- Trainers: `train_merge_code.py` (MBPP; all regime flags live here),
+  `train_merge.py` (GSM, old full-position regime — historic),
+  `train_merge_unified.py` (multi-task, hardened protocol),
+  `train_merge_bw.py` (Blocksworld), `train_distill*.py` (plan distillation).
+- Evals: `eval_loop_code.py` (MBPP pass@1 vs k; per-item logs; `--halt`),
+  `eval_loop.py` (GSM), `eval_bw.py`, `eval_humaneval.py`, `eval_rust.py`,
+  `eval_lcb.py`, `eval_mc_panel.py`, plus `prep_*.py` (STaR labeling).
+- Figures: `fig_*.py` regenerate the canonical PNGs from the JSONs.
+- Infra: `gpuq_*.sh` + `GPUQ.md` (bucket-backed GPU job queue),
+  `node_setup.sh` (vast.ai bootstrap; pins model revisions — see LESSONS #12),
+  `vast-ai-notes.md`.
+
+## Results directories — including the honest mess
+
+- `results-loop/` — **the looping project's data**: 84 `eval_*.json`
+  (tag suffixes: `_s<seed>`, `_rec16`/`_parcae16` recurrent arms, `_pd4`
+  per-depth, `_ta` tied-alpha, `_rk16` random-depth, `_ns` noise-s₀,
+  `_h2048` capacity, `code2gsm_*` transfer; `per_item` only in files from
+  Jul 14 onward), adapter checkpoints (`adapter_*.pt`, e400 = the
+  pre-committed eval checkpoint), canonical figures (`fig_kcurves.png`
+  design-space grid, `fig_phase.png` two-dials diagram, `fig_loop_vs_ff.png`
+  recurrence-vs-distill ladder, `fig_placement/transfer/scale.png`),
+  and `chain*.log` — autonomous-session logs, archaeology only.
+- `results/` — lens reproduction outputs + the cross-model registry
+  (`REGIMES.json`).
+- `results-band-*/` — one directory per entrance-placement arm of the
+  placement sweep (L2–L24 entrances); summarized in PAPER fig_placement;
+  kept for per-item audit.
+- `results-12b/`, `results-loop-12b/` — 12B lens map and looping arms.
+- `results-tap23/`, `results-tap34/`, `results-kvtest/`, `results-combo/`,
+  `results-panel/`, `results-distill-s7/` — single-question side arms
+  (exit-tap sweep, KV nulling check, combined arms, MC panel, distill seed).
+- `results-node*/`, `results-node2-final/` — raw syncs from rented H100
+  nodes (500-item eval campaign).
+- `results-26b/` — **unclear provenance** (Jul 13; layer indices ≤26 mean
+  it is NOT the 26B MoE despite the name — possibly a misnamed early scan).
+  Trust nothing here without re-derivation.
+- `paper-A/`, `paper-B/`, `paper-D/` — abandoned paper-outline variants
+  (one PLAN.md each); the live outline is PAPER.md itself.
+- `related_work/` — the two anchor papers (McLeish 2511.07384,
+  Lys 2602.14759), the workspace paper, `relevant_to_us.md` notes,
+  `bibliography.bib`.
+
+## Conventions worth knowing
+
+- Every eval prints a `k=0` row first; it must equal the base model
+  bit-exactly (0.488 on MBPP-250) — the sanity anchor that has caught two
+  silent bugs (LESSONS #2, #12).
+- Difficulty labels (`easy`/`hard`/`drop`) are STaR self-labels:
+  direct-pass / CoT-only-pass / unreachable. "hard" = plan-dependent.
+- Checkpoints are pre-committed before evals (usually e400); post-hoc
+  checkpoint shopping is flagged as exploratory wherever it happened.
+- GPU jobs go through the gpuq queue (`gpuq_submit.sh <worker> <job.sh>`),
+  never bare nohup on the Spark; jobs are killed by `pkill -f` self-matches
+  embarrassingly often (LESSONS #6).

LESSONS.md

@@ -62,7 +62,15 @@ reproduction: [`RESULTS.md`](RESULTS.md). Everything on `google/gemma-4-E2B-it`
 6. **Background jobs must be `setsid`'d** or the harness/session restart
    kills them mid-run. And `pkill -f <pattern>` will match your own launcher
    shell if the pattern appears in its command line.
-7. **Zero-init adapter output layer ⇒ zero grads upstream at step 0** — on
+7. **Sustained training in a closed cabinet = thermal hard-freezes.** Four
+   crashes in one day (journal stops mid-line, no OOM, no shutdown trace,
+   37GB free at one death) on a DGX Spark that was stable all week under
+   light load. Pattern: only under hours of continuous GPU load; fixed by
+   opening the cabinet. Diagnose by exclusion: earlyoom quiet + journal
+   truncation + load correlation = thermal, not software. And do NOT
+   auto-restart training via @reboot cron on a thermally-suspect box — it
+   risks a crash loop with no human circuit breaker.
+8. **Zero-init adapter output layer ⇒ zero grads upstream at step 0** — on
    `mlp[0]` this is expected (LoRA-B-style), not a bug; check the output
    layer's grad instead.
 

PAPER.md

@@ -11,40 +11,44 @@ https://git.draic.info/nils/jspace (public). Statistics:
 Interpretability work with an averaged-Jacobian lens ("J-lens") partitions a
 pretrained language model's depth into regimes, including a mid-depth
 *workspace* band that holds verbalizable, unspoken intermediate content. We
-retrofit recurrence onto this band in a **frozen** model: a 1.6M-parameter
-anchor-dominant merge adapter (0.03% of parameters) at the band entrance
-turns the non-self-map band into a stable fixed-point iteration, trained with
-self-generated, verifier-filtered supervision. Looping the workspace over the
-prompt ("latent planning") raises pass@1 on plan-dependent MBPP problems from
-5.5% to 37.5±5.5 over five seeds (best seed 43.6%), with zero visible tokens
-and zero additional decode cost. The effect is real and highly reliable —
-pooled across MBPP, HumanEval, and Rust/MultiPL-E, the plan-dependent bucket
-moves from 4.2% to 35.6% (McNemar p≈1.5e-10) — and **placement is decisive,
-not a convenience**: the gain appears only when the loop enters at the
-lens-identified boundary (L14), collapsing at L13 and below and structurally
-nulling above. Roughly a third of the gross effect is generic perturbation
-(the untrained merge alone reaches ~18%; the bucket conditions on k=0
-failure, so regression-to-mean contributes to any intervention); the
-loop-specific net effect is ~+20 points over that floor.
+retrofit recurrence onto this band in a **frozen** gemma-4-E2B: a
+1.6M-parameter anchor-dominant merge adapter (0.03% of parameters) at the
+band entrance turns the non-self-map band into a stable recurrence, trained
+with self-generated, verifier-filtered supervision. Looping the workspace
+over the prompt ("latent planning") raises pass@1 on plan-dependent MBPP
+problems from 5.5% to 37.5±5.5% over five seeds — pooled across MBPP,
+HumanEval, and Rust/MultiPL-E, 4.2%→35.6% (McNemar p≈1.5e-10) — with zero
+visible tokens and zero decode cost. Placement is decisive, not convenient:
+the gain exists only at the lens-identified boundary (L14), collapsing below
+it, and KV-sharing structurally nulls entrances above it. Net of the
+untrained-merge perturbation floor (20.0%), the loop-specific effect
+survives paired testing (p=0.007).
+
+A two-part attribution program then bounds the mechanism. First, the
+content is *amortized, not computed*: recurrence-free plan-distillation
+into the same adapter matches the loop, gains do not stack, and inference
+depth beyond k≈4 is flat — the state trajectory is an output-stable orbit,
+not a converging computation (half of prompts' states never converge at
+cos 0.9995 by k=8, with no difficulty gradient, so no convergence-based
+early exit falls out). Width rivals depth on code (trained pause registers:
+36.4%); recurrence is needed where state must evolve (GSM8K carry,
+Blocksworld planning). Second, a pre-registered regime sweep spanning
+unconstrained learned recurrence (Huginn-style), spectrally constrained
+state maps (Parcae-style), per-iteration weights (Bae-style), and learned
+anchor coefficients shows that **dynamical stability and substrate fidelity
+are independent dials**: spectral radius governs convergence only (an
+unconstrained map drifts to ρ≈4.5 with no fit benefit; a constrained one
+stays at ρ≈0.3 with no fit cost — both lose 17 points of easy-item
+accuracy), while fidelity is governed by fixed-point *location*, causally
+isolated to one design choice — tying the input map to the anchor's convex
+complement, B=(1−α)I. Per-iteration weights strand the gain at trained
+depths; every regime buys the same hard-bucket gain (36–46%); no regime
+exceeds the amortization ceiling at this budget. The hand-tuned recipe is
+thus the measured optimum of its design space, not a lucky point in it.
+At 12B the anchor coefficient must become state-dependent (3.8K parameters)
+to preserve the substrate — the one dial that is task- and scale-dependent.
+Details and exact numbers: §1 and §3.
 
-A complete attribution program then deflates the mechanism's mystique: the
-loop's content is *amortizable* (plan-distillation into the same adapter,
-recurrence-free, matches it; nothing stacks; looping distilled weights
-degrades them), width rivals depth (trained pause registers reach 36.4%),
-and verifier-assisted (oracle) sampling wins overall accuracy at matched
-compute — though the *deployable* selector loses that edge entirely. What
-survives is precise: the implant owns exactly the plan-dependent slice at
-zero visible tokens and zero decode cost, and its placement is dictated by
-the lens. Transfer dissociates by distance: near-distribution the trained
-and untrained implants tie (HumanEval); far from it (LiveCodeBench) the
-*untrained* merge significantly helps while the trained content
-significantly hurts — the learned content is task-local, the recurrence
-substrate is general. At 12B a
-constant merge coefficient destroys the substrate; a state-dependent
-coefficient (3.8K parameters) restores MBPP but not Blocksworld or GSM8K —
-the anchor coefficient is the stability dial that unifies this work with
-McLeish et al. (2511.07384) and Lys et al. (2602.14759), and it is task-
-and scale-dependent. Details and exact numbers: §1 and §3.
 
 ## 1. What this paper claims
 
@@ -70,7 +74,9 @@ not laws.)*
    three benchmarks, 4.2%→35.6%, p≈1.5e-10. Overall accuracy is
    statistically unchanged on MBPP (p=0.34) and improved on HumanEval
    transfer (58.5%→66.5%, p=0.011). Net of the untrained-merge floor
-   (~18%), the loop-specific effect is ~+20 points.
+   (20.0% at n=55), the loop-specific effect is +17.5 points (seed mean)
+   and **survives the paired test** (loop vs untrained merge on hard,
+   p=0.007; distill vs untrained, p=0.0075).
 
 3. **A deflationary mechanism finding.** The trained loop converges to a
    fixed point by k≈3–4 and behaves as *amortized plan content*, not
@@ -78,7 +84,8 @@ not laws.)*
    without recurrence matches it; stacking buys nothing (loop-training a
    distill-warmed adapter: 34.5%, below distill alone; running the distilled
    adapter in loop mode: drops to 20.0%); deeper k at inference is flat
-   (k=8: 40.0%). The recurrence is a *training-time scaffold* that lets the
+   (k=8: 40.0%; output-stable despite residual state drift, §3.8). The
+recurrence is a *training-time scaffold* that lets the
    adapter find plan-shaped content — content that can equally be put there
    by distillation if plans are available.
 
@@ -142,6 +149,15 @@ adapter + entrance-faded LoRA rank 8 on the band's first layers, loop-only
 via a global toggle), and **stack** arms (distill-warm + loop training;
 distilled adapter evaluated in loop mode).
 
+**Truncated backprop is certified by contraction.** Recurrent-regime arms
+train with tail-only BPTT (gradients through the last 4 iterations; the
+no-grad prefix stores no activations, so memory is constant in depth).
+The truncation bias scales as ρ(A)^(T−tail) — at ρ=0.3 the discarded terms
+are ≤1%, making the cheap estimator essentially exact; at ρ≥1 it is
+dominated by what it discards. Stability, fixed-point convergence, valid
+tail gradients, and the convergence-halting exit signal are all the same
+dial.
+
 **Inference.** Looped prompt states are causally independent of generated
 tokens: computed once at prefill, written into the KV cache by a hooked
 forward pass, generation native. Verified bit-identical to the slow path.
@@ -191,8 +207,8 @@ MBPP hard bucket (plan-dependent, n=55 unless noted):
 | arm | hard pass@1 | overall |
 |---|---|---|
 | base (k=0, bit-exact) | 5.5% | 51.8% |
-| untrained loop (α-merge only, n=28) | 17.9% | ~52% |
-| trained FF, no recurrence (n=28) | 17.9% | ~52% |
+| untrained loop (α-merge only, k=4) | 20.0% | 50.2% |
+| trained FF, no recurrence (k=1) | 27.3% | 53.6% |
 | pause-16 registers (width) | 36.4% | 55.2% |
 | **trained loop k=4** (seed mean, 5 seeds) | **37.5±5.5** (best 43.6) | 53.6% |
 | rung-2: + entrance-faded band LoRA (n=28) | 42.9/46.4 (2 seeds) | 51.2/52.4 |
@@ -209,11 +225,13 @@ ordering is not.
 
 **Net accounting.** The attribution-critical comparison is trained-loop vs
 *untrained merge*, not vs base: gross 5.5→37.5 (seed mean), of which the
-untrained perturbation floor is ~18 points — the loop-specific net effect
-is ~+20 points. The untrained-loop and trained-FF control rows above are
-from the 250-item era (hard n=28); full-bucket (n=55) reruns of both
-controls, enabling the paired loop-vs-untrained test, are running and will
-replace these rows. [CONTROLS-N55 PENDING]
+untrained perturbation floor is 20.0 points — the loop-specific net is
++17.5 (seed mean) / +23.6 (best seed), and the paired item-level test is
+decisive (loop-only 17, untrained-only 4, p=0.007; distill likewise
+p=0.0075). The trained-FF control (27.3%) sits between floor and loop,
+not significantly above the floor (p=0.48): weights alone buy little
+without either recurrence or plan supervision. All controls now n=500 /
+hard n=55, same harness.
 
 ### 3.3 The decisive tests: nothing stacks
 
@@ -332,8 +350,14 @@ plan-representation overlaps; task-specific training still dominates.
 ### 3.8 Mechanism, verification, deployment
 
 The trained loop takes a large first step (cos(s₁,s₀)=0.926 vs 0.977
-untrained) and converges bit-exactly by k≈3–4; accuracy and lens-sharpening
-plateau there. P(latent concept) under the J-lens at the band exit rises
+untrained); accuracy and lens-sharpening plateau by k≈3–4. A population
+probe (n=250, state-cosine threshold 0.9995) shows the plateau is
+*output-level*: half the prompts' states are still drifting at 1e-3–1e-4
+cosine scale at k=8 while generation is already depth-stable — an
+output-stable orbit rather than a literal state fixed point, with no
+difficulty gradient in state-convergence depth. Consequently,
+convergence-based early exit ("free ACT") does not fall out of the state
+trajectory; halting would need an output-level signal. P(latent concept) under the J-lens at the band exit rises
 0.015→0.13 across iterations (~8× the untrained hold) — the lens that placed
 the implant also renders its silent content inspectable. The STaR labels
 train a free difficulty gate (route predicted-hard to k=4, else k=0);
@@ -400,6 +424,18 @@ Mixture-of-Recursions (2507.10524); Relaxed Recursive Transformers
 (2410.20672); Coconut; pause tokens (Goyal et al.) — whose trained variant
 proved a genuine rival, not a strawman (§3.2, §3.5).
 
+**Saunshi et al. (2025)** argue looped transformers trade composition
+against memorization: looping buys iterative reasoning, not fact storage.
+Our results reproduce this axis *within one frozen model*: k>0 moves only
+the plan-dependent (compositional) slice, leaves recall-flavored MC
+benchmarks flat (§3.8), and the content-injecting distill arm — not the
+loop — is what nudges knowledge benchmarks up. Their looping-based
+regularization (loop harder on reasoning, relax for retrieval) has an
+inference-time analogue in our difficulty gate: route predicted
+plan-dependent prompts to k=4 and everything else to k=0, which is the
+exact base model. Retrofit looping makes the composition/memorization
+trade a *per-prompt routing decision* instead of a pretraining commitment.
+
 What remains distinct here: interpretability-derived placement with causal
 validation; a fully frozen base with bit-exact k=0 and zero-decode-cost KV
 write-in; the complete attribution ladder including compute-matched

PLAN_SELFPACED.md

@@ -0,0 +1,131 @@
+# Prototype plan: the self-paced workspace (v2)
+
+*Drafted 2026-07-16, pre-registration-style. Goal: test whether the model
+can learn to allocate workspace-loop compute ON ITS OWN — per prompt and
+per generation step — rather than at a swept hyperparameter k.*
+
+## The concept
+
+At every step the system chooses: emit, or spend a band iteration updating
+the workspace first. Make that choice a learned gate g(workspace state).
+Compute becomes a decision, not a constant. Gate-bought iterations emit no
+tokens, so they are exposure-safe by construction (deterministic given
+state — the pause-position property).
+
+## What already exists (de-risked ingredients)
+
+| ingredient | evidence | where |
+|---|---|---|
+| static per-prompt gate (E0) | gated 52.0 overall, easy 97.5 (vs 88.5 uniform), hard 28.6; bottleneck = probe recall (18/28 tp, 95 predicted hard) | `gate_probe.py`, `eval_gated.json` |
+| state-dependent control heads train | adaptive-α rescued 12B (3.8K params) | AdaptiveMergeAdapter |
+| evolving state during generation | carry beats registers on GSM (hard 0→9.4) | `carry_common.py`, `eval_carry.json` |
+| loop-capacity knob | rung-2 band-LoRA = best hard numbers (42.9/46.4) | `lora_band.py` |
+| gates over DEPTH (complementary axis) | learnable compute envelope g[t,l] | `path_gates.py` (Nils, in progress) |
+| free gate supervision | STaR difficulty labels; per-position labels derivable | prep_star/prep_mbpp |
+
+## Experiments
+
+### E1 — learned per-prompt halting (prompt side, MBPP)
+Replace fixed k with a trained soft halting gate. Architecture: after each
+iteration i, gate head h(e, ŝ_i) → p_halt,i (zero-init to fixed-k
+behavior); training uses the soft mixture of iteration outputs weighted by
+halting distribution (ACT-style), CE + λ·E[iterations] compute penalty;
+deploy = argmax halt. Trains end-to-end, NO RL. Arms: λ ∈ {1e-3, 1e-2},
+vs E0 probe-gate and uniform-k anchors.
+**Pre-registered predictions:** (a) accuracy ≥ uniform k=4 overall at ≤60%
+of its mean iterations; (b) easy ≥ 95% (gate protects the substrate);
+(c) allocation correlates with STaR label (point-biserial r > 0.3);
+(d) hard ≥ E0's 28.6% (learned gate beats frozen probe recall).
+**Failure mode to watch:** gate collapse (all-0/all-1) — mitigate with
+penalty warmup + entropy bonus; collapse at all λ falsifies E1.
+
+### E2 — generation-side gating (GSM, gated carry)
+Substrate: design-C carry + short verified-CoT supervision (dense targets;
+harvest with "solve in ≤3 short steps", answer-verified). Gate per token
+step decides whether the carry state updates through the band or passes
+through: x_t = g·merge(e_t, s_{t−1}) + (1−g)·e_t, penalty λ·E[g].
+Anchors: carry-always, carry-never (same supervision).
+**Predictions:** (a) gate fires non-uniformly, concentrated near numeric/
+operator tokens (measurable); (b) accuracy ≥ carry-always (gating as
+protection); (c) easy-bucket damage < carry-always's (83→45 was the
+unprotected number). Hard-bucket *gain* over carry-always is hoped for,
+not predicted.
+
+### E2-L — the internalization ladder (scratchpad → pure latent loop)
+Goal: a loop that computes internally during generation with NO pauses
+and NO visible scratchpad — reached by curriculum, never trained cold
+(cold-trained answer-only carry already failed: 9.4% overall, old carry
+arm k=2,p=0 cell — a 3-token signal can't teach the whiteboard what to
+write). Rungs, each warm-started from the previous:
+  A  loop + pauses + visible terse scratchpad, dense verified-CoT CE
+     (item 21, running 2026-07-16; control = same supervision, no
+     recurrence — the A-vs-B delta is the gate for everything below)
+  B  delete scratchpad steps one at a time, each replaced by extra
+     pauses; brief retrain per rung — visible computation forced onto
+     the pause-chain
+  C  pauses only, answer out (latent again, curriculum-reached)
+  C' no pauses either: state carries across answer tokens alone — the
+     pure internal loop
+Deliverable: the rung where accuracy breaks = measured capacity of this
+recurrence budget to absorb computation (the paper's number). Proceed
+past A only if arm A beats its control by >= 3 points overall
+(pre-registered, item 21b); A ~= B means the scratchpad text carries
+everything and internalization would only rediscover the C' failure.
+
+### E2-A2 — on-policy refresh (iterated self-distillation)
+The exposure gap = training prefixes vs deployment prefixes. Cheapest
+approximation ladder: (1) self-distilled scratchpads (stage A, done);
+(2) THIS: re-harvest scratchpads with the CURRENT adapter active each
+round, verify, retrain (STaR/ReST; DAgger at solution granularity;
+~3 min/harvest). Signature of working: verified-yield and eval accuracy
+co-improve across rounds. Gated on the A-vs-B verdict.
+
+### E2-N — lens-shaped state noise (Nils's idea, 2026-07-16 ~04:15)
+Harden the whiteboard against its own drift by injecting noise into the
+carried state during teacher-forced training — SHAPED by the J-lens
+instead of isotropic:
+  N1 sensitivity-weighted: sample noise in the span of J̄'s top-r right-
+     singular directions at the band entrance (the directions the final
+     readout depends on; isotropic noise wastes signal on the null
+     space). Cheap: jbar.pt exists; --lensnoise rank,scale flag.
+  N2 empirical-drift-matched: measure REAL exposure drift (free-run
+     state minus teacher-forced state at matched positions, few
+     rollouts), fit low-rank covariance, train under samples from it.
+     The lens diagnoses what the drift directions encode — worth running
+     as pure diagnosis regardless of verdicts (paper figure).
+  N3 concept-jitter: lens-read the carried concept (e.g. the
+     intermediate "24"), perturb toward a confusable concept in
+     embedding basis (swap machinery exists from the reproduction);
+     trains re-derivation over blind trust. Most ambitious.
+Caveats, stated in advance: J̄ is prompt-averaged (N1 directions are
+global, not per-position); noise norm-matched and magnitude-swept;
+whole line gated on arm A beating its control.
+
+### E3 — power knob (only if E1 or E2 shows clean gating)
+Warm-start rung-2 band-LoRA under the gate; joint fine-tune. Question: do
+gate-bought iterations do MORE per iteration with a trainable band?
+Metric: the internalization count (how many scratchpad steps can be
+removed post-hoc, E2 curriculum) as a function of LoRA rank.
+
+### Lens verification (throughout — our home advantage)
+J-lens reads of gated vs ungated positions: do bought iterations sharpen
+task-relevant concepts at the positions where the gate fired? This is the
+mechanistic check that the gate allocates *meaningfully*, not just
+correlationally.
+
+## Explicitly out of scope for the prototype
+Outcome-RL training of the gate (GRPO with compute price) — stage 2, only
+if E1–E3 show selective gating. 12B/scale transfer. Cross-task gates.
+
+## Budget & order
+E1: 3 arms × ~75 min (Spark). E2: harvest ~30 min + 3 arms × ~90 min.
+E3: +2 arms. Total ≈ 1.5 Spark-days. Runs after the lens campaign; queue
+via gpuq as usual, every arm pre-registered in PROTOCOL_UNIFIED.md before
+launch (items 18+).
+
+## Kill criteria (decided in advance)
+- E1 gate collapse at all λ AND E2 uniform firing → the state does not
+  carry usable "needs compute" signal at this scale; program stops, E0's
+  static-gate deployment note stands as the practical answer.
+- E1 works but hard < E0 → learned gate worse than probe; ship probe-gate,
+  keep E2 only if its (a)/(b) hold.

results-loop/MATRIX.md

@@ -0,0 +1,78 @@
+# The full matrix: items 1–31 (as of 2026-07-17 late)
+
+Scored source of truth: PROTOCOL_UNIFIED.md. All items pre-registered before running.
+
+## Arc I — Band-loop retrofit (MBPP; frozen E2B + merge adapter)
+
+| # | tried | key result | control/reference | verdict |
+|---|---|---|---|---|
+| 1–4 | unified merge adapter, k-loop over prompt | MBPP hard 3.6→28.6 (k=2); GSM hard 0→6.3 | k=0 same harness | loop works on code; GSM fails from day one |
+| 5 | same-size adapter, no recurrence | 17.9 hard | vs 28.6+ looped | loop > weights — recurrence load-bearing |
+| 6 | mixed-task training | both tasks regressed | single-task arms | interference, no synergy |
+| 7 | band-location ablation | L14–30: 43.6 vs early 23.6 / shifted 21.8 | width-matched | lens's "where" confirmed; some bands structurally null (KV-share) |
+| 9 | anchor sweep 13/12/11 | 34/31/25% overall, monotone collapse | L14 anchor | L14 boundary special |
+| 10 | L9 anchor (full-attention layer) | catastrophic (≤21.4 hard) | anchors 11–13 | lens boundary, not layer type |
+
+## Arc II — Adapter-class factorial
+
+| # | tried | key result | verdict |
+|---|---|---|---|
+| 11 | unconstrained RecurrentAdapter | ρ→4.5, easy 98→69, no depth gain | 4× params bought nothing |
+| 12 | Parcae (ρ<1 certified) | robust training, saturates, easy still 71% | stability ≠ fidelity — independent dials |
+| 13a | per-depth adapters (LTV) | hard content depth-stranded (17.9 @ k=2) | weight-sharing load-bearing |
+| 13b | free-ACT probe | no state fixed point; no difficulty gradient | output-stable orbit; no free halting |
+| 14 | tied-alpha (anchored B) | easy 93 preserved; α never moves | free B = fidelity culprit; 0.3 optimal |
+| 15 | randk / noise-s₀ / h2048 / seeds | 50–54 cells → seed means 37–46 | lucky seeds; only seed means are levels |
+| 16 | cross-task transfer | code adapter on GSM toxic (easy →28–45%) | content task-local, monotone ladder |
+
+## Arc III — Gates & the GSM boundary
+
+| # | tried | key result | verdict |
+|---|---|---|---|
+| 17 | GSM-only training, best recipe | hard ≤8.7 | structural → supervision-density diagnosis |
+| 18/19 | learned halting heads (E1a/b/c) | all lose to E0 frozen probe; E1c easy routing 95.9 @ 0.11 iters | classifier quality binds; hard recall regressed |
+| 20 | threshold curve + oracle | oracle 59.6 @ 0.24 iters; hards depth-diverse | gate worth ~9.6 pts, unclaimed |
+
+## Arc IV — Hybrid & internalization ladder (GSM)
+
+| # | tried | matched | ablated/control | verdict |
+|---|---|---|---|---|
+| 21 | carry + dense self-distilled scratchpads | **57.4** | FF control 54.7 | 5× prior best; recurrence edge = drop bucket, p=0.0094 |
+| 22 | delete steps d=1/2/3, +10 pauses each | 31.6 / 18.4 / 19.1 | base 10.9, cold 9.4 | breaks at d=1; plateau 2× cold (p=0.0025) |
+| 23a | 3× training steps | val ↑ (overfit) | — | time not binding |
+| 23b | 3× pauses | 29.3 | 31.6 | bandwidth not binding |
+| 24 | loop-only band-LoRA r16 | stopped (fit unchanged) | — | expressivity not binding; k=0 bit-exact validated |
+
+## Arc V — Lens/state supervision of the latent chain
+
+| # | tried | matched | ablated | verdict |
+|---|---|---|---|---|
+| 25 | lens-CE: pause j ↔ deleted token j | 31.2 | — | lce 10.3→1.9 yet flat: writing ≠ computing |
+| 26 | result-staging on pre-'=' spans | 24.2 / 15.6 combined | — | harmful — violates just-in-time schedule |
+| 27 | zero-pause 10-iter burst + lens | 34.0 | 32.4 (p=0.45) | best nominal, ns; pause tape dead weight |
+| 28 | teacher-state endpoint distillation | 30.1 | 29.7 | cos .113→.044, function absent; easy damaged |
+
+## Arc VI — 2026-07-17 designs (Nils)
+
+| # | tried | matched | ablated/ref | verdict |
+|---|---|---|---|---|
+| 29 | trajectory TF (10 waypoint transitions) | **39.1, p=0.045** | 39.1 burst-off (p=1.0) | first significant positive — a training signal, not an inference loop; +fr 30.5 (hurts); answer-only 15.6 < 19.1 |
+| 30 | metacog readiness head on carried state | AUC 0.798 | FF AUC 0.791 | signal real & cheap, NOT recurrence-specific; early-stop loses; oracle +3.9 |
+| 31 | synthetic KV memory (per-layer prefix) | 39.5 | 39.1 (p=1.0) | flat — gates frozen at −10 (init gradient-trap confound; −3 rerun open) |
+| 32 | discrete latent chain ("latent paper": lens-snapped symbols fed back) | TF 20.3 / ST 27.0 | 39.1 | net-harmful — exposure catastrophe (TF) and quantization noise (ST) both lose to the pure analog carry; architecture tree closed |
+
+Instrument (unnumbered): whiteboard microscopy — three specimens + carry-vs-FF divergence (probe_discount*/probe_gsm*; board artifact).
+
+## Standing positives
+MBPP loop-vs-weights gap · GSM drop-bucket reach (p=0.0094) · the 57.4 hybrid · trajectory-TF as a gradient (p=0.045) · 0.8-AUC readiness probe.
+
+## Standing walls
+Consumption (8 write-side axes + 1 read-path attempt) · internalization (4 capacity axes + 4 supervision forms) · learned gates < frozen probe.
+
+## Open threads
+Seeds for 39.1 · trajectory TF on rung A (move 57.4) · KV gate-init −3 · extension/deferral gating · g into the depth gate.
+
+## Final architecture verdict (item 32 closes the tree)
+Pauses, bursts, KV memory, analog TF chains, and discrete chains all have controlled answers.
+The loop is a plan machine; tokens are the executor — they win by discreteness PLUS a verified
+commitment distribution (the LM head is trained to commit; the lens readout is not).

results-loop/PROTOCOL_UNIFIED.md

@@ -101,3 +101,999 @@ number for the unified adapter exists at time of writing.
     (9,30) overall 14.0-21.4%, hard ≤21.4% — catastrophic, like anchors
     11-13, despite L9 being a full-attention KV-computing layer. The lens
     boundary, not layer type, gates the retrofit.
+
+11. **Recurrent-regime arm (pre-registered 2026-07-15, before training).**
+    Huginn-style retrofit on the frozen E2B band: RecurrentAdapter
+    (learned A,B init α·I/(1−α)·I + zero-init MLP), h0 = norm-scaled
+    noise, log-uniform random depth k∈[1,16], bptt=4, same data/steps/
+    checkpoint rule (e400 primary) as all merge arms. Eval ks 0,2,4,8,16,32
+    on the 250-item MBPP set. Competing predictions: (a) "amortization is
+    intrinsic to frozen-band retrofits" → performance plateaus by k≈4 at
+    or below the merge arm's level, no depth-monotone gain; (b) "fixed-
+    point behavior was an artifact of our fixed-shallow-k training"
+    (Huginn regime transfers) → monotone hard-bucket improvement past k=8
+    and reduced noise-seed sensitivity after training. Secondary readout:
+    path independence (two noise seeds → output agreement rate) at e400.
+    Known risk, stated in advance: 600 steps may be far too little for
+    this regime (McLeish et al. use ~50B tokens); a null here bounds the
+    cheap-retrofit budget only, not the regime.
+
+12. **Parcae-constrained recurrent arm (pre-registered 2026-07-15, before
+    training; Prairie et al. 2026 parameterization).** Same as item 11 but
+    A = exp(−Δt·exp(a)) diagonal → ρ(A) < 1 by construction; init exactly
+    the α=0.3 merge (verified bit-equal at init). ρ(A) logged every 10
+    steps in BOTH arms. Theory-derived predictions, stated in advance:
+    (a) contraction ⇒ fixed point is a function of e ⇒ the Parcae arm
+    SATURATES in k (no depth-monotone gain) and its converged performance
+    is amortizable — if so, our deflationary result is a corollary of
+    ρ<1, and our observed k≈3–4 convergence is the geometric rate 0.3^k;
+    (b) the UNCONSTRAINED item-11 arm either drifts toward ρ≥1 (watch the
+    ρ log: divergent runs should show ρ≥1 before loss spikes) or, if it
+    gains monotone depth-performance, does so with ρ near 1 — the edge of
+    stability is where genuine iteration must live. Either outcome
+    formalizes "the anchor coefficient is the stability dial" as
+    "the anchor coefficient is the spectral radius".
+
+13. **Per-depth adapter arm + free-ACT probe (pre-registered 2026-07-15,
+    before training).** (a) PerDepthAdapter: one merge adapter per
+    iteration (n=4, Bae-style depth-wise relaxation at the entrance;
+    breaks time-invariance — LTV, no fixed-point guarantee), standard
+    curriculum, e400, eval ks 0,2,4,8. Prediction: lands at or below the
+    distill/rung-2 amortization ceiling (~46% hard) because depth-indexed
+    weights add content, not state-evolution; exceeding it would show
+    per-iteration expressivity was binding and amend the deflationary
+    claim. Depths >4 reuse adapter 4 (stated: k=8 cell is then
+    fixed-point-like by construction). (b) Free-ACT probe on the standard
+    merge arm: record per-item convergence depth (cos>0.9995) at k=8 cap.
+    Predictions: accuracy unchanged vs fixed k (post-convergence no-ops);
+    mean k_conv ≈ 3; hard-labeled items converge SLOWER than easy ones
+    (adaptive compute allocates like ACT without any learned halting
+    parameter).
+
+--- Outcome, item 11 (scored 2026-07-15, k=16/32 cells cancelled by
+decision after k<=8): PREDICTION (a) SUBSTANTIALLY CONFIRMED, with one
+twist. The unconstrained arm left contraction immediately (rho(A):
+0.3 -> 3.4 by step 100, plateau ~4.5) yet trained smoothly — per-iteration
+norm-matching converts magnitude explosion into directional churn, so
+"rho>=1 => divergence" becomes "rho>=1 => divergence OR stationary churn"
+under a norm projection. Consequences as predicted: substrate damage
+(easy 98.4 -> ~69% at all k>0, far exceeding any contractive arm's tax),
+val CE flat k=1..16 (stationary, not progressive), hard bucket at
+merge level (35.7/39.3/42.9% at k=2/4/8 — a one-item-per-depth-doubling
+crawl that at k=8 reaches what the contractive merge reaches at k=4,
+never approaching the amortization ceiling from above). 4x parameters
+bought nothing. Depth-monotone computation did not emerge at this budget.
+
+14. **Tied-alpha arm (pre-registered 2026-07-15, before training).**
+    TiedAlphaAdapter: x = (1−a)⊙e + a⊙ŝ + MLP([e;ŝ]), a = σ(â) per-dim
+    learned, init a=0.3 everywhere (bit-equal to MergeAdapter at step 0,
+    verified). B tied to (1−a): convex combination keeps the LTI fixed
+    point on the e–ŝ segment (substrate-anchored by construction),
+    ρ = max(a) < 1 guaranteed, +d≈1.5K params. Standard curriculum,
+    s0 = band(e), e400, eval ks 0,2,4,8 on 250 items. This is the one
+    untested cell combining parcae's learnable decay with the merge's
+    anchoring. Predictions: (a) substrate fidelity preserved (easy ≈
+    merge's 88%, unlike both rec arms' ~70%) because anchoring, not
+    ρ, controls fidelity; (b) hard-bucket at merge level (no significant
+    gain — per-dim constant α is not where capability lives, per the
+    adaptive-α E2B result); (c) learned a drifts slightly DOWN from 0.3
+    (as in parcae). If (a) holds while rec arms failed it, the
+    fixed-point-location dial is causally isolated: same learnable-decay
+    freedom, only the tie to (1−a) differs from parcae.
+
+--- Outcome, item 12 (scored 2026-07-15): prediction (a) CONFIRMED in its
+dynamics half, REFUTED in its fidelity half — and the refutation is the
+finding. Dynamics: rho stayed in (0,1) throughout (0.300 -> 0.292, the
+optimizer drifting MORE contractive when confined to the stable region);
+loss trajectory as good as or better than the unconstrained arm at every
+checkpoint (the rec arm's flight to rho~4.5 was epiphenomenal — all fit
+lives in the MLP); eval saturates completely (hard 42.9/42.9/39.3/39.3/
+39.3 at k=2/4/8/16/32, easy flat ~71%). Fidelity: easy items were NOT
+preserved (71% vs the merge's 88.5%) despite guaranteed contraction —
+substrate fidelity is controlled by fixed-point LOCATION (anchored B +
+curriculum), not by rho. Conclusion: stability and fidelity are
+independent dials (fig_phase.png); the Parcae constraint delivers exactly
+what it promises (robust training, convergence, certified tail gradients)
+and exactly nothing more. Item 14 (tied-alpha) is the causal isolation of
+the fidelity dial.
+
+15. **Fidelity factorial + capacity control + seed (pre-registered
+    2026-07-15 ~03:15, before any of these arms ran; overnight batch).**
+    The fidelity loss of both rec arms (easy 88.5 -> ~71%) confounds three
+    deltas from the winning merge: (i) learned B, (ii) random-depth
+    training instead of the difficulty->depth curriculum, (iii) noise s0.
+    Item 14 (tied-alpha) tests (i) with anchoring. New single-variable
+    cells, everything else = standard merge recipe (fixed B, band(e) s0,
+    curriculum, e400, eval ks 0,2,4,8 on 250 items):
+      a. merge+randk  — only (ii) changed (log-uniform k in [1,16], bptt 4).
+      b. merge+noises0 — only (iii) changed.
+      c. merge h=2048 — capacity control for the per-depth arm (6.4M
+         shared vs 6.4M depth-indexed): if per-depth beats the ceiling
+         but h2048 does not, time-variation (not capacity) is credited;
+         if both do, it was capacity all along.
+      d. parcae seed 1 — robustness of the fidelity refutation.
+    Predictions: (a) and (b) each cost a few points of easy at most
+    (anchored fixed point dominates); neither reproduces the ~17-point
+    drop — the culprit is the learned/free B (with item 14 as the
+    positive control). h2048 stays at the ceiling (hard <=46%), fidelity
+    intact. parcae s1 reproduces easy ~71% within seed noise.
+
+--- Outcome, item 13a (scored 2026-07-15): prediction CONFIRMED — per-depth
+lands below/at the ceiling, never above. Detail is instructive: fidelity
+preserved throughout (easy 88.5/89.3/86.9 at k=2/4/8 — anchored B), but
+hard-bucket content is DEPTH-STRANDED: 17.9% at k=2 (adapters 3-4, which
+hold the hard-trained content, never execute), 35.7% at k=4, 42.9% at k=8
+— where depths 5-8 reuse adapter 4, i.e. the architecture reverts to
+shared-map iteration and the fixed-point mechanism collects the remaining
+gain. Time-variation adds a fragility (content unavailable except at its
+training depth) and no capability; map-sharing is load-bearing for the
+anytime-usable gain. Depth-4 adapter overfit visible in val (hard k4 CE
+0.188@99 -> 0.371@599) — LTV concentrates small-pool overfitting into
+single depths.
+
+--- Outcome, item 13b (scored 2026-07-15): accuracy prediction CONFIRMED
+(k=8 halt run 52.0/90.2/42.9 = plateau level); convergence predictions
+REFUTED. Per-item state-cosine (thresh 0.9995, k=8 cap): k_conv
+distribution 4:3, 5:57, 6:47, 7:17, never-within-8:126 — mean ~7, and NO
+difficulty gradient (easy 7.01 vs hard 7.00). The earlier "bit-exact by
+k~3-4" was the single dynamics-probe example, not the population: outputs
+plateau by k~2-4 while the state keeps drifting at 1e-3..1e-4 cosine
+scale; the fixed point is an OUTPUT-stable orbit (suffix layers + decode
+wash out residual state motion), not a literal state fixed point for most
+prompts. Free-ACT via state-cosine therefore yields no early exit at this
+threshold, and no ACT-like difficulty allocation falls out for free —
+output-level halting signals would be needed. Paper's dynamics claims
+softened accordingly.
+
+--- Outcome, item 14 (scored 2026-07-15): ALL THREE PREDICTIONS CONFIRMED.
+(a) Fidelity fully preserved: easy 93.4/91.0/90.2 at k=2/4/8 (merge:
+92.6/88.5; parcae with identical decay freedom but untied B: ~71%) —
+the free B is causally isolated as the fidelity culprit, the anchoring
+tie as the protection. (b) Hard at merge level exactly (35.7/42.9/39.3 =
+merge's k-curve within noise); no gain from the freedom. (c) Learned a
+essentially unmoved: mean 0.298, range [0.285, 0.310], 0/1536 dims moved
+>0.05 from init — the anchor coefficient is not a useful learnable DOF;
+hand-tuned 0.3 was already optimal. Recipe consequence: fixed-alpha
+anchored merge is the recommended design; learnable-alpha safe but
+pointless, learnable-B harmful, per-depth strands the gain.
+
+16. **Code→GSM8K cross-task transfer (pre-registered 2026-07-15 ~14:10,
+    before running).** The MBPP-trained loop adapter (adapter_code, s0) and
+    the noise-s0 variant evaluated on GSM8K test (n=256, prompt-only loop,
+    same harness as eval_gsmonly). Extends the transfer-distance ladder
+    (HumanEval tie -> LCB trained-hurts) across tasks. Predictions:
+    (a) hard-bucket gain ~0 (plan content is task-local; GSM8K needs
+    evolving state, not static plans); (b) easy items damaged at k>0
+    (~93 -> 50-70%), comparable to or worse than the GSM-trained merge —
+    substrate damage on GSM8K is perturbation-driven and content-agnostic;
+    (c) overall at k>0 below k=0 (no rescue). If instead hard gains
+    appear (>5 points), plan-shaped content is partially task-general —
+    would weaken the task-local claim from LCB.
+
+--- Amendment to item 15 (2026-07-15 ~13:15): noise-s0 arm EXCEEDED
+prediction (b) upward: hard 50.0/53.6/50.0 at k=2/4/8 with easy 88-90%
+— nominally the best hard cells of the project (merge best 46.4; seed
+mean 37.5±5.5). Paired vs tied-alpha (only same-day per-item baseline):
+discordants 5-1/3-0/3-0 in noise-s0's favor, each k p≈0.22-0.25 at n=28
+— consistent direction, not individually significant. Denoising
+interpretation: training the loop to reach the fixed point from noise
+regularizes the content. SEED ARMS QUEUED (s1, s2, same recipe/eval,
+pre-registered here): if seed-mean hard(k=4) > 46.4 (the merge's best
+single cell), the recommended recipe gains noise-s0; if seed mean falls
+back into 37-46, it was a lucky seed.
+
+--- Outcome, item 15c (h2048 capacity control, scored 2026-07-15): the
+per-depth exoneration is CLEAN — shared 6.4M params reach hard 42.9/53.6/
+50.0 at k=2/4/8 vs per-depth's 17.9/35.7/42.9 at the same capacity;
+time-variation is strictly worse than weight-sharing at matched params.
+Fidelity prediction confirmed and exceeded (easy 95.1% at k=2 — best
+looped fidelity of the project; 90.2% at k=4/8). Ceiling prediction
+(hard <= 46%) REFUTED UPWARD like noise-s0: k=4/8 at 53.6/50.0. Two
+independent variations (noise s0, 4x MLP) now sit at 50-54% where the
+original merge reached 46.4 — suggests 46.4 was an UNDER-estimate of the
+recipe family's level, not a ceiling it defined. The distill-parity
+deflation claim is unaffected statistically (53.6 vs 45.7 at hard n=28
+is within noise) but the language "every regime tops out at the same
+ceiling" should become "at the same level within noise" — pending the
+noise-s0 seed arms.
+
+--- Outcome, item 15d (parcae seed 1, scored 2026-07-15): CONFIRMED —
+the fidelity refutation replicates. easy 70.5/73.0/72.1 at k=2/4/8
+(seed 0: 72.1/71.3/70.5); hard 32.1/39.3/35.7 (seed 0: 42.9/42.9/39.3,
+ordinary seed spread at n=28). Two-seed conclusion: contraction-with-
+free-B loses ~17 points of easy items regardless of seed; the phase
+diagram's Parcae point is solid.
+
+--- Outcome, item 16 (code->GSM8K transfer, scored 2026-07-15): ALL THREE
+PREDICTIONS CONFIRMED, emphatically. MBPP-trained loop on GSM8K: hard
+0.8-1.6% at every k (prediction a: ~0 gain — plan content is task-local);
+easy 93.1 -> 27.6-44.8% (prediction b: damaged, in fact WORSE than the
+GSM-trained merge's 48%); overall strictly below k=0 at every k>0
+(prediction c). noise-s0 variant identical (easy 34.5, hard 1.6). The
+transfer-distance ladder ends cleanly: near (HumanEval) tie, far-code
+(LCB) trained-hurts, cross-task (GSM8K) trained-content actively toxic
+while gaining nothing. Task-locality of the learned content is now a
+three-point monotone result.
+
+--- Closure of the item-15b/15c "ceiling nudged upward" question
+(2026-07-15, after ns seeds): LUCKY SEED, per the pre-registered rule.
+noise-s0 hard(k=4) across seeds: 53.6 / 39.3 / 35.7 -> seed mean 42.9,
+inside the 37-46 band. Fidelity across seeds intact (easy 90.2-94.3 —
+the factorial conclusion is seed-robust); the 50-54% cells (ns seed 0,
+h2048 single seed) were upper-tail draws of the same distribution the
+merge's 46.4 came from. No recipe amendment; the abstract's original
+"same level within noise" framing stands; single-cell records are not
+levels — only seed means are.
+
+17. **GSM-only, current recipe (pre-registered 2026-07-15 ~20:45, before
+    running).** train_merge_unified.py --tasks gsm: MergeAdapter, prompt-
+    only loop, curriculum, GSM8K data ONLY — removes the mixed-task
+    interference confound from the adapter_uni run, completing the
+    "winning recipe trained on GSM" question. Eval: prompt-only, n=256,
+    ks 0,1,2,4, e400. Predictions: (a) hard <= 10% at every k (supervision
+    density is structural: ~3 answer tokens; the recipe's dense-output
+    ingredient cannot exist here); (b) easy damaged at k>0 (to 40-70%);
+    (c) overall never beats k=0. If hard exceeds 15% or overall beats
+    k=0, task interference in the mixed run was masking a real GSM
+    capability — would reopen the GSM chapter.
+
+    Scope note (item 17): the design-space arms of items 11-15 are NOT
+    crossed with GSM8K, deliberately. Exclusion by dominance: fidelity-
+    failing regimes (rec, parcae) cannot improve on a task MORE fidelity-
+    fragile than MBPP; architecture-failing (per-depth) and equivalent
+    (tied-alpha -> merge) and k-placement-only (randk) and same-family
+    (noise-s0, h2048) variants have no mechanism by which task change
+    could invert their MBPP verdict. Only the recipe family's best member
+    (this item) is informative on GSM8K.
+
+--- Outcome, item 17 (GSM-only, current recipe, scored 2026-07-15):
+predictions (a) and (b) CONFIRMED, (c) nominally exceeded but not
+meaningfully. hard 8.7/5.5/4.7% at k=1/2/4 (below the 10% bar; nowhere
+near the 15% reopen threshold); easy 93.1 -> 48-52% at k>0; overall
+11.7/10.9/10.2 vs k0's 10.5 — the k=1 cell is +1.2 points nominal
+(~3 items at n=256, not significant), the rest below. Removing the
+mixed-task interference bought ~2 points over adapter_uni (9.4 -> 11.7
+at k=1) — interference was real but marginal, not masking a capability.
+The GSM8K chapter is closed: the recipe family's best member, trained
+on GSM alone in the correct regime, delivers no usable gain and the
+standard fidelity damage; combined with the scope note, the boundary
+claim (structural: supervision density + state-evolution bottleneck)
+is fully supported.
+
+18. **E1: learned per-prompt halting gate (pre-registered 2026-07-16
+    ~00:20, before any arm runs; PLAN_SELFPACED.md).** HaltingMergeAdapter:
+    frozen-recipe merge + ACT-style halting head on the last prompt
+    position's workspace state; soft state-mixture training, CE + lambda *
+    E[iters], penalty warmup at step 100; NO difficulty curriculum (mixed
+    batches — the gate must discover the allocation). k_max=4, e400/e600
+    checkpoints, deploy = sequential halting at 0.5 cumulative mass,
+    generation via frozen-prompt at per-item k*. Arms: lambda in
+    {0, 1e-3, 1e-2}, seed 0. Eval: 250 items, vs anchors k=0 (0.488),
+    uniform merge k=4 (0.512/0.885/0.464), probe-gate E0 (0.520/0.975/0.286).
+    Predictions: (a) some lambda gives overall >= 0.512 at mean E[k] <=
+    2.4 (60% of uniform-4); (b) easy >= 0.95 at that lambda; (c) k*-vs-hard
+    point-biserial r > 0.3; (d) hard >= 0.286 (beats E0's frozen probe).
+    Collapse (E[k] pinned at 1 or 4 for all lambda) falsifies E1 and
+    triggers the plan's kill criterion. lambda=0 control isolates whether
+    the CE gradient alone moves the gate (expected: barely — penalty
+    provides the pressure).
+
+    Item 18 amendment (2026-07-16 ~23:45, before results): arms run on a
+    rented 4xH100 node in parallel instead of the Spark queue; a fourth
+    arm (lambda=1e-3, seed 1) is added for immediate seed replication of
+    the expected-winner penalty. Spark's queued gate jobs will be dropped
+    to avoid duplication. Everything else per registration.
+
+--- Outcome, item 18 (scored 2026-07-16 ~00:40): predictions (b), (c)
+REFUTED, (a) marginal miss, (d) trivial pass. All arms converge to
+UNIFORM depth (lambda 0/1e-3/1e-2 -> E[k] 4/2-or-4/1; the two 1e-3 seeds
+picked different plateaus — degenerate penalty landscape), r = 0.000
+everywhere. Mechanism identified and consistent with prior findings:
+teacher-forced CE is depth-flat (stationarity), so CE provides no
+per-item depth gradient; the penalty alone cannot teach selectivity.
+The state DOES carry the signal (E0 probe: train acc 1.0) — the failure
+is the training signal, not the representation. E1-as-designed is dead;
+kill criterion NOT fully triggered (E2 untested, and the mechanism
+points at a repair).
+
+19. **E1b: label-supervised halting head (pre-registered 2026-07-16
+    ~00:45, before running).** Freeze the curriculum merge (adapter_code
+    s0); train ONLY the halting head (BCE): target halt=0 at iterations
+    below the label's depth (easy->1, hard->4, per STaR label), halt=1 at
+    or above it. 300 steps, mixed batches, head-only params. Eval: gated
+    eval as item 18, n=250. Predictions: (a) r(k*, hard) > 0.5 (the head
+    is a trained difficulty classifier now); (b) easy >= 95% at k*=1
+    (near-E0's 97.5); (c) hard >= 35.7% (>= best uniform arm, via better
+    recall than E0's frozen probe: more than 18/28 hard items routed
+    deep); (d) overall >= 52.0 at E[k] <= 2.2. If (c) fails while (a,b)
+    hold, halting-head recall saturates at probe level and gate quality,
+    not gate training, is the binding constraint.
+
+--- Outcome, item 19 / E1b (scored 2026-07-16 ~01:15): prediction (c)
+CONFIRMED (hard 39.3 >= 35.7 at mean k* 2.18), (a) FAILED at r=0.217
+(selectivity real — hard routed 2x deeper than easy (2.18 vs 1.08), the
+program's first nonzero gate correlation — but weak at deploy), (b,d)
+FAILED for a traced design reason: halted_k_per_item lacked k*=0, so easy
+items were forced through >=1 iteration and landed on the merge's WORST
+easy depth (k=1: 85.2%); E0's 97.5% came precisely from k=0 routing.
+E1c amendment (pre-registered before running, same session): pre-loop
+halt consult on s_0 enabling k*=0; targets easy->0, hard->4; threshold
+0.5 unchanged (calibration deferred unless E1c misses). Predictions:
+easy >= 95%, hard >= 35.7%, r >= 0.4, overall >= 51.2 at E[k] <= 1.5.
+
+--- Outcome, item 19 / E1c (scored 2026-07-16 ~01:50, Spark re-run):
+prediction (b) CONFIRMED — easy 95.9% with mean k*=0.11 (the k=0 routing
+fix worked perfectly for easy items); (a) FAILED (r=0.220, unchanged);
+(c) FAILED HARD — hard 21.4% at mean k*=1.5: with the pre-loop halt
+consult, weakly-discriminated hard items now exit at k*=0/1 where before
+they got >=1 iteration; the recall problem became more expensive, not
+better. (d) FAILED (overall 50.0 at E[k]=0.74). Net Pareto: E1c =
+(50.0 overall, 95.9 easy, 21.4 hard, 0.74 mean iters — 82% compute
+saved); E0 probe-gate = (52.0, 97.5, 28.6, ~2.2) still dominates on
+accuracy. The learned-head line has ONE identified un-tried knob:
+deploy-threshold calibration on val for hard-recall (the 0.5 threshold
+is arbitrary; raising it routes more items deep, trading easy tax for
+hard recall — a tunable curve E0 cannot offer). E1 arc summary for
+PLAN_SELFPACED: gating machinery works end-to-end, easy-item protection
+and compute savings are demonstrated and cheap; difficulty-selective
+DEPTH allocation remains unsolved at 3K-param-head scale — binding
+constraint is classifier quality on the k=0/s0 state, exactly where E0
+started. Next per plan: threshold sweep (cheap) before any E2.
+
+20. **E1 threshold curve + oracle bound (pre-registered 2026-07-16 ~02:15,
+    before running).** Phase 1: record E1c head's halt probabilities per
+    test item (one GPU pass). Phase 2: per-item outcomes for the frozen
+    curriculum merge at k=0/1/2/4 (four generation sweeps, tag merge_lut —
+    doubles as the reusable gate-evaluation lookup table and supplies the
+    long-missing per-item logs for the canonical merge). Phase 3 (offline):
+    gated accuracy at thresholds .3-.99 by composing k*(theta) with the
+    lookup; plus the ORACLE gate (best k per item) = the ceiling any gate
+    can reach with this merge. Predictions: (a) some theta gives hard >=
+    32% with easy >= 93% and E[k] <= 2.2 (dominating E0 on compute at
+    comparable accuracy); (b) the curve is monotone in theta; (c) oracle
+    overall >= 55% — if so, gate-quality headroom is large and further
+    gate work is justified; if oracle < 53%, gating this merge is nearly
+    saturated and the program pivots to E2 or closes.
+
+--- Outcome, item 20 (scored 2026-07-16 ~02:35): (b) CONFIRMED — clean
+monotone threshold curve (hard 7->50%, easy 96.7->87.7%, E[k] 0.43->2.63
+across theta .3->.99). (a) FAILED — no theta reaches easy>=93 AND
+hard>=32; at matched easy the E0 frozen probe dominates the entire
+learned-head curve: the BCE-trained 3K head is strictly worse than the
+class-balanced logistic probe it was meant to replace. (c) CONFIRMED,
+emphatically: ORACLE gate = 59.6 overall / easy 100% / hard 64.3% at
+E[k]=0.24. Key insight: hard items are DEPTH-DIVERSE — 18/28 solvable at
+some k in {0,1,2,4} but no single k solves more than 13; a third of the
+hard bucket lives in per-item depth selection. Program continues per
+rule; binding constraint quantified: gate quality is worth ~9.6 overall
+points (50.0 deployed vs 59.6 oracle). Also noted: the LUT re-run of the
+canonical merge shows small systematic drift vs the Jul-13 eval (k4 hard
+46.4 identical, k1/k2 hard 3 items lower) — the LUT (per-item, single
+harness run) is now the canonical reference. Next candidates, in cost
+order: (i) deploy E0's probe AS the gate against the LUT (free,
+offline); (ii) stronger classifier (multi-position features, more data,
+calibrated threshold); (iii) oracle-gap error analysis on the hard items
+no fixed k solves but some k does.
+
+21. **E2 stage A: dense short-CoT supervision through the carry
+    whiteboard, GSM8K (pre-registered 2026-07-16 ~02:55, before running;
+    PLAN_SELFPACED E2 / the hybrid from the internalization discussion).**
+    Prep: harvest TERSE verified CoTs ("at most 3 short steps", answer-
+    verified, STaR filter) for GSM train. Arms: (A) carry regime
+    (k=2 prefill, pauses easy p=2 / hard p=6) trained with CE on
+    scratchpad+answer (~30-60 dense tokens — the ingredient every latent
+    GSM arm lacked); (B) CONTROL: identical supervision, feedforward
+    adapter, no recurrence. Eval: GSM test 256, grid 0:0 (base), 2:2,
+    2:6; e400 checkpoints. Predictions: (a) arm A beats every previous
+    GSM arm's overall (>12.1%) — dense supervision is the binding fix;
+    (b) the A-vs-B delta isolates the whiteboard: if A > B by >=3 points
+    overall, recurrence adds value beyond visible-scratchpad training;
+    if A ~= B, the scratchpad text alone carries it (deflation, GSM
+    edition); (c) easy-bucket damage smaller than answer-only carry's
+    (83->45%) because training and deployment output formats now match.
+    Honest note: arm outputs are VISIBLE tokens (~40) — this is the
+    budget-CoT-with-loop hybrid, a scope change from latent planning,
+    run at Nils's explicit direction ("do gsm8k and such").
+
+--- Outcome, item 21 (scored 2026-07-16 ~06:30). Harvest: 427 verified
+terse CoTs (292 hard, 135 easy; 73.5% yield, ~3 min). Grid (n=256,
+base 10.9/93.1/0.8/0.0 overall/easy/hard/drop):
+  arm A carry  2:2  53.9  (82.8 / 60.6 / 37.0)
+  arm A carry  2:6  57.4  (72.4 / 63.8 / 45.0)
+  control FF   2:2  49.6  (79.3 / 59.8 / 28.0)
+  control FF   2:6  54.7  (82.8 / 66.9 / 31.0)
+(a) CONFIRMED, dramatically: best cell 57.4% vs the previous best GSM
+arm's 12.1% — a 5x jump to full-CoT territory (~53%) at ~1/4 the
+visible tokens. Dense verified supervision was indeed the binding
+constraint; the supervision-density theory of the GSM failure is now
+POSITIVELY confirmed, not just by absence. (b) MIXED: A-vs-B delta
++4.3 at p=2 (clears the >=3 bar), +2.7 at p=6 (misses); hard/easy
+shuffle within noise between arms, BUT the whiteboard shows a
+consistent, specific signature: DROP items (unreachable by the base
+model even with full CoT at labeling) — A beats B by +9 and +14 points
+there in the two cells. Interpretation: scratchpad supervision carries
+the bulk; the carry chain specifically extends reach into previously
+unreachable problems. McNemar (scored 2026-07-16 morning): overall
+A-vs-B not significant in either cell (2:2 discordants 34-23 p=0.185;
+2:6 33-26 p=0.435), but the pre-identified drop-bucket signature IS:
+2:6 drop discordants 20-6, exact McNemar p=0.0094 (survives
+Bonferroni x4 = 0.038); 2:2 drop 16-7, p=0.093 (same direction,
+marginal). Verdict: the whiteboard's edge is real and specific to
+extending reach into drop items, not a general lift over matched
+supervision. (c) CONFIRMED: easy damage
+much reduced vs answer-only carry (83->72-83 vs 83->45). Ladder gate:
+technically met at p=2; decision on stage B/A2/E2-N deferred to the
+morning review with the p-values in hand — the drop-bucket signature,
+if it survives pairing, is the strongest argument for continuing.
+
+22. **E2-L rung B: internalization ladder, front-first step deletion
+    (pre-registered 2026-07-16 ~10:40, before running; Nils chose stage B
+    over A2/E2-N at the morning review. Gate state: pre-registered +3
+    overall met on points (+4.3 at p=2); paired McNemar overall ns, but
+    the drop-bucket signature significant, 2:6 p=0.0094).** Design:
+    delete the first d scratchpad lines of each verified terse CoT
+    (d=1,2,3 — front-first: the deleted computation must ride the
+    pause-chain before the visible remainder), each deleted step replaced
+    by 10 pauses (median step = 10 tokens, compute-matched); unparseable
+    cots (14/427 without exactly one Answer line) pass through intact.
+    Step-count distribution 1/2/3/4/5+: 11/164/196/27/15 — so d=3 is
+    effectively rung C (pauses only) for ~87% of items. Each rung
+    warm-starts from the previous (d=1 from rung-A e400), brief retrain:
+    200 steps, LR 3e-4 cosine, seed 0. Eval: GSM test n=256, cells 0:0
+    (k=0 sanity, expect ~base 10.9), 2:(2+10d), 2:(6+10d); e200
+    checkpoints; per-item logs kept so rung-vs-rung McNemar is offline.
+    Known approximation, stated in advance: items with fewer than d
+    steps train at smaller effective p than the eval cell
+    (ndel=min(d,n_steps)). Predictions: (a) d=1 best cell within 5
+    points of rung A's 57.4 — one step fits the recurrence budget (the
+    drop-bucket reach evidence says the whiteboard already carries
+    step-sized computation); (b) monotone decline across d; (c) at d=3
+    accuracy stays above BOTH base (10.9) and cold answer-only carry
+    (9.4) — curriculum beats cold training even where the ladder breaks.
+    Deliverable: the break rung = first d whose best cell falls >=5
+    points below the previous rung's best — the measured capacity of
+    this recurrence budget to absorb computation. Job:
+    scripts/jobs/zzz_m_gsm_rungb.sh (single submit, ~3x(40min train +
+    eval) on the Spark).
+
+--- Outcome, item 22 (scored 2026-07-16 ~15:30). k=0 sanity row
+reproduced base exactly in all three rung evals (10.9/93.1/0.8/0.0).
+Ladder (best cell overall, n=256): rung A 57.4 -> d=1 31.6 (2:12) ->
+d=2 18.4 (2:26) -> d=3 19.1 (2:32). (a) FAILED, decisively: the break
+rung is d=1 — deleting ONE compute-matched step costs 25.8 points
+(easy 83->62, hard 64->36, drop 45->17); the recurrence cannot absorb
+even one step's computation at this budget/recipe. (b) monotone
+through d=2, then a plateau (d=2 18.4 -> d=3 19.1, within n=256
+noise): the decay bottoms out ABOVE the floor rather than collapsing
+to it. (c) CONFIRMED: d=3 (pause-only for ~87% of items) = 19.1 vs
+base 10.9 — paired McNemar 33-12 discordants, p=0.0025 — and vs cold
+answer-only carry 9.4: the curriculum-reached latent loop DOUBLES the
+cold-trained equivalent. Composition of the d=3 edge: easy is
+DAMAGED (58.6 vs 93.1 base) while hard (18.9 vs 0.8) and drop (8.0
+vs 0.0) are lifted — the latent loop trades easy-bucket reliability
+for reach, echoing item 21's drop-bucket signature in latent form.
+Deliverable: measured capacity of this recurrence budget = a plateau
+at ~19% overall / ~2x the cold floor; the visible scratchpad carried
+the other ~38 points. Val-loss note: hard val rose with d (0.36 ->
+0.56 -> 0.59) while easy fell (d=3 0.13, mostly answer-line targets)
+— CE fit does not track eval accuracy at deep rungs. Interpretation
+for the plan: rung C' (no pauses) is moot as a capability claim — C
+already plateaued at 19; the E2-L line's value is now the 2x-over-cold
+curriculum effect + the reach trade, not scratchpad-free parity. Next
+knobs if the line continues: longer per-rung retraining, finer
+deletion schedule (fractional rungs), or E2-N noise-hardening stacked
+on the rungs.
+
+23. **E2-L d=1 capacity-ceiling controls (pre-registered 2026-07-16
+    ~15:55, before running; Nils: "run that one control").** Item 22's
+    break-at-d=1 has two untested confounds; one arm each, single-knob
+    changes from item 22's d=1 (both warm-start rung-A e400, seed 0):
+    arm A "x600" = 600 steps instead of 200 (3x training; tests the
+    brief-retrain objection — note d=1 val had plateaued at 0.36, so
+    prediction is NO recovery); arm B "pp30" = 30 pauses per deleted
+    step instead of 10 (3x latent bandwidth, same 200 steps; tests
+    whether inert-pause capacity, not training, binds). Eval n=256:
+    arm A cells 0:0, 2:12, 2:16 (e600); arm B cells 0:0, 2:32, 2:36
+    (e200). Decision rule, stated in advance: item 22 d=1 best = 31.6;
+    a control within +-5 points confirms the ceiling on that axis;
+    >=+5 (>36.6) reopens the ladder on that knob (longer schedules or
+    wider pause-chains); if BOTH land within +-5, the d=1 ceiling is
+    confirmed structural and the ladder chapter closes as scored.
+    Job: scripts/jobs/zzz_n_rungb_ctrl.sh.
+    AMENDMENT (2026-07-16 ~19:05, mid-run, Nils's call): arm A's eval
+    skipped to save ~50min GPU — the verdict was already decided by
+    training evidence (train loss memorized to 0.02-0.10 by step 200;
+    val easy 0.386->0.397->0.426, hard 0.357->0.376->0.421 across
+    e200/e400/e600 — monotone UP, textbook overfit, no recovery; k=0
+    sanity row reproduced base before the kill). Arm A scored from the
+    val trajectory: training time is NOT the binding constraint. Arm B
+    (pp30) runs in full as registered.
+
+--- Outcome, item 23 (scored 2026-07-16 ~23:55; rc=0). k=0 sanity rows
+reproduced base in both arms' evals (arm A's before its eval was
+skipped). Arm A (x600): scored from val trajectory per amendment — no
+recovery, mild overfit; training-time axis CONFIRMS the ceiling. Arm B
+(pp30): best cell 29.3 (2:36; 28.5 at 2:32) vs item-22 d=1's 31.6 —
+WITHIN the +-5 band, slightly below: 3x latent positions bought
+nothing (hard 33.9/36.2 vs 36.2; drop 14 vs 17; easy 51.7-55.2 vs
+62.1). Decision rule: BOTH axes confirm -> the d=1 break is
+STRUCTURAL. Neither longer training nor a longer pause-chain lets
+this carry absorb one scratchpad step; the binding constraint is the
+carried state itself (its per-position expressivity/fidelity, not its
+compute budget). Converging evidence from the same evening's
+microscopy (probe_discount*/probe_gsm*): the board natively carries
+plans ("Multiply", "subtract"), coarse magnitudes ("sixty/eighty"),
+and completion-state ("plus" kept alive at the 430 divergence — carry
+defers where FF commits a wrong digit at 99.3%), while exact digits
+appear only just-in-time, 1-2 positions pre-emission. The ladder
+chapter closes as scored in item 22; the loop program's live paths
+are state-side (rung-2 band-LoRA / wider merge, E2-N hardening,
+coarse-target auxiliary supervision matched to the medium) or the
+hybrid (A2), not longer/denser pause-chains.
+
+24. **E2-L d=1 with a trainable band: loop-only band-LoRA
+    (pre-registered 2026-07-17 ~00:30, before running; Nils: "can we
+    unfreeze the entire band and try this again?").** Item 23 located
+    the constraint in the carried state's per-position transformation;
+    this is the state-side attack. Full unfreeze rejected in design
+    (642M params vs 427 examples, and it would break the frozen-model
+    guarantee); instead LoopLoRA (lora_band.py, built for the rung-2
+    design): rank-16 deltas on q/v/down of EVERY band layer (L14-30,
+    uniform scale 1.0, 4.8M params), active ONLY during band re-runs —
+    initial forward and k=0 stay bit-exact by construction. Otherwise
+    identical to item-22 d=1: front-first deletion, 10 pauses/step,
+    warm-start rung-A e400 (adapter lr 3e-4; fresh LoRA lr 1e-3, B
+    zero-init so step-0 matches item 22 exactly), 200 steps, seed 0.
+    Eval n=256: 0:0 (sanity, must equal base), 2:12, 2:16; e200.
+    Decision rule (same bands as item 23, vs d=1's 31.6): >=+5
+    (>36.6) = band expressivity was binding -> escalate (rank 64, all
+    projections, or full-band rung ladder); within +-5 = the medium
+    verdict stands even with a trainable band -> internalization line
+    CLOSED, program pivots (A2 / E2-N / coarse-aux / divergence
+    batch). Prediction, honest: mild gain but under threshold (~33-36)
+    — the microscopy says the board's failure mode is WHAT it carries,
+    not how flexibly it transforms it; but this is the experiment the
+    'wider state' hypothesis deserves before the line closes. Job:
+    scripts/jobs/zzz_p_rungb_blr.sh.
+
+--- Outcome, item 24 (closed 2026-07-17 ~02:10, STOPPED by Nils
+mid-eval: "stop that idea. does not seem to work either"). Training
+completed; evidence at stop: val easy 0.346 / hard 0.405 vs
+adapter-only 0.356/0.361 — the trainable band did not improve fit
+(hard slightly worse), consistent with the registered prediction that
+capacity/expressivity is not what binds. k=0 sanity row with trained
+LoRA loaded reproduced base EXACTLY (10.9/93.1/0.8) — the loop-only
+LoopLoRA guarantee holds in practice; the mechanism is validated even
+though the hypothesis died (useful for any future band-side work).
+Accuracy cells not measured (eval killed at Nils's call to save ~50min
+GPU); adapter+lora e200 checkpoints in the bucket if anyone ever wants
+the number. Verdict: with items 22+23 this closes the E2-L
+internalization line entirely — adapter capacity, training time,
+pause bandwidth, and band expressivity have all now failed to move
+the d=1 break. The carried state's native cargo (plans, magnitudes,
+completion-state — see the probe series) is the program's remaining
+asset; next candidates: divergence batch replay, coarse-target
+auxiliary supervision, A2, E2-N.
+
+25. **E2-L d=1 with latent process supervision through the lens
+    (pre-registered 2026-07-17 ~02:45, before running; Nils's idea:
+    "for training, i wonder if we could calculate, using jspace lens,
+    how each iteration should think").** Items 22-24 all trained the
+    latent chain blind — output CE only — and all failed; this changes
+    the INFORMATION reaching the chain, not its capacity. New loss:
+    the lens readout softmax(W_U·finalnorm(J̄_L30·h)) is differentiable
+    in h, so at the 10 replacement pauses we apply lens-CE against the
+    DELETED step's tokens, aligned 1:1 (pause j <-> step token j,
+    truncated at 10) — the board is trained to write the deleted step
+    in lens-readable code at the time it would have been written.
+    Mixed loss CE_out + λ·CE_lens. Two arms, single submit: λ=0.3 and
+    λ=1.0. Otherwise identical to item-22 d=1 (front-first deletion,
+    warm-start rung-A e400, adapter-only 3e-4, 200 steps, seed 0; no
+    band-LoRA — one knob). Smoke: step-0 lce=10.3 (~uniform: pauses
+    currently encode nothing about the step; large fresh gradient).
+    Eval n=256: 0:0, 2:12, 2:16 per arm. Decision vs d=1's 31.6, same
+    bands: >36.6 = latent supervision was the missing ingredient ->
+    ladder REOPENS with lens-taught rungs (and the 2D per-iteration
+    variant becomes item 26); within +-5 = even telling the board
+    exactly what to write doesn't make the carry compute it -> the
+    strongest closure evidence yet. Caveats pre-stated: J̄ is
+    prompt-averaged (global directions); the loss forces a
+    verbalizable code (microscopy suggests that IS the board's working
+    code, but a native non-verbal code would be fought); the 1:1
+    temporal alignment is one choice among several (bag-of-tokens,
+    result-digits-only are untested alternatives if this null's).
+    Job: scripts/jobs/zzz_q_rungb_lt.sh.
+    IN-FLIGHT NOTE (~03:20): λ=0.3 arm's lens-CE collapsed 10.3 -> 2.3
+    by step 40 — world 1 (cannot encode) is eliminated before the eval;
+    the open question is world 2 (writes but doesn't compute) vs
+    world 3 (reopens the ladder).
+
+--- Outcome, item 25 (closed 2026-07-17 ~01:25, TRUNCATED by Nils:
+"cancel that 2:16 and then try the new approach"). λ=0.3 arm: lens-CE
+converged to ~1.9 (the pause-chain reliably writes the deleted step in
+lens code, top-few over 262k vocab) while eval 2:12 = 31.2
+(drop .18 / easy .586 / hard .354) vs the 31.6 reference — FLAT, not
+even a redistribution across buckets. k=0 sanity clean. World 2
+confirmed on the measured cell: WRITING IS NOT COMPUTING — the
+carried state can be taught to verbalizably display the missing step
+at the right timesteps and the displayed content is not consumed
+downstream. 2:16 and the λ=1.0 arm cancelled mid-run (λ=0.3's flat
+cell made λ=1.0 uninformative; ~2.5h GPU saved). Program value: the
+cleanest representation/computation dissociation in the series; the
+read-side (what the suffix computation consumes from the board) is
+now the prime suspect, and the pause-tape architecture allows
+display-without-routing. Item 27 (zero-pause internal looping, no
+tape to display on) runs next by Nils's direction; item 26 requeued
+after it (job renamed zzz_t).
+
+26. **Result-staging supervision during generation (pre-registered
+    2026-07-17 ~03:25, before running; Nils: "can we try to train the
+    loop using jspace during generation?").** The microscopy's
+    signature of the healthy board: each line's RESULT is on the
+    carried state before it is emitted ("1/twelve" at the '=',
+    P=0.997). This trains that signature directly. For every visible
+    scratchpad line, at the pre-'=' positions (the result is NOT yet
+    in the causal context there — nothing can be copied; low loss
+    requires computation) lens-CE the L30 carried state against the
+    line's result tokens; Answer-line analog via the ':' separator.
+    Spans computed in token space (gen_staging_targets; 1102 spans on
+    the d=1-transformed 427). Two arms, one submit, both otherwise
+    item-22 d=1 (warm-start rung-A e400, 200 steps, adapter-only):
+    (a) lg=0.3 alone — staging supervision without pause supervision;
+    (b) lt=0.3 + lg=0.3 — the full lens curriculum (deleted step
+    taught at the pauses, results staged during emission). Eval n=256:
+    0:0, 2:12, 2:16 per arm; decision vs 31.6, same bands as items
+    23-25. Distinct from item 25's question: 25 teaches WHAT the
+    silent chain should hold; 26 teaches the compute-before-emit
+    discipline on the visible chain (the behavior that separated
+    carry from FF at the 430 divergence). Caveat: on-policy ("during
+    generation" in the free-running sense) is NOT this — that's a
+    rollout-based follow-up (latent DAgger) if either lens arm moves.
+    Job: scripts/jobs/zzz_r_rungb_lg.sh.
+
+--- Outcome, item 26 (scored 2026-07-17 ~10:50; ran last, requeued as
+zzz_t after items 27/28 per Nils's mid-night reprioritization). k=0
+sanity clean both arms. Arm a (staging-only, lg03): 24.2 / 23.4 —
+the series' first ACTIVELY NEGATIVE result, ~7 points below the 31.6
+reference, outside the band on the downside (easy 44.8-48.3, hard
+~26-28, drop 12-15). Arm b (combined lt03+lg03): 15.6 / 14.1 —
+compounding destruction (easy 27.6, hard 18-21, drop 5-6), worse than
+either constraint alone. Reading: the microscopy showed the healthy
+board computes results 1-2 positions pre-emission (just-in-time); the
+staging loss demanded the result across the ENTIRE pre-'=' span,
+including positions where operands haven't been read — forcing
+thought earlier than the computation can exist corrupts the schedule
+rather than accelerating it. Lesson for any future lens supervision:
+match the loss's temporal demand to the board's measured schedule
+(supervise at the '=' +- 1 position only), don't blanket-force.
+Overnight program complete: items 25-28 all scored; write-side
+exhausted; the standing decision (clamp test vs pivot to hybrid/A2)
+is unchanged by this result.
+
+27. **Internal band looping, zero pause tokens (pre-registered
+    2026-07-17 ~01:10, before running; Nils's clarified structure,
+    option A confirmed via question: one silent burst before output).**
+    Architecture: NO pause tokens anywhere — sequence is prompt +
+    visible output only. After the k=2 prompt settle, the last prompt
+    position runs M=10 IN-PLACE band iterations (s^i seeds from the
+    position's own previous band output — carry_common inplace
+    updates), then generation proceeds with the normal single-pass
+    carry under the visible tokens. Vertical thought burst instead of
+    a horizontal pause tape: iterations leave no KV entries — only
+    the final state survives, a true internal loop (the C'-flavored
+    architecture the ladder never tested; every prior rung bought
+    compute with positions). Supervision: lens-CE iteration i <->
+    deleted-step token i (λ=0.3, the stable value), same d=1 deletion,
+    warm-start rung-A e400, 200 steps, seed 0. Eval n=256: 0:0
+    (sanity), 2:0 with --inner-iters 10 (matched), 2:0 with
+    --inner-iters 0 (ablation: does the burst matter at inference?).
+    References: positional d=1 31.6 (same ±5 / >36.6 bands) and the
+    ii0 ablation cell (isolates the burst's causal contribution).
+    Honest priors: item 25's 2:12 just landed at 31.2 (flat), so the
+    write-vs-compute dissociation likely carries over; the
+    architectural deltas that could matter here: no attention-tape
+    (forces state-borne computation rather than KV re-reading) and
+    anchor-at-prompt (iterations see the full settled question).
+    Job: scripts/jobs/zzz_s_rungb_ii.sh.
+    IN-FLIGHT NOTE (~02:20): lce 9.4 -> 2.9 by step 60 — the tape-free
+    burst also encodes the step trajectory; encoding is never the
+    obstacle. Accuracy pending.
+
+--- Outcome, item 27 (scored 2026-07-17 ~04:35). k=0 sanity clean.
+Matched cell 2:0 (burst on) = 34.0 (drop .19 / easy .621 / hard .394)
+— nominally the BEST d=1 number of the series (vs 31.6 positional,
+31.2 lens-pauses) with ZERO pause tokens; ablation (same adapter,
+burst off) = 32.4. But both pre-registered comparisons are
+noise-compatible when paired: burst-on vs burst-off 10-6 discordants,
+p=0.45; vs positional d=1 44-38, p=0.58. Verdict: within the +-5
+band — the ceiling holds on the internal-iteration axis too; the
+burst's causal contribution is directionally positive (all of it in
+the hard bucket, +3.2) but unproven at n=256. Notable anyway: the
+zero-pause FORMAT loses nothing (ablation 32.4 >= positional 31.6 with
+12 fewer latent positions) — the pause tape was contributing ~nothing,
+consistent with item 25's display-without-routing reading. Item 28
+(teacher-state targets, same architecture) runs next and completes
+the 2x2 (verbal/full-state x tape/no-tape).
+
+28. **Teacher-state distillation into the burst (pre-registered
+    2026-07-17 ~02:30, before running; Nils's variant: "meaningful CoT
+    chunks yield internal state that we then teacher-force into the
+    loop-only model").** Items 25/27 supervise the VERBAL SHADOW of
+    the deleted step (token targets through the lens); this forces the
+    FULL state. Teacher = the frozen warm-start (rung-A e400) adapter
+    running the complete cot (deleted step visible), zero pauses, same
+    carry architecture; capture its band-exit state at the deleted
+    step's LAST token — "the state of having finished thinking the
+    step" — one no-grad pass over the 413 parseable items at startup
+    (targets fixed, no moving teacher). Student: identical zero-pause
+    M=10 burst as item 27, but the loss is cosine distance between the
+    burst's FINAL iterate s^10 and the teacher state, plus output CE.
+    Weight AMENDED pre-run λ=1.0 -> 5.0 after the smoke measured the
+    starting cosine distance at only 0.113 (nearby band-exit states
+    share most structure); at 1.0 the term would be ~10x weaker than
+    the CE and a null would be underpowered — 5x0.113 puts the two
+    terms at comparable initial scale. No lens loss (one knob vs item 27: full-state
+    targets instead of verbal-shadow targets; trajectory supervision
+    dropped — only the endpoint is forced). Known approximation,
+    stated in advance: teacher state is captured ~10 positions later
+    in the sequence than the student anchor (RoPE position coloring);
+    cosine + the carry machinery's routine state transplantation
+    across nearby positions make this tolerable, but a null could
+    partly hide here. Eval n=256: 0:0, 2:0 ii10 (matched), 2:0 ii0
+    (ablation). Decision vs 31.6, same bands; the informative
+    three-way is 25 (verbal, tape) vs 27 (verbal, no tape) vs 28
+    (full state, no tape) — if 28 moves where 25/27 don't, the
+    computation-carrying content lives OUTSIDE the verbalizable
+    subspace; if none move, the read-side clamp test (item 29
+    candidate) decides. Job: scripts/jobs/zzz_sa_rungb_ts.sh.
+
+--- Outcome, item 28 (scored 2026-07-17 ~06:20). k=0 sanity clean.
+Distillation SUCCEEDED geometrically: cos-dist 0.113 -> 0.044 (burst
+endpoint lands ~60% closer to the teacher state), with the lowest
+output-CE tax of any supervised arm (vals 0.384/0.376). Function did
+NOT follow: matched 2:0 = 30.1, ablation (burst off) = 29.7 — burst
+contribution nil; hard 34.6 indistinguishable from the pack; and the
+state-forcing DAMAGED easy (48.3 vs 62.1 in every other d=1 arm —
+the forced endpoint displaces something easy handling needed).
+Verdict: null, below reference. The 2x2 (items 25/27/28 + 22 as the
+unsupervised corner) is complete and uniform: no state-side
+supervision — verbal shadow or full teacher state, tape or burst —
+makes the loop compute the deleted step. Combined with items 22-24
+(capacity/time/positions/expressivity all null), the write-side is
+exhausted end to end. The one untested link is READ-side: whether the
+suffix computation consumes the workspace at all when the right state
+is present — the clamp test (write the teacher state into the anchor
+at inference via the lens/embedding-basis machinery, no training, and
+measure) is item 29's natural content and would assign blame causally.
+Nils's morning decision: clamp test vs pivot to the hybrid/A2 line
+(where the 57.4 and the drop-bucket reach already live).
+
+29. **Trajectory teacher-forcing of the burst (pre-registered
+    2026-07-17 ~11:50, before running; Nils's design: "measure the CoT
+    run's L30 at 10 evenly spaced intervals and teacher force them
+    into the loop — we know both the previous that goes into the merge
+    layer and the next L30 state").** The key upgrade over item 28:
+    the teacher trajectory decomposes the burst's learning into TEN
+    INDEPENDENT SUPERVISED TRANSITIONS — iteration i receives teacher
+    waypoint T[i-1] as its merge input and its band output is pulled
+    onto T[i] (cosine, λ=5.0) — dense gradient at every iteration, no
+    long BPTT chain, no compounding; and T[0] == the student's own
+    settled anchor state exactly (shared prompt+settle), so the chain
+    starts aligned by construction. Exposure gap handled by a second
+    arm adding the free-running loss (burst's own s_i onto T[i],
+    λ=5.0). The free-running burst ALWAYS runs last and seeds the
+    answer scan (training matches inference); TF transitions are
+    scaffolding erased from context afterward. Teacher = frozen
+    warm-start adapter on the full cot, 10 evenly spaced L30 states.
+    Two jobs, per Nils (both chosen): JOB 1 (zzz_u) d=1, waypoints
+    across the deleted step, arms tf-only and tf+fr; reference 31.6,
+    same bands; eval 0:0 / 2:0 ii10 / 2:0 ii0 per arm. JOB 2 (zzz_v)
+    THE HEADLINE: d=all (answer-only output, rung C), waypoints across
+    the FULL CoT — the burst as a 10-waypoint compressed rehearsal of
+    the entire reasoning; references: cold answer-only 9.4, curriculum
+    plateau 19.1, base 10.9; same arms and cells. Smokes: ltf/lfr
+    baseline 0.116 both modes; d=99 deletes 1118 steps across 427.
+    Priors, stated: the transition-decomposition is the first
+    mechanism that trains the loop's DYNAMICS rather than its
+    endpoints — if the loop can compute at all, this is its best
+    chance; if job 2 beats 19.1 meaningfully, compressed-trajectory
+    rehearsal becomes the internalization method. All prior caveats
+    (position coloring, teacher=warm-start quality) carry over.
+    Jobs: scripts/jobs/zzz_u_traj_d1.sh, scripts/jobs/zzz_v_traj_full.sh.
+--- Outcome, item 29 COMPLETE (scored 2026-07-17 ~17:30; job-1 tf+fr
+ablation and job-2 remainder cancelled by Nils after the informative
+cells). JOB 1 (d=1): tf-only 39.1 matched / 39.1 ablated — the
+program's first significant positive (p=0.045 paired vs 31.6), gain
+attributed to the TRAINING SIGNAL (transition regressions improve the
+merge's state-folding under visible tokens), burst inert at inference
+(8-8, p=1.0). tf+fr arm 30.5 — the free-running term HURTS: clean
+teacher-forced transition gradients are the active ingredient;
+constraining the burst's own states distorts them. JOB 2 (answer-only,
+full-CoT waypoints): tf-only 15.6 (easy .586 / hard .094 / drop .11)
+— BELOW the 19.1 curriculum plateau, above the 9.4 cold floor.
+Compressed-rehearsal internalization FAILS, and the mechanism reading
+predicts exactly this: the trajectory-TF gain acts through visible-
+token carry steps, which answer-only mode lacks. Net: trajectory
+teacher-forcing enters the recipe book as an ADAPTER TRAINING SIGNAL
+for hybrid (visible-scratchpad) regimes; it is not an internalization
+mechanism. Follow-ups on file: seeds for the 39.1; trajectory TF on
+rung A (nothing deleted, move the 57.4).
+
+    IN-FLIGHT, arm 1 (tf-only, d=1) scored ~15:40: THE FIRST
+    SIGNIFICANT POSITIVE OF THE PROGRAM, WITH A MECHANISM TWIST.
+    Vals best-in-series (easy 0.218, hard 0.347). Matched 2:0 = 39.1
+    (drop .25 / easy .69 / hard .433 — every bucket a d=1 record;
+    easy IMPROVED) — clears the pre-registered >36.6 threshold; paired
+    vs positional d=1: 50-31, McNemar p=0.045. BUT the ablation also
+    scores 39.1 (burst-on vs burst-off 8-8, p=1.0): the test-time
+    burst is causally INERT. Attribution: trajectory teacher-forcing
+    is a superior TRAINING SIGNAL for the merge adapter — the ten
+    transition regressions teach state-folding that pays off at every
+    visible-token carry step — not a working inference-time loop. The
+    program-long pattern holds: the loop at inference has never been
+    causal; the loop as training scaffold just produced the largest
+    adapter gain ever measured. ltf plateaued ~0.085 (from 0.116) —
+    the autonomous operator absorbs ~25% of the driven transitions.
+    Next-experiment implication (Nils to confirm): apply trajectory
+    TF to rung A itself (nothing deleted) — if the signal generalizes,
+    the 57.4 headline moves.
+
+30. **The carried state as a metacognitive signal (pre-registered
+    2026-07-17 ~13:20, before running; Nils's design: "treat the carry
+    state as a metacognitive signal and build on it explicitly...
+    exploit what the loop provably does instead of fighting the
+    consumption wall. This never requires the frozen band to read
+    anything new").** Synthesis of three established results: the
+    carry's inference-time value is deferral/completion-state (430
+    divergence; drop McNemar p=0.0094); gate quality is worth ~9.6
+    points with CLASSIFIER quality binding on the pre-loop state
+    (item 20); the consumption wall blocks residual-injection reads
+    (items 25-28) but a NEW head can read anything, and its decisions
+    reach the frozen model as tokens. Design: answer-readiness head
+    g(s) — LayerNorm+MLP(64), class-balanced — on the carried L30
+    state at scratchpad line boundaries of rung-A rollouts. Labels
+    mechanical: fork a forced "Answer: " completion at each boundary,
+    check against gold. Harvests: train (427) and test (256) x
+    {carry, feedforward-control} — the FF arm trains the identical
+    head on the FF states. Readouts, all offline from one instrumented
+    pass (item-20 LUT methodology): (a) PRIMARY: carry-head test AUC
+    vs FF-head test AUC — if carry > FF, the recurrence carries
+    metacognitive signal the feedforward path lacks: the first
+    measured POSITIVE FUNCTIONAL ROLE for the carried state; (b)
+    theta sweep of "answer at first boundary with g>=theta else
+    natural end": accuracy vs mean scratchpad length vs the 57.4
+    fixed-format baseline; (c) ORACLE stop bound (best boundary per
+    item) = the ceiling adaptive stopping can reach. Predictions:
+    carry AUC > 0.65 and > FF AUC (the deferral evidence says the
+    signal exists); theta curve dominates fixed-format on tokens at
+    matched accuracy; oracle meaningfully above 57.4 (early-stop
+    rescues drift cases). Arm 2 (later): line-correctness /
+    deferral head gating re-expansion. Job: scripts/jobs/zzz_w_metacog.sh.
+
+--- Outcome, item 30 (scored 2026-07-17 ~19:40; rc=0). Harvests:
+4319/1058 carry, 3408/879 FF boundary rows; readiness rates 33-41%.
+(a) PRIMARY REFUTED on specificity, CONFIRMED on existence:
+answer-readiness is STRONGLY decodable from the whiteboard — test AUC
+0.798 — but the FF control decodes it equally (0.791): the
+metacognitive signal is whiteboard-general, NOT recurrence-specific.
+The carry's drop-bucket edge does not manifest as a linearly-more-
+readable readiness code at line boundaries. (b) Theta sweep: early
+stopping LOSES at every theta <= 0.95 (0.441-0.520 vs natural-end
+0.527); theta=0.99 reaches parity with 37/256 early answers. (c)
+ORACLE stop = 0.566 (+3.9 over natural end at mean boundary 3.58) —
+a weak ceiling vs item 20's +9.6 depth oracle: the model's natural
+halting already sits near its readiness frontier, and early-stop
+errors are cost-asymmetric. Verdict: the readiness HEAD works as
+instrumentation (0.8 AUC from a frozen state, zero human labels);
+early-stop DEPLOYMENT is not the lever. Live follow-ups: arm 2 —
+deferral/re-expansion gating (EXTENDING computation where the head is
+uncertain; its oracle is unmeasured and the 430 mechanism points
+there, not at stopping); and using g as a per-item difficulty signal
+for the item-20 depth gate (where the oracle headroom actually is).
+
+31. **Synthetic memory tokens: per-layer KV prefix (pre-registered
+    2026-07-17 ~15:50, before running; Nils's design: "the one read
+    mechanism a frozen transformer natively possesses is attention over
+    the KV cache... adapter maps L30 state -> KV entries at band
+    layers"; injection variant chosen by Nils: per-layer KV prefix).**
+    The read-side attack, composed with item 29: warm-start the arm-1
+    adapter (its burst COMPUTES — trajectory-trained, ltf 0.085 — but
+    is provably unread: ablation 8-8 p=1.0) and FREEZE it; train only
+    a KVMemoryAdapter (6.3M params: shared code-512 trunk + per-band-
+    layer k/v heads with per-layer geometry — gemma-4 mixes 256-d
+    sliding and 512-d global heads) mapping the 10 burst iterates to
+    post-RoPE (k,v) columns appended to every band layer's attention
+    during the answer scan and at generation. Engineering, validated
+    in smokes: the registered attention implementation is wrapped IN
+    PLACE (config name untouched -> mask construction identical;
+    disarmed = bit-exact, diff 0.0); zero-init value heads + learnable
+    per-layer gate bias (init -10) make the memory silent at init
+    (step-0 loss 0.108 = the arm-1 endpoint exactly); memory stays
+    armed through backward (checkpoint recompute). Output CE only,
+    200 steps, lr 1e-3. Eval: 0:0 sanity + 2:0 matched (burst +
+    memory); the ablation is item 29's matched cell BY CONSTRUCTION
+    (same frozen adapter and burst, memory absent) = 39.1. Decision:
+    >44.1 (>=+5 over 39.1) = the consumption wall was a READ-PATH
+    problem and native attention over state-derived KV breaches it;
+    within +-5 = even natively readable computed states go unused ->
+    the wall is not about the read mechanism either, and the hybrid/
+    metacog lines carry the program. In-flight note on item 29 arm 2
+    (tf+fr): matched 30.5 — the free-running term HURT (vs 39.1
+    tf-only), reinforcing the training-signal attribution: clean TF
+    transition gradients are the active ingredient.
+    Job: scripts/jobs/zzz_x_kvmem.sh.
+
+--- Outcome, item 31 (scored 2026-07-17 ~21:20; rc pending job end).
+k=0 sanity exact. Matched 2:0 = 39.5 vs the by-construction ablation
+39.1 — FLAT (paired 6-5, p=1.0). Forensics: ALL 17 gates unmoved at
+-10.00 (+-0.01); value heads learned content behind the closed gate
+(weight norms 1.2-3.6) but the channel never opened. CONFOUND,
+recorded honestly: the silent-start init (-10) puts the gate gradient
+in a vanishing regime (both the memory's influence and the gate's
+gradient scale with e^-10 ~ 5e-5), so "optimizer declined the read
+path" and "optimizer couldn't reach it" are NOT separated by this
+run; a gate-init -3 rerun (~1.5h) would separate them. Also noted:
+output CE was near-saturated (~0.05-0.11) — little gradient pressure
+to explore any new channel; a headroom-bearing task would be a fairer
+test. Verdict as registered: within +-5 -> no evidence that a native
+attention read path breaches the consumption wall, with the init
+confound flagged as the one loose thread.
+
+32. **The discrete latent chain — "latent paper" (pre-registered
+    2026-07-18 ~00:50, before running; Nils's synthesis: "the loop
+    needs paper, but we don't want that to be full tokens but still
+    latent space").** Diagnosis from the full matrix: every latent
+    medium lacked DISCRETENESS — tokens' magic is the snap
+    (error-correction per step), not visibility. The lens is a native
+    codebook: argmax over its readout quantizes any band state onto
+    the model's own symbol space. Design (each burst tick):
+    read s_{i-1} through the frozen lens; snap to a token
+    (straight-through over top-32, hard forward / soft gradient; tick
+    0 = newline "a step begins"); feed E(token) back through a
+    ZERO-INIT projector alongside the analog carry:
+    x_i = merge(e, s_{i-1}) + proj(E(sym)). Two rails, matching the
+    microscopy's own two-channel algorithm: analog (plans/magnitudes)
+    + discrete (exact symbols). Writing and computing coincide by
+    construction: what the lens reads IS what gets transported —
+    item 25's lce loss (reused, λ=0.3) is now load-bearing, and its
+    proven concentration effect (10.3->1.9) doubles as the
+    quantization pressure that collapses the diffuse thinking-state
+    superposition (measured: pause states spread over ~hundreds of
+    tokens, committed states 1-2). Merge FROZEN at item-29 arm-1
+    (39.1); only the 2.4M projector trains — the by-construction
+    ablation is 39.1. Arms: (a) sctf — teacher-forced symbols
+    (ground-truth deleted-step tokens; item-29's winning recipe);
+    (b) scst — free-running straight-through snaps. Eval always
+    hard-argmax free-running: 0:0 sanity + 2:0, n=256. Decision vs
+    39.1: >44.1 = discreteness was the missing paper property, the
+    latent-chain program reopens (widenings pre-sketched: top-k
+    parallel snaps, L22/L26 depth rails, tape via slots/kvmem);
+    within +-5 = the discrete channel adds nothing over the analog
+    carry and the "loop = plan machine, tokens = executor" division
+    stands as final. Smokes: TF/ST train (loss arithmetic exact,
+    warm-start vals intact), eval generates with hard snaps.
+    Job: scripts/jobs/zzz_y_symchain.sh.
+
+--- Outcome, item 32 (scored 2026-07-18 ~06:10). k=0 sanity clean both
+arms. BOTH ARMS BELOW REFERENCE — latent paper is net-harmful at this
+scale, with both failure modes mapped: (a) sctf (teacher-forced
+symbols): lens-CE concentrated to 1.6-2.0 (below item 25's endpoint,
+through the zero-init projector alone against a frozen merge) yet
+free-running eval = 20.3 (easy .345!) — EXPOSURE CATASTROPHE: a wrong
+snap is a hard corruption; a projector trained to trust symbols
+propagates it and poisons the analog rail (-18.8 vs ablation). (b)
+scst (straight-through self-exposure): lce plateaus 2.8-4.4 (never
+fully concentrates under its own snap noise), eval = 27.0 — recovers
+7 of TF's 19 lost points exactly as scheduled-sampling theory
+predicts, but still -12.1 vs the pure analog 39.1. Conclusion: the
+snap's error-correction is real but its error-INJECTION dominates at
+2B/10-tick scale — discreteness in the loop costs more than it
+corrects; visible tokens win not just by discreteness but by
+discreteness + a VERIFIED sampling distribution (the LM head was
+trained for token commitment; the lens readout was not). Per the
+pre-registered decision rule: the division stands as FINAL —
+the loop is a plan machine; tokens are the executor. The latent-paper
+widenings (top-k, depth rails, tape) are closed unless a soft-snap
+variant (mixture feedback, no hard argmax) is ever pre-registered.
+Item 32 closes the architecture tree: pauses, bursts, KV memory,
+analog TF chains, and discrete chains all have controlled answers.

results-loop/STATS.md

@@ -2,6 +2,8 @@
 
 ## Headline numbers (Wilson 95% CIs)
 
+- **MBPP untrained merge k=4 (n=500 rerun)**: overall 0.502 [0.458, 0.546] (n=500); hard 0.200 [0.116, 0.324] (n=55)
+- **MBPP trained FF k=1 (n=500 rerun)**: overall 0.536 [0.492, 0.579] (n=500); hard 0.273 [0.173, 0.402] (n=55)
 - **MBPP loop s0 k=0 (base)**: overall 0.518 [0.474, 0.561] (n=500); hard 0.055 [0.019, 0.149] (n=55)
 - **MBPP loop s0 k=2**: overall 0.530 [0.486, 0.573] (n=500); hard 0.309 [0.203, 0.440] (n=55)
 - **MBPP loop s0 k=4**: overall 0.536 [0.492, 0.579] (n=500); hard 0.436 [0.314, 0.567] (n=55)
@@ -22,6 +24,10 @@
 
 - loop k=4 vs k=0, overall: A-only 30, B-only 39, n=500, p=0.3356 (n.s.)
 - loop k=4 vs k=0, hard: A-only 1, B-only 22, n=55, p=5.722e-06 (**significant**)
+- loop k=4 vs UNTRAINED merge k=4, hard (net effect): A-only 4, B-only 17, n=55, p=0.007197 (**significant**)
+- loop k=4 vs UNTRAINED merge k=4, overall: A-only 29, B-only 46, n=500, p=0.06395 (n.s.)
+- trained FF vs UNTRAINED merge, hard: A-only 7, B-only 11, n=55, p=0.4807 (n.s.)
+- distill k=1 vs UNTRAINED merge k=4, hard: A-only 3, B-only 15, n=55, p=0.007538 (**significant**)
 - distill k=1 vs loop k=4, overall: A-only 33, B-only 37, n=500, p=0.7202 (n.s.)
 - distill k=1 vs loop k=4, hard: A-only 10, B-only 9, n=55, p=1 (n.s.)
 - stack-train k=4 vs distill k=1, hard: A-only 10, B-only 6, n=55, p=0.4545 (n.s.)

results-loop/eval_code_rec16_partial.json

@@ -0,0 +1,47 @@
+{
+ "tag": "rec16_e400_PARTIAL",
+ "note": "k=16,32 cancelled by decision after k<=8 showed prediction (a); rho(A) from checkpoints",
+ "rho_trajectory": {
+  "e100": 3.357,
+  "e200": 4.31,
+  "e300": 4.456,
+  "e400": 4.525,
+  "e500": 4.492,
+  "e600": 4.465
+ },
+ "ks": {
+  "0": {
+   "acc": 0.488,
+   "by_label": {
+    "easy": 0.984,
+    "hard": 0.036,
+    "drop": 0.01
+   }
+  },
+  "2": {
+   "acc": 0.408,
+   "by_label": {
+    "easy": 0.697,
+    "hard": 0.357,
+    "drop": 0.07
+   }
+  },
+  "4": {
+   "acc": 0.412,
+   "by_label": {
+    "easy": 0.697,
+    "hard": 0.393,
+    "drop": 0.07
+   }
+  },
+  "8": {
+   "acc": 0.408,
+   "by_label": {
+    "easy": 0.689,
+    "hard": 0.429,
+    "drop": 0.06
+   }
+  }
+ },
+ "n": 250
+}

results-loop/gate_threshold_curve.json

@@ -0,0 +1,93 @@
+{
+ "curve": [
+  {
+   "theta": 0.3,
+   "overall": 0.488,
+   "by_label": {
+    "easy": 0.9672131147540983,
+    "hard": 0.07142857142857142,
+    "drop": 0.02
+   },
+   "ek": 0.432
+  },
+  {
+   "theta": 0.5,
+   "overall": 0.5,
+   "by_label": {
+    "easy": 0.9590163934426229,
+    "hard": 0.17857142857142858,
+    "drop": 0.03
+   },
+   "ek": 0.74
+  },
+  {
+   "theta": 0.7,
+   "overall": 0.496,
+   "by_label": {
+    "easy": 0.9426229508196722,
+    "hard": 0.17857142857142858,
+    "drop": 0.04
+   },
+   "ek": 1.136
+  },
+  {
+   "theta": 0.8,
+   "overall": 0.508,
+   "by_label": {
+    "easy": 0.9344262295081968,
+    "hard": 0.2857142857142857,
+    "drop": 0.05
+   },
+   "ek": 1.388
+  },
+  {
+   "theta": 0.9,
+   "overall": 0.496,
+   "by_label": {
+    "easy": 0.8852459016393442,
+    "hard": 0.39285714285714285,
+    "drop": 0.05
+   },
+   "ek": 1.76
+  },
+  {
+   "theta": 0.95,
+   "overall": 0.492,
+   "by_label": {
+    "easy": 0.8770491803278688,
+    "hard": 0.42857142857142855,
+    "drop": 0.04
+   },
+   "ek": 2.084
+  },
+  {
+   "theta": 0.98,
+   "overall": 0.504,
+   "by_label": {
+    "easy": 0.8770491803278688,
+    "hard": 0.4642857142857143,
+    "drop": 0.06
+   },
+   "ek": 2.412
+  },
+  {
+   "theta": 0.99,
+   "overall": 0.508,
+   "by_label": {
+    "easy": 0.8770491803278688,
+    "hard": 0.5,
+    "drop": 0.06
+   },
+   "ek": 2.628
+  }
+ ],
+ "oracle": {
+  "overall": 0.596,
+  "by_label": {
+   "easy": 1.0,
+   "hard": 0.6428571428571429,
+   "drop": 0.09
+  },
+  "ek": 0.236
+ }
+}

results-loop/metacog_auc.json

@@ -0,0 +1 @@
+{"carry": 0.7981836131859141, "ff": 0.791359567919433}

results-loop/stats_final.json

@@ -1,4 +1,40 @@
 {
+ "MBPP untrained merge k=4 (n=500 rerun)": {
+  "overall": {
+   "acc": 0.502,
+   "n": 500,
+   "ci": [
+    0.458,
+    0.546
+   ]
+  },
+  "hard": {
+   "acc": 0.2,
+   "n": 55,
+   "ci": [
+    0.116,
+    0.324
+   ]
+  }
+ },
+ "MBPP trained FF k=1 (n=500 rerun)": {
+  "overall": {
+   "acc": 0.536,
+   "n": 500,
+   "ci": [
+    0.492,
+    0.579
+   ]
+  },
+  "hard": {
+   "acc": 0.2727272727272727,
+   "n": 55,
+   "ci": [
+    0.173,
+    0.402
+   ]
+  }
+ },
  "MBPP loop s0 k=0 (base)": {
   "overall": {
    "acc": 0.518,
@@ -275,6 +311,30 @@
    "b_only": 22,
    "p": 5.7220458984375e-06
   },
+  "loop k=4 vs UNTRAINED merge k=4, hard (net effect)": {
+   "n": 55,
+   "a_only": 4,
+   "b_only": 17,
+   "p": 0.007197380065917969
+  },
+  "loop k=4 vs UNTRAINED merge k=4, overall": {
+   "n": 500,
+   "a_only": 29,
+   "b_only": 46,
+   "p": 0.06394991646706696
+  },
+  "trained FF vs UNTRAINED merge, hard": {
+   "n": 55,
+   "a_only": 7,
+   "b_only": 11,
+   "p": 0.480682373046875
+  },
+  "distill k=1 vs UNTRAINED merge k=4, hard": {
+   "n": 55,
+   "a_only": 3,
+   "b_only": 15,
+   "p": 0.007537841796875
+  },
   "distill k=1 vs loop k=4, overall": {
    "n": 500,
    "a_only": 33,

results/REGIMES.json

@@ -0,0 +1,59 @@
+{
+ "_doc": "Canonical per-model J-lens regime registry. Band = inclusive layer range whose lens readout shows workspace behavior (persist+content high, sensor/motor low; exp4_regimes.py). kv_share_start = first layer reusing KV from below (entrances at or above it are structurally null for band looping). Lives in results/ next to the raw jbar tensors and exp4 scan logs; bucket mirror: results-lens/. Revisions are the pinned model SHAs the scan ran on.",
+ "google/gemma-4-E2B-it": {
+  "revision": "9dbdf8a839e4e9e0eb56ed80cc8886661d3817cf",
+  "num_layers": 35,
+  "hidden": 1536,
+  "workspace_band": [
+   14,
+   30
+  ],
+  "kv_share_start": 15,
+  "jbar": "results/jbar.pt",
+  "scan": "results/exp4.log",
+  "status": "mapped + loop-validated (full program, PAPER.md)"
+ },
+ "google/gemma-4-12B-it": {
+  "revision": "0e2b1058541244490925fbacf8972041435691ac",
+  "num_layers": 48,
+  "hidden": 3840,
+  "workspace_band": [
+   36,
+   45
+  ],
+  "kv_share_start": null,
+  "jbar": "bucket:results-lens/jbar_12b.pt",
+  "scan": "results/exp4_12b.log",
+  "status": "mapped + loop-validated (adaptive-alpha required; MBPP only)"
+ },
+ "google/gemma-4-E4B-it": {
+  "revision": "fa62d88df2e6df5efa9d26ad6b3beaea2765f0cd",
+  "num_layers": 42,
+  "hidden": 2560,
+  "workspace_band": null,
+  "kv_share_start": 25,
+  "jbar": "results/jbar_e4b.pt (150/256 prompts \u2014 ckpt-salvaged)",
+  "scan": "results/exp4_e4b.log",
+  "status": "mapped 2026-07-16, PROVISIONAL: no clear workspace signature. sensor L11-22 (peak 0.36@L22), motor onset L23 rising to 0.52@L41, persistence flat ~0.05-0.13 (E2B's band-entry persistence bump is ABSENT). Candidate thin band L23-28 sits inside the KV-shared zone (L24+) \u2014 band looping likely structurally hampered on E4B. Needs: ignition cross-check + full-prompt jbar top-up before strong claims."
+ },
+ "google/gemma-4-31B-it": {
+  "revision": "b9ea41a2887d8607f594846523f94c6cc75ac8a4",
+  "num_layers": 60,
+  "hidden": 5376,
+  "workspace_band": null,
+  "kv_share_start": "none found in config (no num_kv_shared_layers key printed \u2014 verify in scan; if truly absent, all entrances structurally live)",
+  "jbar": "bucket:results-lens/jbar_31b.pt (256/256 prompts)",
+  "scan": "results/exp4_31b.log (regimes_31b.pt reconstructed via parse_regimes_log.py; scan's own save hit the results/-CWD bug)",
+  "status": "mapped 2026-07-16, PROVISIONAL: E2B-style mid-depth workspace signature ABSENT (like E4B). Persistence+content bump sits EARLY instead \u2014 L7-16 (persist 0.30-0.49 peak L14, content 0.76-0.97, sensor/motor ~0). Sensor is two-lobed: L26-40 (peak 0.17@L26) and L49-56 (~0.12). Motor essentially absent until the final layer (0.06-0.07 L50-56, 0.20@L59). Ignition cross-check (in-log): commitment pinned hard through L38, collapses to ~0 at L42-46, becomes write-responsive at L54-58 (sign flips with w>=0.5 on all three pairs). Early persist zone vs late write-responsiveness disagree \u2014 no single band supported yet; needs jbar-side analysis before any band is entered."
+ },
+ "google/gemma-4-26B-A4B-it": {
+  "revision": "01e5b3ee840d3a9e0b0b493c593e85398a30ef75",
+  "num_layers": 30,
+  "hidden": 2816,
+  "workspace_band": null,
+  "kv_share_start": null,
+  "jbar": "bucket:results-lens/jbar_26b_a4b.pt (256/256 prompts)",
+  "scan": "results/exp4_26b_a4b.log + results/regimes_26b_a4b.pt (saved directly \u2014 first scan through the patched exp4_regimes.py; includes full per-layer ignition tensors)",
+  "status": "mapped 2026-07-16, PROVISIONAL: only 30 layers (MoE, A4B active; num_kv_shared_layers=0 in config \u2014 all entrances structurally live). Same family pattern as E4B/31B, NOT E2B: persistence bump EARLY and thin (L5-6, 0.33/0.25), then flat ~0.03-0.08; sensor lobe L10-18 (peak 0.21@L13); motor weak and only terminal (0.11@L29); content high throughout mid (0.6-0.93). Ignition heavily saturated (many +/-1.00 cells) but write-responsive late: L22-26 commitment flips to the written concept at w>=0.5 on all three pairs (dog/piano L26 -1.00 -> +1.00). MoE lens-validity check still required before trusting any band; no band entered."
+ }
+}

results/exp4_26b_a4b.log

@@ -0,0 +1,57 @@
+
Loading weights:   0%|          | 0/1013 [00:00<?, ?it/s]
Loading weights: 100%|██████████| 1013/1013 [00:00<00:00, 11419.56it/s]
+layer | sensor(top==cur) motor(top==next) persist(top10 Jaccard) content-word
+L 0 | 0.00                      | 0.00                      | 0.07 | 0.82
+L 1 | 0.00                      | 0.00                      | 0.08 | 0.48
+L 2 | 0.00                      | 0.00                      | 0.18 | 0.64
+L 3 | 0.00                      | 0.00                      | 0.08 | 0.61
+L 4 | 0.00                      | 0.00                      | 0.08 | 0.87
+L 5 | 0.00                      | 0.00                      | 0.33 | 0.93
+L 6 | 0.00                      | 0.00                      | 0.25 | 0.93
+L 7 | 0.00                      | 0.00                      | 0.15 | 0.57
+L 8 | 0.07 #                    | 0.00                      | 0.05 | 0.40
+L 9 | 0.07 #                    | 0.00                      | 0.06 | 0.79
+L10 | 0.18 ###                  | 0.01                      | 0.04 | 0.66
+L11 | 0.17 ###                  | 0.01                      | 0.04 | 0.64
+L12 | 0.14 ##                   | 0.01                      | 0.04 | 0.72
+L13 | 0.21 ####                 | 0.02                      | 0.05 | 0.64
+L14 | 0.16 ###                  | 0.02                      | 0.03 | 0.65
+L15 | 0.12 ##                   | 0.03                      | 0.04 | 0.59
+L16 | 0.12 ##                   | 0.02                      | 0.03 | 0.72
+L17 | 0.14 ##                   | 0.04                      | 0.02 | 0.62
+L18 | 0.12 ##                   | 0.02                      | 0.03 | 0.60
+L19 | 0.07 #                    | 0.04                      | 0.04 | 0.71
+L20 | 0.09 #                    | 0.01                      | 0.05 | 0.79
+L21 | 0.09 #                    | 0.02                      | 0.04 | 0.87
+L22 | 0.09 #                    | 0.04                      | 0.06 | 0.91
+L23 | 0.10 #                    | 0.05                      | 0.08 | 0.87
+L24 | 0.08 #                    | 0.06 #                    | 0.08 | 0.88
+L25 | 0.07 #                    | 0.06 #                    | 0.07 | 0.80
+L26 | 0.07 #                    | 0.07 #                    | 0.08 | 0.80
+L27 | 0.07 #                    | 0.07 #                    | 0.07 | 0.85
+L28 | 0.06 #                    | 0.09 #                    | 0.05 | 0.80
+L29 | 0.00                      | 0.11 ##                   | 0.05 | 0.38
+
+ignition: commitment C=(P1-P2)/(P1+P2) at read pos, by layer
+pair            | w:   0.00  0.25  0.50  0.75  1.00
+dog/piano     L 2 | +1.00  +1.00  +1.00  +1.00  +1.00
+dog/piano     L 6 | -0.74  -0.75  -0.83  -0.80  -0.81
+dog/piano     L10 | +0.58  +0.63  +0.91  +0.92  +0.92
+dog/piano     L14 | +0.85  +0.17  +0.69  +0.81  +0.15
+dog/piano     L18 | -0.00  -0.01  +0.66  +0.94  +0.67
+dog/piano     L22 | +0.94  +0.93  +0.98  +1.00  +1.00
+dog/piano     L26 | -1.00  -1.00  +0.39  +1.00  +1.00
+ocean/violin    L 2 | +1.00  +1.00  +1.00  +1.00  +1.00
+ocean/violin    L 6 | +1.00  +1.00  +1.00  +1.00  +1.00
+ocean/violin    L10 | +0.00  +0.00  +0.00  +0.00  +0.00
+ocean/violin    L14 | +0.00  +0.00  +0.00  +0.00  +0.00
+ocean/violin    L18 | +0.00  +0.00  +0.29  +0.27  +0.00
+ocean/violin    L22 | +0.98  +0.28  +1.00  +1.00  +1.00
+ocean/violin    L26 | -0.56  -0.26  +0.98  +1.00  +1.00
+dragon/bicycle   L 2 | +0.00  +0.00  +0.00  +0.00  +0.00
+dragon/bicycle   L 6 | -1.00  -1.00  -1.00  -1.00  -1.00
+dragon/bicycle   L10 | +0.00  +0.00  +0.00  +0.00  +0.00
+dragon/bicycle   L14 | +0.00  +0.00  +0.00  +0.00  +0.00
+dragon/bicycle   L18 | +0.00  +0.00  +0.00  +0.00  +0.00
+dragon/bicycle   L22 | +0.98  +0.40  +1.00  +0.86  +0.91
+dragon/bicycle   L26 | +0.05  +0.51  +1.00  +0.58  +0.34
+saved /workspace/jspace/results/regimes_26b_a4b.pt

results/exp4_31b.log

@@ -0,0 +1,124 @@
+
Loading weights:   0%|          | 0/1188 [00:00<?, ?it/s]
Loading weights:  99%|█████████▊| 1172/1188 [00:00<00:00, 11704.66it/s]
Loading weights: 100%|██████████| 1188/1188 [00:00<00:00, 11701.74it/s]
+layer | sensor(top==cur) motor(top==next) persist(top10 Jaccard) content-word
+L 0 | 0.02                      | 0.00                      | 0.04 | 0.36
+L 1 | 0.02                      | 0.00                      | 0.00 | 0.62
+L 2 | 0.04                      | 0.00                      | 0.02 | 0.48
+L 3 | 0.03                      | 0.00                      | 0.03 | 0.51
+L 4 | 0.02                      | 0.00                      | 0.08 | 0.31
+L 5 | 0.01                      | 0.00                      | 0.18 | 0.65
+L 6 | 0.01                      | 0.00                      | 0.15 | 0.59
+L 7 | 0.00                      | 0.00                      | 0.38 | 0.49
+L 8 | 0.00                      | 0.00                      | 0.47 | 0.47
+L 9 | 0.00                      | 0.00                      | 0.40 | 0.83
+L10 | 0.00                      | 0.00                      | 0.48 | 0.95
+L11 | 0.00                      | 0.00                      | 0.31 | 0.97
+L12 | 0.00                      | 0.00                      | 0.31 | 0.76
+L13 | 0.00                      | 0.00                      | 0.36 | 0.88
+L14 | 0.00                      | 0.00                      | 0.49 | 0.95
+L15 | 0.00                      | 0.00                      | 0.30 | 0.97
+L16 | 0.00                      | 0.00                      | 0.28 | 0.97
+L17 | 0.01                      | 0.00                      | 0.24 | 0.68
+L18 | 0.02                      | 0.00                      | 0.18 | 0.69
+L19 | 0.01                      | 0.00                      | 0.25 | 0.66
+L20 | 0.07 #                    | 0.00                      | 0.11 | 0.64
+L21 | 0.08 #                    | 0.00                      | 0.07 | 0.77
+L22 | 0.04                      | 0.00                      | 0.08 | 0.69
+L23 | 0.05                      | 0.00                      | 0.13 | 0.83
+L24 | 0.03                      | 0.00                      | 0.16 | 0.96
+L25 | 0.04                      | 0.00                      | 0.19 | 0.93
+L26 | 0.17 ###                  | 0.00                      | 0.04 | 0.69
+L27 | 0.07 #                    | 0.00                      | 0.06 | 0.79
+L28 | 0.11 ##                   | 0.00                      | 0.05 | 0.83
+L29 | 0.12 ##                   | 0.00                      | 0.05 | 0.80
+L30 | 0.11 ##                   | 0.01                      | 0.05 | 0.63
+L31 | 0.15 ##                   | 0.00                      | 0.03 | 0.69
+L32 | 0.14 ##                   | 0.00                      | 0.03 | 0.49
+L33 | 0.15 ##                   | 0.01                      | 0.02 | 0.63
+L34 | 0.12 ##                   | 0.00                      | 0.02 | 0.69
+L35 | 0.12 ##                   | 0.01                      | 0.02 | 0.63
+L36 | 0.10 #                    | 0.00                      | 0.02 | 0.54
+L37 | 0.08 #                    | 0.00                      | 0.03 | 0.59
+L38 | 0.09 #                    | 0.01                      | 0.03 | 0.72
+L39 | 0.11 ##                   | 0.01                      | 0.03 | 0.74
+L40 | 0.13 ##                   | 0.01                      | 0.06 | 0.83
+L41 | 0.03                      | 0.00                      | 0.05 | 0.86
+L42 | 0.02                      | 0.00                      | 0.08 | 0.83
+L43 | 0.02                      | 0.00                      | 0.05 | 0.85
+L44 | 0.04                      | 0.00                      | 0.06 | 0.82
+L45 | 0.06 #                    | 0.02                      | 0.05 | 0.88
+L46 | 0.06 #                    | 0.01                      | 0.06 | 0.93
+L47 | 0.02                      | 0.02                      | 0.05 | 0.83
+L48 | 0.05                      | 0.04                      | 0.05 | 0.83
+L49 | 0.08 #                    | 0.05                      | 0.04 | 0.93
+L50 | 0.12 ##                   | 0.06 #                    | 0.04 | 0.91
+L51 | 0.14 ##                   | 0.06 #                    | 0.06 | 0.88
+L52 | 0.12 ##                   | 0.07 #                    | 0.07 | 0.88
+L53 | 0.12 ##                   | 0.07 #                    | 0.08 | 0.87
+L54 | 0.12 ##                   | 0.07 #                    | 0.10 | 0.78
+L55 | 0.09 #                    | 0.07 #                    | 0.12 | 0.79
+L56 | 0.09 #                    | 0.06 #                    | 0.11 | 0.69
+L57 | 0.06 #                    | 0.04                      | 0.13 | 0.54
+L58 | 0.02                      | 0.02                      | 0.35 | 0.44
+L59 | 0.00                      | 0.20 ###                  | 0.08 | 0.36
+
+ignition: commitment C=(P1-P2)/(P1+P2) at read pos, by layer
+pair            | w:   0.00  0.25  0.50  0.75  1.00
+dog/piano     L 2 | -0.84  -0.83  -0.79  -0.76  -0.77
+dog/piano     L 6 | -0.98  -0.99  -0.99  -0.98  -0.99
+dog/piano     L10 | -0.97  -0.97  -0.97  -0.97  -0.98
+dog/piano     L14 | -0.98  -0.98  -0.98  -0.98  -0.99
+dog/piano     L18 | -0.99  -0.99  -0.99  -0.99  -0.99
+dog/piano     L22 | -0.85  -0.85  -0.86  -0.87  -0.87
+dog/piano     L26 | -0.83  -0.81  -0.82  -0.85  -0.85
+dog/piano     L30 | -0.41  -0.40  -0.35  -0.45  -0.50
+dog/piano     L34 | -0.46  -0.46  -0.63  -0.73  -0.78
+dog/piano     L38 | -0.56  -0.58  -0.74  -0.77  -0.84
+dog/piano     L42 | -0.00  +0.00  +0.01  +0.00  -0.00
+dog/piano     L46 | -0.00  +0.00  +0.00  +0.00  -0.00
+dog/piano     L50 | +0.01  +0.01  +0.06  +0.02  +0.02
+dog/piano     L54 | -0.03  -0.01  +0.10  +0.17  +0.12
+dog/piano     L58 | -0.21  -0.17  +0.32  +0.30  +0.24
+ocean/violin    L 2 | +0.92  +0.93  +0.93  +0.92  +0.89
+ocean/violin    L 6 | +0.96  +0.97  +0.97  +0.96  +0.95
+ocean/violin    L10 | +0.99  +0.99  +1.00  +0.99  +0.99
+ocean/violin    L14 | +0.99  +0.99  +0.99  +0.99  +0.99
+ocean/violin    L18 | +0.82  +0.87  +0.82  +0.72  +0.61
+ocean/violin    L22 | -0.89  -0.87  -0.87  -0.89  -0.92
+ocean/violin    L26 | -0.66  -0.59  -0.68  -0.76  -0.81
+ocean/violin    L30 | -0.30  -0.19  -0.15  -0.33  -0.46
+ocean/violin    L34 | +0.09  +0.22  -0.09  -0.39  -0.51
+ocean/violin    L38 | +0.51  +0.58  +0.19  -0.15  -0.22
+ocean/violin    L42 | +0.18  +0.14  +0.19  +0.02  -0.04
+ocean/violin    L46 | -0.02  -0.03  -0.00  -0.08  -0.09
+ocean/violin    L50 | +0.53  +0.48  +0.62  +0.33  +0.14
+ocean/violin    L54 | -0.99  -0.99  +0.18  +0.28  +0.34
+ocean/violin    L58 | -0.74  -0.82  +0.36  +0.38  +0.37
+dragon/bicycle   L 2 | -1.00  -1.00  -1.00  -1.00  -1.00
+dragon/bicycle   L 6 | -1.00  -1.00  -1.00  -1.00  -1.00
+dragon/bicycle   L10 | -0.99  -0.99  -0.99  -0.99  -0.99
+dragon/bicycle   L14 | -0.99  -0.99  -0.99  -0.99  -0.99
+dragon/bicycle   L18 | -0.99  -0.99  -0.99  -0.98  -0.98
+dragon/bicycle   L22 | -0.93  -0.93  -0.92  -0.90  -0.92
+dragon/bicycle   L26 | -0.96  -0.95  -0.95  -0.92  -0.94
+dragon/bicycle   L30 | -0.74  -0.77  -0.71  -0.67  -0.72
+dragon/bicycle   L34 | -0.79  -0.77  -0.77  -0.80  -0.80
+dragon/bicycle   L38 | -0.84  -0.84  -0.85  -0.81  -0.86
+dragon/bicycle   L42 | -0.04  -0.04  -0.03  -0.01  -0.02
+dragon/bicycle   L46 | -0.01  -0.01  -0.01  -0.00  -0.00
+dragon/bicycle   L50 | -0.47  -0.48  -0.36  -0.23  -0.23
+dragon/bicycle   L54 | -0.68  -0.81  +0.00  +0.10  +0.11
+dragon/bicycle   L58 | -0.74  -0.80  +0.04  +0.10  +0.07
+Traceback (most recent call last):
+  File "/workspace/jspace/scripts/exp4_regimes.py", line 142, in <module>
+    main()
+  File "/workspace/jspace/scripts/exp4_regimes.py", line 137, in main
+    torch.save({"sensor": sensor, "motor": motor, "persist": persist,
+  File "/venv/main/lib/python3.12/site-packages/torch/serialization.py", line 1003, in save
+    with _open_zipfile_writer(f) as opened_zipfile:
+         ^^^^^^^^^^^^^^^^^^^^^^^
+  File "/venv/main/lib/python3.12/site-packages/torch/serialization.py", line 865, in _open_zipfile_writer
+    return container(name_or_buffer)  # type: ignore[arg-type]
+           ^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/venv/main/lib/python3.12/site-packages/torch/serialization.py", line 829, in __init__
+    torch._C.PyTorchFileWriter(
+RuntimeError: Parent directory results does not exist.

results/exp4_e4b.log

@@ -0,0 +1,91 @@
+
Loading weights:   0%|          | 0/2076 [00:00<?, ?it/s]
Loading weights:  56%|█████▋    | 1170/2076 [00:00<00:00, 11691.45it/s]
Loading weights: 100%|██████████| 2076/2076 [00:00<00:00, 11843.72it/s]
+layer | sensor(top==cur) motor(top==next) persist(top10 Jaccard) content-word
+L 0 | 0.00                      | 0.00                      | 0.02 | 0.78
+L 1 | 0.00                      | 0.00                      | 0.17 | 0.37
+L 2 | 0.00                      | 0.00                      | 0.07 | 0.49
+L 3 | 0.00                      | 0.00                      | 0.13 | 0.90
+L 4 | 0.00                      | 0.00                      | 0.27 | 0.98
+L 5 | 0.00                      | 0.00                      | 0.22 | 0.76
+L 6 | 0.00                      | 0.00                      | 0.45 | 0.97
+L 7 | 0.00                      | 0.00                      | 0.08 | 0.85
+L 8 | 0.00                      | 0.00                      | 0.10 | 0.60
+L 9 | 0.00                      | 0.00                      | 0.30 | 0.69
+L10 | 0.01                      | 0.00                      | 0.10 | 0.65
+L11 | 0.07 #                    | 0.00                      | 0.06 | 0.62
+L12 | 0.02                      | 0.00                      | 0.11 | 0.67
+L13 | 0.01                      | 0.00                      | 0.13 | 0.80
+L14 | 0.09 #                    | 0.00                      | 0.08 | 0.88
+L15 | 0.07 #                    | 0.04                      | 0.08 | 0.76
+L16 | 0.12 ##                   | 0.02                      | 0.10 | 0.90
+L17 | 0.09 #                    | 0.09 #                    | 0.08 | 0.81
+L18 | 0.12 ##                   | 0.07 #                    | 0.09 | 0.82
+L19 | 0.13 ##                   | 0.09 #                    | 0.09 | 0.60
+L20 | 0.22 ####                 | 0.02                      | 0.07 | 0.85
+L21 | 0.17 ###                  | 0.00                      | 0.05 | 0.89
+L22 | 0.36 #######              | 0.00                      | 0.02 | 0.83
+L23 | 0.00                      | 0.13 ##                   | 0.10 | 0.35
+L24 | 0.00                      | 0.13 ##                   | 0.09 | 0.37
+L25 | 0.00                      | 0.11 ##                   | 0.11 | 0.43
+L26 | 0.00                      | 0.19 ###                  | 0.10 | 0.57
+L27 | 0.00                      | 0.18 ###                  | 0.08 | 0.63
+L28 | 0.00                      | 0.12 ##                   | 0.06 | 0.61
+L29 | 0.00                      | 0.27 #####                | 0.06 | 0.60
+L30 | 0.00                      | 0.33 ######               | 0.05 | 0.56
+L31 | 0.00                      | 0.36 #######              | 0.05 | 0.54
+L32 | 0.00                      | 0.38 #######              | 0.06 | 0.63
+L33 | 0.00                      | 0.43 ########             | 0.06 | 0.63
+L34 | 0.00                      | 0.38 #######              | 0.04 | 0.70
+L35 | 0.00                      | 0.35 ######               | 0.04 | 0.73
+L36 | 0.00                      | 0.40 ########             | 0.04 | 0.69
+L37 | 0.00                      | 0.43 ########             | 0.04 | 0.67
+L38 | 0.00                      | 0.44 ########             | 0.03 | 0.65
+L39 | 0.00                      | 0.42 ########             | 0.03 | 0.67
+L40 | 0.00                      | 0.46 #########            | 0.03 | 0.58
+L41 | 0.00                      | 0.52 ##########           | 0.05 | 0.46
+
+ignition: commitment C=(P1-P2)/(P1+P2) at read pos, by layer
+pair            | w:   0.00  0.25  0.50  0.75  1.00
+dog/piano     L 2 | +0.76  +0.76  +0.76  +0.76  +0.81
+dog/piano     L 6 | +1.00  +1.00  +0.99  +0.99  +0.99
+dog/piano     L10 | +0.41  +0.41  +0.41  +0.36  +0.46
+dog/piano     L14 | +0.00  -0.06  -0.12  -0.12  -0.12
+dog/piano     L18 | +0.24  +0.46  +0.95  +0.93  +0.93
+dog/piano     L22 | +0.00  +0.08  +0.27  +0.00  +0.00
+dog/piano     L26 | +0.38  +1.00  +1.00  +1.00  +1.00
+dog/piano     L30 | +0.37  +0.32  +0.56  +0.28  +0.23
+dog/piano     L34 | +0.91  +0.91  +0.98  +0.99  +0.99
+dog/piano     L38 | -0.80  -0.51  +0.76  +0.86  +0.91
+ocean/violin    L 2 | +0.06  +0.00  +0.06  +0.00  -0.06
+ocean/violin    L 6 | +0.05  +0.12  +0.11  +0.21  +0.32
+ocean/violin    L10 | -0.16  -0.15  -0.14  -0.08  -0.10
+ocean/violin    L14 | -0.46  -0.41  -0.36  -0.36  -0.36
+ocean/violin    L18 | -0.81  -0.79  -0.51  -0.24  -0.19
+ocean/violin    L22 | -0.00  -0.00  -0.00  -0.00  -0.00
+ocean/violin    L26 | +1.00  +1.00  +1.00  +1.00  +1.00
+ocean/violin    L30 | +0.06  +0.03  +0.01  +0.00  +0.00
+ocean/violin    L34 | +0.98  +0.98  +0.98  +0.99  +0.99
+ocean/violin    L38 | -0.75  -0.69  +0.15  +0.62  +0.69
+dragon/bicycle   L 2 | -0.96  -0.97  -0.98  -0.98  -0.98
+dragon/bicycle   L 6 | +0.01  +0.02  +0.07  +0.16  +0.26
+dragon/bicycle   L10 | -0.53  -0.52  -0.46  -0.39  -0.36
+dragon/bicycle   L14 | -0.46  -0.46  -0.41  -0.41  -0.41
+dragon/bicycle   L18 | +0.55  +0.64  +0.70  +0.79  +0.76
+dragon/bicycle   L22 | -0.00  -0.00  -0.00  -0.01  -0.02
+dragon/bicycle   L26 | +1.00  +1.00  +0.99  +0.99  +0.99
+dragon/bicycle   L30 | +0.00  +0.00  -0.00  -0.00  -0.00
+dragon/bicycle   L34 | +0.54  +0.53  +0.50  +0.52  +0.52
+dragon/bicycle   L38 | -0.77  -0.62  -0.33  +0.27  +0.60
+Traceback (most recent call last):
+  File "/home/nils/jspace/scripts/exp4_regimes.py", line 142, in <module>
+    main()
+  File "/home/nils/jspace/scripts/exp4_regimes.py", line 137, in main
+    torch.save({"sensor": sensor, "motor": motor, "persist": persist,
+  File "/home/nils/jspace/.venv/lib/python3.12/site-packages/torch/serialization.py", line 1002, in save
+    with _open_zipfile_writer(f) as opened_zipfile:
+         ^^^^^^^^^^^^^^^^^^^^^^^
+  File "/home/nils/jspace/.venv/lib/python3.12/site-packages/torch/serialization.py", line 864, in _open_zipfile_writer
+    return container(name_or_buffer)  # type: ignore[arg-type]
+           ^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/home/nils/jspace/.venv/lib/python3.12/site-packages/torch/serialization.py", line 828, in __init__
+    torch._C.PyTorchFileWriter(
+RuntimeError: Parent directory results does not exist.

scripts/GPUQ.md

@@ -25,6 +25,33 @@ happens in the filename (`00_`, `01_`, …). The bucket is both transport
 and durable state: a dead node's pending jobs stay visible and can be
 moved to another worker with one `rclone move`.
 
+## Data contract (selective sync)
+
+Jobs declare what they need and what they produce as comments; the worker
+does the rest — no node needs everything, and results survive node death:
+
+```
+# gpuq-in:  results-loop/mbpp_data.json results-loop/adapter_code.pt
+# gpuq-out: results-loop/eval_code_gate*.json results/jbar_31b.pt
+```
+
+Paths are repo-relative, mirrored at `jspace:jspace/<same path>`.
+Inputs are pulled before the job starts. Outputs are pushed every
+`$GPUQ_SYNC_EVERY` seconds (default 120) while the job runs and once at
+exit — a dying node loses at most one interval. The in-flight log is
+also mirrored to `gpuq/<worker>/running/` each cycle. Globs allowed in
+basenames; repeat lines for more paths; jobs with no declarations sync
+nothing (backward compatible). Manual counterpart from any machine:
+
+```
+scripts/gpuq_sync.sh pull results-loop "eval_code_gate*.json"
+scripts/gpuq_sync.sh push results-loop "adapter_code.pt"
+```
+
+Nodes need the rclone remote configured for any of this; keep a scoped
+(write-limited) key for rented nodes. Without credentials the worker
+still runs jobs — sync lines just no-op.
+
 ## Bucket layout
 
 ```

scripts/carry_common.py

@@ -36,18 +36,26 @@ def prompt_prefill(looper, adapter, e, calls, prompt_mask, k):
 
 
 def carry_steps(looper, adapter, e, calls, S, X, step_updates,
-                use_checkpoint=False):
-    """Sequential scan. step_updates: list of (row_idx, pos) index tensors."""
-    for rows, pos in step_updates:
+                use_checkpoint=False, iter_states=None):
+    """Sequential scan. step_updates: list of (row_idx, pos, [inplace])
+    index tensors. inplace=True re-iterates the SAME position, seeding
+    from its own previous band output (internal band looping) instead of
+    its left neighbor. iter_states: optional list — every inplace
+    update's fresh band output at pos is appended (for lens losses)."""
+    for upd in step_updates:
+        rows, pos = upd[0], upd[1]
+        inplace = len(upd) > 2 and upd[2]
         if rows.numel() == 0:
             continue
-        seed = S[rows, pos - 1]
+        seed = S[rows, pos] if inplace else S[rows, pos - 1]
         x_new = adapter(e[rows, pos], seed)
         X = X.clone()
         X[rows, pos] = x_new.to(X.dtype)
         S = (checkpoint(lambda X_: looper.band(X_, calls), X,
                         use_reentrant=False) if use_checkpoint
              else looper.band(X, calls))
+        if inplace and iter_states is not None:
+            iter_states.append(S[rows, pos])
     return S, X
 
 
@@ -63,8 +71,64 @@ def build_step_updates(prompt_lens, total_lens, device):
     return updates
 
 
+def splice_inner_iters(updates, inner_iters, inner_at, prompt_lens, dev, B):
+    """Insert inner_iters in-place band iterations at the (batch-uniform
+    offset) anchor position, right after the scan first settles it."""
+    j_anchor = int((inner_at - prompt_lens).max())
+    rows = torch.arange(B, device=dev)
+    inner = [(rows, inner_at.to(dev), True)] * inner_iters
+    if j_anchor < 0:
+        # anchor is the last PROMPT position (no pauses at all):
+        # iterate there before the scan enters the visible tokens
+        return inner + updates
+    out = []
+    for j, u in enumerate(updates):
+        out.append(u)
+        if j == j_anchor:
+            out += inner
+    return out
+
+
+def sym_iterate(looper, adapter, proj, e, calls, S, X, rows, anchor, m,
+                lens_fn, embed_w, sym_tf=None, start_id=None, topk=32,
+                use_checkpoint=False, iter_states=None):
+    """Item 32: discrete latent chain at the anchor. Each tick reads the
+    previous anchor state through the lens, snaps it to a token
+    (straight-through over top-k) or takes the teacher token (sym_tf:
+    (B, m) ids, teacher forcing), and feeds that token's embedding back
+    through a zero-init projector ALONGSIDE the analog carry:
+        x_i = merge(e, s_{i-1}) + proj(E(sym))
+    Tick 0 uses start_id (a newline: 'a step begins')."""
+    for i in range(m):
+        s_prev = S[rows, anchor]
+        if sym_tf is not None:
+            symb = embed_w[sym_tf[:, i]]
+        elif i == 0:
+            symb = embed_w[torch.full((rows.shape[0],), start_id,
+                                      device=e.device)]
+        else:
+            logits = lens_fn(s_prev).float()
+            p, idx = torch.softmax(logits, -1).topk(topk, dim=-1)
+            p = p / p.sum(-1, keepdim=True)
+            soft = (p.unsqueeze(-1) * embed_w[idx].float()).sum(-2)
+            hard = embed_w[idx[:, 0]].float()
+            symb = hard + soft - soft.detach()
+        x_new = (adapter(e[rows, anchor], s_prev).float()
+                 + proj(symb.float()))
+        X = X.clone()
+        X[rows, anchor] = x_new.to(X.dtype)
+        S = (checkpoint(lambda X_: looper.band(X_, calls), X,
+                        use_reentrant=False) if use_checkpoint
+             else looper.band(X, calls))
+        if iter_states is not None:
+            iter_states.append(S[rows, anchor])
+    return S, X
+
+
 def carry_logits(looper, adapter, input_ids, attention_mask, prompt_lens,
-                 k, use_checkpoint=False, feedforward=False):
+                 k, use_checkpoint=False, feedforward=False,
+                 return_states=False, inner_iters=0, inner_at=None,
+                 iter_states=None):
     """Teacher-forced design-C forward (right-padded batch).
 
     feedforward=True: pause-token control — same positions get the adapter as
@@ -81,18 +145,26 @@ def carry_logits(looper, adapter, input_ids, attention_mask, prompt_lens,
         S = (checkpoint(lambda x_: looper.band(x_, calls), x,
                         use_reentrant=False) if use_checkpoint
              else looper.band(x, calls))
-        return looper.suffix_logits(S, calls)
+        out = looper.suffix_logits(S, calls)
+        return (out, S) if return_states else out
     S, X = prompt_prefill(looper, adapter, e, calls, prompt_mask, k)
     total_lens = attention_mask.sum(-1)
     updates = build_step_updates(prompt_lens.to(dev), total_lens.to(dev), dev)
+    if inner_iters and inner_at is not None:
+        updates = splice_inner_iters(updates, inner_iters, inner_at,
+                                     prompt_lens.to(dev), dev,
+                                     input_ids.shape[0])
     S, X = carry_steps(looper, adapter, e, calls, S, X, updates,
-                       use_checkpoint=use_checkpoint)
-    return looper.suffix_logits(S, calls)
+                       use_checkpoint=use_checkpoint,
+                       iter_states=iter_states)
+    out = looper.suffix_logits(S, calls)
+    return (out, S) if return_states else out
 
 
 @torch.no_grad()
 def generate_carry_c(looper, adapter, tok, input_ids, attention_mask,
-                     k, p, max_new_tokens=10, feedforward=False):
+                     k, p, max_new_tokens=10, feedforward=False,
+                     inner_iters=0, kvmem=None, symchain=None):
     """Greedy design-C generation (left-padded batch, uniform positions).
 
     Appends p pause tokens, prefill-loops the prompt, carries through the
@@ -123,7 +195,29 @@ def generate_carry_c(looper, adapter, tok, input_ids, attention_mask,
             updates = [(torch.arange(B, device=dev),
                         torch.full((B,), n_prompt + j, device=dev,
                                    dtype=torch.long)) for j in range(p)]
-            S, X = carry_steps(looper, adapter, e, calls, S, X, updates)
+            if symchain is not None and inner_iters:
+                anchor_sc = torch.full((B,), n_prompt + p - 1, device=dev,
+                                       dtype=torch.long)
+                S, X = sym_iterate(
+                    looper, adapter, symchain["proj"], e, calls, S, X,
+                    torch.arange(B, device=dev), anchor_sc, inner_iters,
+                    symchain["lens_fn"], symchain["embed_w"],
+                    start_id=symchain["start_id"])
+                updates = updates  # pauses (if any) already handled above
+            elif inner_iters:
+                anchor = torch.full((B,), n_prompt + p - 1, device=dev,
+                                    dtype=torch.long)
+                inner = [(torch.arange(B, device=dev), anchor, True)
+                         for _ in range(inner_iters)]
+                # p=0: iterate at the last prompt position, before any
+                # visible token — no pause tokens involved
+                updates = (inner + updates) if p == 0 else (updates + inner)
+            itst = [] if (kvmem is not None and inner_iters) else None
+            S, X = carry_steps(looper, adapter, e, calls, S, X, updates,
+                               iter_states=itst)
+            if kvmem is not None and itst:
+                from kv_memory import arm_memory
+                arm_memory(kvmem(torch.stack(itst, 1)))
         else:
             X = torch.cat([X_store, e[:, X_store.shape[1]:]], 1)
             rows = torch.arange(B, device=dev)

scripts/eval_carry_cot.py

@@ -0,0 +1,155 @@
+"""E2 stage A eval (item 21): GSM8K accuracy for short-CoT-trained arms.
+
+Generates with generate_carry_c (prefill loop k + pause carry + per-token
+carry) or feedforward mode for the control arm; scores last_number vs
+gold, by STaR label. Grid over (k,p) cells.
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+import torch
+
+from carry_common import generate_carry_c
+from loop_common import (BandLooper, MergeAdapter, chat_prompt,
+                         DIRECT_SUFFIX, last_number, num_eq)
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+from jlens.core import load_model  # noqa: E402
+
+OUT = Path(os.environ.get("LOOP_OUT",
+    Path(__file__).resolve().parent.parent / "results-loop"))
+
+
+@torch.no_grad()
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--adapter", required=True)
+    ap.add_argument("--tag", required=True)
+    ap.add_argument("--grid", default="0:0,2:2,2:6",
+                    help="comma list of k:p cells")
+    ap.add_argument("--n", type=int, default=256)
+    ap.add_argument("--batch", type=int, default=8)
+    ap.add_argument("--feedforward", action="store_true")
+    ap.add_argument("--max-new", type=int, default=160)
+    ap.add_argument("--bandlora", default=None, metavar="LORA_PT",
+                    help="load a lora_*_e*.pt loop-only band-LoRA checkpoint")
+    ap.add_argument("--inner-iters", type=int, default=0, metavar="M",
+                    help="M in-place band iterations at the last pause")
+    ap.add_argument("--kvmem", default=None, metavar="KVMEM_PT",
+                    help="KVMemoryAdapter checkpoint: burst states become "
+                     "band-layer KV prefix entries at generation")
+    ap.add_argument("--symchain", default=None, metavar="PROJ_PT",
+                    help="item 32: discrete latent chain — zero-init "
+                     "projector checkpoint; generation snaps hard argmax")
+    args = ap.parse_args()
+
+    model, tok = load_model(dtype=torch.bfloat16)
+    tok.padding_side = "left"
+    looper = BandLooper(model)
+    kvmem = None
+    if args.kvmem:
+        from kv_memory import install, KVMemoryAdapter
+        from loop_common import BAND
+        install(model)
+        sd = torch.load(args.kvmem, map_location="cuda")
+        code = sd["trunk.1.weight"].shape[0]
+        kvmem = KVMemoryAdapter(model, band=BAND, code=code).cuda()
+        kvmem.load_state_dict(sd)
+        kvmem.eval()
+        print(f"kv-memory loaded: {args.kvmem} (code={code})", flush=True)
+    if args.bandlora:
+        from lora_band import inject_band_lora
+        ck = torch.load(args.bandlora, map_location="cuda")
+        scales = {l: 1.0 for l in ck["band"]}
+        ps = inject_band_lora(looper.tm, ck["band"][0], scales,
+                              rank=ck["rank"])
+        assert len(ps) == len(ck["tensors"]), (len(ps), len(ck["tensors"]))
+        for pr, t in zip(ps, ck["tensors"]):
+            pr.data = t.cuda()
+        print(f"band-lora loaded: {args.bandlora} "
+              f"(r={ck['rank']}, layers {ck['band'][0]}-{ck['band'][-1]})",
+              flush=True)
+    symchain = None
+    if args.symchain:
+        d_ = model.config.get_text_config().hidden_size
+        proj = torch.nn.Linear(d_, d_).cuda()
+        proj.load_state_dict(torch.load(args.symchain, map_location="cuda"))
+        proj.eval()
+        jbar = torch.load(Path(__file__).resolve().parent.parent
+                          / "results/jbar.pt", map_location="cuda")["Jbar"]
+        from loop_common import BAND
+        J30 = jbar[BAND[1]].float()
+        tm = model.model.language_model
+        softcap = model.config.get_text_config().final_logit_softcapping
+
+        def lens_fn(h):
+            x = tm.norm((h.float() @ J30.T).to(tm.norm.weight.dtype))
+            lg = model.lm_head(x)
+            return softcap * torch.tanh(lg / softcap) if softcap else lg
+
+        symchain = {"proj": proj, "lens_fn": lens_fn,
+                    "embed_w": model.get_input_embeddings().weight.detach(),
+                    "start_id": tok("\n",
+                                    add_special_tokens=False)["input_ids"][0]}
+        print(f"symchain loaded: {args.symchain}", flush=True)
+    adapter = MergeAdapter(
+        d=model.config.get_text_config().hidden_size).cuda()
+    adapter.load_state_dict(torch.load(args.adapter, map_location="cuda"))
+    adapter.eval()
+
+    items = [it for it in json.load(open(OUT / "star_data.json"))
+             if it["split"] == "test"][: args.n]
+    print(f"[{args.tag}] GSM carry-cot eval on {len(items)}, "
+          f"grid={args.grid} ff={args.feedforward}", flush=True)
+
+    res = {"tag": args.tag, "grid": {}, "n": len(items)}
+    for cell in args.grid.split(","):
+        k, p = (int(x) for x in cell.split(":"))
+        t0 = time.time()
+        hits, per_label, per_item = 0, {}, []
+        for i in range(0, len(items), args.batch):
+            chunk = items[i : i + args.batch]
+            enc = tok([chat_prompt(tok, it["question"], DIRECT_SUFFIX)
+                       for it in chunk], return_tensors="pt", padding=True,
+                      add_special_tokens=False).to("cuda")
+            if k == 0 and p == 0:
+                gen = model.generate(**enc, max_new_tokens=args.max_new,
+                                     do_sample=False)
+            else:
+                gen = generate_carry_c(looper, adapter, tok,
+                                       enc["input_ids"],
+                                       enc["attention_mask"], k, p,
+                                       max_new_tokens=args.max_new,
+                                       feedforward=args.feedforward,
+                                       inner_iters=args.inner_iters,
+                                       kvmem=kvmem, symchain=symchain)
+                if kvmem is not None:
+                    from kv_memory import arm_memory
+                    arm_memory(None)
+            for j, it in enumerate(chunk):
+                txt = tok.decode(gen[j, enc["input_ids"].shape[1]:],
+                                 skip_special_tokens=True)
+                ok = num_eq(last_number(txt), it["gold"])
+                hits += ok
+                d = per_label.setdefault(it["label"], [0, 0])
+                d[0] += ok
+                d[1] += 1
+                per_item.append({"idx": it["idx"], "ok": bool(ok)})
+        acc = hits / len(items)
+        by = {l: c / n for l, (c, n) in per_label.items()}
+        res["grid"][cell] = {"acc": acc, "by_label": by,
+                             "per_item": per_item}
+        print(f"{cell}: acc={acc:.3f}  "
+              f"by_label={ {l: round(v,3) for l,v in by.items()} }"
+              f"  ({time.time()-t0:.0f}s)", flush=True)
+    json.dump(res, open(OUT / f"eval_{args.tag}.json", "w"), indent=1)
+    print("wrote", OUT / f"eval_{args.tag}.json")
+
+
+if __name__ == "__main__":
+    main()