Turn 6 · claude

# wsp31 author brief (read fully at the start of every turn)

You are one of three authors (claude, gpt, gemini) taking turns. Your job: make Gemma 4 31B solve more coding-agent
tasks **by editing its weights, with no training**. You read the model (weights, activations, traces, failures),
decide what to change, build the change as a closed-form edit, predict its effect, and queue it. A separate runner
spends the rollouts and writes the measured result next to your prediction. You are scored on tasks gained over the
champion in the same batch (the unedited model plus the edits that have already passed; see "The champion"), on the
margin over your matched control, and on how well your predictions held.

**Be bold.** Small safe nudges were tried on the 4B model and were lost in the noise (see `PRIOR_E4B.md`). You get
two entries per round and then wait for their results, so each one counts; a third variation of a null result is a
wasted round. High-risk ideas with a clear mechanism and a
prediction that could be wrong are what this programme wants. Say what would prove you wrong.

## Where you work

- Everything happens on host `wrx90`, reached with `ssh -o BatchMode=yes wrx90 '<command>'`. Write scripts in your
  local working directory, copy them with `scp`, run them with ssh. Keep ssh output small (`tail`, `cut`, `head`).
- Root: `/home/keith/gemma-v2` (below: `$R`). Python: `$R/tii-venv/bin/python` (torch, transformers, vLLM 0.19.1,
  peft, safetensors; no scipy). `. $R/env.sh` sets `R` and `PY`.
[... 206 lines cut ...]
- An edit that passes both stages is promoted: it becomes part of the champion for everything after it.
- The champion is confirmed on tasks you do not see, against the unedited model, and the final champion gets one
  pre-registered held-out run. A changed edit is a new edit.
- A combination of your own edits is a new queue entry with its own record, prediction and control. Combining with
  edits that already passed needs nothing from you: that is what the champion does.

Single-run agent evaluations are noisy by several tasks. An edit worth having shows up as ten or more tasks.
Aim there.

# Notes of author claude (rewritten end of turn 3, 13 Nov 2026, 1:10 AM ET)

No edit has a stage-1 result yet. Queued, unscored: 0007-0010, four below.

## What the unedited model does wrong (b001, 288 episodes; code/seq_stats.py)
- Solved 54%. Per 120 tasks: 25 failures at the 7.5-min limit (13 empty patches), 11 at the 30-call cap, 20 wrong
  patches. 15 of 94 tasks differ between identical arms (one-run sd about 4 tasks).
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
  the first 12 calls) 0.31; first edit at calls 6-11: 0.70-0.80.
- The thought before the first edit is long (24% / 35% beyond 800 in solved / failed), so a depth gate cuts into it.
  Deep thoughts after the first edit are rare: "pre-edit" adds little to a depth condition.

## Queued this turn (READY; all 60 layers, 180 matrices, 4.4-5.3% of the network; code/net_job.py)
One neuron per layer becomes a ridge-LDA detector that writes a stream direction at a small dose.
1. net-deep-gate-close-b12, 2. net-deep-gate-close-b05: depth >= 800 -> end-of-thought contrast (dose pair).
3. net-preedit-commit-close-b05: depth >= 400 and no edit yet -> end-of-thought + "first-edit thought" contrast.
4. net-preedit-commit-b12: the commit contrast alone (teacher-forced it moves no tool choice; likeliest null).
Pre-test, 4 held-out episodes, 3 long thoughts: cut 2/3, 1/3, 1/3, 0/3; short thoughts and true ends intact;
controls (sign-flipped write) cut nothing. No served generation was run: what follows a cut thought is unmeasured.
[... 99 lines cut ...]
| 0015 new | gemini | exact-close-r4-subspace | Spectral rank-4 exact-context within-call thought-close writer subspace across all 60 layers (0.38%) | queued_s2 | -4 to +11 | +4.5 (74 vs 72) corrected |  | - |
| 0016 | gemini | rumination-damp-r2-net | Subtractive rank-2 deep-rumination attractor damping across all 280 mid-to-late modules (0.36%) | parked | -5 to +10 |  |  | - |
| 0017 | gemini | late-preedit-commit-gate | Coordinate-whitened GeGLU late pre-edit commit gate across 13 high-signal layers (dose 1.20) | parked | -3 to +10 |  |  | - |
| 0018 | gemini | dual-budget-rescue-r5 | Dual-cap rescue stack: rank-4 exact-close writer subspace (0.38%) plus 13-layer late pre-edit commit gate | parked | -4 to +14 |  |  | - |
| 0025 | gpt | code-writer-damp-r4-033 | Damp the code-versus-prose style contrast in writers in all layers at 0.33 percent | queued_s1 | -6 to +12 |  |  | - |
| 0026 | gpt | code-writer-damp-r4-011 | Damp the code-versus-prose style contrast in writers in all layers at 0.11 percent | queued_s1 | -5 to +10 |  |  | - |
| 0027 | gpt | code-reader-damp-r4-033 | Damp the code-versus-prose style contrast in readers in all layers at 0.33 percent | parked | -8 to +14 |  |  | - |
| 0028 | gemini | nullspace-close-r4-midlate | Protocol-nullspace rank-4 exact thought-close writer subspace across L10-59 (0.48%) | queued_s1 | +1 to +13 |  |  | - |

# wsp31 queue status (2026-11-13 18:51:16 EST)

Rule: {"s1_promote": 3.0, "s1_harmful": -6.0, "s2_min": 4.0, "ctrl_margin": 5.0, "total_pass": 10.0, "total_harmful": -10.0}

Champion (the base every new edit is scored against): Generation 0: the unedited model. No edit has passed yet.

## Batches

| batch | stage | gpu | state | arms | rows | note |
|---|---|---|---|---|---|---|
| b001 | s1 | 1 | done | base aa zero | 360 | {"base": 60, "episodes": 120, "aa": [60, 60, 6, 6], "arms": {"zero": [65, 5.0]}} |
| b002 | s1 | 1 | done | base e0008 e0011 aa | 480 | {"base": 60, "episodes": 120, "aa": [60, 62, 4, 6], "arms": {"e0008": [51, -10.0], "e0011": [51, -10.0]}} |
| b003 | s1 | 0 | done | base e0012 e0015 aa | 480 | {"base": 58, "episodes": 120, "aa": [58, 52, 9, 3], "arms": {"e0012": [34, -21.0], "e0015": [61, 6.0]}} |
| b004 | s1 | 1 | done | base e0021 e0020 aa | 408 | {"base": 56, "episodes": 102, "aa": [56, 59, 4, 7], "arms": {"e0021": [50, -7.5], "e0020": [47, -10.5]}} |
| b003-supp1 | s1 | 0 | done | base e0012 e0015 aa | 124 | {"tasks": 31, "record": "0029", "solved": {"base": [58, 72], "e0012": [34, 44], "e0015": [61, 74], "aa": [52, 67]}} |
[line removed by the dashboard scrubber]
| b001-supp1 | s1 | 1 | running | base aa zero | 37 |  |

## Edits

[... 109 lines cut ...]
  "free_slot_before_grading": true
 },
 "task_set": "wsp31_screen_v2",
 "lora_target_modules": true,
 "spec_k": 3,
 "swa_fix": true,
[line removed by the dashboard scrubber]
}

Fri Nov 13 06:51:34 PM EST 2026
 28053 tools/TOOLS.md
  9736 tools/ARCH.md
199383 interp/REPORT.md
237172 total
# wsp31 tools for edit authors

Changelog (newest first; times US Eastern):
- Fri 13 Nov, 3:51 PM: **three of the first four edits were harmful (-10 to -21 tasks): read "Before you submit"
  (section 5) first.** GPU 0 for pre-tests only while an author turn is open (section 3). New `delimprobe.py`.
[line removed by the dashboard scrubber]
  12:39 AM speed (trap 12): **the server's rank limit sets the price of an adapter**.
- Thu 12 Nov: 11:40 PM first served runs of `dose.py`, `validate.py`, `vgen.py`, `closeprobe.py`; 10:55 PM stacks
  of rank 34 to 96 applied as written; 10:30 PM **thought-end pre-tests need exact contexts**, rank limits 64 or 128
  (never 96); 10:00 PM champion support, network-wide builders; 8:36 PM first version. Earlier commands all still work.

