Deep-thought gate (dose 0.1) plus the model s own end-of-thought neurons at 9 times their write

In the unedited batch b001 (three identical arms, 61 episodes finished when read) 14 of the 28 failures end at the
7.5-minute session limit, at least 10 of them with an empty patch and 8 of those without a single file edit (at 110
episodes, 9:40 PM ET: solved 44%, at the limit 35%, empty patch 25%). At about
25 generated tokens per second per stream the limit is a budget of about 11,300 generated tokens. Limit episodes
generate 11,341 tokens, 9,149 of them thinking, and 48% of everything they generate lies beyond token 400 of a thought
(solved episodes: 24%, 1,631 tokens per episode; `code/cf_budget.py`). The deep parts are re-readings of code with
"Wait, ..." restarts. Making long thoughts end sooner should return that wall-clock to tool calls, so that episodes
which now time out without a patch get to edit, test and submit.

Different from the E4B "think briefly" edits (28 / 28 / 25 vs 29, PRIOR_E4B.md): there the session limit was not
reported as binding; here it ends 23% to 35% of unedited episodes, and the edit is built from the state at the logged ends of
thoughts (and, in families B and C, acts only deep inside a long thought), not from a short-vs-long contrast.

Spec `B:0.1,N:8` of `code/build_think.py` (families in `code/thinklib.py`; rebuild with `build.sh`).

