Turn 13 · gpt

 succeeded in 291ms:
# 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,
[... 213 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.

 succeeded in 410ms:
# Author gpt - turn 10, complete: two entries READY

Started 2026-11-14 14:00 UTC; deadline 15:30 UTC. Updated 2026-11-14T14:37:01.094685+00:00. Champion generation 0 at design and pre-test. This turn is one round; submit no third entry.

Previous round: source-grounding ICV doses 3/1 null (-2.5/-3.5). Apparent edit-error reductions were mostly malformed-call counts within unedited variation. Close-writer and close-neuron amplification were harmful; no more forced-close work.

New family: paired-outcome writer maps, rank 4 across all 120 o_proj/down_proj matrices. Fit 18 within-task success/failure pairs, holding out 3 hash-split paired tasks; exact unedited b007/x001/x003/x004/x005 calls, same editing tool, nearest prompt lengths among last qualifying calls. Episode success is a noisy proxy for local edit correctness. Older/newer budgets and different local subproblems remain confounds. No hidden-test text enters the fit.

Closed form: at each writer, target failed thought means toward successful means; preserve successful, prompt and syntax means with ridge. Rank-4 output SVD; compose the map with W; equalize per-matrix relative norm. No optimizer or trained-adapter direction. Reversed controls keep A exactly and negate B. CPU rebuilds match config, weights and metadata byte for byte. Full code, inputs, captures, hashes and audit receipts: code/turn10. Queue records contain the equations and episode names.

Queued: paired-outcome-writers-r4-100, paired-outcome-writers-r4-033. Network sizes are 0.999984% and 0.329996% if both are queued; largest matrices 2.561328% and 0.845276%. Both meet training-size requirements. Predictions: -6 to +12 and -4 to +9 stage-1 tasks. Stage 1 is design data; stage 2 is the first unseen-task outcome check.

[line removed by the dashboard scrubber]

GPU use so far: 1761.03 seconds across 2 finished holds, GPU 0 only through lock and wrapper. No rollouts. No stage-2 or sealed traces read; all fit/check task IDs passed nine stage-2 exclusion lists. Scratch stays below 10 GB.

Next turn: read RESULTS before deciding. If null, do not try another dose of this weak-transfer family. If positive, separate gains on the 18 fit tasks from the other stage-1 tasks; do not fit on stage 2. Missing tool: a pre-test validated to predict task gains.
# Results for author gpt (2026-11-14 14:22:18 EST)

[... 77 lines cut ...]
| 0038 | claude | fcv-brief-b20 | Think-briefly instruction vector, self-consistent compile (dose 2): each layer writes only what the paragraph's mean shift still lacks | done | -2 to +8 | -2.0 (75 vs 78) |  | null |
| 0039 | claude | fcv-brief-exact-b20 | Instruction pair vector: think briefly + be exact about what the issue asks, compiled self-consistently into one neuron per layer (dose 2) | queued_confirm | -4 to +8 | +2.0 (79 vs 78) |  | null |
| 0043 new | gemini | spec-audit-thought-gate | Thought-gated reliability-shrunk Problem Statement spec-audit steering across all 60 MLP layers | queued_confirm | +2 to +7 | +2.5 (79 vs 78) provisional |  | null |
| 0044 new | gemini | dual-audit-postedit-boost | Stateful two-neuron post-edit spec-audit boost with thought and edit-history gating over 180 MLP matrices | running_confirm | +3 to +8.5 | +5.5 (82 vs 78) provisional |  | - |
[line removed by the dashboard scrubber]
| 0050 new | claude | fcv-brief-exact3-b20 | Instruction pair vector, 'be exact about what the issue asks' part written three times in layers 6 to 24, think-briefly part at dose 2 | queued_confirm | -5 to +7 | +4.0 (81 vs 76) provisional |  | - |
[line removed by the dashboard scrubber]
| 0056 | gemini | tri-phase-concise-audit-veto | Capacity-regularized three-phase GeGLU controller for concise thoughts, post-edit spec audit, and pre-submit veto | running_s1 | +4 to +9.5 |  |  | - |

 succeeded in 323ms:
# wsp31 queue status (2026-11-14 14:22:20 EST)

Rule: {"s1_promote": 2.0, "s1_harmful": -6.5, "s2_min": 0.5, "ctrl_margin": 0.5, "total_pass": 8.0, "total_harmful": -10.5, "run2_bar": 8.0}

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

Reference arms of a new batch: the unedited model served through an all-zero adapter, the same serving path as an edit (ledger record 0033).

[line removed by the dashboard scrubber]

## Batches

| batch | stage | gpu | state | arms | rows | note |
|---|---|---|---|---|---|---|
| x003 | s1 | box | done | base e0035 e0036 aa | 480 | {"base": 81, "episodes": 120, "aa": [81, 82, 3, 4], "arms": {"e0035": [79, -2.5], "e0036": [78, -3.5]}} |
| b004-supp1 | s1 | 1 | done | base e0021 e0020 aa | 76 | {"tasks": 19, "record": "0042", "solved": {"base": [56, 70], "e0021": [50, 60], "e0020": [47, 58], "aa": [59, 73]}} |
| b009 | s2 | 1 | done | base e0032 c0032 aa | 872 | {"base": 127, "episodes": 218, "aa": [127, 114, 20, 7], "arms": {"e0032": [123, 2.5], "c0032": [120, -0.5]}} |
| x004 | s1 | box | done | base e0038 e0039 aa | 480 | {"base": 78, "episodes": 120, "aa": [78, 76, 7, 5], "arms": {"e0038": [75, -2.0], "e0039": [79, 2.0]}} |
| x005 | s1 | box | done | base e0007 e0009 aa | 480 | {"base": 75, "episodes": 120, "aa": [75, 73, 7, 5], "arms": {"e0007": [74, 0.0], "e0009": [3, -71.0]}} |
[... 166 lines cut ...]
[line removed by the dashboard scrubber]
| [0054](ledger/0054-claude-fast1-throughput-deploy.md) | 2026-11-14 | claude | throughput | fast1 deploy - 24 streams per server, GPU memory share 0.95 and Son's adaptive ngram drafts on the rented boxes and on wrx90 | none (serving change; no task set was run for this record) / none yet; first box batch on the new kit will be x009, first wrx90 batch with ngram_fix not formed at the time of writing | running | n/a | deployed without a pass bar at Keith's request; lane's single-window measurement 317.0 tok/s against a mean of 278.6 (+13.8 %); not yet verified in a real batch |
[line removed by the dashboard scrubber]
| [0056](ledger/0056-gemini-tri-phase-concise-audit-veto.md) | 2026-11-14 | gemini | edit | Capacity-regularized three-phase GeGLU controller for concise thoughts, post-edit spec audit, and pre-submit veto | wsp31_screen_v2 / x009 | running | - | - |
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
| [0059](ledger/0059-claude-fast2-throughput-deploy.md) | 2026-11-14 | claude | throughput | fast2 deploy - fp8 KV cache, 48 streams and the rest of Son's serving stack on the rented boxes and on wrx90 (changes the numbers; new comparable group) | none (serving change; no task set was run for this record) / none yet; last box batch before fast2 is x008 (or x009 if it forms before the kit commit), last wrx90 batches before are b010 (GPU 1) and b011 (GPU 0); first fast2 batches are named in the Result when they form | running | n/a | deployed without a pass bar at Keith's request; lane's replay measurement 430.0 tok/s against 314.3 for fast1 (+37 %); not yet verified in a real batch |
[line removed by the dashboard scrubber]

 succeeded in 410ms:
# 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

[... 4263 lines cut ...]
- The agy reader: no family-A answer and no scale-up answer (amendment 4a); at about 9 minutes per call and with
  half of the calls empty it is still inside the family-B pilot, in the fixed order of amendment 2, and is
  reported with its n. Every verdict of section 4 is for two readers.
- Priority 4 of the lane (do atlas or reader predictions agree with what edits did in rollouts): eleven entries
  are queued, none has a stage-1 result yet; predictions and scorer registered (amendments 5 to 5d, section
  3.6).

**Managing output size**

 succeeded in 291ms:
  314 /home/keith/gemma-v2/wsp31/tools/TOOLS.md
  144 /home/keith/gemma-v2/wsp31/tools/ARCH.md
  458 total
sed: -e expression #1, char 4: unterminated address regex
# Interpretability lane: what is known about the inside of Gemma 4 31B

[line removed by the dashboard scrubber]
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`.

[line removed by the dashboard scrubber]

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 unless stage 2 is named, one rollout per task and arm: 120 tasks in b002 and b003, 102
[line removed by the dashboard scrubber]

- **New (9:09 AM ET, Sat 14 Nov 2026): stage 2 of 0032 (claude; the constant "think briefly" vector at dose 4) is finished and the edit did
  not pass (runner +2.5, verdict null). This lane registered five predictions for this batch before reading it
[... 115 lines cut ...]
replay_panel.jsonl
selection.json
served.py
source_hashes.json
tools
tools_sha256.json
turn_receipt.json
verify_rebuild.py

 succeeded in 338ms:
# 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`.

    . /home/keith/gemma-v2/env.sh; T=$R/wsp31/tools
    export WSP31_WORK=$R/wsp31/authors/<you>/scratch     # caches and server logs of the tools go here, not into $T

[... 289 lines cut ...]

[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).

**Preparing to read architecture survey**

 succeeded in 338ms:
# Gemma 4 31B (QAT w4a16) architecture, as served

Source: `config.json` and the safetensors header of `/home/keith/gemma-v2/models/gemma-4-31b-it-qat-w4a16-ct`
(one file, 23.27 GB, 2009 tensors) and the vLLM 0.19.1 model code that serves it
(`vllm/model_executor/models/gemma4.py`). The lane's forward pass `g31.py` implements exactly this graph; its
agreement with the server is measured in `REPORT.md`.

## Sizes

| item | value |
|---|---|
| layers | 60 |
| residual width d | 5376 |
| MLP width | 21504 neurons per layer (4 d), gated: `gelu_tanh(gate . x) * (up . x)` |
| attention heads | 32 query heads per layer |
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
| biases | none anywhere in the language model |
[... 2227 lines cut ...]
    "fit_error": 0.5773635393935951,
    "check_error": 0.9956785977607787,
    "ridge": 0.02,
    "rank": 4
  }
]
**Improving robust script execution and error mapping**
**Testing task-invariant outcome contrasts**

 succeeded in 75ms:
turn10
turn4
turn7
after_capture.sh
audit_boundary.py
audit_snapshot.py
author_capture.py
boundary_probe.py
build_combo.py
build_overlap.sh
build_project.py
cancel_optional.py
capture_job.sh
close033_record.json
close050_record.json
combo_candidates.txt
combo_guard.py
complete_entry.py
finalize_entry.py
[... 16 lines cut ...]
served_body.sh
served_candidates.txt
served_job.sh
shift011_record.json
skip_candidates.json
snapshot_tools.sh
update_frozen_manifest.py
verify_rebuild.py

 succeeded in 162ms:
"""Paired-outcome writer transport. Closed-form ridge/SVD; no optimizer."""
import json,sys,time,hashlib,argparse,os
from pathlib import Path
import torch
C=Path(__file__).resolve().parent;A=C.parent.parent;S=A/'scratch/turn10';T=C/'tools'
sys.path.insert(0,str(T));import g31
from edits import EditSet
torch.set_num_threads(8);torch.set_grad_enabled(False)
def unit(x):return x/x.norm(dim=-1,keepdim=True).clamp_min(1e-20)
def log(*x):print(time.strftime('%H:%M:%S'),*x,flush=True)
def records():return [json.loads(l) for l in (C/'pairs.jsonl').open()]
def capture(m):
 out=[]
 for pair in records():
  row={'instance':pair['instance'],'split':pair['split']}
  for side in ['pos','neg']:
   r=pair[side];ids=r['ids'];s=r['start'];ce=s+r['comp'].index(101)
   thought=r['thought_pos']
   syntax=[i for i in range(ce,len(ids)-1) if ids[i] in [101,48,49,52,236787]][:12]
[... 208 lines cut ...]
# Freeze only tool sources, with byte hashes, under author-owned code.
dst=C/'tools';dst.mkdir(exist_ok=True)
for f in T.glob('*.py'):shutil.copy2(f,dst/f.name)
(dst/'data').mkdir(exist_ok=True)
shutil.copy2(T/'data/fro_norms.json',dst/'data/fro_norms.json')
(C/'tools_sha256.json').write_text(json.dumps({f.name:hashlib.sha256(f.read_bytes()).hexdigest() for f in dst.glob('*.py')},indent=2))

**Preparing for stage 1 inspection**

 succeeded in 109ms:
## C. Ranked edit ideas for raising a Gemma 4 31B coding agent's held-out solve rate (no training)

Ranking is by my estimate of expected held-out gain times probability of a clean confirmation. That estimate is mine, not a sourced figure. "Bake" means compile into your rank-32 LoRA-shaped adapter or a gated quiet-neuron write.

