Think-briefly + be-exact prompt compiled where a prompt enters: many-key rank-8 down_proj maps in 7 global-attention layers, dose 2

Every instruction vector so far (0031 to 0039, 0035 / 0036, 0043 / 0044) writes a constant, or a gated constant, into
all 60 layers. That is not how an instruction in the prompt acts. At a position thousands of tokens later the
instruction can enter the stream only where a layer's attention reads the instruction tokens, and 50 of the 60 layers
see 1,024 tokens back (`ARCH.md`). Beyond the first thousand tokens after the issue, the instruction enters through
the ten global-attention layers (5, 11, ..., 59) and nowhere else; all other change in the stream is the network's own
response to a shifted input, which the unedited weights already compute. So the faithful compile is small: give
each global layer the write that its attention to the instruction would have produced, as a function of the context.

Measured this turn (`code/mk_job.py`, 35 fit calls, forward pass). Pass 1: the call with the paragraph pair of 0039
in the prompt. Pass 2: the call without it, with the stream after every layer replaced by the prompted stream at all
positions from the insertion on; before each replacement, `gap_L` = prompted minus computed is what layer L failed to
produce although its input was the prompted stream.
- Size of `gap_L` over the stream, mean over 5,817 positions: global layers 5 to 59: 0.0081, 0.0055, 0.0041, 0.0063,
  0.0101, 0.0073, 0.0085, 0.0072, 0.0121, 0.0213; local layers 2 to 52: 0.0008 to 0.006; layer 0 0.010, layers 54
  to 58 0.009 to 0.012. A local layer's share comes from positions within 1,024 tokens of the instruction and from
  bf16 rounding (the two passes compute the same layer at shifted absolute positions), so the targets sit on a
  noise floor of comparable size: at 20 local layers the held-out R^2 below is negative.
- **A constant explains none of it**: R^2 of the fit calls' mean gap on held-out calls is 0.00 to 0.02 at every layer.
- A rank-8 linear map from the layer's own MLP activations (dual ridge on 5,817 keys, ridge chosen on held-out
  calls) explains on held-out calls: layer 17 0.12, 23 0.13, 29 0.36, 35 0.40, 41 0.39, 47 0.14, 53 0.08; global
  layers 5, 11, 59: 0.02, 0.04, 0.01 (left unchanged). What the instruction adds depends on the context, and a
  third of that dependence is linear in the activations of the layer that has to write it.

The edit: `dW(down_proj of layer L) = 2 x` that rank-8 map, in layers 17, 23, 29, 35, 41, 47, 53. Seven matrices.

Teacher-forced on 8 held-out calls against the model prompted with the pair (table in the recipe): this entry
reproduces **0.53** of the prompt's effect on the next-token distribution; the constant vector of the same prompt
(0039) 0.40, at a larger KL from the unedited model; this entry at dose 1 0.37, at dose 3 0.36 (overshoot). The
constant vectors lower log p(close) inside thoughts by 0.2, which the prompt does not do (-0.006); this entry: +0.05.
A version that also edits the local layers passing the same bar (1, 2, 6, 9, 26, 30, 39) reproduces 0.30 and moves
the stream at layers 6 to 18 five to seven times as far as the prompt: the local layers learn the shift of positions
near the instruction and apply it everywhere. That is why this entry is global layers only.

What I expect it to do: what the pair prompt does, more closely than 0039 did. 0039 (constant, dose 2) cut the median
output tokens per episode from about 9,500 to 6,838 and empty patches from 7, 8 to 3, and scored +2.0 (x004). Whether
the prompt itself gains tasks at 20,000 tokens is not known (I may not run rollouts), so this entry tests the compile
method on behaviour first and the instruction second.

Different from the rows it resembles. 0039: same prompt, constant write, 180 matrices; here a context-dependent map
in 7 matrices, no neuron replaced. 0043 / 0044 (gemini): gated neurons, each still writing one vector. 0047 / 0048
(gpt): a map on writer outputs fitted to outcome labels; here the target is a prompt's measured effect, the keys are
MLP activations, and no outcome label is used. 0024 (first `manykey.py` run): keys to one fixed direction in a band of
mid layers. E4B "prompt rules compiled into weights" (PRIOR_E4B.md): a rank-16 reconstruction of the prompt the
model already had; these two paragraphs are not in the harness prompt.