Statistics (`code/data/think_stats.pt`, written by `code/think_job.py` in one GPU-0 hold with `tools/g31.py`, the
tools lane's forward pass, whose agreement with the served model is NOT VERIFIED YET in TOOLS.md): one rollout per
instance of `tools/data/probe_screen.jsonl` (unedited run s1_base), every fourth instance held out for the pre-test,
the rest truncated to 11,000 tokens. Positions per episode: E = last token of a thought (the model's next token was
`<channel|>`; the token the history re-rendering merged with a newline is restored), up to 40; thought positions
at depth < 100 (80), 100..399 (60), >= 400 (120); 80 positions outside thoughts. Depth = tokens since `<|channel>`.

Family B (gated, state side), layers 30, 32, ..., 48, one neuron per layer replaced outright (`set`): the
neuron `j_L` with the smallest mean |activation| over all sampled positions. Gate row = `(3 / sigma) (w - (theta /
cbar) m)`: `w` = unit diagonal-LDA probe on `mlp_in[L]` (late thought positions, depth >= 400, against early thought
positions, depth < 100, and positions outside thoughts), `theta` = 95% quantile of the probe on the negatives,
`sigma` = sd on the positives, `m` = unit mean `mlp_in` (the model has no bias; `m . x` is `cbar` at every position).
Up row = `m / cbar` (reads 1). Down column = `clipdiv(d_L / |d_L|, w_post_L) * dose * |d_L| * rms_y_L / (gbar_L *
layer_scalar_L)` with `gbar_L` = mean activation of the new neuron on the late positions and `d_L` as in family A
(E minus other thought positions): at an average late position the write moves `resid_post` by `dose * d_L`.

Family N (weights only, the model's own end-of-thought neurons): the down_proj columns of the MLP neurons of
layers 57, 58, 59 whose direct write lens is dedicated to token 101 `<channel|>` are multiplied by `1 + dose`. Selection
(`code/end_neurons.py`, CPU, no activations): for neuron j, `x_j = final_norm_w * post_ff_norm_w * down[:, j]`,
`z_j = ((E[101] - mean_vocab E) . x_j) / sqrt(x_j^T Cov_vocab(E) x_j)` (the z-score of `<channel|>` in the neuron's
write lens over the 262,144-token vocabulary, exact); selected `z_j >= 6`, at most 16 per layer, layers 48..59
searched: 2 neurons in layer 57 (4238 z 16.9, 18123 z 11.8), 2 in layer 58 (1622 z 10.9, 15419 z 6.5), 16 in layer
59 (14974 z 22.7, 6539 z 18.6, 3378 z 12.0, 18515 z 11.2, ...); none in layers 48..56. Lists and columns:
`code/data/end_neurons.pt`. Control for this family: for each selected neuron, a neuron of the same layer with
`|z| < 1` nearest in column norm (pool of 4000, seed 4242), scaled by the same factor.

Gate variant g3 (`code/think_refit.py`, CPU refit from the saved MLP inputs): sharpness 12 instead of 3, positives = thought positions at depth >= 800, negatives = thought positions at depth < 200 and positions outside thoughts (threshold = 95% quantile of the negatives). Training-set firing rate, layers 30..48: depth < 100 0.05-0.09, 100..399 0.17-0.23, 400..799 0.28-0.45, >= 800 0.57-0.75, outside thoughts 0.00-0.03, at thought ends 0.00; AUC 0.88-0.91. This entry uses `code/data/think_stats_g3.pt`: the class means and neurons of `think_stats.pt` with these gates in place of the first version described under Family B.

Control (`ctrl/`): same code path and statistics; the written unit direction has the sign of every coordinate
flipped at random (seed 1000 + layer) before `clipdiv`. Per-coordinate magnitudes are unchanged, so the control has
the same norm in the stream, in the raw MLP output and in |dW|_F, the same read vector / gate, and a write direction
with cosine about 0 to the edit's. It is the right control for "this direction, not a write of this size at these
positions".
For the family N part the control scales, by the same factor 9, 20 other neurons (one per selected neuron, same layer,
`|z| < 1`, nearest in column norm). The control of the combination was not pre-tested as one adapter; its two parts
were (rows `G3B0p1c` below; family N control at factor 4 in the first pass: no change from unedited).

Built as intended; approximations: bf16 storage of the factors (8 significant bits), the 5% `clipdiv` mask, and the
bias-free threshold (the constant is read from the mean-input direction).

Checker:

```
saved queue/deep-gate-b01-end-neurons-x9/edit r 16 modules 33 max rel_fro 0.1999
saved queue/deep-gate-b01-end-neurons-x9/ctrl r 16 modules 33 max rel_fro 0.19988
OK edit: 33 modules changed (of 33 present), r=16, max |dW|_F/|W|_F 0.1999 at 59.down_proj
OK ctrl: 33 modules changed (of 33 present), r=16, max |dW|_F/|W|_F 0.1999 at 59.down_proj
```

Pre-test (teacher-forced on the held-out episodes, truncated to 8,000 tokens, `code/think_report.py`; forward pass
NOT VERIFIED YET against the server; arms named family+dose, a trailing `c` is the control). `dlp101` = change of
log p(`<channel|>`) at thought positions by depth class and at E; `explen ratio` = expected thought tokens under the
arm's end hazard along the logged thoughts, relative to the unedited model, for thoughts logged shorter / longer
than 400 tokens; `dlpnext` = change of the log-prob of the logged token (collateral); `top1 agree` = share of
positions whose top token is unchanged (`think` = first token after a thought, `tool` = tool name); `p101 non` =
mean p(`<channel|>`) outside thoughts.

```
episodes 5 ['PyCQA__flake8.cf15', 'Mimino666__langdet', 'Delgan__loguru-130', 'PyCQA__pyflakes-27', 'HIPS__autograd.ac0'] arms per episode [11, 11, 11, 11, 11]
n by class {'E': 29, 'early': 2051, 'mid': 3020, 'late': 3870, 'non': 750, 'think_pt': 29, 'tool_pt': 29}
base expected/logged thought tokens: short 2708/2712 (23 thoughts)  long 6227/6258 (6 thoughts)
base mean lp101: early -24.99 mid -25.83 late -24.72 E -0.79 non -20.54
arm      | dlp101 early  mid  late     E | explen ratio short long | dlpnext early  late   non think  tool | top1 agree early late think tool | p101 non
G3B0p1   |   0.11   0.47   2.04  -0.06 |     1.00  0.69        |  -0.00  -0.06  -0.00  -0.00  -0.00 |  1.00  0.95  1.00  1.00 | 0.0001 (base 0.0001)
G3B0p1N8 |   0.26   0.59   3.03   0.37 |     0.94  0.40        |  -0.00  -0.07  -0.04  -0.02   0.00 |  0.99  0.95  1.00  1.00 | 0.0017 (base 0.0001)
G3B0p1c  |   0.01   0.04   0.25   0.00 |     1.00  1.00        |  -0.00  -0.01  -0.00  -0.00   0.00 |  1.00  0.98  1.00  1.00 | 0.0001 (base 0.0001)
```

Greedy reading of the same passes (the harness decodes at temperature 0): along each logged thought, the first
position where `<channel|>` is the arm's top token. `cut<end` = share of thoughts that would end before their
logged end, `extends` = share where `<channel|>` is not the top token even at the logged end, `tokens kept` =
tokens up to the first cut / logged tokens, `E top=101` = share of logged thought ends where `<channel|>` is top
(the unedited forward pass itself reproduces only this share of the logged ends, see `base`).

```
arm      | short thoughts: n  cut<end  extends  tokens kept | long (>=400): n  cut<end  extends  tokens kept  median cut depth | E top=101 | thought positions (not E) with top=101
base     |  23    0.00     0.13       1.00 |   6    0.17     0.17       0.99     1284 | 0.83 (29) | 0.0001 | outside thoughts (non, think, tool points): n 808, top=101 0, top unchanged 1.000
G3B0p1   |  23    0.00     0.13       1.00 |   6    0.33     0.17       0.66      714 | 0.79 (29) | 0.0002 | outside thoughts (non, think, tool points): n 808, top=101 0, top unchanged 0.993
G3B0p1N8 |  23    0.22     0.09       0.95 |   6    0.67     0.00       0.48      245 | 0.86 (29) | 0.0038 | outside thoughts (non, think, tool points): n 808, top=101 1, top unchanged 0.976
G3B0p1c  |  23    0.00     0.13       1.00 |   6    0.17     0.17       0.99     1284 | 0.83 (29) | 0.0001 | outside thoughts (non, think, tool points): n 808, top=101 0, top unchanged 0.991
```

Not tested: free-running generation under the edit (no rollouts, no served probe in this turn), so whether a thought
that is ended early is followed by a sensible tool call is only covered by the `think` / `tool` columns above.

Runner facts (2026-11-12 21:41:05 EST): source `wsp31/authors/claude/queue/deep-gate-b01-end-neurons-x9/`; served copy `wsp31/queue/frozen/claude__deep-gate-b01-end-neurons-x9/`; sha256 over files, edit `7420174256401a5a30ccecda309729ff140eca98e251ccf10f21484a0a528167`, control `38b3f07860c0811253a257097ec28d7ac26a14ae4ba88538399ff976586923ac`; both passed the checker.

predicted_gain_120: -5 to 9

Behaviour that should move: the deep-thought gate (family B, dose 0.1, gate g3) ends long thoughts, and the model's own
end-of-thought neurons at 9 times their write (family N, dose 8) keep natural ends decisive, which the gate alone
weakens slightly (`E top=101` 0.79 for the gate alone, 0.83 unedited, 0.86 for the combination). Pre-test of the
combination itself: long thoughts keep 48% of their tokens, short thoughts 95%.
- thinking tokens per episode: down 20% to 40% (5,700 to between 3,400 and 4,600);
- episodes ending at the 7.5-minute limit: down by a quarter to a half of the unedited arm's rate (35% at 110 episodes: to 18-27%); empty patches down in the same proportion (25%: to 13-20%);
- tool calls per episode: up by 1 to 4.
Control (`ctrl/`): thinking tokens per episode within 8% of the unedited arm, session-limit rate within 6 points,
gain between -4 and +4 (identical unedited arms already differ by a few tasks).

The hypothesis is wrong if (a) thinking tokens per episode fall by less than 10%: the teacher-forced cut does not
transfer to free-running episodes (the model re-opens the thought it was made to close); or (b) thinking falls by
20% or more and the limit rate falls, but the edit does not gain tasks: long thoughts are then a symptom of hard
tasks and not the cause of the failures; or (c) the control shows the same fall in thinking tokens: then it is not
this direction. A rise of episodes that stop at the 30-tool-call cap by more than 8 points over the unedited arm would mean the saved time went into
more calls and not into finishing.

Caveats written before the run: the pre-test has only 5 held-out episodes (6 long thoughts); the lane's forward pass
reproduces only 83% of the logged thought ends on the unedited model (agreement with the server NOT VERIFIED YET);
nothing was generated under the edit, so the first tool call after a thought that was cut short is untested.
Unedited reference (b001): at 61 episodes solved 54%, at the session limit 23%, thinking tokens per episode 5,700
(solved 4,637, limit 9,149). At 110 episodes (9:40 PM ET): solved 44%, at the session limit 35%, empty patch 25%, at
the 30-tool-call cap 17%; 8.6% of calls think 800 tokens or more, 17.6% think 400 or more. The percentages predicted
above are relative to whatever the unedited arm of the same batch shows.

**Stage 1** (batch `x005`, 4 arms on one server, concurrency 4 per arm, finished 2026-11-14 08:49:03 EST; `results/wsp31/batches/x005/`). Reference arm: unedited. Both reference arms are the unedited model served through an all-zero adapter, the same serving path as an edit (ledger record 0033). Box batch: run on rented boxes as 4 shards by task, every arm of a shard on one server; its edits are compared only with its own reference arms. Episode budget of every arm: 20,000 generated tokens, 60 tool calls, 80 turns (budget `x2`, harness `harness_x2`).

- unedited: solved 75 of 120, agent errors 23, at session limit 23, at tool-call cap 7, empty patch 9, median tool calls 24.0, mean 405.7 s, median 24.9 completion tokens/s of model time.
- edit: solved 74 of 120, agent errors 14, at session limit 13, at tool-call cap 6, empty patch 6, median tool calls 21.0, mean 331.7 s, median 26.0 completion tokens/s of model time; vs base on 120 common tasks: -1.0 tasks (95% interval -9.0 to +7.0), base-only 8, arm-only 7, exact p 1.0.
- second unedited arm (identical weights): solved 73 against 75; 7 tasks solved only by the first, 5 only by the second (12 tasks differ; record 0003 measured 11.3 per identical pair); median 25.0 completion tokens/s. The gain used by the rule is against the mean of the two reference arms per task.
- edit against the mean of the two reference arms: +0.0 tasks of 120 (95% interval -6.5 to +6.0).
- Predicted gain -5 to +9; measured +0.0: inside the interval.

Parked 2026-11-13 09:12:02 EST, not screened: rounds began on 13 Nov 2026 and each author keeps two waiting entries. The author can put it back in a later round (an empty file `RESUBMIT` in `wsp31/authors/claude/queue/deep-gate-b01-end-neurons-x9/`); it then counts as one of that round's entries and is served from the frozen copy, unchanged.

Put back by its author 2026-11-14 07:13:46 EST: waits for stage 1 again, served from the frozen copy, unchanged.

null by the fixed rule: stage-1 gain +0.0, bar +3, harmful at -6 or below.