Everything here lives in `$R/wsp31/tools` (below `$T`; `$R = /home/keith/gemma-v2`). Each entry ends with
**Verified by** (a measurement that was made) or **NOT VERIFIED YET** (written, first real run still queued; use it,
but do not build a claim on its numbers alone). Architecture facts are in `$T/ARCH.md` (read "Consequences for
weight edits" there before designing an edit); measurements with commands are in `$T/REPORT.md`.
[... 291 lines cut ...]

## 8. Not available yet

[line removed by the dashboard scrubber]
- Activation atlas and its views; `--champion` runs of `dose.py`, `validate.py`, `closeprobe.py`, `vgen.py`.
- Any single entry beyond rank 32 per matrix, and edits of norms, `layer_scalar` or embeddings (`overlay.py` exists
  as code, has not been served, and the runner does not accept it).
- A probe verdict that predicts rollout outcome: the registered ranking test failed on four edits (section 5).

# Ledger index (generated by tools/ledger.py index; do not edit by hand)

Read this before proposing anything. A row marked `null` or `harmful` is not to be retried unless the new
record says what is different and why that difference should matter.

| id | date | author | track | title | set / batch | status | verdict | result |
|---|---|---|---|---|---|---|---|---|
| [0001](ledger/0001-claude-unedited-baseline-noise-floor.md) | 2026-11-12 | claude | baseline | Unedited 31B on the screening set, two passes (base rate and identical-arm noise) | wsp31_screen_v1 / s1_base | done | inconclusive | stopped at 59 of 720 episodes; 54% ended at the session limit at concurrency 16 |
| [0002](ledger/0002-claude-state-of-the-art-survey.md) | 2026-11-12 | claude | survey | Survey of training-free weight editing to November 2026, with 20 ranked edit ideas for 31B | - / - | done | n/a | reports/2026-11-12-weight-editing-survey.md |
| [0003](ledger/0003-claude-identical-arms-batch-noise-floor.md) | 2026-11-12 | claude | baseline | Three identical-weight arms in one batch (base rate, noise floor, adapter-path check, runner shakedown) | wsp31_screen_v1 / b001 | done | n/a | base 60, aa 60, zero 65 of 120; d 11.3 tasks per identical pair; bars +3 / -6 / +4 / +5 / +10 / -10 |
| [0004](ledger/0004-claude-size-of-real-training-updates.md) | 2026-11-12 | claude | baseline | How far real training moves the weights (size reference for edits) | - / - | done | n/a | research/wsp31/tools/train_size.py (numbers below) |
| [0005](ledger/0005-claude-tools-lane-edit-toolchain.md) | 2026-11-12 | claude | tools | Tools lane (31B edit toolchain: exact loader and forward pass, LoRA builders, checker, pre-tests, champion support) | wsp31_screen_v1 / - | running | - | research/wsp31/edit_tools/REPORT.md |
| [0006](ledger/0006-claude-interp-lane-readers-failure-modes-directions.md) | 2026-11-12 | claude | interp | Interpretability lane (can LLMs read the weights; failure modes; per-layer directions for training-sized edits) | wsp31_screen_v1 / - | running | - | research/wsp31/interp/REPORT.md |
| [0007](ledger/0007-claude-deep-gate-b01-end-neurons-x9.md) | 2026-11-12 | claude | edit | Deep-thought gate (dose 0.1) plus the model s own end-of-thought neurons at 9 times their write | wsp31_screen_v1 / - | parked | - | - |
| [0008](ledger/0008-claude-deep-thought-gate-g3-b03.md) | 2026-11-12 | claude | edit | Deep-thought gate: one neuron per layer 30-48 detects depth >= 800 inside a thought and writes the end-of-thought state (dose 0.3) | wsp31_screen_v1 / b002 | done | harmful | stage 1: -10.0 of 120 tasks |
[line removed by the dashboard scrubber]
| [0010](ledger/0010-claude-early-gate-b01-end-neurons-x9.md) | 2026-11-12 | claude | edit | Early deep-thought gate (fitted on depth >= 400, dose 0.1) plus own end-of-thought neurons x9: the strong dose of the gated family | wsp31_screen_v1 / - | parked | - | - |
| [0011](ledger/0011-gpt-writer-close-amplify-033.md) | 2026-11-12 | gpt | edit | Amplify natural thought-ending writes across all layers at 0.33 percent | wsp31_screen_v1 / b002 | done | harmful | stage 1: -10.0 of 120 tasks |
| [0012](ledger/0012-gpt-writer-close-amplify-050.md) | 2026-11-12 | gpt | edit | Amplify natural thought-ending writes across all layers at 0.50 percent | wsp31_screen_v1 / b003 | done | harmful | stage 1: -21.0 of 120 tasks |
| [0013](ledger/0013-gpt-writer-close-shift-011.md) | 2026-11-12 | gpt | edit | Shift common writer output toward thought endings across all layers at 0.11 percent | wsp31_screen_v1 / - | parked | - | - |
[... 38 lines cut ...]
0023-claude-net-preedit-commit-close-b05.md
[line removed by the dashboard scrubber]
0025-gpt-code-writer-damp-r4-033.md
0026-gpt-code-writer-damp-r4-011.md
0027-gpt-code-reader-damp-r4-033.md
0028-gemini-nullspace-close-r4-midlate.md
0029-claude-correction-b003-supp1.md
TEMPLATE.md

Fri Nov 13 06:52:34 PM EST 2026
__pycache__
addnotes.py
build_think.py
cf_budget.py
data
end_neurons.py
extras
extras3
fail_stats.py
fill_fb.py
fillvgen.py
fin_gpu.sh
finalize.py
finalize3.py
fix_records.py
gpu_hold.sh
gpu_job.sh
gpu_job3.sh
inspect_probe.py
[... 84 lines cut ...]
6.9G	scratch
index, memory.used [MiB], utilization.gpu [%]
0, 64998 MiB, 100 %
1, 90514 MiB, 100 %
-rw-rw-r-- 1 keith keith 0 Nov 12 19:07 ../../gpu0.lock
/home/keith/gemma-v2/wsp31/gpu0.lock: 2741564 2741565 2741577 2741579 2746356
               total        used        free      shared  buff/cache   available
Mem:             183          23          47           5         119         160

# Interpretability lane: what is known about the inside of Gemma 4 31B

Lane `wsp31/interp`. Updated 6:30 PM ET, Fri 13 Nov 2026 (update 13: batch b004 scored against the registered predictions and analysed: entries 0020 and 0021, both harmful, both through looping long thoughts (section 3.8.7, first block; PROTOCOL amendment 3r); before that, update 12 of 3:07 PM ET, Fri 13 Nov 2026: a CPU check for broken tool-call syntax and for loops, `toolcall_check.py`, with the pre-test size it needs (section 3.8.6, first block); the coordinator's decisions on the readout and on GPU use (handover); before that, update 11 of 2:50 PM ET, Fri 13 Nov 2026: first four stage-1 re
own runs; anything else is labelled. Pre-registration: `PROTOCOL.md` (sections 0-5 and dated amendments 1, 2, 3, 3a,
3b, 3c, 3d, 3e, 3f, 3g, 3h, 3i, 3j, 3k, 4, 4a, 4b, 5, 5a, 5b, 5c, 5d, 5e). Located-and-causally-checked components: `ATLAS.md` (one entry since 1:06 AM ET, Fri 13 Nov: the close-the-thought direction). Lens-only readings:
`ATLAS_lens.md`.

## For edit authors, start here (6:30 PM ET, Fri 13 Nov 2026): six close-the-thought edits have been screened; none reduced cut-offs; two broke tool-call syntax, three turned long thoughts into loops

The author brief points to this block. It is kept current and can be read alone; the dated blocks below it are
the record. All screening numbers here are stage 1, one rollout per task and arm: 120 tasks in b002 and b003, 102
tasks of a new screen set in b004. b004 is provisional (19 of its 102 tasks are owed a rerun for every arm) and
so is b002; the rerun of b003's 31 owed tasks is done (note under the table). Details: sections 3.8 and 3.8.7.

- **Results so far** (solved of 120, in the last two rows of 102; "control" is a second arm with the unedited
  weights in the same batch):

  | entry | idea | base | control | edit | cut-offs base / control / edit |
  |---|---|---|---|---|---|
  | 0008 (claude) | deep-thought gate | 60 | 62 | 51 | 33 / 35 / 52 |
[... 74 lines cut ...]
2068:## 4. Can frontier LLMs read the weights? Scale-up and pilot (pre-registered; PROTOCOL sections 1, 2, 5, amendments 4, 4a)
2077:### 4.0 Scale-up: the confirmatory run (scored 10:56 PM ET; amendment 4)
2174:### Pilot. Family A: pick the context that makes the neuron fire (5-way, chance 20%, 24 neurons)
2210:### Pilot. Family B: which card is the real neuron (2AFC, chance 50%, 20 items each)
2223:### Pilot decision (PROTOCOL section 5; superseded by 4.0 for families A and B)
2230:### Weights-only atlas facts behind the numbers (no reader involved)
2241:## 5. Not verified, not done
[line removed by the dashboard scrubber]

  example a path ending in a backtick), 99% of the `edit_file` calls are refused for missing arguments, 25% of the
  commands are malformed, and 58% of all tool calls end in an error (12% at base). Every one of its 120 episodes
  is hit; it needs 26 calls per episode where base needs 19.5. In 0011 the same at a lower dose: 40% of
  `read_file` and 91% of `edit_file` calls malformed, 38% of tool calls in error. Why amplifying the close writers
  does this has not been measured.
  **Check before you submit (CPU, no server, on the output of your own pre-test):**
  `python /home/keith/gemma-v2/wsp31/interp/toolcall_check.py INPUT`, where INPUT is what your pre-test wrote: the
  `.json` of `tools/vgen.py` or `tools/dose.py`, a rollout directory, or a `task_results.jsonl`. It prints the share
  of tool calls with an unpaired `<|"|>` (id 52) next to the seven unedited arms screened so far (0.7% to 1.1%) and
  a verdict, BROKEN, NOT BROKEN or UNDECIDED; exit code 3 means BROKEN. **How much output it needs** (measured on
  0011, the weaker of the two breaks): 8 whole episodes, or 10 episodes of 10 calls each, or 100 single tool calls.
  At these sizes 0011 is called BROKEN in 99% or more of the random samples of its rollouts and no unedited arm in
  more than 0.1% (0012: 3 episodes or 40 calls). **Do not test on the first call of an episode only:** none of the
  236 first calls of 0011 and 0012 is malformed; the break is there from the second call on (27% and 39% of calls
  2 to 5). Limits: these sizes come from the edited model's own episodes; the rate on contexts cut from unedited
  trajectories has not been measured. The "well-formed tool call" class of `dose.py` and `vgen.py` checks, by its
  code, the name and the braces and not the delimiters, so it is not this check. Section 3.8.6 has the numbers.
- **Failure 2: long thoughts turn into loops (0008, 0020, 0021: the deep-thought gate, one author, three
[line removed by the dashboard scrubber]
  and 0021, against 605 at base and 642 in the control). But the thoughts that still get long do not end: of
[... 38 lines cut ...]
[line removed by the dashboard scrubber]
  beyond depth 400, 23.3% beyond 800, 8.5% beyond 1600; in cut-off episodes 54.5%, 34.8% and 15.3%. These are
[line removed by the dashboard scrubber]
- **The counting tool `wsp31/interp/flipcount.sh` is still NOT VALIDATED. Do not rely on its numbers.** Its first
  GPU run (2:17 to 2:42 PM ET) passed two of its three registered checks and failed the third by a small margin
  (unedited p(close) at 20 logged closes 0.903, registered 0.897 with a tolerance of 0.005; cause not diagnosed).
  Measured runtime: about 110 s per adapter (14 passes in a hold of 25.5 minutes, model load included). It does
  not look at tool-call syntax, so it would not have caught failure 1.

## New for edit authors (7:39 AM ET, Fri 13 Nov 2026): which layers carry the close direction; a second direction (tool choice)

Holds 7 to 12 ran unattended from 1:11 to 4:53 AM ET (the lane agent had stopped at 1:15 AM ET) and were evaluated at
7:32 AM ET with the unchanged rule of amendments 3g and 3k (`dirs/dose_eval.py`, log `logs/dose_eval_full.log`).
Table and limits: section 3.5.1. `ATLAS.md`, "Confirmed", entries 1 and 2.

- **Close direction: layers 0-19 are not needed.** Pushed on layers 20-59 only, at 1% of the stream norm per
  layer, it does what it does on all 60 layers (+6.4 nat at goes-on points and -11.0 nat at real closes against the
  stronger control, 10 of 10 episodes each; all 60 layers: +6.2 and -11.8) at 55% to 65% of the disturbance (KL 0.14
  and 0.42 nat against 0.21 and 0.77). Confirmed at 0.3% and at 1%.
- **Layers 30-48 alone** (where the queued gate edits write): confirmed at 1% (+4.4 and -5.7 nat against the
  control, 10 of 10 episodes each) with KL 0.05 and 0.10 nat. That is two thirds of the plus effect and half of the
  minus effect of layers 20-59 for about 40% and 25% of the disturbance. At 0.3% the minus sense is under the
  1 nat bar (-0.6), so not confirmed there.
- **The coherent window stays narrow:** layers 20-59 are incoherent at 2% per layer (KL 2.1 and 3.7 nat), layers
  30-48 at 3% (KL 2.0 and 3.0; 2% was not run on that set).
- **Tool choice (`dirs/out/tool_act.pt`, plus = edit or write, minus = read, get or run):** confirmed on layers 0-59
  at 2% per layer only (+10.5 and -4.0 nat of log-odds against the stronger control, 10 of 10 episodes each, KL
  0.52 and 0.45 nat). Not confirmed at 1% (plus +5.3 nat, 10 of 10; minus -1.2 nat, 8 of 10) and not confirmed on
  layers 20-59 at its registered doses (1%: plus +5.2, 10 of 10; minus -0.7, 7 of 10; 2% was not run on that set).
[... 103 lines cut ...]
re-rendered; agreement on an edited model: not measured beyond the tools lane's rank-4 comparison.
Section 3 uses the unedited model only. The dose check (3.5) changes activations inside the pass through
hooks; that has no served counterpart.

**Data rule since 12:15 AM ET, Fri 13 Nov (coordinator; PROTOCOL amendment 5d):** everything under
`results/wsp31/base/` is open design data (its 22 stage-2 tasks were removed from stage 2 for every edit, which
is now 218 tasks). This lane fits and tests on stage-1 tasks and the base/ runs only and never fits on stage-2
batch traces or per-task results.

Fri Nov 13 06:54:04 PM EST 2026
    PID     ELAPSED COMMAND
2741564       02:57 flock -n /home/keith/gemma-v2/wsp31/gpu0.lock ./sessJ.sh
2741565       02:57 /bin/bash ./sessJ.sh
3
2741564       02:57 flock -n /home/keith/gemma-v2/wsp31/gpu0.lock ./sessJ.sh
48:- Prompt rules and the same rules compiled into weights (rank-16 reconstruction, R2 0.53 / 0.41): no gain either way.
61:5. Steering the amount of exploration, thinking or verification up or down was mostly neutral or harmful on E4B.
  490 code/net_job.py
   22 code/net_build.py
  200 code/thinklib.py
   17 code/gpu_job3.sh
  729 total

# What was already tried on Gemma 4 E4B (paper track, 4-12 Nov 2026)

These are training-free weight edits on the small model, written by Claude, GPT and Gemini, measured on 170
[line removed by the dashboard scrubber]
only for 31B) and on 130 held-out tasks. Sources: the private paper repository (`gemma-weight-programming`), its
experiment log and result files. Counts are tasks solved of 170 unless stated; "vs" is the same-batch unedited arm.

None of these results transfers to 31B automatically. They are listed so that a 31B attempt of the same kind is made
on purpose, with a reason, and not by accident.

## Method that was used

A frontier LLM diagnosed failures from logged agent decisions, located a direction in the residual stream (difference
of means between decision classes), compiled it into a closed-form MLP edit (always-on, or gated by a "quiet neuron"
that fires only under a condition such as "no file edited yet"), wrote a prediction, and tested against a
norm-matched random control.

## What moved behaviour

- Edits control their targeted decision with a dose-response in replay; matched random controls do not. Submit rate
[... 34 lines cut ...]
1. Development gains of 3 to 5 tasks of 170 did not survive held-out data. Single-run agent evaluation noise is
   several tasks; a held-out test of +5 of 130 needs about 790 tasks x 3 rollouts for 80% power. Hence larger
   screening sets, replication before confirmation, and a separate confirmation tier before golden.
2. Two servers with the same weights differed by 11.7 tasks in one run. Arms are compared only within a server.
3. Greedy decoding was not repeatable run to run on the serving stack. Identical-arm noise is measured, not assumed.
4. Early batches flattered an edit (+4.3) and later ones did not (+1.1). Replication is part of the pass rule.
5. Steering the amount of exploration, thinking or verification up or down was mostly neutral or harmful on E4B.
   The largest measured loss was edits made against stale file text, which no edit reduced.

#!/bin/bash
# GPU-0 job 3 of author claude (run only through code/gpu_hold.sh under the gpu0 lock): capture, fit, build, evaluate
# with the forward pass, then one served vgen check of the arms named in scratch/job3/vgen_arms.txt.
. /home/keith/gemma-v2/env.sh
cd /home/keith/gemma-v2/wsp31/authors/claude
export WSP31_WORK=$PWD/scratch CUDA_DEVICE_ORDER=PCI_BUS_ID CUDA_VISIBLE_DEVICES=0
H0=$(date +%s)
$PY code/net_job.py > scratch/logs/job3.log 2>&1
NOW=$(date +%s)
LEFTH=$((1560 - 100 - (NOW - H0)))
LEFTT=$((1794545791 + 5400 - 15 * 60 - NOW))
[ $LEFTT -lt $LEFTH ] && LEFTH=$LEFTT
echo "python part done after $((NOW - H0)) s; session budget $LEFTH" >> scratch/logs/job3.log
if [ $LEFTH -ge 280 ] && [ -s scratch/job3/vgen_arms.txt ]; then
  ARMS=$(cat scratch/job3/vgen_arms.txt)