Risks. (1) Fitted on calls of at most 4,600 tokens; late calls of an episode are three to six times longer and the
map is applied at every position, including the system prompt and the issue (30 keys per call before the insertion
were fitted to zero change, so it is small there on the fit calls). (2) The target is first order in the RMS norm
after the MLP; at dose 2 the stream moves 0.56 to 0.85 of the prompted shift at a cosine of 0.43 to 0.55. (3) Three
of ten global layers, among them the two earliest, are not carried, so what the prompt does through layers 5 and 11 is
missing. (4) 35 fit calls; layers 17, 23, 47, 53 pass the bar of 0.05 with 0.08 to 0.14 only.

Fitted on (task, unedited arm of batch b001, call index; all stage-1 tasks, none in a stage-2 list; the 35
calls of turn 6, no outcome labels; every fourth of them held out to choose the ridge and the layers): mewwts__addict.75284f95.func_basic__9sg9rq7f base 3; scitokens__scitokens-193 aa 5; benoitc__gunicorn.bacbf8aa.func_basic__3napqcbj zero 3; rasbt__mlxtend-1087 zero 22; r1chardj0n3s__parse.30da9e4f.func_pm_remove_cond__k4df18dk zero 1; ross-rotordynamics__ross-177 aa 4; lepture__mistune.bf54ef67.combine_module__dalnbilu aa 3; openmdao__openmdao-3315 aa 22; prettytable__prettytable.ca90b055.func_basic__1mmuxqev zero 3; cool-RR__PySnooper.57472b46.lm_rewrite__031xvy9b zero 3; wireservice__csvkit-800 aa 11; life4__textdistance.c3aca916.combine_file__ciwv50c6 base 2; ishepard__pydriller-84 zero 2; zopefoundation__zope.configuration-34 base 26; stingraysoftware__stingray-234 base 29; jsvine__pdfplumber.02ff4313.func_pm_remove_assign__1v9soh1j zero 3; sqlfluff__sqlfluff-5362 zero 24; prometheus__client_python-1134 base 3; Textualize__textual-1352 zero 19; ipython__traitlets-517 aa 28; django-money__django-money.835c1ab8.combine_module__bqggrnha aa 13; pallets__jinja.ada0a9a6.func_basic__2vdao9be zero 27; geographika__mappyfile-146 zero 21; pypa__hatch-1148 aa 13; gcaufield__MonkeyPack-27 base 2; hdmf-dev__hdmf-1270 base 15; tophat__syrupy-768 zero 2; rubik__radon.54b88e58.func_basic__8pbqxg0r zero 8; juju-solutions__charms.reactive-71 zero 32; manicmaniac__sqlalchemy-repr-7 base 1; keis__base58-46 base 3; urbandataanalytics__SwissKnife-12 base 3; pytask-dev__pytask-200 zero 27; conda__conda-6131 aa 31; mewwts__addict.75284f95.combine_file__3fttj8ti zero 1.

base: champion generation 0

No edit had passed when this entry was built; statistics, weights and pre-tests are those of the unedited model.

size: whole network 0.1662% over 7 matrices, largest matrix 3.1560%

control size: whole network 0.1662% over 7 matrices, largest matrix 3.1560%

Not training-sized: 7 `down_proj` matrices at rank 8 (median 1.73% of a matrix, stable rank 2.3). The mechanism says
where a prompt enters, and that is ten layers. The round's training-sized entry is `fcv-brief-exact3-b20`.

Paragraphs (inserted together at the end of the first user message; tokens in `code/data/fcv2_stats.pt`, 115 tokens):

> Important: keep your thinking very short. Before each tool call, think in at most three short sentences: what you just learned and what you will do next. Never write long plans, never draft or rewrite code in your thoughts, and never go over the same point twice.

> Important: be exact about what the issue asks. In every thought keep in view the precise behaviour the issue describes, with each example, input variant and error message it mentions, and make your change fix the general cause so that all of them work, not only the case that was reported.

Per fit call (`code/mk_job.py`, `tools/g31.py`, bf16 mirror of the served model; e = insertion position):
1. prompted pass; keep `resid_post` of every layer at every position from e on.
2. unprompted pass with hooks: at `resid_post` of layer L, `gap_L[p]` = prompted - computed at the key positions, then
   the stream from e on is overwritten with the prompted one. Keys: `mlp_act` of layer L in this pass. Key positions,
   `random.Random(1100 + call index)`: 30 before e (target 0), up to 60 between e and the start of the logged
   completion, up to 100 of the completion (5,817 keys in all).