| # | Idea | Motivating source | Data needed | Risk |
|---|---|---|---|---|
| 1 | **Bake TACT's overthinking and overacting axes with a band gate.** Fit OT-vs-CAL and OA-vs-CAL (orthogonalised) at `<channel\|>` (end of thought) on judge-labelled steps. Implement TACT-Gate's "subtract excess beyond calibrated band" as a one-sided gated neuron per top-AUC layer (a GeGLU gate gives a soft threshold). Verify hook-vs-baked equivalence first | TACT (+4.8 avg on Gemma-4-26B-A4B; random and shuffled controls ≤0) | Your failure traces, chunk-labelled by a frontier judge (TACT spent ~$600 for 2k trajectories); activations at end-of-thought | Medium. Only TACT's own evidence; ~3.2% harmful flips; a soft gate is an approximation of the hook |
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
| 4 | **Spectrally filtered donor delta.** Take community gemma-4-31B-it agentic-coding LoRAs. Keep each matrix's dominant singular directions, Frobenius-match magnitude, and DARE/TIES-merge several. Treat the dose α as a hyperparameter | Selective-RL (controls beat magnitude-only and random low-rank); fine-tuning transfer; DARE/TIES | Donor LoRAs (verify licence, data, contamination); none are RL-trained | Medium–high. Unknown donor quality. Note: this imports someone else's training, so it is "training-free for us" and may need to be reported separately from "LLM-authored" |
| 5 | **Head-level cognitive edits (CREST/ThinkEdit style).** Find heads whose outputs separate productive from unproductive verification and backtracking (or premature "submit"); remove or add the component in those heads' o_proj | CREST (up to +17.5%); ThinkEdit (0.2% of params, +3.34%) | Per-head activations at labelled step types | Medium. Shown on math reasoning, not agents |
| 6 | **Verification / tool-use direction.** One residual direction raising the rate of "run tests / inspect output" actions, dosed in the agent loop | Tool-call rates (0→90%; QA 0.29→0.56); TACT's overacting axis as the counterweight | Contrast of states before tool-call vs no-tool turns | Medium. Too much dose means more steps or timeouts. Pair with idea 1's OA axis |
| 7 | **RYS middle-block duplication.** Materialise a 61–68-layer checkpoint that repeats a contiguous mid block; search (i, j) on dev agent tasks or a proxy (teacher-forced NLL on successful trajectories, plus LCB) | RYS on Qwen3.5-27B | Proxy sweep (cheap), then agent evals | Medium–high. Weak evidence; adds KV cache; counts as an architecture edit for framing |
| 8 | **Agency-axis nudge at prefill**, so the agent acts rather than defers or stalls (relevant if traces show hedging or asking for confirmation) | Agency axis (d=1.01; decode-only had no effect) | Contrast "acts" vs "asks or stalls" turns | Medium. Risk of reckless actions; side-effect check needed |
| 9 | **Behaviour-basis composition with black-box coefficient search.** Build a basis (persistence, verification, brevity, tool-use, format) and let TPE or CMA-ES search coefficients on dev, constrained by KL on held-out chat | Steer2Adapt (+8.2%); Heretic's TPE + KL; Evo-L2S | Basis vectors; dev split; KL reference set | High overfitting risk. Requires strict dev/test isolation |
| 10 | **Projection ablation of a "give-up / premature-finish" direction** (Arditi-style orthogonalisation of writer matrices), searched Heretic-style | Arditi et al.; Heretic | Contrast of states before early-submit failures vs successful continuations | Medium. Ablation is global, so may over-suppress legitimate finishing |
| 11 | **ExPO extrapolation of the Gemma 4 31B instruction-tuning delta** (IT + α·(I
[... 1920 characters cut ...]

 succeeded in 431ms:
PARTITION 18 {'base': 12, 'aa': 9, 'e0047': 11, 'e0048': 14}
PARTITION 102 {'base': 56, 'aa': 55, 'e0047': 53, 'e0048': 55}
gain django-money__django-money.835c1ab8.lm_rewrite__v5cndhkm fit False
TRACE base /home/keith/gemma-v2/results/wsp31/batches/b010/base/rebench/shard0_gpu0/traces/trace_django-money__django-money.835c1ab8.lm_rewrite__v5cndhkm.json module>\\n  File \\\"<stdin>\\\", line 27, in test_get_or_create_with_default_money\\nAssertionError: Expected USD, got USD\\n\", \"exit_code\": 0}",
        "extra": {
          "tool_name": "run_command",
          "elapsed_s": 863.3930084705353,
          "timestamp": 1794670529.91105,
          "author": "swe_developer_agent"
        }
      },
      "metrics": {
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
      },
      "llm_call_count": 1,
      "extra": {
[... 2605 lines cut ...]
+for k in ['0047','0048','0049','0050']:
+ p=next((R/'tii-wsp31-doc/research/wsp31/ledger').glob(k+'-*.md'));s=p.read_text();print('LEDGER',k,s[:s.find('## Result')])
+report=(R/'wsp31/interp/REPORT.md').read_text().splitlines()
+for j,l in enumerate(report):
+ if 'flips.py' in l or 'count_flips' in l or 'replay.py' in l:print('REPORT COMMAND','\n'.join(report[max(0,j-3):j+6]))
+print('SIZES')
+for p in [A/'scratch',A/'code/turn10']:
+ print(str(p),sum(f.stat().st_size for f in p.rglob('*') if f.is_file())/1e9)

 exited 1 in 376ms:
base raw 120 unique 120 current list 120 overlap 104 solved 80
aa raw 120 unique 120 current list 120 overlap 104 solved 75
e0047 raw 120 unique 120 current list 120 overlap 104 solved 75
e0048 raw 120 unique 120 current list 120 overlap 104 solved 81
PARKED RECORD title: Damp the code-versus-prose style contrast in readers in all layers at 0.33 percent

## Hypothesis

[line removed by the dashboard scrubber]

[line removed by the dashboard scrubber]

## Exact recipe

base: champion generation 0

Code: code/turn4/build_fidelity.py. Inputs: code/turn4/fidelity_calls.jsonl and fidelity_directions.pt; captured by fidelity_worker.py with the frozen g31 library in code/turn4/tools. No optimizer, trained-adapter direction, agent rollout or new server.

Per task, sample at most 32 interior code-argument positions and 32 preceding thought positions, evenly spaced. Capture raw writer directions (post-attention output divided by its norm weight; raw MLP output), and normalized reader inputs (attention input norm of resid_pre; mlp_in). Normalize each position to unit length before averaging. For each layer and space, subtract thought mean from code mean and remove its projection on the normalized grand mean of the two classes. Take the top four right singular vectors of the six task differences; weight each projector by squared singular value divided by the leading squared singular value. SVD signs are fixed by the largest absolute coordinate.
[... 712 lines cut ...]
+report=(R/'wsp31/interp/REPORT.md').read_text().splitlines()
+for j,l in enumerate(report):
+ if 'flips.py' in l or 'count_flips' in l or 'replay.py' in l:print('REPORT COMMAND','\n'.join(report[max(0,j-3):j+6]))
+print('SIZES')
+for p in [A/'scratch',A/'code/turn10']:
+ print(str(p),sum(f.stat().st_size for f in p.rglob('*') if f.is_file())/1e9)

**Checking time requirement**

 exited 1 in 157ms:
2026-11-14T14:24:39.9240733-05:00
"""CPU use of the documented g31 forward pass; no gradients or rollouts."""
import os,sys,json,time,hashlib
from pathlib import Path
os.environ['CUDA_VISIBLE_DEVICES']=''
R=Path('/home/keith/gemma-v2'); A=R/'wsp31/authors/gpt'; C=A/'code/turn4'; S=A/'scratch/turn4'
sys.path.insert(0,str(C/'tools'))
import torch,g31
torch.set_num_threads(16);torch.set_grad_enabled(False)
def spread(xs,n):return xs if len(xs)<=n else [xs[round(i*(len(xs)-1)/(n-1))] for i in range(n)]
def atom(path,x):
    p=Path(path);tmp=p.with_suffix(p.suffix+'.tmp');torch.save(x,tmp);tmp.replace(p)
recs=[json.loads(x) for x in (C/'fidelity_calls.jsonl').open()]
m=g31.G31(device='cpu',cache_dense=True);t0=time.time()
for ri,r in enumerate(recs):
    outf=S/f'capture_{ri}.pt'
    if outf.exists():continue
    cp=spread(r['fidelity']['code'],32);tp=spread(r['fidelity']['thought'],32)
    dp=[p['pos'] for p in r['points']]
[... 147 lines cut ...]
## Failures and how to do differently

- symptom: `COMPLETE`, valid evidence, or nonzero partial fitness looks like a solve -> cause: those establish harness execution, not exact ARC correctness -> fix: require exact held-out scoring before claiming task success. [Task 2]
- symptom: failed generation calls or late evolution waste the bounded task window -> evidence: `AssertionError('Empty final answer')`, `AssertionError('Incomplete final answer: length')`, and repeated `Evolution request budget exhausted` -> fix: constrain mutation attempts and stop evolution once useful request budget is exhausted. [Task 2]
- symptom: warmup looks healthy but scoring is slow -> cause: warmup did not predict long-prompt latency; first scoring TTFT was about 99.98 seconds despite a 48.43-second warmup -> fix: budget using real scoring-request latency. [Task 2]

[line removed by the dashboard scrubber]
**Optimizing rotation and task fitting strategy**

 succeeded in 392ms:
2026-11-14T19:25:56.733968Z ERROR codex_core::tools::router: error=apply_patch verification failed: Failed to find expected lines in C:\Users\Owner\.codex\memories\MEMORY.md:
- when the assistant stopped after the handoff audit, the user said “Well keep working why did you stop?” -> after a takeover reconstruction, continue into the next authorized bounded experiment rather than ending with a status report. [Task 1]
[line removed by the dashboard scrubber]
- for the Darwinian run, preserve the intentionally bounded one-task, 360-second, no-submission scope and distinguish harness completion from solve accuracy. [Task 2]

## Reusable knowledge

[line removed by the dashboard scrubber]
- When the visible thread is stale, read the full session JSONL; the app thread reader omitted the newest prior turn. Use explicit one-command second-hop SSH calls and verify hostname/GPU state before launch to avoid nested-host confusion. [Task 1]
- `C:/Python314/python.exe darwinian-smoke/validate_output.py --version 2` passed. The task finished within the budget: answer saved at `329.5542` seconds, task checks at `331.0993`; 10 programs generated, 9 valid, 19 completed calls, 4 failed calls, and zero post-run GPU processes. [Task 2]
- Exact held-out scoring for `0934a4d8` was `pass_at_2=0.0`; the best partial fitness was `correctness=0.43110714285714286`, and the saved crop/rotation program matched 0/4 training outputs. [Task 2]

## Failures and how to do differently

- symptom: `COMPLETE`, valid evidence, or nonzero partial fitness looks like a solve -> cause: those establish harness execution, not exact ARC correctness -> fix: require exact held-out scoring before claiming task success. [Task 2]
- symptom: failed generation calls or late evolution waste the bounded task window -> evidence: `AssertionError('Empty final answer')`, `AssertionError('Incomplete final answer: length')`, and repeated `Evolution request budget exhausted` -> fix: constrain mutation attempts and stop evolution once useful request budget is exhausted. [Task 2]
- symptom: warmup looks healthy but scoring is slow -> cause: warmup did not predict long-prompt latency; first scoring TTFT was about 99.98 seconds despite a 48.43-second warmup -> fix: budget using real scoring-request latency. [Task 2]

 succeeded in 2573ms:
12:tensor for one direction set per layer (layers missing from a dict are skipped). The directions are orthonormalised;
14:entries of data/fro_norms.json, the same yardstick as train_size.py.
17:passes through an RMS norm before it reaches the residual stream, so multiplying a whole writer by a constant does
19:an RMS norm with a learned weight per coordinate, and those weights span 1e-6 to 1e3. space="module" (default) takes
20:D in the module's own space (reader input after the norm, writer output before the norm) and is the plain orthogonal
21:projector. space="stream" takes D in the residual stream and converts through the norm weight w with an oblique
33:NORM_IN = {"q_proj": "input_layernorm", "k_proj": "input_layernorm", "v_proj": "input_layernorm",
34:           "gate_proj": "pre_feedforward_layernorm", "up_proj": "pre_feedforward_layernorm"}
35:NORM_OUT = {"o_proj": "post_attention_layernorm", "down_proj": "post_feedforward_layernorm"}
39:def fro_norms():
40:    """{"layer.mod": |W|_F} for all 420 entries (global layers list v_proj with the k_proj norm)."""
43:        p = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data", "fro_norms.json")
48:def net_norm():
49:    return sum(v * v for v in fro_norms().values()) ** 0.5
52:def orthonormal(D):
53:    """Rows of D [k, n] -> orthonormal rows spanning the same space (float64). Fails on dependent rows."""
78:        return orthonormal(torch.as_tensor(D, dtype=torch.float64).reshape(-1, self.arch.d))
82:        """Random directions of the same shape as D (tensor, or dict {layer: tensor}), orthonormal, and with
87:        S = orthonormal(D.reshape(-1, D.shape[-1]))
[... 288 lines cut ...]
+for k in ['0047','0048','0049','0050']:
+ p=next((R/'tii-wsp31-doc/research/wsp31/ledger').glob(k+'-*.md'));s=p.read_text();print('LEDGER',k,s[:s.find('## Result')])
+report=(R/'wsp31/interp/REPORT.md').read_text().splitlines()
+for j,l in enumerate(report):
+ if 'flips.py' in l or 'count_flips' in l or 'replay.py' in l:print('REPORT COMMAND','\n'.join(report[max(0,j-3):j+6]))
+print('SIZES')
+for p in [A/'scratch',A/'code/turn10']:
+ print(str(p),sum(f.stat().st_size for f in p.rglob('*') if f.is_file())/1e9)

 succeeded in 5121ms:
CURRENT {'negative_retained': 0.10651787205270753, 'contrast_retained': 0.7017286356879866, 'null_error': 1.1513821204295686e-14}
none fit_LOO_cos 0.02707640642956317 n 680
means fit_LOO_cos 0.018834548102492025 n 680
syntax_means fit_LOO_cos 0.024356141927590294 n 680
syntax_all fit_LOO_cos 0.008903073989371324 n 680

diff --git a/turn13/diagnose_basis.py b/turn13/diagnose_basis.py
new file mode 100644
index 0000000000000000000000000000000000000000..964dfcf91528ab716852a6343f41391606dd9330
--- /dev/null
+++ b/turn13/diagnose_basis.py
@@ -0,0 +1,23 @@
+import json,sys,torch
+from pathlib import Path
+C=Path(__file__).resolve().parent;sys.path.insert(0,str(C));import rotation as rot
+rows=torch.load(C.parent/'turn10/capture_stats.pt',weights_only=False);sel=json.loads((C/'selection.json').read_text());tr=[r for r in rows if r['instance'] in sel['fit']]
+d=json.loads((C/'fit_diagnostics.json').read_text());print('CURRENT', {k:sum(x[k] for x in d)/len(d) for k in ['negative_retained','contrast_retained','null_error']})
+out=[]
+for mode in ['none','means','syntax_means','syntax_all']:
[... 135 lines cut ...]
+report=(R/'wsp31/interp/REPORT.md').read_text().splitlines()
+for j,l in enumerate(report):
+ if 'flips.py' in l or 'count_flips' in l or 'replay.py' in l:print('REPORT COMMAND','\n'.join(report[max(0,j-3):j+6]))
+print('SIZES')
+for p in [A/'scratch',A/'code/turn10']:
+ print(str(p),sum(f.stat().st_size for f in p.rglob('*') if f.is_file())/1e9)

**Assessing error-feedback recovery approach**

 succeeded in 319ms:
CAPTURE_DONE
FIT_DONE
STOP_GUARD
STOP_WORKER
capture_0.pt
capture_1.pt
capture_2.pt
capture_3.pt
capture_4.pt
capture_5.pt
capture_6.pt
capture_7.pt
capture_8.pt
code-joint-damp-r4-047-ctrl.json
code-joint-damp-r4-047-edit-p6.json
code-joint-damp-r4-047-edit-p7.json
code-joint-damp-r4-047-edit.json
code-reader-damp-r4-033-ctrl.json
code-reader-damp-r4-033-edit-p6.json
[... 289 lines cut ...]
+ print(str(p),sum(f.stat().st_size for f in p.rglob('*') if f.is_file())/1e9)

**Planning training strategy**

I’m thinking through a simple approach to perform rounds of training with multiple doses and ensuring that each entry finishes before starting the next. GPU resources are locked and unavailable, so I’ll rely on CPU workers with enough memory and time management to avoid pointless waits. I’ll set up scripts to queue and handle task timeouts properly.
**Designing dose and rotation experiments**

I’m choosing training doses starting with 1, falling back to 0.33 if needed, and planning rotation experiments with complementary reads. Each step waits for the previous to finish, balancing numeric tolerance limits while managing logs and edits carefully for precise control.

diff --git a/turn13/diagnose_basis.py b/turn13/diagnose_basis.py
new file mode 100644
index 0000000000000000000000000000000000000000..964dfcf91528ab716852a6343f41391606dd9330
--- /dev/null
+++ b/turn13/diagnose_basis.py
@@ -0,0 +1,23 @@
+import json,sys,torch
+from pathlib import Path
+C=Path(__file__).resolve().parent;sys.path.insert(0,str(C));import rotation as rot
+rows=torch.load(C.parent/'turn10/capture_stats.pt',weights_only=False);sel=json.loads((C/'selection.json').read_text());tr=[r for r in rows if r['instance'] in sel['fit']]
+d=json.loads((C/'fit_diagnostics.json').read_text());print('CURRENT', {k:sum(x[k] for x in d)/len(d) for k in ['negative_retained','contrast_retained','null_error']})
+out=[]
+for mode in ['none','means','syntax_means','syntax_all']:
+ scores=[]
+ for mod in ['o_proj','down_proj']:
+  for l in range(0,60,3):
+   P=torch.stack([r['pos'][mod]['thought'][l] for r in tr]).double();N=torch.stack([r['neg'][mod]['thought'][l] for r in tr]).double()
+   for i in range(len(tr)):
+    jj=[j for j in range(len(tr)) if i!=j];p=P[jj].mean(0);n=N[jj].mean(0)
+    if mode=='none':h=torch.zeros((0,len(p)),dtype=torch.float64)
[... 378 lines cut ...]
+for k in ['0047','0048','0049','0050']:
+ p=next((R/'tii-wsp31-doc/research/wsp31/ledger').glob(k+'-*.md'));s=p.read_text();print('LEDGER',k,s[:s.find('## Result')])
+report=(R/'wsp31/interp/REPORT.md').read_text().splitlines()
+for j,l in enumerate(report):
+ if 'flips.py' in l or 'count_flips' in l or 'replay.py' in l:print('REPORT COMMAND','\n'.join(report[max(0,j-3):j+6]))
+print('SIZES')
+for p in [A/'scratch',A/'code/turn10']:
+ print(str(p),sum(f.stat().st_size for f in p.rglob('*') if f.is_file())/1e9)

 succeeded in 4572ms:
[line removed by the dashboard scrubber]
LIVE_BOUNDARY 120 273 fit 17 selected 8

diff --git a/turn13/diagnose_basis.py b/turn13/diagnose_basis.py
new file mode 100644
index 0000000000000000000000000000000000000000..964dfcf91528ab716852a6343f41391606dd9330
--- /dev/null
+++ b/turn13/diagnose_basis.py
@@ -0,0 +1,23 @@
+import json,sys,torch
+from pathlib import Path
+C=Path(__file__).resolve().parent;sys.path.insert(0,str(C));import rotation as rot
+rows=torch.load(C.parent/'turn10/capture_stats.pt',weights_only=False);sel=json.loads((C/'selection.json').read_text());tr=[r for r in rows if r['instance'] in sel['fit']]
+d=json.loads((C/'fit_diagnostics.json').read_text());print('CURRENT', {k:sum(x[k] for x in d)/len(d) for k in ['negative_retained','contrast_retained','null_error']})
+out=[]
+for mode in ['none','means','syntax_means','syntax_all']:
+ scores=[]
+ for mod in ['o_proj','down_proj']:
+  for l in range(0,60,3):
[... 462 lines cut ...]
+for k in ['0047','0048','0049','0050']:
+ p=next((R/'tii-wsp31-doc/research/wsp31/ledger').glob(k+'-*.md'));s=p.read_text();print('LEDGER',k,s[:s.find('## Result')])
+report=(R/'wsp31/interp/REPORT.md').read_text().splitlines()
+for j,l in enumerate(report):
+ if 'flips.py' in l or 'count_flips' in l or 'replay.py' in l:print('REPORT COMMAND','\n'.join(report[max(0,j-3):j+6]))
+print('SIZES')
+for p in [A/'scratch',A/'code/turn10']:
+ print(str(p),sum(f.stat().st_size for f in p.rglob('*') if f.is_file())/1e9)

 succeeded in 4012ms:
OK edit: 120 modules changed (of 120 present), r=2, max |dW|_F/|W|_F 0.008452 at 24.o_proj
OK ctrl: 120 modules changed (of 120 present), r=2, max |dW|_F/|W|_F 0.008451 at 13.o_proj
edit {"r": 2, "scale": 2.0, "changed": 120, "of": 420, "net_rel": 0.0033, "rel_median": 0.00845, "rel_min": 0.008449, "rel_max": 0.008452, "rel_max_mod": "24.o_proj", "total_rel": 0.00845, "total_fro": 6.806, "stable_rank_median": 1.794, "part_rank_median": 1.993}
  by type {'down_proj': 0.00845, 'o_proj': 0.00845}
  by depth (10-layer bands) [0.00845, 0.00845, 0.00845, 0.00845, 0.00845, 0.00845]
ctrl {"r": 2, "scale": 2.0, "changed": 120, "of": 420, "net_rel": 0.0033, "rel_median": 0.00845, "rel_min": 0.008449, "rel_max": 0.008451, "rel_max_mod": "13.o_proj", "total_rel": 0.00845, "total_fro": 6.806, "stable_rank_median": 1.794, "part_rank_median": 1.993}
  by type {'down_proj': 0.00845, 'o_proj': 0.00845}
  by depth (10-layer bands) [0.00845, 0.00845, 0.00845, 0.00845, 0.00845, 0.00845]

diff --git a/turn13/cpu.sh b/turn13/cpu.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b52dc6655d8b4cfef8f40488e07731ee3eb32fd9
--- /dev/null
+++ b/turn13/cpu.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+A=/home/keith/gemma-v2/wsp31/authors/gpt
+export CUDA_VISIBLE_DEVICES=''
[... 513 lines cut ...]
+for k in ['0047','0048','0049','0050']:
+ p=next((R/'tii-wsp31-doc/research/wsp31/ledger').glob(k+'-*.md'));s=p.read_text();print('LEDGER',k,s[:s.find('## Result')])
+report=(R/'wsp31/interp/REPORT.md').read_text().splitlines()
+for j,l in enumerate(report):
+ if 'flips.py' in l or 'count_flips' in l or 'replay.py' in l:print('REPORT COMMAND','\n'.join(report[max(0,j-3):j+6]))
+print('SIZES')
+for p in [A/'scratch',A/'code/turn10']:
+ print(str(p),sum(f.stat().st_size for f in p.rglob('*') if f.is_file())/1e9)

 succeeded in 314ms:
PARTITION {'fit': {'n': 18, 'scores': {'base': 12, 'aa': 9, 'e0047': 11, 'e0048': 14}, 'e0048_gain': 3.5}, 'nonfit': {'n': 86, 'scores': {'base': 56, 'aa': 55, 'e0047': 53, 'e0048': 55}, 'e0048_gain': -0.5}, 'all_eligible': {'n': 104, 'scores': {'base': 68, 'aa': 64, 'e0047': 64, 'e0048': 69}, 'e0048_gain': 3.0}}
TRACE [task] base resolved True steps 48
The line `import qiskit._accelerate` is on line 17.
Then on line 23, it does `sys.modules["qiskit._accelerate.nlayout"] = qiskit._accelerate.nlayout`.

If `qiskit._accelerate` is not installed, `import qiskit._accelerate` will fail.
But in my case, I'm mocking it.

Wait, if I do:
```python
import sys
from unittest.mock import MagicMock
mock_acc = MagicMock()
sys.modules['qiskit._accelerate'] = mock_acc
```
Then when `qiskit/__init__.py` does `import qiskit._accelerate`, it will get the `mock_acc`.
Then it does `qiskit._accelerate.nlayout`.
Since `qiskit` is the module being initialized, `qiskit._accelerate` should be available as an attribute of `qiskit` AFTER `import qiskit._accelerate` runs.

[... 660 lines cut ...]
+for k in ['0047','0048','0049','0050']:
+ p=next((R/'tii-wsp31-doc/research/wsp31/ledger').glob(k+'-*.md'));s=p.read_text();print('LEDGER',k,s[:s.find('## Result')])
+report=(R/'wsp31/interp/REPORT.md').read_text().splitlines()
+for j,l in enumerate(report):
+ if 'flips.py' in l or 'count_flips' in l or 'replay.py' in l:print('REPORT COMMAND','\n'.join(report[max(0,j-3):j+6]))
+print('SIZES')
+for p in [A/'scratch',A/'code/turn10']:
+ print(str(p),sum(f.stat().st_size for f in p.rglob('*') if f.is_file())/1e9)

 succeeded in 334ms:
2026-11-14T19:30:36Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 302 lines cut ...]
+report=(R/'wsp31/interp/REPORT.md').read_text().splitlines()
+for j,l in enumerate(report):
+ if 'flips.py' in l or 'count_flips' in l or 'replay.py' in l:print('REPORT COMMAND','\n'.join(report[max(0,j-3):j+6]))
+print('SIZES')
+for p in [A/'scratch',A/'code/turn10']:
+ print(str(p),sum(f.stat().st_size for f in p.rglob('*') if f.is_file())/1e9)

**Reviewing CPU model loading**

 succeeded in 291ms:
    PID     ELAPSED     TIME   RSS STAT
2502167       02:13 00:00:00  8036 S
2502168
BASE 0 4274 127.5
            h = tap("resid_mid", l, h)
            x = tap("mlp_in", l, self.rms(h, wt("pre_feedforward_layernorm")))
            gate = tap("gate", l, self.lin(l, "gate_proj", x))
            up = tap("up", l, self.lin(l, "up_proj", x))
            act = self._r(gelu_tanh(gate.float())) * up
            del gate, up, x
            act = tap("mlp_act", l, act)
            y = tap("mlp_raw", l, self.lin(l, "down_proj", act))
            del act
            y = tap("mlp_out", l, self.rms(y, wt("post_feedforward_layernorm")))
            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:
[... 360 lines cut ...]
+print('SIZES')
+for p in [A/'scratch',A/'code/turn10']:
+ print(str(p),sum(f.stat().st_size for f in p.rglob('*') if f.is_file())/1e9)

**Managing test execution and optimization**
**Optimizing build process and environment tracking**

I’m thinking through how to reuse cached baselines and manage calls count without interrupting running processes. I want to ensure reproducibility by hashing environment versions and source files and plan to add safeguards in the build system to keep outputs contained within authorized paths while preserving metadata for auditing.

 succeeded in 352ms:
{
 "modules": {
  "0.down_proj": {
   "rank": 2,
   "fro": 0.6339876807248452,
   "rel_fro": 0.008450502301279932
  },
  "0.o_proj": {
   "rank": 2,
   "fro": 0.6170449573051224,
   "rel_fro": 0.00845050229957423
  },
  "1.down_proj": {
   "rank": 2,
   "fro": 0.6087646099457497,
   "rel_fro": 0.008450502297192677
  },
  "1.o_proj": {
   "rank": 2,
[... 743 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
+for name,subset in [('fit',common&fit),('nonfit',common-fit),('all_eligible',common)]:
+ scores={a:sum(bool(v[i]['resolved']) for i in subset) for a,v in arms.items()}
+ out[name]={'n':len(subset),'scores':scores,'e0048_gain':scores['e0048']-(scores['base']+scores['aa'])/2}
[... 345 lines cut ...]
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Analyzing model norm and rotation behavior**
**Examining angle alignment and rotation overshoot**

 succeeded in 319ms:
BASE 0 4274 127.5
2026-11-14T19:32:28Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 725 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 283ms:
BASE 0 4274 127.5
ARM 0 edit 108.5 {"all": {"n": 100, "flips": 1, "dlogp": -0.007340584545525175, "kl": 0.005293620315449618, "dclose": 0.4621321571158478, "base_top_logged": 100, "top_logged": 99}, "thought": {"n": 32, "flips": 0, "dlogp": -0.010921124211407562, "kl": 0.008643491400014185, "dclose": 0.8128703609108925, "base_top_logged": 32, "top_logged": 32}, "action": {"n": 59, "flips": 1, "dlogp": -0.005282460344672639, "kl": 0.0024668491955563638, "dclose": 0.3152950092897577, "base_top_logged": 59, "top_logged": 58}, "syntax": {"n": 7, "flips": 0, "dlogp": -0.010386163746586265, "kl": 0.015313011395526084, "dclose": 0.3668459483555385, "base_top_logged": 7, "top_logged": 7}, "close": {"n": 1, "flips": 0, "dlogp": -1.4659890439361334e-05, "kl": 1.0120653314515948e-05, "dclose": -1.4659890439361334e-05, "base_top_logged": 1, "top_logged": 1}, "think": {"n": 1, "flips": 0, "dlogp": -0.00019951333524659276, "kl": 2.5003784685395658e-05, "dclose": -0.9689483642578125, "base_top_logged": 1, "top_logged": 1}}
    PID     ELAPSED     TIME   RSS STAT
2502168       04:57 01:02:19 78310412 Rl

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
[... 351 lines cut ...]
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Optimizing rotation and dose parameters**
**Managing sequential task execution**

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
+for name,subset in [('fit',common&fit),('nonfit',common-fit),('all_eligible',common)]:
+ scores={a:sum(bool(v[i]['resolved']) for i in subset) for a,v in arms.items()}
+ out[name]={'n':len(subset),'scores':scores,'e0048_gain':scores['e0048']-(scores['base']+scores['aa'])/2}
[... 401 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Coordinating task timing and strategies**

 succeeded in 418ms:
ARM 0 edit 108.5 {"all": {"n": 100, "flips": 1, "dlogp": -0.007340584545525175, "kl": 0.005293620315449618, "dclose": 0.4621321571158478, "base_top_logged": 100, "top_logged": 99}, "thought": {"n": 32, "flips": 0, "dlogp": -0.010921124211407562, "kl": 0.008643491400014185, "dclose": 0.8128703609108925, "base_top_logged": 32, "top_logged": 32}, "action": {"n": 59, "flips": 1, "dlogp": -0.005282460344672639, "kl": 0.0024668491955563638, "dclose": 0.3152950092897577, "base_top_logged": 59, "top_logged": 58}, "syntax": {"n": 7, "flips": 0, "dlogp": -0.010386163746586265, "kl": 0.015313011395526084, "dclose": 0.3668459483555385, "base_top_logged": 7, "top_logged": 7}, "close": {"n": 1, "flips": 0, "dlogp": -1.4659890439361334e-05, "kl": 1.0120653314515948e-05, "dclose": -1.4659890439361334e-05, "base_top_logged": 1, "top_logged": 1}, "think": {"n": 1, "flips": 0, "dlogp": -0.00019951333524659276, "kl": 2.5003784685395658e-05, "dclose": -0.9689483642578125, "base_top_logged": 1, "top_logged": 1}}
ARM 0 ctrl 135.1 {"all": {"n": 100, "flips": 1, "dlogp": -0.002020346350227129, "kl": 0.0033075774012214488, "dclose": 0.018663277691957775, "base_top_logged": 100, "top_logged": 99}, "thought": {"n": 32, "flips": 1, "dlogp": -0.0035035845075792604, "kl": 0.007416361859540005, "dclose": -0.22475601732730865, "base_top_logged": 32, "top_logged": 31}, "action": {"n": 59, "flips": 0, "dlogp": 0.00019527668418624567, "kl": 0.0011193065591329995, "dclose": 0.1508838685892396, "base_top_logged": 59, "top_logged": 59}, "syntax": {"n": 7, "flips": 0, "dlogp": -0.014565399020869205, "kl": 0.0038386396790604594, "dclose": -0.08710997445242745, "base_top_logged": 7, "top_logged": 7}, "close": {"n": 1, "flips": 0, "dlogp": -3.241833474021405e-05, "kl": 1.0682764695957303e-05, "dclose": -3.241833474021405e-05, "base_top_logged": 1, "top_logged": 1}, "think": {"n": 1, "flips": 0, "dlogp": 0.0005489563336595893, "kl": 0.0005139131098985672, "dclose": 0.76617431640625, "base_top_logged": 1, "top_logged": 1}}
2026-11-14T19:35:00Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
[... 406 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Analyzing CPU and memory workload**

 succeeded in 339ms:
ARM 0 ctrl 135.1 {"all": {"n": 100, "flips": 1, "dlogp": -0.002020346350227129, "kl": 0.0033075774012214488, "dclose": 0.018663277691957775, "base_top_logged": 100, "top_logged": 99}, "thought": {"n": 32, "flips": 1, "dlogp": -0.0035035845075792604, "kl": 0.007416361859540005, "dclose": -0.22475601732730865, "base_top_logged": 32, "top_logged": 31}, "action": {"n": 59, "flips": 0, "dlogp": 0.00019527668418624567, "kl": 0.0011193065591329995, "dclose": 0.1508838685892396, "base_top_logged": 59, "top_logged": 59}, "syntax": {"n": 7, "flips": 0, "dlogp": -0.014565399020869205, "kl": 0.0038386396790604594, "dclose": -0.08710997445242745, "base_top_logged": 7, "top_logged": 7}, "close": {"n": 1, "flips": 0, "dlogp": -3.241833474021405e-05, "kl": 1.0682764695957303e-05, "dclose": -3.241833474021405e-05, "base_top_logged": 1, "top_logged": 1}, "think": {"n": 1, "flips": 0, "dlogp": 0.0005489563336595893, "kl": 0.0005139131098985672, "dclose": 0.76617431640625, "base_top_logged": 1, "top_logged": 1}}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 405 lines cut ...]
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Reviewing model and audit constraints**
**Implementing finalization checks**

 exited 1 in 405ms:
BASE 1 3318 120.3
cat: /home/keith/gemma-v2/wsp31/queue/champion.json: No such file or directory

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 972 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 exited 1 in 386ms:
BASE 1 3318 120.3
2026-11-14T19:38:02Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 476 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Summarizing task update considerations**

 succeeded in 340ms:
ARM 1 edit 104.9 {"all": {"n": 154, "flips": 1, "dlogp": -0.007142502133580573, "kl": 0.004837392131542546, "dclose": 0.44202161210554336, "base_top_logged": 154, "top_logged": 153}, "thought": {"n": 64, "flips": 0, "dlogp": -0.011823831979045685, "kl": 0.007448128786366869, "dclose": 0.7119215168058872, "base_top_logged": 64, "top_logged": 64}, "action": {"n": 76, "flips": 1, "dlogp": -0.0036085247712992776, "kl": 0.002099100460288249, "dclose": 0.2886407249852231, "base_top_logged": 76, "top_logged": 75}, "syntax": {"n": 10, "flips": 0, "dlogp": -0.007282435318802527, "kl": 0.010723335912193478, "dclose": 0.13802995681762695, "base_top_logged": 10, "top_logged": 10}, "close": {"n": 2, "flips": 0, "dlogp": 0.0020255355921108276, "kl": 0.000744056815165095, "dclose": 0.0020255355921108276, "base_top_logged": 2, "top_logged": 2}, "think": {"n": 2, "flips": 0, "dlogp": -9.945864496785362e-05, "kl": 1.2519097950303149e-05, "dclose": -0.40634727478027344, "base_top_logged": 2, "top_logged": 2}}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 990 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 1705ms:
{"python": "3.13.13 (main, Jun  2 2026, 22:27:49) [Clang 22.1.3 ]", "torch": "2.10.0+cu128", "platform": "Linux-7.0.0-43-generic-x86_64-with-glibc2.43", "threads_pretest": 16, "gpu_seconds_this_turn": 0, "cpu_backend": "g31 mirror=True cache_dense=True", "model_config_sha256": "b100d85e571c25b688e82919d819253063a1defb0e6cee3b9b1c1fbad99bd0c2", "model_files": {"model.safetensors": 23265352448}, "scratch_bytes": 4311920572}
ARM 1 edit 104.9 {"all": {"n": 154, "flips": 1, "dlogp": -0.007142502133580573, "kl": 0.004837392131542546, "dclose": 0.44202161210554336, "base_top_logged": 154, "top_logged": 153}, "thought": {"n": 64, "flips": 0, "dlogp": -0.011823831979045685, "kl": 0.007448128786366869, "dclose": 0.7119215168058872, "base_top_logged": 64, "top_logged": 64}, "action": {"n": 76, "flips": 1, "dlogp": -0.0036085247712992776, "kl": 0.002099100460288249, "dclose": 0.2886407249852231, "base_top_logged": 76, "top_logged": 75}, "syntax": {"n": 10, "flips": 0, "dlogp": -0.007282435318802527, "kl": 0.010723335912193478, "dclose": 0.13802995681762695, "base_top_logged": 10, "top_logged": 10}, "close": {"n": 2, "flips": 0, "dlogp": 0.0020255355921108276, "kl": 0.000744056815165095, "dclose": 0.0020255355921108276, "base_top_logged": 2, "top_logged": 2}, "think": {"n": 2, "flips": 0, "dlogp": -9.945864496785362e-05, "kl": 1.2519097950303149e-05, "dclose": -0.40634727478027344, "base_top_logged": 2, "top_logged": 2}}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 488 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Waiting for CPU processing**

 succeeded in 406ms:
ARM 1 ctrl 109.9 {"all": {"n": 154, "flips": 1, "dlogp": 0.0006244219864349624, "kl": 0.0032483187565515276, "dclose": 0.04569848307588685, "base_top_logged": 154, "top_logged": 153}, "thought": {"n": 64, "flips": 1, "dlogp": 0.0025256935794457647, "kl": 0.00615748392213826, "dclose": -0.07883423566818237, "base_top_logged": 64, "top_logged": 63}, "action": {"n": 76, "flips": 0, "dlogp": 0.0006078774185667157, "kl": 0.0009885458557457392, "dclose": 0.14678386638039037, "base_top_logged": 76, "top_logged": 76}, "syntax": {"n": 10, "flips": 0, "dlogp": -0.01019443247819254, "kl": 0.002687631086255138, "dclose": 0.04527435302734375, "base_top_logged": 10, "top_logged": 10}, "close": {"n": 2, "flips": 0, "dlogp": -0.0051440149181871675, "kl": 0.0018206553213531151, "dclose": -0.0051440149181871675, "base_top_logged": 2, "top_logged": 2}, "think": {"n": 2, "flips": 0, "dlogp": 0.000275133816842299, "kl": 0.00025750547507641386, "dclose": 0.2424640655517578, "base_top_logged": 2, "top_logged": 2}}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 1017 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 2175ms:
PANEL_COUNTS [100, 54, 53, 73, 56, 56, 42, 59]
rotation033 done False seconds 706.2940995693207
edit 2 {'n': 154, 'flips': 1, 'dlogp': -0.007142502133580573, 'kl': 0.004837392131542546, 'dclose': 0.44202161210554336, 'base_top_logged': 154, 'top_logged': 153} close {'n': 2, 'flips': 0, 'dlogp': 0.0020255355921108276, 'kl': 0.000744056815165095, 'dclose': 0.0020255355921108276, 'base_top_logged': 2, 'top_logged': 2} syntax {'n': 10, 'flips': 0, 'dlogp': -0.007282435318802527, 'kl': 0.010723335912193478, 'dclose': 0.13802995681762695, 'base_top_logged': 10, 'top_logged': 10}
ctrl 2 {'n': 154, 'flips': 1, 'dlogp': 0.0006244219864349624, 'kl': 0.0032483187565515276, 'dclose': 0.04569848307588685, 'base_top_logged': 154, 'top_logged': 153} close {'n': 2, 'flips': 0, 'dlogp': -0.0051440149181871675, 'kl': 0.0018206553213531151, 'dclose': -0.0051440149181871675, 'base_top_logged': 2, 'top_logged': 2} syntax {'n': 10, 'flips': 0, 'dlogp': -0.01019443247819254, 'kl': 0.002687631086255138, 'dclose': 0.04527435302734375, 'base_top_logged': 10, 'top_logged': 10}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
[... 1037 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 562ms:
diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
+for name,subset in [('fit',common&fit),('nonfit',common-fit),('all_eligible',common)]:
+ scores={a:sum(bool(v[i]['resolved']) for i in subset) for a,v in arms.items()}
[... 502 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Analyzing task readiness and validation**

 succeeded in 431ms:
ARM 1 ctrl 109.9 {"all": {"n": 154, "flips": 1, "dlogp": 0.0006244219864349624, "kl": 0.0032483187565515276, "dclose": 0.04569848307588685, "base_top_logged": 154, "top_logged": 153}, "thought": {"n": 64, "flips": 1, "dlogp": 0.0025256935794457647, "kl": 0.00615748392213826, "dclose": -0.07883423566818237, "base_top_logged": 64, "top_logged": 63}, "action": {"n": 76, "flips": 0, "dlogp": 0.0006078774185667157, "kl": 0.0009885458557457392, "dclose": 0.14678386638039037, "base_top_logged": 76, "top_logged": 76}, "syntax": {"n": 10, "flips": 0, "dlogp": -0.01019443247819254, "kl": 0.002687631086255138, "dclose": 0.04527435302734375, "base_top_logged": 10, "top_logged": 10}, "close": {"n": 2, "flips": 0, "dlogp": -0.0051440149181871675, "kl": 0.0018206553213531151, "dclose": -0.0051440149181871675, "base_top_logged": 2, "top_logged": 2}, "think": {"n": 2, "flips": 0, "dlogp": 0.000275133816842299, "kl": 0.00025750547507641386, "dclose": 0.2424640655517578, "base_top_logged": 2, "top_logged": 2}}
2026-11-14T19:42:32Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 507 lines cut ...]
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Assessing CPU and memory usage**
**Timing analysis of CPU calls**
**Managing computation and data retention**

 succeeded in 409ms:
BASE 2 3511 162.7
    PID     ELAPSED     TIME   RSS STAT
2502168       15:39 03:02:14 77291964 Rl

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
[... 508 lines cut ...]
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Analyzing CPU and model processing constraints**
**Examining module control and rotation effects**
**Managing task timing and sequencing**

 succeeded in 628ms:
ARM 2 edit 129.0 {"all": {"n": 207, "flips": 1, "dlogp": -0.008588384693270586, "kl": 0.004432475776580121, "dclose": 0.4596963754333758, "base_top_logged": 207, "top_logged": 206}, "thought": {"n": 82, "flips": 0, "dlogp": -0.016787292717005967, "kl": 0.007788788422777857, "dclose": 0.733681675864429, "base_top_logged": 82, "top_logged": 82}, "action": {"n": 106, "flips": 1, "dlogp": -0.003127304499716763, "kl": 0.0016030522114641554, "dclose": 0.30723534889940946, "base_top_logged": 106, "top_logged": 105}, "syntax": {"n": 13, "flips": 0, "dlogp": -0.005617713498780246, "kl": 0.008251695189082411, "dclose": 0.20577041919414812, "base_top_logged": 13, "top_logged": 13}, "close": {"n": 3, "flips": 0, "dlogp": 0.0011614701749446492, "kl": 0.0005402681175231313, "dclose": 0.0011614701749446492, "base_top_logged": 3, "top_logged": 3}, "think": {"n": 3, "flips": 0, "dlogp": -6.582892774531501e-05, "kl": 8.486286153204977e-06, "dclose": -0.08339818318684895, "base_top_logged": 3, "top_logged": 3}}
2026-11-14T19:45:55Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 508 lines cut ...]
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Evaluating training step adjustments**
**Reviewing GPU availability**
**Managing GPU resource locking and usage**
**Reviewing template usage for serving**

 succeeded in 90ms:
"""Greedy single-call continuations of logged stage-1 contexts. No tools execute."""
import argparse,json,sys,time,hashlib,os,statistics,collections
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor
C=Path(__file__).resolve().parent;A=C.parent.parent;S=A/'scratch/turn10';T=C/'tools'
sys.path.insert(0,str(T));import g31,dose,vclient
def panel():
 fit={json.loads(l)['instance'] for l in (C/'pairs.jsonl').open()}
 sets=A.parent.parent/'queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split())
 deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
 rs=[]
 for l in Path('/home/keith/gemma-v2/wsp31/tools/data/probe_calls_b001_full.jsonl').open():
  r=json.loads(l)
  if r['instance'] in fit or r['instance'] not in allow or r['instance'] in deny or r['call']<2:continue
  c=r['calls'][-1];comp=c['comp'];s=c['start']
  if 101 not in comp or 48 not in comp or 49 not in comp:continue
  ce=comp.index(101)
  if s+ce>5500 or len(comp)-ce>600 or len(comp)>1500:continue
  rs.append(dict(instance=r['instance'],run=r['run'],call=r['call'],prompt=r['ids'][:s],comp=comp,resolved=r['resolved']))
[... 1186 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 exited 1 in 3612ms:
PANEL 112 54

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 1189 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 846ms:
ARM 2 ctrl 112.2 {"all": {"n": 207, "flips": 2, "dlogp": 0.001928901138217393, "kl": 0.004121416045297609, "dclose": 0.01962965621804461, "base_top_logged": 207, "top_logged": 205}, "thought": {"n": 82, "flips": 2, "dlogp": 0.00522798794129122, "kl": 0.008985646165527274, "dclose": -0.173363860060529, "base_top_logged": 82, "top_logged": 80}, "action": {"n": 106, "flips": 0, "dlogp": 0.0007671681544112254, "kl": 0.0008010345512268781, "dclose": 0.17275264128199164, "base_top_logged": 106, "top_logged": 106}, "syntax": {"n": 13, "flips": 0, "dlogp": -0.007815310702566282, "kl": 0.002074191279287788, "dclose": 0.05228079282320463, "base_top_logged": 13, "top_logged": 13}, "close": {"n": 3, "flips": 0, "dlogp": -0.003228955431647288, "kl": 0.0013055885598684351, "dclose": -0.003228955431647288, "base_top_logged": 3, "top_logged": 3}, "think": {"n": 3, "flips": 0, "dlogp": 0.00018453516194464706, "kl": 0.0001730736876576581, "dclose": -0.2341893513997396, "base_top_logged": 3, "top_logged": 3}}
2026-11-14T19:47:55Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 585 lines cut ...]
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Estimating task timing and resource use**
**Diagnosing timing and record update issues**

 succeeded in 432ms:
ARM 2 ctrl 112.2 {"all": {"n": 207, "flips": 2, "dlogp": 0.001928901138217393, "kl": 0.004121416045297609, "dclose": 0.01962965621804461, "base_top_logged": 207, "top_logged": 205}, "thought": {"n": 82, "flips": 2, "dlogp": 0.00522798794129122, "kl": 0.008985646165527274, "dclose": -0.173363860060529, "base_top_logged": 82, "top_logged": 80}, "action": {"n": 106, "flips": 0, "dlogp": 0.0007671681544112254, "kl": 0.0008010345512268781, "dclose": 0.17275264128199164, "base_top_logged": 106, "top_logged": 106}, "syntax": {"n": 13, "flips": 0, "dlogp": -0.007815310702566282, "kl": 0.002074191279287788, "dclose": 0.05228079282320463, "base_top_logged": 13, "top_logged": 13}, "close": {"n": 3, "flips": 0, "dlogp": -0.003228955431647288, "kl": 0.0013055885598684351, "dclose": -0.003228955431647288, "base_top_logged": 3, "top_logged": 3}, "think": {"n": 3, "flips": 0, "dlogp": 0.00018453516194464706, "kl": 0.0001730736876576581, "dclose": -0.2341893513997396, "base_top_logged": 3, "top_logged": 3}}
2026-11-14T19:48:39Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 1219 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 338ms:
BASE 3 3422 117.0
2026-11-14T19:50:04Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 598 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Updating script notes and status**

 succeeded in 384ms:
diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
+for name,subset in [('fit',common&fit),('nonfit',common-fit),('all_eligible',common)]:
+ scores={a:sum(bool(v[i]['resolved']) for i in subset) for a,v in arms.items()}
[... 1215 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 360ms:
ARM 3 edit 149.2 {"all": {"n": 280, "flips": 3, "dlogp": -0.012765508108402608, "kl": 0.005906676855180606, "dclose": 0.5057695739414028, "base_top_logged": 280, "top_logged": 277}, "thought": {"n": 113, "flips": 2, "dlogp": -0.02218463081612219, "kl": 0.010535746400144812, "dclose": 0.8111202611332446, "base_top_logged": 113, "top_logged": 111}, "action": {"n": 143, "flips": 1, "dlogp": -0.002323144115776367, "kl": 0.0012712028728712628, "dclose": 0.3158928330961641, "base_top_logged": 143, "top_logged": 142}, "syntax": {"n": 16, "flips": 0, "dlogp": -0.00456594910450292, "kl": 0.0067075749469361345, "dclose": 0.2609369158744812, "base_top_logged": 16, "top_logged": 16}, "close": {"n": 4, "flips": 0, "dlogp": -0.16550343173730653, "kl": 0.04355022809977527, "dclose": -0.16550343173730653, "base_top_logged": 4, "top_logged": 4}, "think": {"n": 4, "flips": 0, "dlogp": -5.011673840726871e-05, "kl": 6.513465883983827e-06, "dclose": 0.3183097839355469, "base_top_logged": 4, "top_logged": 4}}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 602 lines cut ...]
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Analyzing closeguard failure dynamics**
[line removed by the dashboard scrubber]
**Analyzing CPU capture and projection process**
**Considering fallback and parking strategy**
**Analyzing candidate fail and resubmission constraints**
**Analyzing test execution timing**

 succeeded in 4236ms:
RESUBMITTED /home/keith/gemma-v2/wsp31/authors/gpt/queue/code-reader-damp-r4-033 {"action": "resubmit frozen entry 0027 unchanged", "at": "2026-11-14T19:54:11.165162+00:00", "files": {"edit/adapter_config.json": "f9e50ffef2bab461589d133f9f10bc6c79f236b28f141cb016093f62c7bc9f87", "edit/adapter_model.safetensors": "5f72934d848b44cdc0105290ad9ccaf85ef620aa530aed048992df704f3f2637", "edit/edit.json": "fdff669f3b3cfe35246bf8f2b51b61e8597d5a9a9cdd3e3fb456187d31d241fa", "ctrl/adapter_config.json": "f9e50ffef2bab461589d133f9f10bc6c79f236b28f141cb016093f62c7bc9f87", "ctrl/adapter_model.safetensors": "a1723bc6ad0a75f759b0bd1b12cf4da49072d28ed97f6617737f05a614dc994b", "ctrl/edit.json": "0c0621f74cdb4f95acd572c7cbac59230db42932efd999c2d961011e907bc43c"}, "checks": {"edit": "OK edit: 300 modules changed (of 300 present), r=4, max |dW|_F/|W|_F 0.003586 at 15.k_proj", "ctrl": "OK ctrl: 300 modules changed (of 300 present), r=4, max |dW|_F/|W|_F 0.003585 at 45.v_proj"}}
DONE 1512.0
2026-11-14T19:54:14Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
[... 639 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Organizing rescale task details**

 succeeded in 712ms:
#!/usr/bin/env python
"""rescale.py IN_DIR OUT_DIR (--net-rel X | --factor C): write a copy of an edit adapter scaled by one common factor
(CPU, seconds). --net-rel X sets the whole-network size sqrt(sum |dW|_F^2) / sqrt(sum |W|_F^2 over all 420 matrices)
to X (0.003 = 0.3%); --factor C multiplies the edit by C. Only lora_B is multiplied, so the copy is a valid adapter
for the checker (lora_alpha stays 2 r) and the relative sizes of the matrices are kept. Rescale the control with the
same --factor (it is printed) so that edit and control keep the same per-matrix norms."""
import argparse
import json
import os
import shutil
import sys

import torch
from safetensors.torch import load_file, save_file

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import netops


[... 1480 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 951ms:
2743884

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 1398 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 exited 1 in 2324ms:
| 0027 | gpt | code-reader-damp-r4-033 | queued_s1 | -8 to +14 |  |  |  | - |
                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^
  File "/home/keith/gemma-devagent-20261001/python/cpython-3.13.13-linux-x86_64-gnu/lib/python3.13/pathlib/_abc.py", line 625, in read_bytes
    with self.open(mode='rb') as f:
         ~~~~~~~~~^^^^^^^^^^^
  File "/home/keith/gemma-devagent-20261001/python/cpython-3.13.13-linux-x86_64-gnu/lib/python3.13/pathlib/_local.py", line 537, in open
    return io.open(self, mode, buffering, encoding, errors, newline)
           ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [Errno 2] No such file or directory: '/home/keith/gemma-v2/wsp31/authors/gpt/scratch/turn13/reader100/edit/adapter_model.safetensors'
BUILT /home/keith/gemma-v2/wsp31/authors/gpt/scratch/turn13/reader100 factor 3.030254323626398
    PID STAT

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
[... 696 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Handling tool execution and logging**

 succeeded in 793ms:
2751113

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 689 lines cut ...]
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Assessing batch processing states**
**Evaluating reader selection criteria**
**Analyzing replay call indexing**
**Noting minor log details**

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
+for name,subset in [('fit',common&fit),('nonfit',common-fit),('all_eligible',common)]:
+ scores={a:sum(bool(v[i]['resolved']) for i in subset) for a,v in arms.items()}
+ out[name]={'n':len(subset),'scores':scores,'e0048_gain':scores['e0048']-(scores['base']+scores['aa'])/2}
[... 780 lines cut ...]
  by type {'gate_proj': 0.01086, 'k_proj': 0.01086, 'q_proj': 0.01086, 'up_proj': 0.01086, 'v_proj': 0.01086}
  by depth (10-layer bands) [0.01086, 0.01086, 0.01086, 0.01086, 0.01086, 0.01086]
[line removed by the dashboard scrubber]
EXTRA_EDIT_CHECK 5397 [task]

**Managing GPU resource locks**
**Handling remote GPU script execution**
**Analyzing GPU resource and process status**

 exited 1 in 382ms:
2026-11-14T19:58:45Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 770 lines cut ...]
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Analyzing model initialization and data loading**
**Monitoring worker timeout and termination**
**Tracking update progress**

 succeeded in 402ms:
ARM 1 edit 191.6 {"all": {"n": 54, "flips": 2, "dlogp": -0.054336542445586916, "kl": 0.04532022125017813, "dclose": 6.016120572057035, "base_top_logged": 54, "top_logged": 52}, "thought": {"n": 32, "flips": 2, "dlogp": -0.08356073607552261, "kl": 0.07005460014836018, "dclose": 5.970150247216225, "base_top_logged": 32, "top_logged": 30}, "action": {"n": 17, "flips": 0, "dlogp": -0.01582375326141558, "kl": 0.008759999779514223, "dclose": 6.013128112344181, "base_top_logged": 17, "top_logged": 17}, "syntax": {"n": 3, "flips": 0, "dlogp": -0.00014910975005477667, "kl": 0.0001534116017865017, "dclose": 6.520684242248535, "base_top_logged": 3, "top_logged": 3}, "close": {"n": 1, "flips": 0, "dlogp": 0.00933869183063507, "kl": 0.05605529993772507, "dclose": 0.00933869183063507, "base_top_logged": 1, "top_logged": 1}, "think": {"n": 1, "flips": 0, "dlogp": -0.0001172947813756764, "kl": 0.00010921176726697013, "dclose": 12.031133651733398, "base_top_logged": 1, "top_logged": 1}}
2026-11-14T20:00:11Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 839 lines cut ...]
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Estimating task timing and resource use**
**Managing script updates dynamically**

 succeeded in 346ms:
443 /home/keith/gemma-v2/wsp31/authors/gpt/NOTES.md

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 1736 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 335ms:
ARM 1 ctrl 132.8 {"all": {"n": 54, "flips": 0, "dlogp": 0.0008770628576499988, "kl": 0.00020739263267459035, "dclose": -0.12799311788856155, "base_top_logged": 54, "top_logged": 54}, "thought": {"n": 32, "flips": 0, "dlogp": 0.0021554433702810627, "kl": 0.0002510169787929839, "dclose": -0.14085006713867188, "base_top_logged": 32, "top_logged": 32}, "action": {"n": 17, "flips": 0, "dlogp": -0.0014244550217500439, "kl": 0.0001566457206037019, "dclose": -0.09195776546702665, "base_top_logged": 17, "top_logged": 17}, "syntax": {"n": 3, "flips": 0, "dlogp": -1.2633696845417338e-05, "kl": 1.519764329790026e-06, "dclose": -0.16667938232421875, "base_top_logged": 3, "top_logged": 3}, "close": {"n": 1, "flips": 0, "dlogp": 0.002640127670019865, "kl": 0.0004990457673557103, "dclose": 0.002640127670019865, "base_top_logged": 1, "top_logged": 1}, "think": {"n": 1, "flips": 0, "dlogp": 7.152543730626348e-07, "kl": 7.653244438188267e-08, "dclose": -0.3437461853027344, "base_top_logged": 1, "top_logged": 1}}
2026-11-14T20:01:41Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 859 lines cut ...]
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Analyzing computational experiment timing and dose testing**
**Verifying script and environment setup**
**Managing Python bytecode caching**
**Managing Python bytecode caching**

 succeeded in 749ms:
ARM 2 edit 147.7 {"all": {"n": 107, "flips": 5, "dlogp": -0.09096558378884427, "kl": 0.08214975652311392, "dclose": 5.818962428259672, "base_top_logged": 107, "top_logged": 102}, "thought": {"n": 50, "flips": 5, "dlogp": -0.1897375642567954, "kl": 0.17049063479585583, "dclose": 4.753700008392334, "base_top_logged": 50, "top_logged": 45}, "action": {"n": 47, "flips": 0, "dlogp": -0.005468089621616549, "kl": 0.004261934913810373, "dclose": 6.787313400430882, "base_top_logged": 47, "top_logged": 47}, "syntax": {"n": 6, "flips": 0, "dlogp": -3.0497038399820062e-06, "kl": 0.00030859094113111496, "dclose": 7.316403230031331, "base_top_logged": 6, "top_logged": 6}, "close": {"n": 2, "flips": 0, "dlogp": 0.0053644884610548615, "kl": 0.03159633162431419, "dclose": 0.0053644884610548615, "base_top_logged": 2, "top_logged": 2}, "think": {"n": 2, "flips": 0, "dlogp": -7.48595248296624e-05, "kl": 6.852916794741759e-05, "dclose": 11.01555061340332, "base_top_logged": 2, "top_logged": 2}}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 1753 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 7929ms:
[
  {
    "instance": "[task]",
    "kind": "thought",
    "context": "line\": 486, \"total_lines\": 486, \"is_truncated\": false}<|\"|>}<tool_response|><|channel>thought\nThe",
    "reference": " code",
    "edit": " function"
  },
  {
    "instance": "[task]",
    "kind": "thought",
    "context": "machine': platform.machine()}\n```\nWait, the user wrote `'unkown'`. Is that a typo for `'unknown'`?\nUsually,",
    "reference": " it",
    "edit": " in"
  },
  {
    "instance": "rubik__radon.54b88e58.func_basic__8pbqxg0r",
    "kind": "thought",
    "context": " regular expression\\n\", \"exit_code\": 2}}<|\"|>}<tool_response|><|channel>thought\nAh, `[` is a special character in some grep versions",
[... 907 lines cut ...]
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

[line removed by the dashboard scrubber]
**Tracking final process steps**

 succeeded in 339ms:
ARM 2 edit 147.7 {"all": {"n": 107, "flips": 5, "dlogp": -0.09096558378884427, "kl": 0.08214975652311392, "dclose": 5.818962428259672, "base_top_logged": 107, "top_logged": 102}, "thought": {"n": 50, "flips": 5, "dlogp": -0.1897375642567954, "kl": 0.17049063479585583, "dclose": 4.753700008392334, "base_top_logged": 50, "top_logged": 45}, "action": {"n": 47, "flips": 0, "dlogp": -0.005468089621616549, "kl": 0.004261934913810373, "dclose": 6.787313400430882, "base_top_logged": 47, "top_logged": 47}, "syntax": {"n": 6, "flips": 0, "dlogp": -3.0497038399820062e-06, "kl": 0.00030859094113111496, "dclose": 7.316403230031331, "base_top_logged": 6, "top_logged": 6}, "close": {"n": 2, "flips": 0, "dlogp": 0.0053644884610548615, "kl": 0.03159633162431419, "dclose": 0.0053644884610548615, "base_top_logged": 2, "top_logged": 2}, "think": {"n": 2, "flips": 0, "dlogp": -7.48595248296624e-05, "kl": 6.852916794741759e-05, "dclose": 11.01555061340332, "base_top_logged": 2, "top_logged": 2}}
2026-11-14T20:06:30Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 871 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Analyzing resource contention and timing**

 succeeded in 422ms:
               total        used        free      shared  buff/cache   available
Mem:             183          85           9           1          91          98
Swap:              7           1           6
2751116

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
[... 1793 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 333ms:
ARM 2 ctrl 179.9 {"all": {"n": 107, "flips": 0, "dlogp": 0.00013662876403509845, "kl": 0.00026864442963143645, "dclose": -0.046318554908045886, "base_top_logged": 107, "top_logged": 107}, "thought": {"n": 50, "flips": 0, "dlogp": 0.0008599286225648939, "kl": 0.0004996009058231366, "dclose": -0.10191348075866699, "base_top_logged": 50, "top_logged": 50}, "action": {"n": 47, "flips": 0, "dlogp": -0.0006692806008073721, "kl": 6.822429038122115e-05, "dclose": 0.02833656554526471, "base_top_logged": 47, "top_logged": 47}, "syntax": {"n": 6, "flips": 0, "dlogp": 3.874785170410178e-05, "kl": 6.835066529061369e-06, "dclose": -0.12105496724446614, "base_top_logged": 6, "top_logged": 6}, "close": {"n": 2, "flips": 0, "dlogp": 0.001423035457264632, "kl": 0.0002586291120678652, "dclose": 0.001423035457264632, "base_top_logged": 2, "top_logged": 2}, "think": {"n": 2, "flips": 0, "dlogp": 2.3841835172788706e-07, "kl": 4.9204089691556874e-08, "dclose": -0.2343730926513672, "base_top_logged": 2, "top_logged": 2}}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 890 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Analyzing processing time and resource usage**

 succeeded in 308ms:
ARM 3 edit 132.9 {"all": {"n": 180, "flips": 9, "dlogp": -0.06356160032089579, "kl": 0.1541926121797758, "dclose": 5.613668160757515, "base_top_logged": 180, "top_logged": 171}, "thought": {"n": 81, "flips": 8, "dlogp": -0.12516095475612132, "kl": 0.28664585286591204, "dclose": 3.801874131332209, "base_top_logged": 81, "top_logged": 73}, "action": {"n": 84, "flips": 1, "dlogp": -0.019979402430988828, "kl": 0.010608511048676576, "dclose": 7.163509618668329, "base_top_logged": 84, "top_logged": 83}, "syntax": {"n": 9, "flips": 0, "dlogp": -0.043404062719673675, "kl": 0.04339252626636557, "dclose": 7.980033344692654, "base_top_logged": 9, "top_logged": 9}, "close": {"n": 3, "flips": 0, "dlogp": 0.2553667895651112, "kl": 1.0848357073652248, "dclose": 0.2553667895651112, "base_top_logged": 3, "top_logged": 3}, "think": {"n": 3, "flips": 0, "dlogp": -8.157417687471025e-05, "kl": 6.71078796585789e-05, "dclose": 9.395751953125, "base_top_logged": 3, "top_logged": 3}}
2026-11-14T20:09:04Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 893 lines cut ...]
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Analyzing KL divergence thresholds**
**Summarizing build and edit process details**
**Managing process termination safely**

 succeeded in 1786ms:
BUILT /home/keith/gemma-v2/wsp31/authors/gpt/scratch/turn13/reader066 factor 1.9999678535934224

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 937 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Tracking script timing**

 succeeded in 270ms:
2925448

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 938 lines cut ...]
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Estimating time and verifying patches**
**Analyzing prediction scaling and validation**

 succeeded in 34ms:
title: Damp the code-versus-prose style contrast in readers across all 60 layers at 1 percent

## Hypothesis

The earlier writer-only code/prose edits were null: 0025 at 0.33% gained -1 task and 0026 at 0.11% gained zero. This round changes where the same contrast acts. The unchanged parked reader edit 0027 occupies the first slot; this second entry raises its dose from 0.33% to 1%. No result for the reader family was available when this choice was made.

Readers determine which parts of the current state attention and MLP units use. Damping a code-versus-prose style subspace on their input side may reduce the loss of code details when the model reasons in prose. This differs from damping those features after the writers produce their outputs. The direction represents code form, not code correctness. The six-task contrast is reproducible between halves (mean cosine 0.6444 for attention-reader inputs and 0.6178 for MLP-reader inputs), but that does not establish a useful change.

The small model's failed correctness probe and the null writer versions are reasons for caution. This is the first screened reader dose comparison, not a third writer dose. More dose may instead impair literal copying, attention routing, or tool syntax. A same-batch comparison to 0027 should distinguish a weak effect from a harmful dose. The first slot was fully resubmitted before this candidate was built.

An unrelated pooled-outcome writer rotation was declined in this turn, without READY: at 0.33%, its mean change in close log p was -0.1655 over four exact calls, below the documented -0.05 warning. Its reserved-task direction alignment was also near zero. No direction or weight from that candidate enters this entry.

## Exact recipe

base: champion generation 0

This is a common-factor rescaling of the author's frozen, closed-form 0027 adapters, not a trained donor. code/turn13/reader_build.py verifies their SHA256 hashes, computes factor=0.01/stored_net_rel(edit), and calls the frozen rescale.write_scaled for both arms with that same factor. Only lora_B changes, followed by bf16 rounding; A, config, modules, rank, and random-control directions stay fixed. The factor is 3.030254323626398. This is exact rescaling of stored factors up to the new bf16 rounding, not a fresh factorization from full-precision projectors.

[line removed by the dashboard scrubber]
[... 1029 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Handling output truncation**

 succeeded in 84ms:
title: Damp the code-versus-prose style contrast in readers across all 60 layers at 1 percent

## Hypothesis

The earlier writer-only code/prose edits were null: 0025 at 0.33% gained -1 task and 0026 at 0.11% gained zero. This round changes where the same contrast acts. The unchanged parked reader edit 0027 occupies the first slot; this second entry raises its dose from 0.33% to 1%. No result for the reader family was available when this choice was made.

Readers determine which parts of the current state attention and MLP units use. Damping a code-versus-prose style subspace on their input side may reduce the loss of code details when the model reasons in prose. This differs from damping those features after the writers produce their outputs. The direction represents code form, not code correctness. The six-task contrast is reproducible between halves (mean cosine 0.6444 for attention-reader inputs and 0.6178 for MLP-reader inputs), but that does not establish a useful change.

The small model's failed correctness probe and the null writer versions are reasons for caution. This is the first screened reader dose comparison, not a third writer dose. More dose may instead impair literal copying, attention routing, or tool syntax. A same-batch comparison to 0027 should distinguish a weak effect from a harmful dose. The first slot was fully resubmitted before this candidate was built.

An unrelated pooled-outcome writer rotation was declined in this turn, without READY: at 0.33%, its mean change in close log p was -0.1655 over four exact calls, below the documented -0.05 warning. Its reserved-task direction alignment was also near zero. No direction or weight from that candidate enters this entry.

## Exact recipe

base: champion generation 0

This is a common-factor rescaling of the author's frozen, closed-form 0027 adapters, not a trained donor. code/turn13/reader_build.py verifies their SHA256 hashes, computes factor=0.01/stored_net_rel(edit), and calls the frozen rescale.write_scaled for both arms with that same factor. Only lora_B changes, followed by bf16 rounding; A, config, modules, rank, and random-control directions stay fixed. The factor is 3.030254323626398. This is exact rescaling of stored factors up to the new bf16 rounding, not a fresh factorization from full-precision projectors.

[line removed by the dashboard scrubber]
[... 3106 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 74ms:
4:C=Path(__file__).resolve().parent;A=C.parent.parent;R=A.parents[2];S=A/'scratch/turn13';T=R/'wsp31/tools';PY=R/'tii-venv/bin/python';src=S/'reader066';dst=A/'queue/code-reader-damp-r4-066'
6:rep=json.loads((src/'replay.json').read_text());sizes=json.loads((src/'size.json').read_text());rc=json.loads((C/'reader066_rebuild_receipt.json').read_text());fit=set(rc['fit_tasks'])
23:shutil.copy2(C/'reader066_rebuild_receipt.json',dst/'rebuild_receipt.json');shutil.copy2(C/'reader066_build.sh',dst/'build.sh')
26: s=sizes[arm]['summary'];prefix='size' if arm=='edit' else 'control size';content.append(f'{prefix}: whole network {100*s["net_rel"]:.6f}% over {s["changed"]} matrices, largest matrix {100*s["rel_max"]:.6f}%')
27:content.extend(['',f'Both official checker runs pass. Largest relative per-matrix edit/control norm mismatch after storage is {100*rc["max_relative_norm_mismatch"]:.5f}%. Both arms reproduce config, weights and metadata byte for byte on an independent rebuild. Receipts and exact size rows accompany this record.',
37: for label,tt in [('three-call panel',tasks-{'[task]'}),('reused edit_file call',{'[task]'})]:
43:record=(C/'reader066_record_draft.md').read_text().replace('BUILD_AND_PRETEST','\n'.join(content));(dst/'record.md').write_text(record)
44:sources=[C/'reader_build.py',C/'reader066_build.sh',C/'reader066_verify.py',C/'reader066_finalize.py',C/'reader066_record_draft.md',C/'replay_cpu.py',C/'replay_calls.jsonl',C/'reader066_cpu.sh',C/'reader_extra_cpu.sh']

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
[... 2142 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
+for name,subset in [('fit',common&fit),('nonfit',common-fit),('all_eligible',common)]:
+ scores={a:sum(bool(v[i]['resolved']) for i in subset) for a,v in arms.items()}
+ out[name]={'n':len(subset),'scores':scores,'e0048_gain':scores['e0048']-(scores['base']+scores['aa'])/2}
[... 1080 lines cut ...]
  by type {'gate_proj': 0.00717, 'k_proj': 0.00717, 'q_proj': 0.00717, 'up_proj': 0.00717, 'v_proj': 0.00717}
  by depth (10-layer bands) [0.00717, 0.00717, 0.00717, 0.00717, 0.00717, 0.00717]
[line removed by the dashboard scrubber]

**Finalizing source code and queue checks**
**Analyzing numerical model precision**
**Confirming environment constraints**
**Analyzing runtime and model behavior**

 succeeded in 383ms:
ARM 1 edit 141.1 {"all": {"n": 54, "flips": 1, "dlogp": -0.03479265799770032, "kl": 0.024426215065823514, "dclose": 3.990525452385622, "base_top_logged": 54, "top_logged": 53}, "thought": {"n": 32, "flips": 1, "dlogp": -0.04961359923558195, "kl": 0.03474757457674471, "dclose": 3.8430864363908768, "base_top_logged": 32, "top_logged": 31}, "action": {"n": 17, "flips": 0, "dlogp": -0.017664256833576947, "kl": 0.009841594230163717, "dclose": 4.226131270913517, "base_top_logged": 17, "top_logged": 17}, "syntax": {"n": 3, "flips": 0, "dlogp": -4.469971221017962e-05, "kl": 3.0365844092254218e-05, "dclose": 4.249955495198567, "base_top_logged": 3, "top_logged": 3}, "close": {"n": 1, "flips": 0, "dlogp": 0.009294705465435982, "kl": 0.039664655923843384, "dclose": 0.009294705465435982, "base_top_logged": 1, "top_logged": 1}, "think": {"n": 1, "flips": 0, "dlogp": -3.659649519249797e-05, "kl": 3.037172973563429e-05, "dclose": 7.906215667724609, "base_top_logged": 1, "top_logged": 1}}
2026-11-14T20:14:32Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 2195 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 367ms:
392 /home/keith/gemma-v2/wsp31/authors/gpt/NOTES.md
ARM 1 ctrl 127.6 {"all": {"n": 54, "flips": 0, "dlogp": 0.0002787641947874262, "kl": 0.00011163661178368193, "dclose": -0.1058409764189963, "base_top_logged": 54, "top_logged": 54}, "thought": {"n": 32, "flips": 0, "dlogp": 0.0004362556142538665, "kl": 0.00018469470769062746, "dclose": -0.13152165710926056, "base_top_logged": 32, "top_logged": 32}, "action": {"n": 17, "flips": 0, "dlogp": 1.3571128440215784e-05, "kl": 3.2480719147019475e-06, "dclose": -0.018828560324276194, "base_top_logged": 17, "top_logged": 17}, "syntax": {"n": 3, "flips": 0, "dlogp": -1.4063907428862876e-05, "kl": 1.709748502776165e-06, "dclose": -0.3125139872233073, "base_top_logged": 3, "top_logged": 3}, "close": {"n": 1, "flips": 0, "dlogp": 0.0009039733558893204, "kl": 5.770320422016084e-05, "dclose": 0.0009039733558893204, "base_top_logged": 1, "top_logged": 1}, "think": {"n": 1, "flips": 0, "dlogp": 5.96045310885529e-07, "kl": 9.671794032328762e-08, "dclose": -0.24999618530273438, "base_top_logged": 1, "top_logged": 1}}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 1097 lines cut ...]
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Analyzing final code compilation steps**
**Reviewing model fidelity and serving details**
**Analyzing training and test status**

 succeeded in 114ms:
import json,hashlib,subprocess,shutil
from pathlib import Path
from datetime import datetime,timezone
C=Path(__file__).resolve().parent;A=C.parent.parent;R=A.parents[2];S=A/'scratch/turn13';T=R/'wsp31/tools';PY=R/'tii-venv/bin/python';src=S/'reader066';dst=A/'queue/code-reader-damp-r4-066'
def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest()
rep=json.loads((src/'replay.json').read_text());sizes=json.loads((src/'size.json').read_text());rc=json.loads((C/'reader066_rebuild_receipt.json').read_text());fit=set(rc['fit_tasks'])
allcalls=[json.loads(l) for l in (C/'replay_calls.jsonl').open()];panel=[allcalls[i] for i in [1,2,3,8]];tasks={r['instance'] for r in panel}
assert len(tasks)==4 and not tasks&fit and (src/'REPLAY_DONE').exists()
sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')]);assert fit|tasks<=allow and not (fit|tasks)&deny
assert 'Generation 0: the unedited model.' in (R/'wsp31/queue/CHAMPION.md').read_text()
for arm in ['edit','ctrl']:
 s=rep['arms'][arm]['summary'];assert {r['instance'] for r in rep['arms'][arm]['rows']}==tasks
 assert s['close']['n']==4 and s['close']['dclose']>=-.05,(arm,s['close'])
 assert s['syntax']['flips']==0,(arm,s['syntax'])
 assert s['all']['kl']<.1 and s['all']['dlogp']>-.1,(arm,s['all'])
 assert sha(src/arm/'adapter_model.safetensors')==rep['adapter_sha256'][arm]==rc[arm]['adapter_model.safetensors']
assert rep['arms']['edit']['summary']['all']['flips']>0
assert sizes['edit']['summary']['net_rel']>=.003 and sizes['edit']['summary']['changed']==300
assert not dst.exists();dst.mkdir(parents=True)
[... 28 lines cut ...]
sources += [p for p in (A/'queue/code-reader-damp-r4-033').rglob('*') if p.is_file() and p.name in ['adapter_config.json','adapter_model.safetensors','edit.json','record.md','build.sh']]
1:title: Damp the code-versus-prose style contrast in readers across all 60 layers at 0.66 percent
5:The earlier writer-only code/prose edits were null: 0025 at 0.33% gained -1 task and 0026 at 0.11% gained zero. This round changes where the same contrast acts. The unchanged parked reader edit 0027 occupies the first slot; this second entry raises its dose from 0.33% to 0.66%. No result for the reader family was available when this choice was made.
13:A 1% reader scout was also declined before READY. After three of its four planned calls, mean KL was 0.15419 over 180 positions. Even zero KL on all 56 remaining positions would leave the final mean at 0.11760, above the preset 0.1 guard. Its observed syntax and thought-ending checks passed; this is an author-chosen distribution limit, not proof of rollout harm. The 0.66% dose was selected adaptively after that result. Both declined scouts remain outside the queue.
19:This is a common-factor rescaling of the author's frozen, closed-form 0027 adapters, not a trained donor. code/turn13/reader_build.py verifies their SHA256 hashes, computes factor=0.0066/stored_net_rel(edit), and calls the frozen rescale.write_scaled for both arms with that same factor. Only lora_B changes, followed by bf16 rounding; A, config, modules, rank, and random-control directions stay fixed. The factor is 1.9999678535934224. This is exact rescaling of stored factors up to the new bf16 rounding, not a fresh factorization from full-precision projectors.
[line removed by the dashboard scrubber]
23:Control: the same builder and negative sign, layers, modules, rank, spectral weights and matched per-matrix norms, with Gaussian orthonormal directions orthogonal to the fitted subspace and its common mean. Seed 314000+100*layer+space_index. Both edit and control receive the same new scale factor. The projector defines its own input gate; there is no separately learned gate. The random control tests whether the code/prose directions matter beyond changing the same amount of weight.
27:Rank 4, alpha 8, bf16 factors; dW=2 B A. The model check
[... 307 characters cut ...]

 succeeded in 353ms:
ARM 1 ctrl 127.6 {"all": {"n": 54, "flips": 0, "dlogp": 0.0002787641947874262, "kl": 0.00011163661178368193, "dclose": -0.1058409764189963, "base_top_logged": 54, "top_logged": 54}, "thought": {"n": 32, "flips": 0, "dlogp": 0.0004362556142538665, "kl": 0.00018469470769062746, "dclose": -0.13152165710926056, "base_top_logged": 32, "top_logged": 32}, "action": {"n": 17, "flips": 0, "dlogp": 1.3571128440215784e-05, "kl": 3.2480719147019475e-06, "dclose": -0.018828560324276194, "base_top_logged": 17, "top_logged": 17}, "syntax": {"n": 3, "flips": 0, "dlogp": -1.4063907428862876e-05, "kl": 1.709748502776165e-06, "dclose": -0.3125139872233073, "base_top_logged": 3, "top_logged": 3}, "close": {"n": 1, "flips": 0, "dlogp": 0.0009039733558893204, "kl": 5.770320422016084e-05, "dclose": 0.0009039733558893204, "base_top_logged": 1, "top_logged": 1}, "think": {"n": 1, "flips": 0, "dlogp": 5.96045310885529e-07, "kl": 9.671794032328762e-08, "dclose": -0.24999618530273438, "base_top_logged": 1, "top_logged": 1}}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 1097 lines cut ...]
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Clarifying finalizer logic and control gating**
**Reviewing record audit and config checks**
**Verifying build and model readiness**
**Monitoring build timing and validation**

 succeeded in 353ms:
ARM 2 edit 115.1 {"all": {"n": 107, "flips": 3, "dlogp": -0.04215716853971167, "kl": 0.03947513241469925, "dclose": 3.759623365042618, "base_top_logged": 107, "top_logged": 104}, "thought": {"n": 50, "flips": 3, "dlogp": -0.0842170030857261, "kl": 0.08006516736714957, "dclose": 2.6655486106872557, "base_top_logged": 50, "top_logged": 47}, "action": {"n": 47, "flips": 0, "dlogp": -0.0066264929884212315, "kl": 0.003693270174395327, "dclose": 4.796512745796366, "base_top_logged": 47, "top_logged": 47}, "syntax": {"n": 6, "flips": 0, "dlogp": 0.00012991268943096657, "kl": 0.00023536662623276547, "dclose": 4.970182418823242, "base_top_logged": 6, "top_logged": 6}, "close": {"n": 2, "flips": 0, "dlogp": 0.005370507074985653, "kl": 0.02277497504837811, "dclose": 0.005370507074985653, "base_top_logged": 2, "top_logged": 2}, "think": {"n": 2, "flips": 0, "dlogp": -2.1099646801303606e-05, "kl": 1.7475982303949422e-05, "dclose": 6.8671674728393555, "base_top_logged": 2, "top_logged": 2}}
2026-11-14T20:18:30Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 1101 lines cut ...]

**Finalizing execution and file handling**
**Managing tool execution sequence**
**Summarizing processing status**
**Formatting final five-line summary**
**Managing final records and process cleanup**
**Assessing convergence metrics**
**Verifying source integrity and timing**

 succeeded in 312ms:
ARM 3 edit 86.7 {"all": {"n": 180, "flips": 7, "dlogp": -0.019658588508019686, "kl": 0.07445539397065223, "dclose": 3.671370541822398, "base_top_logged": 180, "top_logged": 173}, "thought": {"n": 81, "flips": 6, "dlogp": -0.039724163541601486, "kl": 0.13368922580750917, "dclose": 2.0038473458937656, "base_top_logged": 81, "top_logged": 75}, "action": {"n": 84, "flips": 1, "dlogp": -0.01189054547380924, "kl": 0.005014950514557677, "dclose": 5.113254649298532, "base_top_logged": 84, "top_logged": 83}, "syntax": {"n": 9, "flips": 0, "dlogp": -0.00880134872247456, "kl": 0.008895564826970157, "dclose": 5.579740524291992, "base_top_logged": 9, "top_logged": 9}, "close": {"n": 3, "flips": 0, "dlogp": 0.2524072987725958, "kl": 0.6905882627082368, "dclose": 0.2524072987725958, "base_top_logged": 3, "top_logged": 3}, "think": {"n": 3, "flips": 0, "dlogp": -3.0874196454533376e-05, "kl": 2.0969839624740416e-05, "dclose": 6.015595118204753, "base_top_logged": 3, "top_logged": 3}}
2026-11-14T20:20:55Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 2265 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 279ms:
ARM 3 ctrl 84.2 {"all": {"n": 180, "flips": 0, "dlogp": 0.00157240204633011, "kl": 0.00033607284057822956, "dclose": -0.052496607122399536, "base_top_logged": 180, "top_logged": 180}, "thought": {"n": 81, "flips": 0, "dlogp": 0.0026136800625725996, "kl": 0.000586364428901325, "dclose": -0.07170145894274299, "base_top_logged": 81, "top_logged": 81}, "action": {"n": 84, "flips": 0, "dlogp": -0.0004777031425181546, "kl": 7.040398242558348e-05, "dclose": -0.01407986595517113, "base_top_logged": 84, "top_logged": 84}, "syntax": {"n": 9, "flips": 0, "dlogp": -4.5804228597666625e-06, "kl": 3.754454047112511e-06, "dclose": -0.2543450461493598, "base_top_logged": 9, "top_logged": 9}, "close": {"n": 3, "flips": 0, "dlogp": 0.03716307773720473, "kl": 0.002349677227812208, "dclose": 0.03716307773720473, "base_top_logged": 3, "top_logged": 3}, "think": {"n": 3, "flips": 0, "dlogp": 1.1126122293111014e-06, "kl": 2.787564881145954e-07, "dclose": -0.0937487284342448, "base_top_logged": 3, "top_logged": 3}}
2026-11-14T20:23:30Z

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 1136 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

context compacted

 succeeded in 310ms:
Sat Nov 14 08:25:17 PM UTC 2026
ARM 2 edit 115.1 {"all": {"n": 107, "flips": 3, "dlogp": -0.04215716853971167, "kl": 0.03947513241469925, "dclose": 3.759623365042618, "base_top_logged": 107, "top_logged": 104}, "thought": {"n": 50, "flips": 3, "dlogp": -0.0842170030857261, "kl": 0.08006516736714957, "dclose": 2.6655486106872557, "base_top_logged": 50, "top_logged": 47}, "action": {"n": 47, "flips": 0, "dlogp": -0.0066264929884212315, "kl": 0.003693270174395327, "dclose": 4.796512745796366, "base_top_logged": 47, "top_logged": 47}, "syntax": {"n": 6, "flips": 0, "dlogp": 0.00012991268943096657, "kl": 0.00023536662623276547, "dclose": 4.970182418823242, "base_top_logged": 6, "top_logged": 6}, "close": {"n": 2, "flips": 0, "dlogp": 0.005370507074985653, "kl": 0.02277497504837811, "dclose": 0.005370507074985653, "base_top_logged": 2, "top_logged": 2}, "think": {"n": 2, "flips": 0, "dlogp": -2.1099646801303606e-05, "kl": 1.7475982303949422e-05, "dclose": 6.8671674728393555, "base_top_logged": 2, "top_logged": 2}}
ARM 2 ctrl 106.3 {"all": {"n": 107, "flips": 0, "dlogp": -0.00013446936507899402, "kl": 0.00026114946422113724, "dclose": -0.043139690023011344, "base_top_logged": 107, "top_logged": 107}, "thought": {"n": 50, "flips": 0, "dlogp": -0.00030913249458080827, "kl": 0.0005371682559184076, "dclose": -0.08288717269897461, "base_top_logged": 50, "top_logged": 50}, "action": {"n": 47, "flips": 0, "dlogp": 3.3172006732773664e-06, "kl": 2.1528941277460497e-05, "dclose": 0.02668214351572889, "base_top_logged": 47, "top_logged": 47}, "syntax": {"n": 6, "flips": 0, "dlogp": -7.111174719890793e-06, "kl": 1.377945507178661e-06, "dclose": -0.2356842358907064, "base_top_logged": 6, "top_logged": 6}, "close": {"n": 2, "flips": 0, "dlogp": 0.0004763289471156895, "kl": 3.1817069839235046e-05, "dclose": 0.0004763289471156895, "base_top_logged": 2, "top_logged": 2}, "think": {"n": 2, "flips": 0, "dlogp": 1.2516940159912338e-06, "kl": 4.08911489557795e-07, "dclose": -0.1562480926513672, "base_top_logged": 2, "top_logged": 2}}
ARM 3 edit 86.7 {"all": {"n": 180, "flips": 7, "dlogp": -0.019658588508019686, "kl": 0.07445539397065223, "dclose": 3.671370541822398, "base_top_logged": 180, "top_logged": 173}, "thought": {"n": 81, "flips": 6, "dlogp": -0.039724163541601486, "kl": 0.13368922580750917, "dclose": 2.0038473458937656, "base_top_logged": 81, "top_logged": 75}, "action": {"n": 84, "flips": 1, "dlogp": -0.01189054547380924, "kl": 0.005014950514557677, "dclose": 5.113254649298532, "base_top_logged": 84, "top_logged": 83}, "syntax": {"n": 9, "flips": 0, "dlogp": -0.00880134872247456, "kl": 0.008895564826970157, "dclose": 5.579740524291992, "base_top_logged": 9, "top_logged": 9}, "close": {"n": 3, "flips": 0, "dlogp": 0.2524072987725958, "kl": 0.6905882627082368, "dclose": 0.2524072987725958, "base_top_logged": 3, "top_logged": 3}, "think": {"n": 3, "flips": 0, "dlogp": -3.0874196454533376e-05, "kl": 2.0969839624740416e-05, "dclose": 6.015595118204753, "base_top_logged": 3, "top_logged": 3}}
ARM 3 ctrl 84.2 {"all": {"n": 180, "flips": 0, "dlogp": 0.00157240204633011, "kl": 0.00033607284057822956, "dclose": -0.052496607122399536, "base_top_logged": 180, "top_logged": 180}, "thought": {"n": 81, "flips": 0, "dlogp": 0.0026136800625725996, "kl": 0.000586364428901325, "dclose": -0.07170145894274299, "base_top_logged": 81, "top_logged": 81}, "action": {"n": 84, "flips": 0, "dlogp": -0.0004777031425181546, "kl": 7.040398242558348e-05, "dclose": -0.01407986595517113, "base_top_logged": 84, "top_logged": 84}, "syntax": {"n": 9, "flips": 0, "dlogp": -4.5804228597666625e-06, "kl": 3.754454047112511e-06, "dclose": -0.2543450461493598, "base_top_logged": 9, "top_logged": 9}, "close": {"n": 3, "flips": 0, "dlogp": 0.03716307773720473, "kl": 0.002349677227812208, "dclose": 0.03716307773720473, "base_top_logged": 3, "top_logged": 3}, "think": {"n": 3, "flips": 0, "dlogp": 1.1126122293111014e-06, "kl": 2.787564881145954e-07, "dclose": -0.0937487
[... 1587 characters cut ...]

 succeeded in 354ms:
# 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,
[... 1461 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Waiting while inspecting docs**

 succeeded in 411ms:
title: Damp the code-versus-prose style contrast in readers across all 60 layers at 0.66 percent

## Hypothesis

The earlier writer-only code/prose edits were null: 0025 at 0.33% gained -1 task and 0026 at 0.11% gained zero. This round changes where the same contrast acts. The unchanged parked reader edit 0027 occupies the first slot; this second entry raises its dose from 0.33% to 0.66%. No result for the reader family was available when this choice was made.

Readers determine which parts of the current state attention and MLP units use. Damping a code-versus-prose style subspace on their input side may reduce the loss of code details when the model reasons in prose. This differs from damping those features after the writers produce their outputs. The direction represents code form, not code correctness. The six-task contrast is reproducible between halves (mean cosine 0.6444 for attention-reader inputs and 0.6178 for MLP-reader inputs), but that does not establish a useful change.

The small model's failed correctness probe and the null writer versions are reasons for caution. This is the first screened reader dose comparison, not a third writer dose. More dose may instead impair literal copying, attention routing, or tool syntax. A same-batch comparison to 0027 should distinguish a weak effect from a harmful dose. The first slot was fully resubmitted before this candidate was built.

An unrelated pooled-outcome writer rotation was declined in this turn, without READY: at 0.33%, its mean change in close log p was -0.1655 over four exact calls, below the documented -0.05 warning. Its reserved-task direction alignment was also near zero. No direction or weight from that candidate enters this entry.

A 1% reader scout was also declined before READY. After three of its four planned calls, mean KL was 0.15419 over 180 positions. Even zero KL on all 56 remaining positions would leave the final mean at 0.11760, above the preset 0.1 guard. Its observed syntax and thought-ending checks passed; this is an author-chosen distribution limit, not proof of rollout harm. The 0.66% dose was selected adaptively after that result. Both declined scouts remain outside the queue.

## Exact recipe

base: champion generation 0

This is a common-factor rescaling of the author's frozen, closed-form 0027 adapters, not a trained donor. code/turn13/reader_build.py verifies their SHA256 hashes, computes factor=0.0066/stored_net_rel(edit), and calls the frozen rescale.write_scaled for both arms with that same factor. Only lora_B changes, followed by bf16 rounding; A, config, modules, rank, and random-control directions stay fixed. The factor is 1.9999678535934224. This is exact rescaling of stored factors up to the new bf16 rounding, not a fresh factorization from full-precision projectors.
[... 2355 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 422ms:
Sat Nov 14 08:26:34 PM UTC 2026
ARM 3 ctrl 84.2 {"all": {"n": 180, "flips": 0, "dlogp": 0.00157240204633011, "kl": 0.00033607284057822956, "dclose": -0.052496607122399536, "base_top_logged": 180, "top_logged": 180}, "thought": {"n": 81, "flips": 0, "dlogp": 0.0026136800625725996, "kl": 0.000586364428901325, "dclose": -0.07170145894274299, "base_top_logged": 81, "top_logged": 81}, "action": {"n": 84, "flips": 0, "dlogp": -0.0004777031425181546, "kl": 7.040398242558348e-05, "dclose": -0.01407986595517113, "base_top_logged": 84, "top_logged": 84}, "syntax": {"n": 9, "flips": 0, "dlogp": -4.5804228597666625e-06, "kl": 3.754454047112511e-06, "dclose": -0.2543450461493598, "base_top_logged": 9, "top_logged": 9}, "close": {"n": 3, "flips": 0, "dlogp": 0.03716307773720473, "kl": 0.002349677227812208, "dclose": 0.03716307773720473, "base_top_logged": 3, "top_logged": 3}, "think": {"n": 3, "flips": 0, "dlogp": 1.1126122293111014e-06, "kl": 2.787564881145954e-07, "dclose": -0.0937487284342448, "base_top_logged": 3, "top_logged": 3}}
BASE 8 5397 202.4
    PID     ELAPSED STAT
2925448       15:52 S
2925467

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
[... 1140 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Considering user comment timing**

 succeeded in 377ms:
bash: line 1: round: command not found
bash: line 1: 0048: command not found
bash: line 1: champion: command not found
{
  "edit": {
    "adapter_config.json": "f9e50ffef2bab461589d133f9f10bc6c79f236b28f141cb016093f62c7bc9f87",
    "adapter_model.safetensors": "90dda56b9d2048fa7b0221580cdce2e70da9c49a42d91292fe40dcf41da11d34",
    "edit.json": "9178f9c902f19ae1c57547e60d79a1a8d22de650084c2bacb2d8816306fef632",
    "exact_twice_stored_source_update": true
  },
  "ctrl": {
    "adapter_config.json": "f9e50ffef2bab461589d133f9f10bc6c79f236b28f141cb016093f62c7bc9f87",
    "adapter_model.safetensors": "4a2f40a4a719d33beb46bc944cef5425b26bae341adce274f02251fa67d6e841",
    "edit.json": "db0f843a18b3ec1182906d979c26d850ef6e00dad1726f0db104e793c957fb16",
    "exact_twice_stored_source_update": true
  },
  "max_relative_norm_mismatch": 0.0008346710761816302,
  "fit_tasks": [
    "[task]",
[... 1172 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Avoiding repeated quotes**

 succeeded in 288ms:
| 0027 | gpt | code-reader-damp-r4-033 | queued_s1 | -8 to +14 |  |  |  | - |
BASE 8 5397 202.4

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 2293 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 323ms:
Sat Nov 14 08:27:43 PM UTC 2026
BASE 8 5397 202.4
    PID     ELAPSED     TIME STAT   RSS
2925467       17:01 03:23:32 Rl   77690248

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
[... 1138 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Managing note updates**

 succeeded in 378ms:
Sat Nov 14 08:28:47 PM UTC 2026
BASE 8 5397 202.4

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 1136 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Estimating processing time**

 succeeded in 452ms:
Sat Nov 14 08:29:49 PM UTC 2026
ARM 8 edit 222.1 {"all": {"n": 276, "flips": 12, "dlogp": -0.017239774680734045, "kl": 0.06319203302474637, "dclose": 3.459880357487144, "base_top_logged": 276, "top_logged": 264}, "thought": {"n": 113, "flips": 11, "dlogp": -0.04068777692951931, "kl": 0.1296197575646995, "dclose": 1.5591981347683257, "base_top_logged": 113, "top_logged": 102}, "action": {"n": 139, "flips": 1, "dlogp": -0.00857229148918712, "kl": 0.0039344413446056785, "dclose": 4.838294241925795, "base_top_logged": 139, "top_logged": 138}, "syntax": {"n": 16, "flips": 0, "dlogp": 0.0018208240442021406, "kl": 0.005696654619555375, "dclose": 5.443959712982178, "base_top_logged": 16, "top_logged": 16}, "close": {"n": 4, "flips": 0, "dlogp": 0.25054897836525925, "kl": 0.5389156971359625, "dclose": 0.25054897836525925, "base_top_logged": 4, "top_logged": 4}, "think": {"n": 4, "flips": 0, "dlogp": -5.9900004544033436e-05, "kl": 6.79751655070504e-05, "dclose": 4.527284622192383, "base_top_logged": 4, "top_logged": 4}}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 1136 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Analyzing index and plan details**

 succeeded in 385ms:
{
  "reason": "preset mean-KL guard cannot pass even if remaining fourth-call KL is zero",
  "n_observed": 180,
  "n_planned": 236,
  "observed_mean_kl": 0.1541926121797758,
  "best_possible_four_call_mean_kl": 0.11760453471338833,
  "limit": 0.1,
  "caveat": "Author-chosen distribution guard, not a calibrated harm verdict; close and syntax guards passed on observed calls.",
  "never_ready": true
}#!/bin/bash
set -euo pipefail
A=/home/keith/gemma-v2/wsp31/authors/gpt
export CUDA_VISIBLE_DEVICES=''
export WSP31_WORK=$A/scratch/turn13
export OMP_NUM_THREADS=16
exec timeout 900 /home/keith/gemma-v2/tii-venv/bin/python -u "$A/code/turn13/replay_cpu.py" --root "$A/scratch/turn13/reader100" --calls 9 --start 8 --indices 8
#!/bin/bash
set -euo pipefail
A=/home/keith/gemma-v2/wsp31/authors/gpt
[... 2358 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 445ms:
Progress notes updated: 407 words

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 2343 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

 succeeded in 406ms:
Sat Nov 14 08:31:10 PM UTC 2026
ARM 8 edit 222.1 {"all": {"n": 276, "flips": 12, "dlogp": -0.017239774680734045, "kl": 0.06319203302474637, "dclose": 3.459880357487144, "base_top_logged": 276, "top_logged": 264}, "thought": {"n": 113, "flips": 11, "dlogp": -0.04068777692951931, "kl": 0.1296197575646995, "dclose": 1.5591981347683257, "base_top_logged": 113, "top_logged": 102}, "action": {"n": 139, "flips": 1, "dlogp": -0.00857229148918712, "kl": 0.0039344413446056785, "dclose": 4.838294241925795, "base_top_logged": 139, "top_logged": 138}, "syntax": {"n": 16, "flips": 0, "dlogp": 0.0018208240442021406, "kl": 0.005696654619555375, "dclose": 5.443959712982178, "base_top_logged": 16, "top_logged": 16}, "close": {"n": 4, "flips": 0, "dlogp": 0.25054897836525925, "kl": 0.5389156971359625, "dclose": 0.25054897836525925, "base_top_logged": 4, "top_logged": 4}, "think": {"n": 4, "flips": 0, "dlogp": -5.9900004544033436e-05, "kl": 6.79751655070504e-05, "dclose": 4.527284622192383, "base_top_logged": 4, "top_logged": 4}}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
[... 1161 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Reviewing consistency and timing**

 succeeded in 433ms:
Sat Nov 14 08:32:13 PM UTC 2026
ARM 8 edit 222.1 {"all": {"n": 276, "flips": 12, "dlogp": -0.017239774680734045, "kl": 0.06319203302474637, "dclose": 3.459880357487144, "base_top_logged": 276, "top_logged": 264}, "thought": {"n": 113, "flips": 11, "dlogp": -0.04068777692951931, "kl": 0.1296197575646995, "dclose": 1.5591981347683257, "base_top_logged": 113, "top_logged": 102}, "action": {"n": 139, "flips": 1, "dlogp": -0.00857229148918712, "kl": 0.0039344413446056785, "dclose": 4.838294241925795, "base_top_logged": 139, "top_logged": 138}, "syntax": {"n": 16, "flips": 0, "dlogp": 0.0018208240442021406, "kl": 0.005696654619555375, "dclose": 5.443959712982178, "base_top_logged": 16, "top_logged": 16}, "close": {"n": 4, "flips": 0, "dlogp": 0.25054897836525925, "kl": 0.5389156971359625, "dclose": 0.25054897836525925, "base_top_logged": 4, "top_logged": 4}, "think": {"n": 4, "flips": 0, "dlogp": -5.9900004544033436e-05, "kl": 6.79751655070504e-05, "dclose": 4.527284622192383, "base_top_logged": 4, "top_logged": 4}}
    PID     ELAPSED     TIME STAT
2925467       21:31 04:13:35 Rl

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
[... 1163 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Managing repetitive updates**

 succeeded in 399ms:
Sat Nov 14 08:33:14 PM UTC 2026
ARM 8 ctrl 233.2 {"all": {"n": 276, "flips": 0, "dlogp": 0.0014893085695158064, "kl": 0.0003550604835445115, "dclose": -0.05239110624719667, "base_top_logged": 276, "top_logged": 276}, "thought": {"n": 113, "flips": 0, "dlogp": 0.00241121859794254, "kl": 0.000593083514699383, "dclose": -0.07408899332569764, "base_top_logged": 113, "top_logged": 113}, "action": {"n": 139, "flips": 0, "dlogp": -0.00017172295475222776, "kl": 0.00010069774502722838, "dclose": -0.020545383151486622, "base_top_logged": 139, "top_logged": 139}, "syntax": {"n": 16, "flips": 0, "dlogp": 0.006799446330106207, "kl": 0.0004897456858173332, "dclose": -0.1799682378768921, "base_top_logged": 16, "top_logged": 16}, "close": {"n": 4, "flips": 0, "dlogp": 0.013379483629250899, "kl": 0.0022810369001717845, "dclose": 0.013379483629250899, "base_top_logged": 4, "top_logged": 4}, "think": {"n": 4, "flips": 0, "dlogp": 3.546963267808678e-05, "kl": 5.297791176417377e-06, "dclose": -0.10152673721313477, "base_top_logged": 4, "top_logged": 4}}
DONE 1319.0
/home/keith/gemma-v2/wsp31/authors/gpt/scratch/turn13/reader066/REPLAY_DONE

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
[... 1163 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Finalizing tool execution**

 succeeded in 5127ms:
READY /home/keith/gemma-v2/wsp31/authors/gpt/queue/code-reader-damp-r4-066

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 1160 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Inspecting record and status outputs**

 exited 1 in 929ms:
OK edit: 300 modules changed (of 300 present), r=4, max |dW|_F/|W|_F 0.007173 at 15.k_proj
OK ctrl: 300 modules changed (of 300 present), r=4, max |dW|_F/|W|_F 0.00717 at 45.v_proj

GPU 0 remained occupied; GPU 1 was not used. The documented g31 forward implementation ran with device=cpu, mirror=True, dense-weight caching and 16 CPU threads. The edited CPU backend is **NOT VERIFIED against serving**. This does not verify the current serving numerics or long-episode behavior.
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]
[line removed by the dashboard scrubber]

[line removed by the dashboard scrubber]
|---|---:|---:|---:|---:|
| edit / all | 276 | 12 | -0.017240 | 0.063192 |
| edit / thought | 113 | 11 | -0.040688 | 0.129620 |
| edit / action | 139 | 1 | -0.008572 | 0.003934 |
| edit / syntax | 16 | 0 | +0.001821 | 0.005697 |
| edit / close | 4 | 0 | +0.250549 | 0.538916 |
| edit / think | 4 | 0 | -0.000060 | 0.000068 |

[line removed by the dashboard scrubber]

[... 1213 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Reviewing formatting and status constraints**

 succeeded in 743ms:
TURN_COMPLETE {"entries": ["code-reader-damp-r4-033", "code-reader-damp-r4-066"], "edit_flips": [12, 276], "ctrl_flips": [0, 276], "scratch_GB": 4.880110295, "finished": "2026-11-14T20:33:38.666360+00:00", "notes_words": 375}

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
+# The protocol permits these stage-1 batch summaries. No stage-2 rows or logs are used.
+arms={}
+for arm in ['base','aa','e0047','e0048']:
+ p=R/f'results/wsp31/batches/b010/{arm}/rebench/shard0_gpu0/task_results.jsonl'
+ arms[arm]={r['instance_id']:r for r in map(json.loads,p.open()) if r['instance_id'] in allow and r['instance_id'] not in deny}
+common=set.intersection(*[set(x) for x in arms.values()]);out={}
[... 1160 lines cut ...]
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))

**Validating readiness and output consistency**

 succeeded in 440ms:
| 0027 | gpt | code-reader-damp-r4-033 | queued_s1 | -8 to +14 |  |  |  | - |
-rw-rw-r-- 1 keith keith 0 Nov 14 15:33 /home/keith/gemma-v2/wsp31/authors/gpt/queue/code-reader-damp-r4-066/READY
# Author gpt - turn 13 COMPLETE: one resubmission and one new READY

Started 2026-11-14 19:22 UTC; finished 2026-11-14T20:33:38.666360+00:00; before 20:52 deadline. Champion generation 0. Exactly two round entries; do not submit a third. All own pre-test jobs stopped, zero GPU use, scratch 4.880 GB. Full receipt: code/turn13/turn_receipt.json.

Queued unchanged: 0027 code-reader-damp-r4-033 (0.330005%, 300 reader matrices, rank 4). RESUBMIT at 19:54 UTC was ingested as queued_s1. Source/frozen hashes and checkers verified. READY, old record, weights unchanged. Prediction -8 to +14 remains the original frozen prediction.

diff --git a/turn13/audit_previous.py b/turn13/audit_previous.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d39e1ab3680a8fbb1d2bb45e7c9e28423f09340
--- /dev/null
+++ b/turn13/audit_previous.py
@@ -0,0 +1,25 @@
+import json,hashlib,statistics
+from pathlib import Path
+R=Path('/home/keith/gemma-v2');A=R/'wsp31/authors/gpt';C=A/'code/turn13'
+sel=json.loads((A/'code/turn10/selection.json').read_text());fit={r['instance'] for r in sel if r['split']=='fit'}
+sets=R/'wsp31/queue/sets';allow=set((sets/'stage1_ids.txt').read_text().split());deny=set().union(*[set(p.read_text().split()) for p in sets.glob('stage2_ids*.txt')])
[... 1164 lines cut ...]
+ for name in ['adapter_config.json','adapter_model.safetensors','edit.json']:
+  a=sha(p/arm/name);b=sha(S/'rebuild033'/arm/name);assert a==b,(arm,name,a,b);out[arm][name]=a
+sizes=json.loads((p/'size.json').read_text());es={r['mod']:r['fro'] for r in sizes['edit']['rows']};cs={r['mod']:r['fro'] for r in sizes['ctrl']['rows']}
+out['max_relative_control_norm_mismatch']=max(abs(es[k]-cs[k])/es[k] for k in es)
+e=load_file(str(p/'edit/adapter_model.safetensors'));c=load_file(str(p/'ctrl/adapter_model.safetensors'))
+assert set(e)==set(c);out['right_factors_identical']=all(torch.equal(v,c[k]) for k,v in e.items() if 'lora_A' in k)
+assert out['right_factors_identical'];out['files']=out.copy() if False else 'config, weights, edit metadata identical on rebuild'
+(C/'rebuild_receipt.json').write_text(json.dumps(out,indent=2));print('REBUILD',json.dumps(out))