[line removed by the dashboard scrubber]
fi
"""net_job.py (author claude, turn 3): one GPU-0 hold with tools/g31.py (forward pass only, no server).

Network-wide gated neurons: in EVERY layer one (or two) quiet MLP neurons are replaced ("set") by a detector on the
[... 109 lines cut ...]
              d1=[r for r in rows if r[1] == 2], d2=[r for r in rows if r[1] == 3 and r[2] < 800],
              d3=[r for r in rows if r[2] >= 800 and r[1] == 3], non=list(nonr),
              post=[r for r in rows if r[5] and r[1] in (2, 3) and r[2] >= 300],
              fe=[r for r in rows if r[7] and r[1] in (1, 2, 3) and r[2] >= 20])
    sel = {}
    for k in ("E", "d0", "d1", "d2", "d3", "non", "post", "fe"):
        c = by[k]
        rng.shuffle(c)

Fri Nov 13 06:55:23 PM EST 2026

[line removed by the dashboard scrubber]
27.97 (25 of 103), b001 zero 28.00 (24 of 105), `s1_base` 17.25 (31 of 59). Post hoc (added after the registered
[line removed by the dashboard scrubber]
s1_base 6963 and 5263; b001 base 11039 and 7824; aa 11943 and 9882; zero 11812 and 8724. Finished episodes,
median and 90th percentile: s1_base 4737 and 7100; base 6434 and 10554; aa 6908 and 10175; zero 6282 and 10497.
[line removed by the dashboard scrubber]
per second (arithmetic, tool time added). The 8 tasks that are in both `s1_base` and b001: s1_base 16 episodes, 7
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
with speed (reported to the coordinator 12:40 AM ET; PROTOCOL amendment 5e adds the covariate to the scorer).

Serving speed inside a batch, measured by the tools lane (their file `wsp31/tools/data/speedbench.json`; 8
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
128: 25.5 to 25.75 for both arms; up to 64: 27.6 to 27.8 for both; up to 32: 29.4 to 29.5, 28.8 to 28.9 and 29.0
to 29.1 in the three repeats, the same for both arms in each. Unedited streams alone: 33.4 to 33.6; adapter
streams alone 27.3 (limit 128), 29.1 (64), 29.5 (32). In this lane's traces the three b001 arms agree to 0.2
[line removed by the dashboard scrubber]
[... 36 lines cut ...]
- **Most leave the target tests failing and break nothing** (66 of 96; 54 pass none of the target tests). Breaking
  other required tests is the smaller part (27 of 96).
- **The agent mostly had no failing test in hand.** Its last test command after the last edit failed in 17 of 96
  wrong-patch episodes; in 44 it passed and in 31 there was none. A failing last test is twice as common in W as
  in S (18% against 8%) but covers under a fifth of W. The tests the agent runs are mostly not the tests that
  grade it (the grader's target tests are not in the sandbox).
- No end state holds a large share of W without holding a similar share of S, so no decision-level contrast at the
  submit decision is registered from this (amendment 3j item 7).

"""thinklib.py (author claude): closed-form "end the thought" edits for Gemma 4 31B.