3. target in `down_proj` output space: `t = rms(mlp_raw at p) * clipdiv(gap_L[p] / layer_scalar_L, w_post_L)`
   (`thinklib.clipdiv`: division by the weight of the norm after the MLP, zero where it is below its 5% quantile).

Per layer: `K = A A^T` (A: keys, float32, then float64), `alpha = (K + lam tr(K)/N I)^-1 T`, lam from 0.03, 0.3, 3 by
the R^2 at rank 8 on the held-out calls (fit-call index divisible by 4); refit on all calls with that lam; `V8` = top 8
right singular vectors of the fitted values `K alpha` (`torch.svd_lowrank`, q 24, 4 iterations);
`dW_raw = V8 (alpha V8)^T A`. Used if the held-out R^2 is 0.05 or more and the layer is global (L % 6 == 5).
Chosen lam: 3, 3, 3, 0.3, 0.3, 0.3, 3 for layers 17 to 53. Edit: `dW = 2 dW_raw` (`code/mk_build.py`). No optimiser.

Intended against built: intended, the write each global layer lacks, exactly. Built: a rank-8 linear map of the MLP
activations that explains 8% to 40% of it on held-out calls, first order in the norm, in 7 of 10 global layers, at
twice its fitted size (dose chosen on the 8 evaluation calls below: 0.37, 0.53, 0.36 at doses 1, 2, 3). The dose was
chosen on the same 8 calls that the table reports.

Control: the same factors with the sign of every output coordinate (row of the write factor) flipped at random, seed
7000 + L: same layers, rank, read side and |dW|_F; the write goes to directions unrelated to the prompt's. At equal
size it moves the output less (KL 0.0005 against 0.0051): the edit's writes line up with what the layers above read,
a random-sign write does not. It controls for "a context-dependent write of this size in these layers", not for
"an equally large behavioural change".

Rebuild: `build.sh` (CPU, seconds, from the saved factors `code/data/mk_stats.pt`; sha256 of `edit/` and `ctrl/` equal
the evaluated arms `Q20`, `Q20c`; `code/fin11b.sh`). Checker: `OK edit: 7 modules changed (of 7 present), r=8, max
|dW|_F/|W|_F 0.03156 at 35.down_proj`; ctrl the same.

Pre-test 1, teacher-forced (GPU 0 forward pass, `code/mk_eval.py` and `mk_job.py`, `icv_job.evaluate`): 8 held-out
calls of 8 stage-1 tasks not among the fit calls, 1,278 positions, against the model prompted with the pair.

| arm | KL(base to arm) | top token changed, all / in thoughts | share of the prompt's effect reproduced | of the prompt's 24 top-token changes matched | tool-name positions changed | log p(close) inside thoughts / at the 8 closes | stream shift over prompted shift, layers 18 to 59 | cosine |
|---|---|---|---|---|---|---|---|---|
| prompted with the pair | 0.0077 | 1.9% / 3.7% | (target) | 24 | 0 of 8 | -0.006 / -0.20 | 1 | 1 |
| **this entry** (Q20) | 0.0051 | 1.1% / 2.2% | **0.53** | 11 | 0 of 8 | +0.052 / -0.10 | 0.56 to 0.85 | 0.43 to 0.55 |
| dose 1 (Q10) | 0.0014 | 0.6% / 0.9% | 0.37 | 7 | 0 of 8 | -0.003 / -0.01 | 0.29 to 0.47 | 0.42 to 0.52 |
| dose 3 (Q30) | 0.0106 | 1.6% / 2.8% | 0.36 | 13 | 0 of 8 | +0.104 / -0.23 | 0.83 to 1.24 | 0.44 to 0.58 |
| **its control** (Q20c) | 0.0005 | 0.7% / 1.3% | 0.10 | 6 | 0 of 8 | +0.079 / -0.07 | 0.35 to 0.62 | 0.06 to 0.23 |
| all 14 layers that pass, dose 2 (M20) | 0.0086 | 1.5% / 2.8% | 0.30 | 13 | 0 of 8 | +0.013 / -0.16 | 1.1 to 5.5 (7.0 to 7.7 at layers 6 and 12) | 0.33 to 0.62 |
| constant vector of the pair, 0039 (G20) | 0.0060 | 1.5% / 2.6% | 0.40 | 13 | 0 of 8 | -0.198 / -0.11 | 1.2 to 3.0 | 0.40 to 0.59 |

14 top-token changes in 1,278 logged tokens: of the order of 100 per episode, so the edit acts under greedy decoding.

Pre-test 2, thought ends, `tools/closeprobe.py` (40 logged closes, exact contexts; flag below -0.05):

- global layers, dose 2 (Q20): change of log p(close) at close: mean +0.063, raised at 0.900 of 40 positions; change of log p(close) at cont: mean +0.650, raised at 0.595 of 126 positions

Not flagged. `<channel|>` stays the top token at 40 of 40 logged closes (log p -0.071 to -0.008); inside thoughts
it becomes the top token at 2 of 126 positions (0 unedited) and the logged token stays top at 0.913 (0.992).

Pre-test 3, served single turns (`code/icv_gen.py` under `gpu0_session.sh`, port 18400, no tool executed, no rollout;
mid-episode calls of held-out stage-1 tasks, 1,500 tokens at most), and `interp/toolcall_check.py` on them:

| arm | thought tokens mean | median | shorter / longer than unedited | answer tokens mean | same tool as unedited | well-formed tool call | cut | loops |
|---|---|---|---|---|---|---|---|---|
| unedited | 47 | 30 | - | 139 | - | 17 of 17 | 0 | 0 |
| unedited, paragraph I1 alone in the prompt | 35 | 25 | 7 / 0 | 116 | 16 of 17 | 16 of 17 | 0 | 0 |
| Q20 (`mk-pair-global-b20`) | 35 | 30 | 3 / 4 | 128 | 17 of 17 | 17 of 17 | 0 | 0 |
| H23 (`fcv-brief-exact3-b20`) | 44 | 30 | 5 / 4 | 124 | 16 of 17 | 16 of 17 | 0 | 0 |
| Q20c (control of `mk-pair-global-b20`) | 45 | 30 | 1 / 1 | 139 | 17 of 17 | 17 of 17 | 0 | 0 |

17 contexts (calls 2, 17, 4, 17, 9, 3, 12, 12, 21, 26, 2, 13, 12, 17, 4, 26, 15).

`toolcall_check.py`: reference: 0 of 17 tool calls = 0.0%; prompt_I1: 0 of 17 tool calls = 0.0%; Q20: 0 of 17 tool calls = 0.0%; H23: 0 of 17 tool calls = 0.0%; Q20c: 0 of 17 tool calls = 0.0% (unedited rollouts 0.7% to 1.1%; too few calls for the tool's verdict, which needs 60).

Runner facts (2026-11-14 10:15:29 EST): source `wsp31/authors/claude/queue/mk-pair-global-b20/`; served copy `wsp31/queue/frozen/claude__mk-pair-global-b20/`; sha256 over files, edit `cda848be2580d98caf3c516cb9c68fd31c4047b400b15a1c96ffeec6f8c9d3e2`, control `7a6c34e3815de1875e05ee70974fe4b7f56c1a6f3d8f3c87c4ee50fd07040527`; both passed the checker.

predicted_gain_120: -5 to 7

Point estimate +1. Behaviour, against the unedited arms of the same batch (budget `x2`), in the direction of 0039 and
about a third to all of its size:
- median output tokens per episode 7,000 to 9,300 against about 9,000 to 10,000 (0039: 6,838), and below the control's;
- out of budget in 11 to 18 episodes against 18 to 21; empty patch 3 to 7 against 7 to 8;
- finished with a wrong patch 24 to 31 (unedited 27, 28);
- no rise in tool calls (median 19 to 22) and no tool-call syntax errors.
The served turns above set the lower end: thoughts were shorter in 3 of 17 turns and longer in 4 (mean 35 tokens
against 47, most of it from one turn), where the paragraph I1 in the prompt shortened 7 and lengthened none. So the
token saving may be a third of 0039's; the teacher-forced share (0.53 against 0.40) says it should be larger. The
run decides between the two pre-tests.

Control: gain within -4 to +4, tokens per episode within 7% of the reference arms.

What would prove me wrong. (a) Output tokens per episode and tool calls within 5% of the reference arms: a compile
that reproduces half of the prompt's effect token by token does not carry its behaviour over an episode, and the
teacher-forced share is not the number to optimise. (b) Behaviour moves as predicted and the gain is at or below 0:
the method works and this instruction is not worth tasks at 20,000 tokens; the next entry keeps the method and
changes the paragraph. (c) Solved drops by 6 or more with longer thoughts or more calls: a map fitted on short
contexts misfires on long ones (risk 1). A gain of +5 or more here with less than that for `fcv-brief-exact3-b20`
in the same batch would say that fidelity of the compile, not the dose of the constant, is what matters.

Pending.

Pending.