Three families, all built from class means of activations at logged thought positions (no optimiser anywhere):
  A  always-on (Concept Country form): rank-one down_proj term  c (x) v^T  in layers 30..48 even; v = unit mean
     neuron-activation vector over thought positions, c writes the stream direction d_end = mean(resid at the last
[line removed by the dashboard scrubber]
  B  gated: one neuron per layer 30..48 even is replaced ("set") by a detector of "deep inside a long thought"
[line removed by the dashboard scrubber]
  C  gated, output side: the same kind of detector neuron in layers 54, 56, 58 writes the direction that raises the
     <channel|> logit: (E[101] - mean E) * final_norm_weight.
Controls: same code path, the written unit direction has the sign of every coordinate flipped at random (seeded):
identical per-coordinate magnitudes, so identical norm in the stream, in the raw MLP output and in |dW|_F.
"""
import math
import sys

import torch

sys.path.insert(0, "/home/keith/gemma-v2/wsp31/tools")
A_DIR = "/home/keith/gemma-v2/wsp31/authors/claude"
[... 172 lines cut ...]
        if ids[p] == 100:
            inside = True
        flag[p] = inside
        if ids[p] == 101:
            inside = False
    first = rec["calls"][0]["start"] if rec["calls"] else 0
    non = [p for p in range(first, n - 1) if not flag[p]]
    return n, P, non, ids[:n]

        rng.shuffle(c)
        for r in c[:CAPS[k]]:
            sel[r[0]] = r
    return [sel[p] for p in sorted(sel)]


GROUPS = ["E", "think", "fe", "preread", "deep", "prepos"]


def group_masks(meta):
    cls, dep, ed, tool, fe = meta[:, 1], meta[:, 2], meta[:, 5].bool(), meta[:, 6], meta[:, 7].bool()
    think = (cls >= 1) & (cls <= 3)
    return dict(E=cls == 0, think=think, fe=think & fe, preread=think & ~ed & ~fe & ((tool == 0) | (tool == 1)),
                deep=think & (dep >= 800), prepos=think & (dep >= 400) & ~ed)


def capture(m, train):
    nl = len(LAYERS)
    Xs, metas, eps = [], [], []
    gmean, gcnt = [], []
[... 343 lines cut ...]
    extra = [("K05t", A_DIR + "/scratch/fb/K05t", 6)]
    extra = [x for x in extra if os.path.exists(x[1])]
    evaluate(m, st, names, S + "/ad", ev[:4], extra)
    log("done")


if __name__ == "__main__":
    main()

[line removed by the dashboard scrubber]
tok.py:18:def main():
wlib.py:18:def tok():
[line removed by the dashboard scrubber]
wlib.py:25:def name(t):
wlib.py:30:def E(e):
wlib.py:38:def lens(e, v, k=12):
wlib.py:47:def embed_lens(e, r, k=12):
wlib.py:56:def fmt(pairs):
wlib.py:60:def parse_layers(s, n=60):
29:    def __init__(self, model_dir=MODEL_DIR):
46:    def is_global(self, l):
49:    def geom(self, l):
61:    def shape(self, l, mod):
69:def tensor_name(l, mod):
74:def read_header(model_dir=MODEL_DIR):
83:def dequant(packed, scale, group=32):
99:def gelu_tanh(x):
106:    def __init__(self, path, device="cuda:0"):
130:    def __init__(self, device="cuda:0", model_dir=MODEL_DIR, mirror=True, cache_dense=False, layers=None):
[... 13 lines cut ...]
290:        [n_cap_layers, len(cap_pos), dim]}).
296:        cap_pos_t = torch.as_tensor(out_pos if cap_pos is None else list(cap_pos), dtype=torch.long, device=self.dev)
303:        def tap(name, l, x):
307:                caps[name].append(x[cap_pos_t].float().cpu())
344:            if stop_after is not None and l >= stop_after:
357:    def logprobs_from_final(self, hp):
372:    def unembed_f32(self, hp):
[line removed by the dashboard scrubber]

  File "/home/keith/gemma-v2/wsp31/authors/claude/code/peek.py", line 21
    print("ENC", tk.encode("
                           ^
SyntaxError: unterminated string literal (detected at line 21)
Fri Nov 13 06:57:18 PM EST 2026
            h = y + h
            del y
            h = h * (d["layer_scalar"] if m else d["layer_scalar"].float())
            h = tap("resid_post", l, h)
            if stop_after is not None and l >= stop_after:
                return dict(logprobs=None, caps={c: torch.stack(v) for c, v in caps.items()}, resid=h)
        hp = self.rms(h[torch.as_tensor(out_pos, device=self.dev)], self.final_norm if self.mirror
                      else self.final_norm.float())
        lp = self.logprobs_from_final(hp)
        res = dict(caps={c: torch.stack(v) for c, v in caps.items()})
        if topk:
            v, i = lp.topk(topk, dim=-1)
            res["logprobs"] = (v.cpu(), i.cpu())
        else:
            res["logprobs"] = lp
[... 10 lines cut ...]
            logits = logits.float()
        else:
            logits = self.unembed_f32(hp)
            if cap:
                logits = torch.tanh(logits / cap) * cap
        return torch.log_softmax(logits, dim=-1)

    def unembed_f32(self, hp):

[line removed by the dashboard scrubber]
n 4596 call 3 [(4542, 'turn'), (4545, 'cont'), (4557, 'close'), (4558, 'think'), (4561, 'tool')] calls [(4543, 53)]
'<bos><|turn>system\n<|think|>\nYou are a principal Python software engineer resolving a repository issue in `/workspace`.\nYour sole objective is to produce a minimal, root-cause source patch that passes every hidden'
ENC [108, 71122, 236787, 29104]
1 105 '<|turn>system\n<|think|>\nYou are a' | before: '<bos>'
2023 106 '<turn|>\n<|turn>user\nYou are evaluating' | before: ' baseline commit. The agent\ncan submit multiple times; only the final submission is evaluated.\n<|"|>,parameters:{type:<|"|>OBJECT<|"|>}}<tool|>'
2025 105 '<|turn>user\nYou are evaluating a software' | before: '. The agent\ncan submit multiple times; only the final submission is evaluated.\n<|"|>,parameters:{type:<|"|>OBJECT<|"|>}}<tool|><turn|>\n'
3121 106 '<turn|>\n<|turn>model\n<|channel>thought\n' | before: 'txt\n./requirements_test.txt\n./scripts\n./scripts/update_thanks.py\n./tests\n./tox.ini\n```'
3123 105 '<|turn>model\n<|channel>thought\nThe user' | before: './requirements_test.txt\n./scripts\n./scripts/update_thanks.py\n./tests\n./tox.ini\n```<turn|>\n'
ids tail == comp? True 4596 4596
'<|channel>thought\nLet\'s read the `reexec` method.\n<channel|><|tool_call>call:read_file{end_line:450,filepath:<|"|>gunicorn/arbiter.py<|"|>,start_line:401}<tool_call|><|tool_response>'
'<|channel>thought\nLet\'s read the `reexec` method.\n<channel|><|tool_call>call:read_file{end_line:450,filepath:<|"|>gunicorn/arbiter.py<|"|>,start_line:401}<tool_call|><|tool_response>'
[line removed by the dashboard scrubber]
0 j 20849 cbar 26.906 csd 4.111 ratio 0.153 rmsy 0.9813
5 j 12134 cbar 26.094 csd 3.019 ratio 0.116 rmsy 1.1270
10 j 14374 cbar 55.944 csd 9.082 ratio 0.162 rmsy 0.8727
20 j 1333 cbar 18.351 csd 2.759 ratio 0.150 rmsy 0.5473
30 j 14827 cbar 7.714 csd 1.248 ratio 0.162 rmsy 0.1311
40 j 7243 cbar 13.648 csd 2.432 ratio 0.178 rmsy 0.2072
50 j 1517 cbar 23.438 csd 5.693 ratio 0.243 rmsy 0.4741
59 j 9926 cbar 49.876 csd 5.326 ratio 0.107 rmsy 0.7328
rmsy shape torch.Size([60, 8877]) absact torch.Size([60, 21504]) meta torch.Size([8877, 8]) instances 32
ls tensor([0.0986, 0.0732, 0.9922, 0.9727, 0.9844]) rnorm torch.Size([60, 8877]) tensor([ 63.4717, 222.6138, 305.1974, 280.8210, 188.9124, 123.8760])
Fri Nov 13 06:57:35 PM EST 2026

301:class Mock:
302-    """Shape-faithful stand-in for g31.G31 (CPU, random numbers) to test this script's plumbing without the GPU."""
303-
304-    def __init__(self):
305-        self.dev = torch.device("cpu")
306-        self.emb = torch.randn(300, tl.D).to(torch.bfloat16)
307-        self.final_norm = torch.rand(tl.D).to(torch.bfloat16)
308-        self.L = {L: dict(post_feedforward_layernorm=torch.randn(tl.D).to(torch.bfloat16),
309-                          layer_scalar=torch.tensor([0.7]).to(torch.bfloat16)) for L in range(60)}
310-        self.e = EditSet()
311-
312-    def set_adapter(self, a):
313-        self.ad = a
314-
315-    def base_weight(self, l, mod):
316-        return self.e.W(l, mod).to(torch.bfloat16)
317-
318-    def rms(self, x, w=None):
319-        return x
320-
[... 73 lines cut ...]
        out_pos = [n - 1] if out_pos is None else list(out_pos)
        cap_pos_t = torch.as_tensor(out_pos if cap_pos is None else list(cap_pos), dtype=torch.long, device=self.dev)
        capture = set(capture or ())
        assert capture <= set(CAPS), capture - set(CAPS)
        cap_layers = list(self.L) if cap_layers is None else list(cap_layers)
        caps = {c: [] for c in capture}
2741564       07:46 flock -n /home/keith/gemma-v2/wsp31/gpu0.lock ./sessJ.sh
Fri Nov 13 06:58:52 PM EST 2026

k05:
  summary:
    r 1
    scale 2.0
    changed 36
    of 420
    net_rel 0.006315705005421942
    rel_median 0.016847016618445773
    rel_min 0.007049667846547312
    rel_max 0.06538379764159212
    rel_max_mod 53.down_proj
    total_rel 0.02952269048046966
    total_fro 13.02482072143659
    stable_rank_median 1.0
    part_rank_median 1.0
    by_type:
      down_proj 0.016847016618445773
  rows:
    list 36 [{'mod': '24.down_proj', 'fro': 1.1562910090858287, 'rel': 0.015650258125740484, 'top_rel': 0.015650258125740484, 'stable_rank': 1.0, 'part_rank': 1.0}, {'mod': '25.down_proj', 'fro': 0.9241127753681884, 'rel': 0.012332520769521852, 'top_rel': 0.012332520769521852, 'stable_rank': 1.0, 'part_rank': 1
k05c:
[... 62 lines cut ...]
import argparse
import json
import os
import re
import statistics as st
import sys

import torch

vgen.py:129:    ap.add_argument("edits", nargs="*")
vgen.py:130:    ap.add_argument("--port", type=int)
vgen.py:131:    ap.add_argument("--at", choices=sorted(KIND), default="turn")
vgen.py:132:    ap.add_argument("--n", type=int, default=16)
vgen.py:133:    ap.add_argument("--per-record", type=int, default=1)
vgen.py:134:    ap.add_argument("--records", type=int, default=200)
[line removed by the dashboard scrubber]
vgen.py:136:    ap.add_argument("--max-pos", type=int, default=6000)
vgen.py:137:    ap.add_argument("--streams", type=int, default=4)
vgen.py:138:    ap.add_argument("--show", type=int, default=2)
vgen.py:139:    ap.add_argument("--show-chars", type=int, default=500)
vgen.py:140:    ap.add_argument("--probeset", default=os.environ.get("WSP31_CALLSET", os.path.join(T, "data/probe_calls_b001_full.jsonl")))
vgen.py:141:    ap.add_argument("--champion", default=None)
vgen.py:142:    ap.add_argument("--budget", type=float, default=float(os.environ.get("LEFT", 1500)) - 45)
vgen.py:143:    ap.add_argument("--out", default=None)
vgen.py:144:    ap.add_argument("--selftest", action="store_true")
closeprobe.py:66:    ap.add_argument("--adapter", default=None)
closeprobe.py:67:    ap.add_argument("--champion", default=None)
closeprobe.py:68:    ap.add_argument("--probeset", default=os.environ.get("WSP31_CALLSET", os.path.join(T, "data/probe_calls_b001_full.jsonl")))
closeprobe.py:69:    ap.add_argument("--traces", type=int, default=40)
[... 23 lines cut ...]
151-        assert 0 <= j < i
--
215:    def save(self, path, r=None, max_rank=32, note=None):
216-        """Write the adapter. Fails if any module needs more than max_rank. Returns the report also written to
217-        path/edit.json: per module the rank, |dW|_F and |dW|_F / |W|_F."""
218-        fac = self.factors()
Fri Nov 13 07:00:26 PM EST 2026
2741564       09:19 flock -n /home/keith/gemma-v2/wsp31/gpu0.lock ./sessJ.sh

Fri Nov 13 07:03:27 PM EST 2026
[    0.0] deadline 860 capture deadline 400
[    0.9] train 40 eval 8 ['gawel__pyquery.811cd048.', 'cookiecutter__cookiecutt', 'reportportal__client-Pyt', '[task]', '[task]', 'miLibris__flask-rest-jso', 'tianocore__edk2-pytool-l', 'qiskit-community__ffsim-']
[line removed by the dashboard scrubber]
[    3.0] model loaded
[    3.3] captured 0 mewwts__addict.75284f95.func_bas call 3 n 4121 pos 178
[line removed by the dashboard scrubber]
[    3.8] captured 2 benoitc__gunicorn.bacbf8aa.func_ call 3 n 4596 pos 53
[    4.0] captured 3 [task] call 22 n 3668 pos 118
[    4.0] direction I1 records 4 |d|/|resid| every 6th ['0.079'] split-half cos ['-0.02'] |delta|/|d| ['1.00']
[    4.0] direction I2 records 4 |d|/|resid| every 6th ['0.079'] split-half cos ['0.00'] |delta|/|d| ['1.00']
[    4.0] cos(d_I1, d_I2) every 6th ['0.48']
[    4.6] neuron 0 j 11815 {'use': 'mean', 'cv_mean': '0.101', 'cv_ridge': '0.103', 's_bos_before': '1.228', 'proj': False, 'gbar': '7.925', 'act_cv_cal': '0.219', 'act_prompt': '0.982', 'act_prompt_sd': '0.213', 'act_bos': '1.512', 'act_min': '0.839', 'act_max': '1.602'} old norms ['0.93', '0.86', '0.37'] new ['0.10', '0.01']
[    5.2] neuron 20 j 9026 {'use': 'mean', 'cv_mean': '0.104', 'cv_ridge': '0.105', 's_bos_before': '1.233', 'proj': False, 'gbar': '7.949', 'act_cv_cal': '0.226', 'act_prompt': '0.983', 'act_prompt_sd': '0.211', 'act_bos': '1.522', 'act_min': '0.835', 'act_max': '1.595'} old norms ['0.93', '0.86', '0.45'] new ['0.10', '0.01']
[    5.7] neuron 40 j 9561 {'use': 'mean', 'cv_mean': '0.101', 'cv_ridge': '0.103', 's_bos_before': '1.238', 'proj': False, 'gbar': '8.039', 'act_cv_cal': '0.221', 'act_prompt': '0.990', 'act_prompt_sd': '0.215', 'act_bos': '1.533', 'act_min': '0.843', 'act_max': '1.623'} old norms ['1.62', '1.20', '0.53'] new ['0.10', '0.01']
[    6.3] neuron 59 j 16519 {'use': 'mean', 'cv_mean': '0.103', 'cv_ridge': '0.104', 's_bos_before': '1.232', 'proj': False, 'gbar': '8.099', 'act_cv_cal': '0.225', 'act_prompt': '0.982', 'act_prompt_sd': '0.210', 'act_bos': '1.512', 'act_min': '0.836', 'act_max': '1.623'} old norms ['1.24', '1.22', '0.50'] new ['0.10', '0.01']
[    6.3] stats saved; records 4
[    6.3] built A10 r 1 net_rel 0.00419 rho min/med/max 0.370 0.447 0.493
[    6.3] built B10 r 1 net_rel 0.00429 rho min/med/max 0.390 0.460 0.488
[    6.3] built A10c r 1 net_rel 0.00419 rho min/med/max 0.370 0.447 0.493
[... 6 lines cut ...]
[   11.0] SUMMARY B10 {"records": 2, "positions": 327, "flip_all": 1.0, "flip_thought": 1.0, "n_thought": 270, "early_close_top": 0, "dlogp_close_inside": 0.10699129104614258, "n_close": 2, "dlogp_close_at_close": -0.7147636413574219, "close_kept": 0, "n_tool": 2, "flip_tool": 2, "kl_base": 1.0003463441807925, "tv_base": 0.5205394966522123, "dlogp_logged": 0.0006329335203958214, "kl_prompt_to_arm": 0.9997669418288297, "kl_prompt_to_base": 1.000052379176522, "reproduced": 0.0002854223975019554, "shift_cos": 0.062165758296254946, "prompt_flips": 327, "prompt_flips_matched": 0, "resid_cos": ["0.50", "0.50"], "resid_ratio": ["0.99", "0.99"]}
[   11.0] SUMMARY A10c {"records": 2, "positions": 327, "flip_all": 1.0, "flip_thought": 1.0, "n_thought": 270, "early_close_top": 0, "dlogp_close_inside": 0.011581657550953053, "n_close": 2, "dlogp_close_at_close": 0.2917661666870117, "close_kept": 0, "n_tool": 2, "flip_tool": 2, "kl_base": 1.000176479327934, "tv_base": 0.5205026620754044, "dlogp_logged": 0.05053259764971719, "kl_prompt_to_arm": 1.0000794203638665, "kl_prompt_to_base": 1.0005372656959277, "reproduced": 0.0004575994795582572, "shift_cos": 0.038544297582877154, "prompt_flips": 327, "prompt_flips_matched": 0, "resid_cos": ["0.50", "0.50"], "resid_ratio": ["1.00", "1.01"]}
[   11.0] SUMMARY neuron_act_over_gbar {"layers": [0, 59], "bos": ["0.17", "0.04"], "prompt_mean": ["-0.00", "-0.01"], "prompt_sd": ["0.14", "0.13"], "prompt_max": ["0.30", "0.29"], "comp_mean": ["-0.0
[... 164 characters cut ...]

8112
<bos><|turn>system
<|think|>
You are a principal Python software engineer resolving a repository issue in `/workspace`.
Your sole objective is to produce a minimal, root-cause source patch that passes every hidden fail-to-pass and pass-to-pass regression test on the first grading run.

## Critical Environment & Grader Rules
1. **Air-Gapped Sandbox & Available CLI Tools**: No network access. Never run `pip`, `uv`, `conda`, or `git fetch`. Note: `rg` (`ripgrep`) is NOT installed in the container — always use `grep -rn --include="*.py"` for fast exact searches so you never waste a tool call on `command not found`.
2. **Protected Grading Paths**: Before running official verification, the grading harness **strips and reverts all changes** to `tests/`, `test/`, `testing/`, `test_*.py`, `*_test.py`, `conftest.py`, `pyproject.toml`, `setup.cfg`, `pytest.ini`, and `tox.ini`. Every part of your fix MUST reside in non-test production source files.
3. **Untracked File Trap (`git add -N .`)**: `submit_patch` stages ALL untracked files inside `/workspace`! Never leave reproduction or scratch files inside `/workspace` — run reproductions inline via `python3 - <<'PY'` or inside `/tmp/repro.py` in a single `run_command`.
4. **Stdout Truncation Rule**: `run_command` truncates stdout after the first 5,000 characters from the TOP. Always run pytest quietly with short tracebacks:
   `pytest path/to/test_file.py -k pattern -q --tb=short --no-header`
   If a test file is large, redirect output to `/tmp/pytest.log` and inspect `tail -n 80 /tmp/pytest.log` so failure tracebacks at the bottom are never cut off.
5. **Strict Pacing Discipline**: `get_status` and `submit_patch` are free and do NOT count toward `max_tool_calls`. Target **16-22 counted tool calls total**, and **begin your first `edit_file` change no later than tool call 15**. Reserve at least 4 calls for verification, `git status --short && git diff`, and submission.

## Execution Protocol

### Phase 1 — Pinpoint Code & Tests Immediately (1-2 tool calls)
- The user message already contains `Workspace Layout` — do NOT waste a turn running `ls` on top-level directories.
- Run a single compound `run_command` with `grep -rn --include="*.py"` to locate:
[... 103 lines cut ...]
./scripts/update_thanks.py
./tests
./tox.ini
```<turn|>

Fri Nov 13 07:04:20 PM EST 2026
2741564       13:13 flock -n /home/keith/gemma-v2/wsp31/gpu0.lock ./sessJ.sh
2783020       00:30 flock /home/keith/gemma-v2/wsp31/gpu0.lock timeout 1740 code/gpu_hold.sh

Fri Nov 13 07:05:18 PM EST 2026
2741564       14:12 flock -n /home/keith/gemma-v2/wsp31/gpu0.lock ./sessJ.sh
2783020       01:29 flock /home/keith/gemma-v2/wsp31/gpu0.lock timeout 1740 code/gpu_hold.sh
Fri Nov 13 12:56:30 AM EST 2026
title: Deep-thought gate in all 60 layers: one neuron per layer detects depth >= 800 in a thought and writes the end-of-thought state (per-layer dose 0.05)

## Hypothesis

Unedited batch b001 (three identical arms, 288 scored episodes of 120 stage-1 tasks, `code/seq_stats.py`): solved
54%. Of the 133 failures, 60 end at the 7.5-minute session limit (31 with an empty patch), 26 at the 30-call cap and
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]

Same target as ledger 0008 (make long thoughts end sooner so that the wall-clock goes to tool calls), in the regime
record 0004 describes for real training: every layer moved a little, coherently. 0008 replaces one neuron in each of
10 layers (30 to 48) and writes 0.3 of the end-of-thought contrast per layer; this entry replaces one neuron in each
of the 60 layers and writes 0.05 per layer. What is different, and why it could matter: (i) each layer's detector
reads that layer's own representation of thought depth, so the 60 gates err partly independently and the summed
write follows depth more closely than one gate does (held-out firing of single gates: table below);
[... 46 lines cut ...]
# directions and norm weights fitted by code/net_job.py in one GPU-0 hold (`flock $R/wsp31/gpu0.lock timeout 1560
# code/gpu_hold.sh`, which runs code/gpu_job.sh -> code/gpu_job3.sh); net_stats_slim.pt is the subset of
# scratch/job3/net_stats.pt that code/net_job.build_arm reads (written by code/finalize3.py).
. /home/keith/gemma-v2/env.sh
cd /home/keith/gemma-v2/wsp31/authors/claude
$PY code/net_build.py queue/net-deep-gate-close-b05/edit 'deep:end=0.05'
$PY code/net_build.py queue/net-deep-gate-close-b05/ctrl 'deep:end=0.05:ctrl'
$PY $R/wsp31/tools/check_adapter.py queue/net-deep-gate-close-b05/edit && $PY $R/wsp31/tools/check_adapter.py queue/net-deep-gate-close-b05/ctrl

Fri Nov 13 07:05:32 PM EST 2026
2741564       14:26 flock -n /home/keith/gemma-v2/wsp31/gpu0.lock ./sessJ.sh
2783020       01:43 flock /home/keith/gemma-v2/wsp31/gpu0.lock timeout 1740 code/gpu_hold.sh
Fri Nov 13 12:56:30 AM EST 2026
b001
b002
b003
b004
b005
33:    print("%-20s n %3d | calls med %4.1f | dur med %3.0f | any edit %.2f | any test %.2f | test after last edit %.2f | submit call %.2f | first edit idx med %s | think tok med %5.0f | max thought med %5.0f" % (
"""seq_stats.py (CPU): tool sequences of b001 episodes by outcome class (did it test after its last edit, when did it submit)."""
import json, collections, sys, os, re
R = "/home/keith/gemma-v2/results/wsp31/batches/b001/"
rows = []
for arm in ("base", "aa", "zero"):
    for l in open(R + arm + "/rebench/shard0_gpu0/task_results.jsonl"):
        r = json.loads(l)
        if r["duration_seconds"] < 5: continue
        p = r.get("request_log_path")
        if not p or not os.path.exists(p): continue
[... 12 lines cut ...]
        k = ("solved" if r["resolved"] else "fail") + ("/limit" if lim else ("/cap" if cap else "/finished")) + ("/empty" if emp else "")
        rows.append(dict(k=k, seq="".join(seq), think=think, dur=r["duration_seconds"], inst=r["instance_id"], arm=arm))
by = collections.defaultdict(list)
for r in rows: by[r["k"]].append(r)
def last_edit_then_test(s):
    i = max(s.rfind("e"), s.rfind("w"))
    return i >= 0 and "T" in s[i:]
import statistics as st

Fri Nov 13 07:06:38 PM EST 2026
2741564       15:31 flock -n /home/keith/gemma-v2/wsp31/gpu0.lock ./sessJ.sh
2783020       02:48 flock /home/keith/gemma-v2/wsp31/gpu0.lock timeout 1740 code/gpu_hold.sh
Fri Nov 13 12:56:30 AM EST 2026
brief.pt
close_outcome.json
close_rendered.pt
close_thought.pt
dose.json
dose_adapter.json
dose_eval.json
dose_eval_hold6_0104.json
edit_align.json
edit_align4.json
finished.pt
harm_b001.json
harm_b002.json
harm_b003.json
harm_b004.json
harm_cache_b001_aa.json
[... 46 lines cut ...]
              excluded; a weaker one is not;
  UNDECIDED   otherwise: generate more calls.
How small the input can be (resampling of the stage-1 rollouts of 0011 and 0012, dirs/syntax_size.py: BROKEN in
at least 99% of 4000 samples of that size, and in at most 0.1% of the samples of any unedited arm at any size):
  whole episodes: 8 for 0011, the weaker break (3 for 0012);
  episodes cut to their first 10 calls: 10 (5 for 0012);
  single generated tool calls, from contexts in which no malformed call has occurred yet: 100 (40 for 0012).
The FIRST call of an episode never showed the break (0 of 236 first calls of 0011 and 0012; calls 2 to 5: 27% and

    elif at == "turn":
        x["to_close"] = (g.index(CH_END) - 1) if (g[:1] == [CH] and CH_END in g) else None
    return x


def summarise(rows, ref_rows, logged, at):
    r = dose.rates(rows)
    n = max(1, len(rows))
    if at in INSIDE or at == "turn":
        tc = [x["to_close"] for x in rows if x.get("to_close") is not None]
        r["closed"] = len(tc) / n
        r["to_close_median"] = statistics.median(tc) if tc else None
        r["close_at_once"] = sum(t == 0 for t in tc) / n
    r["tool_as_logged"] = sum(x["tool"] is not None and x["tool"] == l for x, l in zip(rows, logged)) / n
    if ref_rows is not None:
        r["tool_as_ref"] = sum(x["tool"] == y["tool"] and x["tool"] is not None for x, y in zip(rows, ref_rows)) / n
        r["same_as_ref"] = sum(x["ids"] == y["ids"] for x, y in zip(rows, ref_rows)) / n
    return r


[... 98 lines cut ...]
[line removed by the dashboard scrubber]
                  f"{tok.decode(x['ids'])[:a.show_chars]!r}")
    if a.out:
        json.dump(res, open(a.out, "w"), indent=1)


if __name__ == "__main__":
    main()

Fri Nov 13 07:24:04 PM EST 2026
[    0.0] deadline 860 capture deadline 400
[    0.8] train 40 eval 8 ['gawel__pyquery.811cd048.', 'cookiecutter__cookiecutt', 'reportportal__client-Pyt', '[task]', '[task]', 'miLibris__flask-rest-jso', 'tianocore__edk2-pytool-l', 'qiskit-community__ffsim-']
[line removed by the dashboard scrubber]
[    5.6] model loaded
[  401.5] capture stops at record 35
[  401.7] direction I1 records 35 |d|/|resid| every 6th ['0.001', '0.002', '0.002', '0.002', '0.002', '0.005', '0.008', '0.009', '0.008', '0.011'] split-half cos ['0.92', '0.97', '0.96', '0.89', '0.83', '0.87', '0.89', '0.75', '0.73', '0.66'] |delta|/|d| ['1.00', '0.52', '0.38', '0.25', '0.67', '0.56', '0.64', '0.48', '0.29', '0.36']
[  401.7] direction I2 records 35 |d|/|resid| every 6th ['0.001', '0.001', '0.001', '0.001', '0.002', '0.002', '0.003', '0.004', '0.003', '0.005'] split-half cos ['0.90', '0.73', '0.82', '0.88', '0.68', '0.51', '0.64', '0.46', '0.35', '0.23'] |delta|/|d| ['1.00', '0.56', '0.35', '0.22', '0.66', '0.66', '0.61', '0.46', '0.30', '0.39']
[  401.7] cos(d_I1, d_I2) every 6th ['0.86', '0.58', '0.61', '0.77', '0.46', '0.35', '0.44', '0.42', '0.38', '0.28']
[  401.9] neuron 0 j 11815 {'use': 'ridge', 'cv_mean': '0.155', 'cv_ridge': '0.027', 's_bos_before': '0.980', 'proj': False, 'gbar': '7.996', 'act_cv_cal': '0.054', 'act_prompt': '0.918', 'act_prompt_sd': '0.076', 'act_bos': '0.960', 'act_min': '0.803', 'act_max': '1.337'} old norms ['0.93', '0.86', '0.37'] new ['0.38', '0.05']
[  402.3] neuron 6 j 1300 {'use': 'ridge', 'cv_mean': '0.173', 'cv_ridge': '0.053', 's_bos_before': '0.744', 'proj': False, 'gbar': '7.909', 'act_cv_cal': '0.104', 'act_prompt': '0.843', 'act_prompt_sd': '0.150', 'act_bos': '0.561', 'act_min': '0.597', 'act_max': '1.332'} old norms ['0.73', '0.61', '0.22'] new ['0.26', '0.03']
[  402.7] neuron 12 j 20529 {'use': 'ridge', 'cv_mean': '0.153', 'cv_ridge': '0.041', 's_bos_before': '1.419', 'proj': False, 'gbar': '7.874', 'act_cv_cal': '0.080', 'act_prompt': '0.816', 'act_prompt_sd': '0.131', 'act_bos': '2.047', 'act_min': '0.655', 'act_max': '1.255'} old norms ['0.89', '0.85', '0.45'] new ['0.46', '0.06']
[  403.1] neuron 18 j 14035 {'use': 'ridge', 'cv_mean': '0.221', 'cv_ridge': '0.048', 's_bos_before': '1.801', 'proj': False, 'gbar': '7.857', 'act_cv_cal': '0.095', 'act_prompt': '0.905', 'act_prompt_sd': '0.119', 'act_bos': '3.306', 'act_min': '0.642', 'act_max': '1.432'} old norms ['0.94', '0.90', '0.46'] new ['0.31', '0.04']
[  403.5] neuron 24 j 16292 {'use': 'ridge', 'cv_mean': '0.139', 'cv_ridge': '0.027', 's_bos_before': '1.212', 'proj': False, 'gbar': '7.922', 'act_cv_cal': '0.054', 'act_prompt': '0.923', 'act_prompt_sd': '0.072', 'act_bos': '1.483', 'act_min': '0.780', 'act_max': '1.134'} old norms ['0.93', '0.88', '0.45'] new ['0.59', '0.07']
[  403.9] neuron 30 j 9712 {'use': 'ridge', 'cv_mean': '0.283', 'cv_ridge': '0.056', 's_bos_before': '0.789', 'proj': False, 'gbar': '7.799', 'act_cv_cal': '0.110', 'act_prompt': '0.833', 'act_prompt_sd': '0.152', 'act_bos': '0.641', 'act_min': '0.602', 'act_max': '1.320'} old norms ['1.65', '0.85', '0.46'] new ['1.17', '0.15']
[  404.3] neuron 36 j 15416 {'use': 'ridge', 'cv_mean': '0.288', 'cv_ridge': '0.061', 's_bos_before': '0.686', 'proj': False, 'gbar': '7.789', 'act_cv_cal': '0.120', 'act_prompt': '0.760', 'act_prompt_sd': '0.199', 'act_bos': '0.484', 'act_min': '0.567', 'act_max': '1.432'} old norms ['0.86', '0.86', '0.56'] new ['1.50', '0.19']
[  404.7] neuron 42 j 13065 {'use': 'ridge', 'cv_mean': '0.353', 'cv_ridge': '0.053', 's_bos_before': '0.894', 'proj': False, 'gbar': '7.861', 'act_cv_cal': '0.103', 'act_prompt': '0.884', 'act_prompt_sd': '0.152', 'act_bos': '0.815', 'act_min': '0.624', 'act_max': '1.277'} old norms ['1.16', '1.30', '0.57'] new ['0.59', '0.07']
[  405.1] neuron 48 j 18196 {'use': 'ridge', 'cv_mean': '0.253', 'cv_ridge': '0.052', 's_bos_before': '0.921', 'proj': False, 'gbar': '7.89
[... 1642 characters cut ...]

Fri Nov 13 07:28:31 PM EST 2026
[  731.7] SUMMARY P_I1 {"records": 8, "positions": 1278, "flip_all": 0.011737089201877934, "flip_thought": 0.01956521739130435, "n_thought": 460, "early_close_top": 0, "dlogp_close_inside": -0.06704983296601669, "n_close": 8, "dlogp_close_at_close": -0.19188229782253075, "close_kept": 7, "n_tool": 8, "flip_tool": 0, "kl_base": 0.007577057945336535, "tv_base": 0.013680886051651084, "dlogp_logged": -0.006151959912178102}
[  731.7] SUMMARY P_I2 {"records": 8, "positions": 1278, "flip_all": 0.010954616588419406, "flip_thought": 0.021739130434782608, "n_thought": 460, "early_close_top": 0, "dlogp_close_inside": 0.0035797290180040442, "n_close": 8, "dlogp_close_at_close": 0.07871341713871516, "close_kept": 8, "n_tool": 8, "flip_tool": 0, "kl_base": 0.002596170435978773, "tv_base": 0.008128937188075369, "dlogp_logged": -0.0015420729122437968}
[  731.7] SUMMARY A10 {"records": 8, "positions": 1278, "flip_all": 0.00782472613458529, "flip_thought": 0.008695652173913044, "n_thought": 460, "early_close_top": 0, "dlogp_close_inside": 0.025003972260848335, "n_close": 8, "dlogp_close_at_close": -0.06221182893068544, "close_kept": 7, "n_tool": 8, "flip_tool": 0, "kl_base": 0.002284866409355859, "tv_base": 0.008035379361378756, "dlogp_logged": -0.0015360360210163865, "kl_prompt_to_arm": 0.0038003891951321435, "kl_prompt_to_base": 0.007577057945336535, "reproduced": 0.4984347193132954, "shift_cos": 0.31067425544273125, "prompt_flips": 15, "prompt_flips_matched": 7, "resid_cos": ["0.25", "0.68", "0.52", "0.45", "0.45", "0.46", "0.52", "0.42", "0.44", "0.40", "0.35"], "resid_ratio": ["1.98", "1.03", "1.21", "1.08", "0.96", "1.12", "0.99", "1.19", "1.14", "1.06", "1.29"]}
[  731.7] SUMMARY B10 {"records": 8, "positions": 1278, "flip_all": 0.006259780907668232, "flip_thought": 0.008695652173913044, "n_thought": 460, "early_close_top": 0, "dlogp_close_inside": 0.03600559701090274, "n_close": 8, "dlogp_close_at_close": 0.028232672836566053, "close_kept": 8, "n_tool": 8, "flip_tool": 0, "kl_base": 0.000552079832714768, "tv_base": 0.0038013023343257874, "dlogp_logged": 2.1247349895175447e-05, "kl_prompt_to_arm": 0.002621133429915039, "kl_prompt_to_base": 0.002596170435978773, "reproduced": -0.00961531399877269, "shift_cos": 0.21528400054000352, "prompt_flips": 14, "prompt_flips_matched": 5, "resid_cos": ["0.24", "0.36", "0.36", "0.40", "0.30", "0.14", "0.26", "0.24", "0.29", "0.28", "0.20"], "resid_ratio": ["1.83", "0.75", "0.77", "0.77", "0.73", "0.65", "0.68", "0.72", "0.66", "0.65", "0.73"]}
[  731.7] SUMMARY A05 {"records": 8, "positions": 1278, "flip_all": 0.004694835680751174, "flip_thought": 0.004347826086956522, "n_thought": 460, "early_close_top": 0, "dlogp_close_inside": -0.01847614620042884, "n_close": 8, "dlogp_close_at_close": -0.014133314517039253, "close_kept": 8, "n_tool": 8, "flip_tool": 0, "kl_base": 0.0008362403448455397, "tv_base": 0.004937003266083802, "dlogp_logged": -0.0001472336603022517, "kl_prompt_to_arm": 0.004820190999709385, "kl_prompt_to_base": 0.007577057945336535, "reproduced": 0.3638439834453059, "shift_cos": 0.291389525029954, "prompt_flips": 15, "prompt_flips_matched": 5, "resid_cos": ["0.26", "0.65", "0.52", "0.46", "0.46", "0.40", "0.51", "0.45", "0.46", "0.41", "0.40"], "resid_ratio": ["1.01", "0.53", "0.62", "0.58", "0.50", "0.59", "0.52", "0.63", "0.64", "0.64", "0.71"]}
[  731.7] SUMMARY B05 {"records": 8, "positions": 1278, "flip_all": 0.004694835680751174, "flip_thought": 0.008695652173913044, "n_thought": 460, "early_close_top": 0, "dlogp_close_inside": 0.011805054934128471, "n_close": 8, "dlogp_close_at_close": -5.70763854739198e-05, "close_kept": 8, "n_tool": 8, "flip_tool": 0, "kl_base": 0.00043379151698126107, "tv_base": 0.0031393494060574937, "dlogp_logged": -0.00020396868306239818, "kl_prompt_to_arm": 0.002470227949472847, "kl_prompt_to_base": 0.002596170435978773, "reproduced": 0.048510869995499806, "shift_cos": 0.1953367507886812, "prompt_flips": 14, "prompt_flips_match
[... 4526 characters cut ...]

ok
Fri Nov 13 07:29:55 PM EST 2026
saved scratch/job6/ad/A30 r 1 net_rel 0.006776 rho min/med/max 0.007 0.031 0.111
saved scratch/job6/ad/A40 r 1 net_rel 0.006864 rho min/med/max 0.009 0.042 0.147
saved scratch/job6/ad/A60 r 1 net_rel 0.007108 rho min/med/max 0.013 0.062 0.221
saved scratch/job6/ad/A20c r 1 net_rel 0.006713 rho min/med/max 0.004 0.021 0.074
saved scratch/job6/ad/A40c r 1 net_rel 0.006863 rho min/med/max 0.009 0.042 0.147
saved scratch/job6/ad/A30c r 1 net_rel 0.006776 rho min/med/max 0.007 0.031 0.111
7ef95058649d3bc00289
saved scratch/tmpA10 r 1 net_rel 0.006675 rho min/med/max 0.002 0.010 0.037
7ef95058649d3bc00289
Fri Nov 13 07:30:02 PM EST 2026
[  731.7] SUMMARY neuron_act_over_gbar {"layers": [0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 59], "bos": ["0.97", "0.55", "2.05", "3.25", "1.47", "0.65", "0.49", "0.81", "0.86", "0.55", "0.25"], "prompt_m
[  731.7] done
python part done after 733 s; left 937
server up after 73s (pid/pgid 2847143, log /home/keith/gemma-v2/wsp31/authors/claude/scratch/logs/server_18400_1113_192820.log)

saved queue/icv-brief-b10/edit r 1 net_rel 0.006675 rho min/med/max 0.002 0.010 0.037
saved queue/icv-brief-b10/ctrl r 1 net_rel 0.006674 rho min/med/max 0.002 0.010 0.037
OK edit: 180 modules changed (of 180 present), r=1, max |dW|_F/|W|_F 0.01611 at 32.gate_proj
OK ctrl: 180 modules changed (of 180 present), r=1, max |dW|_F/|W|_F 0.01611 at 32.gate_proj
mine size: whole network 0.6674% over 180 matrices, largest matrix 1.6113% (32.gate_proj), stable rank 1.0
ctrl size: whole network 0.6674% over 180 matrices, largest matrix 1.6113% (32.gate_proj), stable rank 1.0
7ef95058649d3bc002895663e6e10533e7125fda2294cc54bf67a75314034c14  queue/icv-brief-b10/edit/adapter_model.safet
7ef95058649d3bc002895663e6e10533e7125fda2294cc54bf67a75314034c14  scratch/job6/ad/A10/adapter_model.safetensor
build.sh
ctrl
edit
Fri Nov 13 07:30:25 PM EST 2026
server up after 73s (pid/pgid 2847143, log /home/keith/gemma-v2/wsp31/authors/claude/scratch/logs/server_18400_1113_192820.log)

wrote 15478 chars; 165 lines

control size: whole network 0.6674% over 180 matrices, largest matrix 1.6113%

The size is mostly the removal of the 60 replaced neurons (their old gate and up rows have norms of about 1) and is
not the functional dose: the function depends on beta and on the product of the three vectors of the new neuron.
The functional dose is in the table "stream shift" below.

Built by `code/icv_job.py` (one GPU-0 hold, forward pass `tools/g31.py` only, no server, no optimiser anywhere) and
rebuilt bit for bit by `build.sh` (`code/icv_build.py` from `code/data/icv_stats.pt`; the sha256 of the rebuilt
`edit/adapter_model.safetensors` equals that of the arm the job built and evaluated, `A10`).

Data. `tools/data/probe_calls_b001_full.jsonl` (one record per logged model call: the prompt the server saw plus the
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
Tasks sorted by name; every fourth (index % 4 == 1) is held out for the pre-test, the others are fit tasks, shuffled
with seed 6. Fit calls, in capture order (35 captured before the capture deadline; task, arm, call index):
[line removed by the dashboard scrubber]
No task outcome enters any statistic.
[... 42 lines cut ...]

### Pre-test (forward pass, teacher-forced on the logged path; held-out tasks)

`code/icv_job.py`, function `evaluate`: for each held-out call the logged sequence is run unedited (base), unedited
with the paragraph inserted (prompted), and with each adapter and no paragraph. All numbers are at the positions of
[line removed by the dashboard scrubber]
Fri Nov 13 07:30:33 PM EST 2026
server up after 73s (pid/pgid 2847143, log /home/keith/gemma-v2/wsp31/authors/claude/scratch/logs/server_18400_1113_192820.log)

Fri Nov 13 07:31:24 PM EST 2026
server up after 73s (pid/pgid 2847143, log /home/keith/gemma-v2/wsp31/authors/claude/scratch/logs/server_18400_1113_192820.log)
16 contexts at 'turn' from 16 logged calls of 16 episodes; reference arm: the unedited model (no champion)
reference              n= 16 tool_ok 1.00 bad 0.00 open 0.00 empty 0.00 text 0.00 rep 0.00 cut 0.00 | closes 1.00 after median 127 tok, at once 0.00 | tool as logged 1.00 | 152 tok/s
A10                    n= 16 tool_ok 1.00 bad 0.00 open 0.00 empty 0.00 text 0.00 rep 0.00 cut 0.00 | closes 1.00 after median 129 tok, at once 0.00 | tool as logged 0.94 as ref 0.94 identical 0.12 | 122 tok/s
B10                    n= 16 tool_ok 0.94 bad 0.00 open 0.06 empty 0.00 text 0.00 rep 0.00 cut 0.06 | closes 0.94 after median 130 tok, at once 0.00 | tool as logged 0.88 as ref 0.88 identical 0.44 | 123 tok/s
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]

ok
Fri Nov 13 07:32:21 PM EST 2026
2783020       28:31 flock /home/keith/gemma-v2/wsp31/gpu0.lock timeout 1740 code/gpu_hold.sh
2849393       02:08 flock /home/keith/gemma-v2/wsp31/gpu0.lock timeout 880 code/gpu_hold6b.sh
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
131-    st, r = vclient._post(port, "/v1/completions", body)
132-    if st != 200:
133-        raise RuntimeError(f"completions {st}: {str(r)[:300]}")
134-    ch = r["choices"][0]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
137-
138-
139-def measure(port, model, recs, sel, prompts, a, tok, names):
140-    """One arm: warm the generation prompts (prefill), generate, then the decision points."""
141-    t0 = time.time()
142-    with ThreadPoolExecutor(a.streams) as ex:
[... 42 lines cut ...]
/home/keith/gemma-v2/wsp31/tools/fastprobe.py-36-
--
/home/keith/gemma-v2/wsp31/tools/vclient.py:43:def load_adapter(port, name, path, load_inplace=None):
/home/keith/gemma-v2/wsp31/tools/vclient.py-44-    body = dict(lora_name=name, lora_path=path)
/home/keith/gemma-v2/wsp31/tools/vclient.py-45-    if load_inplace is not None:
/home/keith/gemma-v2/wsp31/tools/vclient.py-46-        body["load_inplace"] = load_inplace
/home/keith/gemma-v2/wsp31/tools/vclient.py-47-    return _post(port, "/v1/load_lora_adapter", body)
/home/keith/gemma-v2/wsp31/tools/vclient.py-48-

[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[{'rec': 0, 'pos': 3318, 'depth': None, 'n': 3319}, {'rec': 1, 'pos': 2529, 'depth': None, 'n': 2530}, {'rec': 2, 'pos': 3135, 'depth': None, 'n': 3136}]

scratch/job6/vgen_turn.json [/home/keith/gemma-v2/wsp31/authors/claude/scratch/job6/ad/A10]
   16 episodes, 16 generated answers, 16 with a complete tool call
   1. unpaired string delimiter: 0 of 16 tool calls = 0.0% (unedited 0.7% to 1.1%, mark 3%; chance of 0 or more at the highest unedited rate 1): tool-call syntax UNDECIDED
      no verdict: NOT BROKEN needs 60 tool calls and a share below 3%; BROKEN needs a share of 3% or more and a chance of 0.001 or less for the calls
[line removed by the dashboard scrubber]

scratch/job6/vgen_turn.json [/home/keith/gemma-v2/wsp31/authors/claude/scratch/job6/ad/B10]
   16 episodes, 16 generated answers, 15 with a complete tool call
   1. unpaired string delimiter: 0 of 15 tool calls = 0.0% (unedited 0.7% to 1.1%, mark 3%; chance of 0 or more at the highest unedited rate 1): tool-call syntax UNDECIDED
      no verdict: NOT BROKEN needs 60 tool calls and a share below 3%; BROKEN needs a share of 3% or more and a chance of 0.001 or less for the calls
[line removed by the dashboard scrubber]
Fri Nov 13 07:32:58 PM EST 2026

Fri Nov 13 07:37:07 PM EST 2026
cat: scratch/hold2_start: No such file or directory
Fri Nov 13 01:07:42 AM EST 2026
== A10
reference cont  all       n= 126  log p(close)  -19.572  top is close 0.000  log p(logged)   -0.114  top is logged 0.992
reference cont  depth<200 n= 112  log p(close)  -19.711  top is close 0.000  log p(logged)   -0.110  top is logged 0.991
reference cont  200..799  n=  13  log p(close)  -19.208  top is close 0.000  log p(logged)   -0.157  top is logged 1.000
reference cont  800+      n=   1  log p(close)   -8.751  top is close 0.000  log p(logged)   -0.001  top is logged 1.000
edit      close all       n=  40  log p(close)   -0.064  top is close 1.000  log p(logged)   -0.064  top is logged 1.000
edit      close depth<200 n=  33  log p(close)   -0.058  top is close 1.000  log p(logged)   -0.058  top is logged 1.000
edit      close 200..799  n=   6  log p(close)   -0.103  top is close 1.000  log p(logged)   -0.103  top is logged 1.000
edit      close 800+      n=   1  log p(close)   -0.046  top is close 1.000  log p(logged)   -0.046  top is logged 1.000
edit      cont  all       n= 126  log p(close)  -19.495  top is close 0.000  log p(logged)   -0.121  top is logged 0.968
edit      cont  depth<200 n= 112  log p(close)  -19.635  top is close 0.000  log p(logged)   -0.117  top is logged 0.964
edit      cont  200..799  n=  13  log p(close)  -19.141  top is close 0.000  log p(logged)   -0.167  top is logged 1.000
edit      cont  800+      n=   1  log p(close)   -8.502  top is close 0.000  log p(logged)   -0.002  top is logged 1.000
change of log p(close) at close: mean +0.006, raised at 0.600 of 40 positions
change of log p(close) at cont: mean +0.077, raised at 0.500 of 126 positions
== B10
[  731.7] done
python part done after 733 s; left 937

Fri Nov 13 07:42:31 PM EST 2026
[  210.1] SUMMARY P_I1 {"records": 8, "positions": 1278, "flip_all": 0.011737089201877934, "flip_thought": 0.01956521739130435, "n_thought": 460, "early_close_top": 0, "dlogp_close_inside": -0.06704983296601669, "n_close": 8, "dlogp_close_at_close": -0.19188229782253075, "close_kept": 7, "n_tool": 8, "flip_tool": 0, "kl_base": 0.007577057945336535, "tv_base": 0.013680886051651084, "dlogp_logged": -0.006151959912178102}
[  210.1] SUMMARY A40 {"records": 8, "positions": 1278, "flip_all": 0.03051643192488263, "flip_thought": 0.04782608695652174, "n_thought": 460, "early_close_top": 0, "dlogp_close_inside": 0.339057907850846, "n_close": 8, "dlogp_close_at_close": -0.4327518849650005, "close_kept": 6, "n_tool": 8, "flip_tool": 0, "kl_base": 0.028197983131162438, "tv_base": 0.029293542363460823, "dlogp_logged": -0.02637370952138319, "kl_prompt_to_arm": 0.01577751081967391, "kl_prompt_to_base": 0.007577057945336535, "reproduced": -1.0822740083945805, "shift_cos": 0.34364097069873123, "prompt_flips": 15, "prompt_flips_matched": 11, "resid_cos": ["0.25", "0.65", "0.51", "0.47", "0.46", "0.46", "0.54", "0.41", "0.41", "0.38", "0.35"], "resid_ratio": ["7.92", "4.09", "4.70", "4.32", "3.69", "4.39", "3.71", "4.48", "4.16", "3.73", "4.83"]}
[  210.1] SUMMARY A40c {"records": 8, "positions": 1278, "flip_all": 0.009389671361502348, "flip_thought": 0.013043478260869565, "n_thought": 460, "early_close_top": 0, "dlogp_close_inside": -0.36400787623032277, "n_close": 8, "dlogp_close_at_close": -0.05681961960112858, "close_kept": 6, "n_tool": 8, "flip_tool": 0, "kl_base": 0.00476613564705345, "tv_base": 0.011413083401550896, "dlogp_logged": -0.0038192201848834145, "kl_prompt_to_arm": 0.011428229137672132, "kl_prompt_to_base": 0.007577057945336535, "reproduced": -0.5082673539148377, "shift_cos": 0.1115314587367719, "prompt_flips": 15, "prompt_flips_matched": 5, "resid_cos": ["-0.04", "-0.06", "0.04", "-0.05", "0.06", "0.11", "0.13", "0.08", "0.11", "0.09", "0.05"], "resid_ratio": ["7.87", "3.55", "3.09", "2.29", "2.33", "2.73", "2.75", "2.71", "2.69", "2.46", "3.14"]}
[  210.1] SUMMARY A20c {"records": 8, "positions": 1278, "flip_all": 0.007042253521126761, "flip_thought": 0.010869565217391304, "n_thought": 460, "early_close_top": 0, "dlogp_close_inside": -0.19604396612747857, "n_close": 8, "dlogp_close_at_close": -0.006481891011389962, "close_kept": 8, "n_tool": 8, "flip_tool": 0, "kl_base": 0.0014005141385214429, "tv_base": 0.006115660403675876, "dlogp_logged": -0.000728221643710267, "kl_prompt_to_arm": 0.007741422114051377, "kl_prompt_to_base": 0.007577057945336535, "reproduced": -0.021692346805398888, "shift_cos": 0.11962747107462518, "prompt_flips": 15, "prompt_flips_matched": 5, "resid_cos": ["-0.03", "-0.04", "0.05", "-0.04", "0.04", "0.05", "0.09", "0.08", "0.13", "0.12", "0.09"], "resid_ratio": ["3.95", "1.72", "1.59", "1.14", "1.15", "1.38", "1.39", "1.41", "1.41", "1.30", "1.64"]}
[  210.1] SUMMARY A30 {"records": 8, "positions": 1278, "flip_all": 0.02269170579029734, "flip_thought": 0.03695652173913044, "n_thought": 460, "early_close_top": 0, "dlogp_close_inside": 0.18860468346139658, "n_close": 8, "dlogp_close_at_close": -0.2943565180275982, "close_kept": 6, "n_tool": 8, "flip_tool": 0, "kl_base": 0.015779610361804797, "tv_base": 0.022213992168645905, "dlogp_logged": -0.014802853301377364, "kl_prompt_to_arm": 0.00824027507331263, "kl_prompt_to_base": 0.007577057945336535, "reproduced": -0.0875296365371323, "shift_cos": 0.33751621753770233, "prompt_flips": 15, "prompt_flips_matched": 11, "resid_cos": ["0.25", "0.67", "0.51", "0.47", "0.45", "0.46", "0.54", "0.43", "0.43", "0.39", "0.35"], "resid_ratio": ["5.96", "3.05", "3.52", "3.25", "2.77", "3.26", "2.79", "3.37", "3.13", "2.82", "3.64"]}
[  210.1] SUMMARY A60 {"records": 8, "positions": 1278, "flip_all": 0.041471048513302036, "flip_thought": 0.06739130434782609, "n_thought": 460, "early_close_top": 0, "dlogp_close_inside": 0.6727929654328719, "n_close
[... 645 characters cut ...]

Fri Nov 13 07:45:14 PM EST 2026
Fri Nov 13 07:45:05 PM EST 2026
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
job6b finished after 407 s
stored unedited reference (7 arms of 120 episodes): unpaired delimiter 0.7% to 1.1% of tool calls (in 3.4% to 8.6% of the episodes); loops 0.0 to 4.3 per 100 episodes (0.0% to 7.5% of long thoughts)
scratch/job6/gen2.json [reference]
   1. unpaired string delimiter: 0 of 17 tool calls = 0.0% (unedited 0.7% to 1.1%, mark 3%; chance of 0 or more at the highest unedited rate 1): tool-call syntax UNDECIDED
scratch/job6/gen2.json [prompt_I1]
   1. unpaired string delimiter: 0 of 17 tool calls = 0.0% (unedited 0.7% to 1.1%, mark 3%; chance of 0 or more at the highest unedited rate 1): tool-call syntax UNDECIDED
scratch/job6/gen2.json [A40]
   1. unpaired string delimiter: 0 of 17 tool calls = 0.0% (unedited 0.7% to 1.1%, mark 3%; chance of 0 or more at the highest unedited rate 1): tool-call syntax UNDECIDED
scratch/job6/gen2.json [A20]
   1. unpaired string delimiter: 0 of 17 tool calls = 0.0% (unedited 0.7% to 1.1%, mark 3%; chance of 0 or more at the highest unedited rate 1): tool-call syntax UNDECIDED
scratch/job6/gen2.json [A10]
   1. unpaired string delimiter: 0 of 17 tool calls = 0.0% (unedited 0.7% to 1.1%, mark 3%; chance of 0 or more at the highest unedited rate 1): tool-call syntax UNDECIDED

saved queue/icv-brief-b20/edit r 1 net_rel 0.006713 rho min/med/max 0.004 0.021 0.074
saved queue/icv-brief-b20/ctrl r 1 net_rel 0.006713 rho min/med/max 0.004 0.021 0.074
OK edit: 180 modules changed (of 180 present), r=1, max |dW|_F/|W|_F 0.01611 at 32.gate_proj
OK ctrl: 180 modules changed (of 180 present), r=1, max |dW|_F/|W|_F 0.01611 at 32.gate_proj
mine size: whole network 0.6713% over 180 matrices, largest matrix 1.6113% (32.gate_proj), stable rank 1.0
ctrl size: whole network 0.6712% over 180 matrices, largest matrix 1.6113% (32.gate_proj), stable rank 1.0
b1dffb49682ccda0c69493ea85d7ffd06ac8f0f25792bb20a4089f07b7fcf90d  queue/icv-brief-b20/edit/adapter_model.safet
b1dffb49682ccda0c69493ea85d7ffd06ac8f0f25792bb20a4089f07b7fcf90d  scratch/job6/ad/A20/adapter_model.safetensor
saved queue/icv-brief-b40/edit r 1 net_rel 0.006864 rho min/med/max 0.009 0.042 0.147
saved queue/icv-brief-b40/ctrl r 1 net_rel 0.006863 rho min/med/max 0.009 0.042 0.147
OK edit: 180 modules changed (of 180 present), r=1, max |dW|_F/|W|_F 0.03001 at 1.down_proj
OK ctrl: 180 modules changed (of 180 present), r=1, max |dW|_F/|W|_F 0.02998 at 1.down_proj
mine size: whole network 0.6864% over 180 matrices, largest matrix 3.0014% (1.down_proj), stable rank 1.0
ctrl size: whole network 0.6863% over 180 matrices, largest matrix 2.9984% (1.down_proj), stable rank 1.0
0f03bfb1f2ff23b16d74a470b177e2bd394241c699239063e6d78e08c80b36c4  queue/icv-brief-b40/edit/adapter_model.safet
0f03bfb1f2ff23b16d74a470b177e2bd394241c699239063e6d78e08c80b36c4  scratch/job6/ad/A40/adapter_model.safetensor
Fri Nov 13 07:46:01 PM EST 2026

56	L6 = list(range(0, 60, 6)) + [59]
57	ninfo = [st["neuron"][L]["info"] for L in range(60)]
58	nact = sm.get("neuron_act_over_gbar", {})
59	HYP = dict(
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
64	
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
67	still got long into loops. This entry pushes nothing towards `<channel|>` and has no gate. It writes, at every
68	position and in every layer, the mean shift of the residual stream that an explicit instruction paragraph causes in
69	the unedited model itself:
70	
71	> {txt}
72	
[line removed by the dashboard scrubber]
74	that movement that is the same at every position is a constant vector per layer, and a constant vector is what an
75	always-on neuron can write (the model has no biases). If the shift carries the instruction, the model plans a short
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
78	
79	Different from the null and harmful rows it resembles. E4B "think briefly" (28 / 28 / 25 vs 29) and E4B "prompt
80	rules compiled into weights" (rank-16 reconstruction, no gain; PRIOR_E4B.md): here the session limit binds in a
81	quarter of the episodes, and the vector is the 31B model's own per-layer response to the instruction, checked
82	against the prompted model on held-out calls (table below). The six close-the-thought edits on 31B: no close push,
83	no depth gate, a different direction (cosine with the logged end-of-thought contrast not measured).
84	
[line removed by the dashboard scrubber]

patched
ok
87:GEN = "\n".join([grow("reference", "unedited"), grow("prompt_I1", "unedited, 
wrote 20033 chars; 217 lines
wrote 19989 chars; 216 lines
Fri Nov 13 07:47:00 PM EST 2026
title: Instruction vector, think briefly: an always-on neuron in each of the 60 layers writes the stream shift a 'keep your thinking very short' paragraph causes (dose 2)

## Hypothesis

[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]

[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
still got long into loops. This entry pushes nothing towards `<channel|>` and has no gate. It writes, at every
[line removed by the dashboard scrubber]
127:| arm | calls / positions | flips | flips in thought | close on top inside | dlogp close inside | dlogp close at close | tool flips | KL from base | reproduced | shift cos | prompt flips matched |
[... 16 lines cut ...]
147:prompt positions mean 0.92 0.84 0.81 0.89 0.91 0.82 0.76 0.89 0.91 0.85 0.92, max 1.12 1.35 1.21 1.28 1.10 1.23 2.07 1.36 1.27 1.23 1.41; BOS 0.97 0.55 2.05 3.25 1.47 0.65 0.49 0.81 0.86 0.55 0.25.
[line removed by the dashboard scrubber]
158:| unedited | 48 | 30 | - | 139 | - | 16 of 17 | 0 | 0 |
159:| unedited, paragraph in the prompt | 35 | 25 | 7 / 0 | 116 | 16 of 17 | 16 of 17 | 0 | 0 |
160:| dose 1 | 71 | 35 | 3 / 3 | 136 | 14 of 17 | 17 of 17 | 0 | 0 |
161:| dose 2 (**this entry**) | 45 | 30 | 4 / 3 | 124 | 16 of 17 | 17 of 17 | 0 | 0 |
162:| dose 4 | 41 | 26 | 6 / 5 | 104 | 17 of 17 | 16 of 17 | 0 | 0 |
[This command modified 1 file you've previously read: mkrec6.py. Call Read before editing.]

Exit code 1
patched
ok
wrote 20646 chars; 224 lines
wrote 20602 chars; 223 lines
Fri Nov 13 07:47:31 PM EST 2026
always-on neuron can write (the model has no biases). If the shift carries the instruction, the model plans a short
[line removed by the dashboard scrubber]
and does not ask for short thoughts, so the instruction adds something the prompt lacks.

Different from the null and harmful rows it resembles. E4B "think briefly" (28 / 28 / 25 vs 29) and E4B "prompt
rules compiled into weights" (rank-16 reconstruction, no gain; PRIOR_E4B.md): here the session limit binds in a
quarter of the episodes, and the vector is the 31B model's own per-layer response to the instruction, checked
against the prompted model on held-out calls (table below). The six close-the-thought edits on 31B: no close push,
no depth gate, a different direction (cosine with the logged end-of-thought contrast not measured).

[line removed by the dashboard scrubber]
be where the patch is designed; a mean shift may carry "an instruction is present" without its content; the same
vector is written at prompt positions, where the real instruction changes nothing before its own position.

[... 76 lines cut ...]
  unpaired string delimiters below 3% of tool calls;
- the first-edit call index does not have to move.

Control (the same always-on neurons writing a sign-scrambled vector of the same size): none of the above; thought
[line removed by the dashboard scrubber]

35
0

patched
ok
wrote 20902 chars; 226 lines
wrote 20858 chars; 225 lines
1:title: Instruction vector, think briefly: an always-on neuron in each of the 60 layers writes the stream shift a 'keep your thinking very short' par
3:## Hypothesis
42:## Exact recipe
46:base: champion generation 0
51:size: whole network 0.6713% over 180 matrices, largest matrix 1.6113%
53:control size: whole network 0.6712% over 180 matrices, largest matrix 1.6113%
197:## Prediction (written before the run)
199:predicted_gain_120: -6 to +6
OK edit: 180 modules changed (of 180 present), r=1, max |dW|_F/|W|_F 0.01611 at 32.gate_proj
OK ctrl: 180 modules changed (of 180 present), r=1, max |dW|_F/|W|_F 0.01611 at 32.gate_proj
build.sh
ctrl
edit
record.md
19M
1:title: Instruction vector, think briefly: an always-on neuron in each of the 60 layers writes the stream shift a 'keep your thinking very short' par
[... 21 lines cut ...]
(the compiled vector does not act as the instruction in a rollout), or (b) thoughts are shorter by that much and
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
the lever, for any edit of this family). A gain of +3 or more with (a) true would not be this mechanism.
Loops above 10 per 100 episodes or broken tool-call syntax mean the always-on write breaks the model at this
dose, and say nothing about the instruction.
Fri Nov 13 07:47:57 PM EST 2026
[This command modified 1 file you've previously read: mkrec6.py. Call Read before editing.]

The size is mostly the removal of the 60 replaced neurons (their old gate and up rows have norms of about 1) and is
not the functional dose: the function depends on beta and on the product of the three vectors of the new neuron.
The functional dose is in the table "stream shift" below.

Built from the statistics of `code/icv_job.py` (GPU-0 hold 1 of this turn, forward pass `tools/g31.py` only, no
server, no optimiser anywhere; doses above 2 and the controls of doses 2 and 4 were built on CPU by
`code/icv_build.py` and evaluated in hold 2 by `code/icv_job.py --eval-only`, `code/gpu_job6b.sh`) and
rebuilt bit for bit by `build.sh` (`code/icv_build.py` from `code/data/icv_stats.pt`; the sha256 of the rebuilt
`code/icv_job.py` and `code/icv_gen.py` are my own scripts, first used this turn; they were checked by a CPU
plumbing run (`--mock`) and by the bit-for-bit rebuild, not against another tool, so read their numbers with that
in mind. 8 held-out calls is a small sample: on the flip columns the controls (0.4% to 1.3% of the thought positions,
4 to 5 of the 15 prompted flips matched) are not separable from doses 0.5 and 1; the KL, "reproduced" and
stream-shift columns do separate edit from control at every dose.

`code/icv_job.py`, function `evaluate`: for each held-out call the logged sequence is run unedited (base), unedited
with the paragraph inserted (prompted), and with each adapter and no paragraph. All numbers are at the positions of
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
at close" = mean change of log p(`<channel|>`) at positions where the agent went on / at the position where it
#!/bin/bash
[... 14 lines cut ...]

queue/icv-brief-b40:
READY
build.sh
ctrl
edit
record.md
Fri Nov 13 07:48:08 PM EST 2026

2026-11-13 19:48:25 EST
prediction section has no 'predicted_gain_120: <low> to <high>' line

2026-11-13 19:48:25 EST
prediction section has no 'predicted_gain_120: <low> to <high>' line

total 48
drwxrwxr-x  4 keith keith  4096 Nov 13 19:48 .
drwxrwxr-x 12 keith keith  4096 Nov 13 19:45 ..
-rw-rw-r--  1 keith keith     0 Nov 13 19:48 READY
-rw-rw-r--  1 keith keith    93 Nov 13 19:48 REJECTED
-rwxrwxr-x  1 keith keith   681 Nov 13 19:45 build.sh
drwxrwxr-x  2 keith keith  4096 Nov 13 19:45 ctrl
drwxrwxr-x  2 keith keith  4096 Nov 13 19:45 edit
-rw-rw-r--  1 keith keith 20902 Nov 13 19:47 record.md
/home/keith/gemma-v2/wsp31/authors/BRIEF.md:72:  then find them in `RESULTS.md`. A third entry in a round is rejected. So choose the two entries that teach the
/home/keith/gemma-v2/wsp31/authors/BRIEF.md:187:**One round: one or two new queue entries, not more** (a third is rejected). A parked entry of yours (listed in
/home/keith/gemma-v2/wsp31/authors/BRIEF.md:216:YET in `TOOLS.md`, say so next to the number. An edit that fails the runner's checker is rejected and a
/home/keith/gemma-v2/wsp31/authors/BRIEF.md:217:`REJECTED` file with the reason appears in its directory.
AUTHOR_LOOP
[... 21 lines cut ...]
dash_collect.py.pre-s2clean
dash_collect.py.pre-supp
deploy_coord
frozen
hold_supp.log
hold_supp.sh
items
loop.out

queue/supp_work/test_supp.py:180:                           f"## Exact recipe\n\nfake\n\n## Prediction (written before the run)\n\npredicted_gain_120: -4 to 9\n\n"
queue/supp_work/test_supp.py:185:          "s2": s2, "verdict": verdict, "predicted_gain_120": [-4.0, 9.0], "record": rec, "base_gen": 0}
queue/supp_work/test_supp.py:964:                                   + "\n\n## Prediction (written before the run)\n\npredicted_gain_120: -1 to 4\n" + "p" * 40 + "\n")
queue/runner.py:467:        lo, hi = it["predicted_gain_120"]
queue/runner.py:525:        p = i["predicted_gain_120"]
queue/runner.py:540:        p = i["predicted_gain_120"]
queue/runner.py:594:    if not re.search(r"predicted_gain_120:\s*-?\d+(\.\d+)?\s*to\s*-?\d+(\.\d+)?", out[SECTIONS[2]]):
queue/runner.py:595:        return None, "prediction section has no 'predicted_gain_120: <low> to <high>' line"
queue/runner.py:678:            pred = re.search(r"predicted_gain_120:\s*(-?\d+(?:\.\d+)?)\s*to\s*(-?\d+(?:\.\d+)?)", rec["sections"][SECTIONS[2]])
queue/runner.py:679:            it["predicted_gain_120"] = [float(pred.group(1)), float(pred.group(2))]
queue/runner.py:[port]:            lo, hi = it["predicted_gain_120"]
queue/runner.py:[port]:        p = it["predicted_gain_120"]
authors/claude/queue/net-deep-gate-close-b05/record.md:146:predicted_gain_120: -6 to 8
authors/gemini/queue/dual-budget-rescue-r5/record.md:138:predicted_gain_120: -4 to 14
authors/gemini/queue/exact-close-r4-subspace/record.md:125:predicted_gain_120: -4 to 11
authors/gemini/queue/late-preedit-commit-gate/record.md:131:predicted_gain_120: -3 to 10
authors/gemini/queue/nullspace-close-r4-midlate/record.md:107:predicted_gain_120: 1 to 13

def ingest():
    c, n = cfg(), 0
    its = items()
    cap = c.get("round_max", 2)                      # entries per author and round
    for a in AUTHORS:
        flight = len(in_flight(its, a))
[line removed by the dashboard scrubber]
            src = Path(it["src"])                    # a parked entry comes back when its author asks, as an entry of the round
            if not (src / "RESUBMIT").exists():
                continue
            (src / "RESUBMIT").unlink()
            if flight >= cap:
                (src / "RESUBMIT_REFUSED").write_text(now() + f"\nround limit: a round is at most {cap} entries and yours is full "
                                                      f"(entries waiting or running in stage 1 count). Ask again in a later turn.\n")
[line removed by the dashboard scrubber]
            (src / "RESUBMIT_REFUSED").unlink(missing_ok=True)
            it["state"] = "queued_s1"; it["ready_time"] = time.time(); it["attempts"] = 0; save_item(it)
            rec = LED / it["record"]
            set_front(rec, status="queued")
            add_to_section(rec, "## Verdict and notes",
[... 58 lines cut ...]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
    if n:
        commit(f"wsp31 ledger: {n} new or resubmitted queued edit record(s)")
    return n


# ---------------------------------------------------------------- ledger writing

    log("REJECT", src, why.splitlines()[0][:160])


def split_record(text):
    out, title = {}, ""
    m = re.search(r"^title:\s*(.+)$", text, re.M)
    if m:
        title = m.group(1).replace("|", "/").strip()[:140]
    for i, s in enumerate(SECTIONS):
        a = text.find(s)
        if a < 0:
            return None, f"record.md has no section {s!r}"
        ends = [text.find(t, a + len(s)) for t in SECTIONS[i + 1:] + ["## Result", "## Verdict"]]
        ends = [e for e in ends if e > 0]
        body = text[a + len(s): min(ends) if ends else len(text)].strip()
        if len(body) < 40:
            return None, f"section {s!r} is empty"
        out[s] = body[:12000]
    if not title:
        return None, "record.md has no 'title:' line"
    if not re.search(r"predicted_gain_120:\s*-?\d+(\.\d+)?\s*to\s*-?\d+(\.\d+)?", out[SECTIONS[2]]):
        return None, "prediction section has no 'predicted_gain_120: <low> to <high>' line"
    return {"title": title, "sections": out}, ""


wrote 20901 chars; 226 lines
wrote 20857 chars; 225 lines
icv-brief-b20 split_record: OK Instruction vector, think briefly: an always-on neuron in ea
['predicted_gain_120: -6 to 6']
icv-brief-b40 split_record: OK Instruction vector, think briefly: an always-on neuron in ea
['predicted_gain_120: -9 to 6']

patched
ok
wrote 20079 chars; 223 lines
wrote 20035 chars; 222 lines
icv-brief-b20 OK 139 {'## Hypothesis': 4947, '## Exact recip': 12000, '## Prediction ': 2216}
   full ## Hypothesis 4947
   full ## Exact recip 12691
   full ## Prediction  2216
icv-brief-b40 OK 139 {'## Hypothesis': 4901, '## Exact recip': 12000, '## Prediction ': 2218}
   full ## Hypothesis 4901
   full ## Exact recip 12691
   full ## Prediction  2218
151:Activation of the always-on neuron over gbar in the edited forward pass (dose 1, held-out calls, 11 layers):
152-completion positions mean 0.94 to 1.00, sd 0.06 to 0.12, min 0.54, max 1.57; prompt positions
153-mean 0.76 to 0.92; BOS 0.25 to 3.25.
154-
42:Fitted on (task, unedited arm of batch b001, call index; all stage-1 tasks, none in a stage-2 list):
[line removed by the dashboard scrubber]
Fri Nov 13 07:50:17 PM EST 2026
[This command modified 1 file you've previously read: mkrec6.py. Call Read before editing.]

patched
ok
wrote 19532 chars; 219 lines
wrote 19488 chars; 218 lines
icv-brief-b20 OK 139
   full ## Hypothesis 4947
   full ## Exact recip 12144
   full ## Prediction  2216
icv-brief-b40 OK 139
   full ## Hypothesis 4901
   full ## Exact recip 12144
   full ## Prediction  2218
Fri Nov 13 07:50:44 PM EST 2026
[This command modified 1 file you've previously read: mkrec6.py. Call Read before editing.]

patched
ok
wrote 19270 chars; 218 lines
wrote 19226 chars; 217 lines
icv-brief-b20 OK 139
   full ## Hypothesis 4947
   full ## Exact recip 11882
   full ## Prediction  2216
icv-brief-b40 OK 139
   full ## Hypothesis 4901
   full ## Exact recip 11882
   full ## Prediction  2218
## Exact recipe

This entry: instruction `I1`, dose beta = 4. Control: the same build with `ctrl`.

base: champion generation 0

No edit had passed when this entry was built; statistics, weights and pre-tests are those of the unedited model.
The entry holds only this change.
[... 42 lines cut ...]
Activation of the always-on neuron over gbar in the edited forward pass (dose 1, held-out calls, 11 layers):
completion positions mean 0.94 to 1.00, sd 0.06 to 0.12, min 0.54, max 1.57; prompt positions
mean 0.76 to 0.92; BOS 0.25 to 3.25.

### Served generation (vLLM through `tools/gpu0_session.sh`, greedy, single turns, no rollout)

Fri Nov 13 07:51:03 PM EST 2026
[This command modified 1 file you've previously read: mkrec6.py. Call Read before editing.]