| # AGENTS.md — handoff for the rubric collection + wall-clock experiments |
|
|
| Written 2026-08-16. Read `CLAUDE.md` first for the project's hard rules; this file |
| is the operational state on top of it: what is running, what is measured, what is |
| built but unrun, and the traps that have already cost time. |
|
|
| --- |
|
|
| ## 0. TL;DR for a new agent |
|
|
| - **You do not need a GPU on your machine.** All GPU work runs on GKE. Your box is |
| a coordinator; a laptop is enough. |
| - **Nothing irreplaceable lives on any single box except `.env`.** Code, rubric |
| libraries, prompts, splits and `rubric_gen/results/*.json` are in git. All 46 |
| experiment runs are in GCS. 36 prepared competitions (153 GB) are in GCS. |
| - **The wall-clock experiment is complete and the interpreter wins.** Ten |
| implementation defects were found and fixed; the honest conclusion is that |
| feedback *precision* is the binding constraint, not speed. |
| - **The new targeted-collection pipeline is BUILT AND NEVER RUN.** Three scripts, |
| two known blockers. See §5. *Update 2026-08-15: now RUNNING at K=10 — see §8; |
| Blockers B and C are fixed in code, A is being diagnosed by a live pilot.* |
|
|
| --- |
|
|
| ## 1. Setting up on a new machine |
|
|
| ```bash |
| git clone git@github.com:7peng/agent-cwm.git && cd agent-cwm |
| |
| # 1. credentials. NOTE: in the original checkout `.env` was a SYMLINK to |
| # /root/.agent-cwm.env, which lives on the pod's EPHEMERAL overlay, not on the |
| # network volume -- one teardown from losing every key. A durable copy is at |
| # /workspace/agent-cwm/.env.backup-onvolume (gitignored via `.env*`). |
| cp /workspace/agent-cwm/.env.backup-onvolume .env && chmod 600 .env |
| # keys present: ANTHROPIC_API_KEY OPENAI_API_KEY GEMINI_API_KEY GITHUB_TOKEN |
| # KAGGLE_API_TOKEN HF_TOKEN WANDB_API_KEY OPENROUTER_API_KEY ELEVENLABS_API_KEY |
| |
| # 2. GCP auth (interactive — a human must do this) |
| gcloud auth application-default login # project edward-sun, region us-east1 |
| |
| # 3. coordinator venv (no kubectl, no docker needed) |
| python3 -m venv gke/.venv |
| gke/.venv/bin/pip install google-cloud-storage kubernetes google-auth |
| |
| # 4. analysis venv (only for local plotting / probes) |
| python3 -m venv .mlebench/venv |
| .mlebench/venv/bin/pip install -e "swe-rubrics[openai,anthropic]" matplotlib pytest |
| |
| # 5. restore experiment results from GCS (they are gitignored) |
| V=gke/.venv/bin/python |
| for r in v5A v5B v6 v7 gated1 cont1 errcol1 errcol2; do |
| $V gke/submit_eval.py collect --run $r |
| done |
| ``` |
|
|
| You do **not** need to download competition data locally. Pods fetch prepared |
| tarballs from `gs://edward-sun-agent-cwm-evals/data/<comp>/prepared.tar.gz` |
| in-region at ~850 MiB/s — measured 0.1–1.6 min per competition. Only prepare data |
| locally if you are adding NEW competitions. **`KAGGLE_API_TOKEN` IS in `.env`** -- |
| an earlier note in this file said Kaggle was unavailable, which was wrong: the test |
| that produced that conclusion ran without the env file loaded. `~/.kaggle` is empty |
| and the installed client (2.2.4) wants OAuth or `KAGGLE_API_TOKEN`, so |
| `export KAGGLE_API_TOKEN=...` from `.env` first. Rules acceptance per competition is |
| still manual on kaggle.com. |
|
|
| **Gitignored, so do not assume a fresh clone has it:** `.env`, `.mlebench/`, |
| `reports/plots/`, `gke/.venv/`, `data/gke_runs/`. |
|
|
| --- |
|
|
| ## 2. Where everything lives |
|
|
| | thing | location | durable? | |
| |---|---|---| |
| | performance rubrics | `rubric_gen/out/performance_dl/` (430 md) | git | |
| | runtime rubrics | `rubric_gen/out/runtime_cost/` (56 md) | git | |
| | error rubrics | `rubric_gen/pools/rubric_db_errors_v8_branched.jsonl` (245) | git | |
| | gated performance set | `rubric_gen/out/performance_gated/` (22) | git | |
| | held-out eval programs | `rubric_gen/pools/eval_scored_wallclock_v1.jsonl` (26) | git | |
| | frozen split | `rubric_gen/splits/error_side_5_15.json` | git | |
| | experiment rows | `data/gke_runs/*.jsonl` | **GCS only** | |
| | competition data | `gs://edward-sun-agent-cwm-evals/data/` (36 comps, 153 GB) | GCS | |
| | findings write-up | `rubric_gen/WALLCLOCK_FINDINGS.md` | git | |
| | dashboard | `dashboard.html`, published to https://codingwm.github.io/ | git | |
|
|
| GCS bucket `gs://edward-sun-agent-cwm-evals`, GKE cluster `agent-cwm-evals`, |
| project `edward-sun`, region `us-east1`. **Never point anything at |
| probe-factory/qd-bloom (us-central1).** |
|
|
| --- |
|
|
| ## 3. Experiment state |
|
|
| Complete, all on the frozen 5/15 split, 1800 s per arm, coder |
| `claude-haiku-4-5`, world model `claude-opus-5`, selector = the coder's model: |
|
|
| | run | what it tested | result | |
| |---|---|---| |
| | `v5A`+`v5B` | baseline after 8 fixes, 731 rubrics | interpreter improves 58% of programs vs 25% for the best WM arm | |
| | `gated1` | 22 causally-gated vs 430 ungated | gating cuts breakage 10→7, wins head-to-head 4/7, still loses to interpreter | |
| | `v6` | 9th fix: rubric body delivered to the coder | head-to-head +4.4% on race, but improved-rate 20%→18% | |
| | `v7` | 10th fix: rubric body reaches the INDEX | **IN FLIGHT** (was 9/20 at handoff) | |
| | `cont1` | GPU contention A/B | 1.74× slowdown at 3 workers/GPU; timeouts 26%→38% | |
|
|
| Headline numbers (`v5`, complete, 97 arm-runs / 20 programs): |
|
|
| | arm | graded | improved | broke | median turns | budget used | |
| |---|---|---|---|---|---| |
| | `wc_interp` | 79% | **58%** | 4 | 14 | 97% | |
| | `wc_race` | 55% | 25% | 9 | 84 | 66% | |
| | `wc_cwm` | 47% | 21% | 10 | 80 | 62% | |
| | `wc_patchrev` | 45% | 15% | 11 | 64 | 62% | |
| | `wc_revise` (floor) | 16% | 11% | 16 | 100 | — | |
|
|
| ### The mechanism, in one line |
|
|
| The world model takes 8× more turns and delivers **fewer** actionable signals |
| (6/program) than the interpreter (10 executions/program), because **87% of its |
| turns find nothing**. At causal precision 0.196 the effective signal is ~1.2 |
| against the interpreter's ~10 — an ~8× deficit. That, not speed, is the result. |
|
|
| ### Ten defects found (all were implementation, not method) |
|
|
| 1. error family never retrieved (0.1% of slots) → per-family stratified slots |
| 2. silent world model triggered a blind rewrite (80% of turns) → widen, never edit |
| 3. same bug in the race arm's own branch |
| 4. repeated fires thrashed → escalate to a surgical diff on the 2nd fire |
| 5. sweep spent the budget on the LLM selector → embedding-only sweep |
| 6. programs hardcoded the collecting box's data root → `relocalize_data_root` |
| 7. keep-best froze on the original at 0 violations → ties go to the later version |
| 8. predictive rubric body dropped when the WM **judged** → raw markdown as `wm_text` |
| 9. predictive rubric body dropped in the **coder's feedback** → carry `detail` |
| 10. predictive rubric body dropped at **indexing** (41% of library keyed by a |
| one-line title) → `embed_key` includes `wm_text` |
| |
| Fixes 8–10 are the same root cause at three stages. Fix 10 was found by a |
| planted-target probe, not by reading traces — a retrieval miss leaves no trace. |
|
|
| ### Corrections already made (do not re-derive these wrongly) |
|
|
| - **Runtime rubrics select hard programs; they do not break them.** 11/11 broke |
| looked causal until the interpreter control showed it also fails on those |
| programs (3/7 vs 12/12). Any "the feedback caused X" claim needs the |
| interpreter's outcome on the SAME programs. |
| - **The race arm uses 66% of its budget, not 18%.** The 18% came from 7 rows. |
| - **Duplication is error-family-specific**: performance 98% unique titles, runtime |
| 100%, error only 54%. |
| - **Gating the 430 is blocked by lost provenance**, not only compute. |
|
|
| --- |
|
|
| ## 4. Measured numbers for planning |
|
|
| Do not re-estimate these; they are measured. |
|
|
| | quantity | value | source | |
| |---|---|---| |
| | states per initial program | 1.9 | errcol2 | |
| | eligible code error rate | 27% of states | errcol2 | |
| | clean rate | 52% | errcol2 | |
| | timeout rate | 21% @1800 s, 38% @3 workers/900 s | errcol2, cont1 | |
| | **error curation emit rate** | **25%** (20 states → 5 written) | `out/error_focused_summary.json` | |
| | **→ error rubrics per program** | **0.13** (≈8 programs per rubric) | chained | |
| | perf pairs → candidates | 1.56 (333 → 520) | `out/conceptual_candidates_summary.json` | |
| | candidates → rubrics | ~83% | 520 → 430 | |
| | GPU contention factor | 1.74× at 3 workers | cont1 | |
| | curation throughput | 9.6 calls/s @32 workers | measured | |
| | whole-library curation | 10–15 min | computed from above | |
| | collection, 77 states | 15.8 h serial → ~16 min at 60-way | errcol2 | |
|
|
| **Curation is minutes. Collection is hours. The bill is set by the emit-rate |
| chain (0.13 rubrics/program), not by GPU count.** |
|
|
| GPU quota, `us-east1` (verified via the compute REST API, not assumed): |
| L4 16 on-demand + 16 spot, T4 8 + 8, A100 16 + 64. **~115 of 128 idle.** |
| A100s exist only in `us-east1-b` in this region and spot stockouts there are real. |
|
|
| --- |
|
|
| ## 5. The new collection pipeline — BUILT, NEVER RUN |
|
|
| Three scripts, all committed, 244 tests passing: |
|
|
| ```bash |
| # one competition per invocation, so each gets its own GPU pod |
| python3 rubric_gen/collect_targeted.py --competition <comp> \ |
| --n-error 10 --n-perf 10 --max-programs 15 --perf-turns 3 --timeout 900 \ |
| --out data/tgt_<comp>.jsonl |
| |
| # both families, provenance preserved; perf goes to the VALIDATED spine |
| python3 rubric_gen/curate_targeted.py --states data/tgt_*.jsonl \ |
| --out out/targeted_v1 --workers 32 |
| python3 rubric_gen/write_rubrics.py --library out/targeted_v1/candidates_perf.jsonl \ |
| --out-dir out/targeted_v1/perf_rubrics # stage 3, do not skip |
| |
| # K-source / M-eval manifest |
| python3 rubric_gen/make_split.py --k 10 --add-eval <5 ids> \ |
| --acknowledge-invalidates --out splits/scale_10_15.json |
| ``` |
|
|
| Routing: crash that is a code defect → error state; clean+graded → climb for score, |
| each improved variant → performance state; timeout → runtime state. Stops when both |
| per-family targets are met. Replaces `--n`, which cannot control what you get. |
|
|
| **Prompts are unchanged from the validated banks.** Error reuses |
| `errors/prompts.py`. Performance drives `prompts/conceptual_prompts.py` |
| (`TRACE_DIAGNOSE`) and hands candidates to `write_rubrics.py`. An earlier draft |
| invented its own performance prompt; that was removed because rubrics from a |
| different prompt are not comparable with the bank that produced the good |
| precision/recall. The real spine also gives you the **novelty constraint** |
| (dedup against existing criteria — the error family's missing 46%) and |
| **`proposed_patch`**, which `wc_patchrev` applies and the surviving 430-rubric |
| export lacks. |
| |
| ### Blocker A — the performance path yields 0 rubrics |
| |
| `errcol2` produced 40 clean programs and **0 graded** ones, so climbing never ran |
| (`one_trajectory` only climbs `if grading:`). Diagnosed as far as: |
|
|
| - `DATA_DIR` is env-driven and correct; `run_shard.py do_cmd` sets |
| `MLEBENCH_DATA_DIR=/scratch/data/mle` |
| - a CPU-only pod confirmed `prepared/private/` is present and a self-grade returns |
| a score |
|
|
| So the failure is in **the submission each program writes**. `_grade_train` |
| swallowed the exception; it now logs it. **Next step: one-competition pilot and |
| read the logged error.** Until then the perf ETA has an unmeasured factor (the |
| climb improvement rate). |
|
|
| ### Blocker B — the split arithmetic |
|
|
| Only 20 competitions are in the split, so `K + M <= 20`. `--k 10 --m 20` is |
| impossible. The fix is `--k 10 --add-eval <5 new>`, and **5 usable spare |
| competitions are already prepared in GCS** (no Kaggle needed): |
|
|
| ``` |
| detecting-insults-in-social-commentary 0.00 GB |
| the-icml-2013-whale-challenge-right-whale-redux 0.20 GB |
| histopathologic-cancer-detection 5.31 GB |
| aptos2019-blindness-detection 8.60 GB |
| siim-isic-melanoma-classification 86.24 GB <- impractical per pod |
| ``` |
|
|
| Note `make_split.py --add-eval` currently checks for **local** prepared files; it |
| needs extending to accept GCS-resident competitions. Promoting 5 eval competitions |
| to source **voids prior eval numbers on them** — the script refuses without |
| `--acknowledge-invalidates`, and that is a human decision, not an agent's. |
|
|
| --- |
|
|
| ## 6. Traps that have already cost time |
|
|
| - **`/workspace` is a RunPod network volume (`mfs#...runpod.net`, 755 T); `/`, |
| `/root` and `/tmp` are a disposable 100 G overlay.** The repo and all 7.4 GB of |
| untracked `temp/` work survive a pod teardown; anything under `/root` does not. |
| That is how the credential symlink above became a hazard. `df -h <path>` before |
| assuming a file is safe. |
|
|
| - **`--mode cmd` gives EVERY shard ALL listed competitions.** One job per |
| competition, or every pod downloads 28 GB. |
| - **Pod resources are not in pod logs.** `--memory` is a string (`48Gi`, not `48` |
| — `48` means 48 *bytes*) and ephemeral storage comes from `GKE_EPHEMERAL` |
| (default `10Gi`). Reconstructing a command from a log silently drops both and |
| you get `FailedMount ... no space left on device`. **Diff against a Job that |
| completed cleanly**, not against the failing pod's events. Known-good: |
| `GKE_EPHEMERAL=100Gi --cpu 8 --memory 48Gi --scratch 150 --gpu nvidia-l4`. |
| - **Regenerating `dashboard.html` destroys 19 figures.** `reports/plots/` is |
| gitignored and most PNGs were built on a retired machine, so `make_dashboard.py` |
| emits "missing figure" boxes. Use `codeworld-gym/scripts/inject_tab.py` to |
| transplant one tab into the complete page. Same for the published |
| `index.html`, which also carries a hand-added banner no template knows about. |
| - **`prepared/` directories can exist with zero files.** |
| `detecting-insults-in-social-commentary` locally is an empty shell. Check file |
| counts, not directory existence. |
| - **`--workers 3` inflates timeouts 26%→38%.** Fine for error collection (a |
| TypeError is contention-immune), wrong for runtime collection (a timeout is only |
| meaningful under sole occupancy). The existing 56 runtime rubrics were collected |
| at 3–4 workers and should be re-examined. |
| - **Collection on containers changes what you collect.** 14 of 20 "eligible" |
| states in `errcol2` were `/dev/shm` exhaustion, not code defects. The filter is |
| in `collect.py is_eligible_error`; keep it. |
| - **Spot is right for collection, wrong for eval.** A preempted collection shard |
| loses a few programs; a preempted eval shard destroys a paired comparison. |
| - **Do not fit anything on the eval set.** A fire→outcome rubric filter derived |
| from eval and then reported on eval is leakage. Derive on train, apply to eval. |
|
|
| --- |
|
|
| ## 7. What I would do next, in order |
|
|
| 1. **Finish `v7`** and compare against `v6` on common programs. Registered |
| prediction: the retrieval fix raises the head-to-head margin and may again |
| LOWER the improved-rate. If so, three individually-correct fixes all point at |
| precision being the binding constraint. |
| 2. **One-competition collection pilot** to fix Blocker A and measure the climb |
| improvement rate — the last guess in the collection ETA. |
| 3. **Train-side fire→outcome filter.** The only unblocked precision lever: label |
| each fire by whether the arm underperformed the interpreter on that same |
| program, derive on train, apply to eval. 846 firing turns are already logged; |
| 64 rubrics have ≥3 fires; 5 always fired on a program the arm lost. |
| 4. **k-vote world-model judge** — fire only on majority of k independent verdicts. |
| Free: the budget is only 62% used and a WM turn is ~9 s. Do NOT gate on |
| self-reported confidence; that was measured uninformative. |
| 5. **Per-family embedding keys.** Measured: keying prose rubrics on `wm_text` |
| alone puts a planted target at median rank 5 (vs 45 shipped, 287 before), but |
| costs the performance family (6 → 22). Since retrieval is stratified per |
| family, per-family keys should get both. |
| 6. Only then scale the library. 83% of the current 731 never fires once, so |
| "mine more rubrics" is the weakest lever until precision and retrieval are |
| fixed. |
|
|
| --- |
|
|
| ## 8. Session 2026-08-15: K=10 scale-up launched (fixes + fleet state) |
|
|
| Continuation of §5/§7 by the next agent. Four fixes landed (all committed, |
| 249 tests pass), then the collection and eval-pool fleets were launched. |
|
|
| ### Eleventh defect: the GPU spread assumed the retired 4-GPU box |
|
|
| `collect.execute` and `wallclock_assist` pinned every program to |
| `CUDA_VISIBLE_DEVICES` ∈ {"1","3","0"} — correct on the old shared box, |
| wrong on every fleet pod, which has exactly ONE GPU enumerated as device 0. |
| Two thirds of programs were pinned to a device that does not exist and |
| silently trained on CPU. Verified in the banked rows: of device-printing |
| programs, errcol2 ran 27 cpu / 11 cuda, cont1 24 cpu / 5 cuda. |
|
|
| Consequences: paired arm comparisons stay fair (the device is a function of |
| state_id, shared by all arms of a program), but ALL absolute rates from pod |
| runs carry the handicap — the 21–38% timeout rates, cont1's "GPU contention" |
| (which was substantially CPU contention), and the runtime family's mined |
| timeout states. The pool is now detected per process (`collect.gpu_pool`, |
| override `RUBRIC_GEN_GPUS=1,3,0` to reproduce the old box); on GKE note |
| nvidia-smi is NOT on PATH (driver mount is `/usr/local/nvidia/bin`), which |
| `gpu_pool` handles. **v5/v6/v7/gated1 all ran pre-fix; the runtime-cost |
| family should be re-examined against this in addition to the 1.74× |
| contention factor.** |
|
|
| ### Blocker C (new, fixed): target_family never reached disk |
| |
| `one_trajectory` appends states to `--out` BEFORE `collect_targeted` |
| classifies them, and the annotation was never re-serialized, so |
| `curate_targeted` — which selects error states by `target_family` — would |
| have read a file where the field never occurs and silently curated zero |
| error rubrics. Fixed: `persist_families` writes the annotation back after |
| each program, and `curate_targeted` re-derives via `classify()` when the |
| field is missing. Regression tests in `tests/test_targeted_persistence.py`. |
|
|
| ### Blocker B (fixed): make_split accepts GCS-resident competitions |
| |
| `make_split.py --gcs-bucket edward-sun-agent-cwm-evals` accepts an |
| `--add-eval` id whose `data/<id>/prepared.tar.gz` + `meta.json` exist in the |
| bucket (the empty-shell hazard cannot occur there — the prep job refuses to |
| upload an empty prepared/public). Ids on the frozen excluded list are |
| refused. |
|
|
| ### The active split: splits/scale_10_15.json |
|
|
| K=10 source = frozen 5 + promoted {random-acts-of-pizza, |
| tabular-playground-series-dec-2021, dogs-vs-cats-redux-kernels-edition, |
| new-york-city-taxi-fare-prediction, tweet-sentiment-extraction}. Eval |
| backfilled to 15 with {detecting-insults-in-social-commentary, |
| the-icml-2013-whale-challenge-right-whale-redux, |
| histopathologic-cancer-detection, aptos2019-blindness-detection, |
| ranzcr-clip-catheter-line-classification} — all GCS-prepared; siim (86 GB) |
| deliberately left out; ranzcr was prepared-but-unlisted in §5's spare list. |
| **Prior eval numbers on the 5 promoted competitions are void** |
| (--acknowledge-invalidates recorded in the manifest). 10 of the 26 rows in |
| `pools/eval_scored_wallclock_v1.jsonl` are on promoted competitions and MUST |
| be filtered out of any eval under the new split. |
|
|
| ### Fleet runs in flight (all `--mode cmd`, code snapshot carries the fixes) |
|
|
| | run(s) | what | resources | |
| |---|---|---| |
| | `tgt10-<comp>` ×10 | targeted collection, one per source comp, `--n-error 10 --n-perf 10 --max-programs 15 --perf-turns 3 --timeout 900` | spot L4 | |
| | `tgtpilot2` | small dog-breed pilot whose job is to surface the `[grade_train]` exception (Blocker A) | on-demand L4 | |
| | `pool-<comp>` ×8 | eval-pool extension: `collect.py --split eval` + `score_states.py` on the 5 new eval comps (n=3) + nfl (3), billion-word (2), stanford-covid (2), `--timeout 1200` | on-demand L4 | |
|
|
| Collect artifacts with `submit_eval.py collect --run <name>` (cmd-mode |
| artifacts land in `shards/0-artifacts/`). Every collection/pool command runs |
| under `RUBRIC_GEN_SPLIT=splits/scale_10_15.json`. |
|
|
| ### Update, later that session: collection done (9/10), P/R measured, scaling started |
|
|
| - **Targeted library v1 exists**: `out/targeted_v1/` — 74 error + 20 perf + |
| 47 runtime rubrics from 9 source comps, full provenance, 0 curation |
| failures. facebook still collecting (see below); fold it in as batch 2 and |
| extend `_existing_criteria` to read `out/targeted_v1` first so batch 2 |
| dedupes against batch 1. |
| - **P/R on the new eval side** (`results/pr_results_targeted_v1.json`, |
| 104 states / 15 comps, opus judge, annotation truth, 6.8k decisions): |
| error precision **0.958** per decision [0.86, 1.0] (23 TP / 1 FP), |
| library-level 0.889 / recall 0.211; conceptual end-to-end **0.25/0.25** |
| vs chance 0.0105 (24x lift; canonical ungated was 0.19 at 4.1x); all |
| controls 0.000. Precision survives scaling; recall is the scaling lever. |
| - **Three more traps found live**: (1) fleet pods have no reliable external |
| internet — Connection-class download failures are environment facts, now |
| excluded from error eligibility (11 of dog-breed's 18 "errors" were this); |
| (2) shm worker crashes can hide UNDER a different terminal exception — |
| stderr is now checked for the narrow marker; (3) `candidates_perf.jsonl` |
| rows must carry `id` (annotate_truth keys on it) — emitted at curation now. |
| - **facebook-recruiting needs a 100Gi pod AND a solution memory cap.** Its |
| programs OOMKilled four pods at 48/60/100Gi. `RUBRIC_GEN_SOLUTION_MEM_GB=85` |
| (env-gated RLIMIT_AS in `collect._pin_to_block`) makes the program die as a |
| MemoryError state instead of killing the container — canary-verified live. |
| - **Anthropic org TPM is a fleet-wide budget** (12M in/min haiku): the old |
| 5×20-180s backoff died under sync retry from ~20 pods; now 8 attempts, |
| 300s cap, jittered. Size any future fleet's parallelism to this. |
| - **Scale-up in motion**: 39 prep jobs submitted for every unprepared, |
| non-excluded MLE-bench comp; failures = the manual Kaggle rules-acceptance |
| list for Edward. Next split: `--k 15` + eval to 30 at the same rate, then |
| full MLE-bench; re-measure P/R at each stage. **Do NOT launch end-to-end |
| wall-clock evals — Edward decides when.** (Pool v2 for that eval already |
| exists: `pools/eval_scored_wallclock_v2.jsonl`, 26 programs / 14 comps.) |
|
|
| ### Remaining sequence after these land |
|
|
| 1. Read `tgtpilot2` / `tgt10-*` logs for `[grade_train]` lines → fix Blocker A |
| → re-run climb where needed. |
| 2. `curate_targeted.py` over `tgt_*.jsonl` (+ `curate_runtime.py` for the |
| timeout states) → `write_rubrics.py` stage 3 for perf candidates. |
| 3. Assemble the v2 eval pool: surviving 16 rows + new `pool_scored_*` clean |
| graded states (dedupe per trajectory, ~2/comp), under the new split. |
| 4. The larger eval: wallclock arms **including wc_interp and wc_revise** (the |
| GPU fix changes execution, so v5's interpreter rows are NOT comparable — |
| every arm must be re-run post-fix), expanded library, new pool, |
| `--stratified-retrieval`, per-family fire rates in the report. |
| 5. Noise floors on this hardware (`noise_floor.py`) before any causal claim. |
|
|
| ### Scale-up dataset inventory (post-prep-fleet, 2026-08-16) |
|
|
| Bucket now holds **50 prepared competitions**. The 39-comp prep sweep ended |
| 14 ok / 10 rules-blocked / 14 size-killed (+1 rules-blocked from a diagnostic |
| rerun: plant-pathology-2021-fgvc8). |
|
|
| Rules acceptance needed (one click each on kaggle.com, then re-run |
| `prep_datasets.py submit --competitions ...`): plant-pathology-2021-fgvc8, |
| predict-volcanic-eruptions-ingv-oe, rsna-2022-cervical-spine-fracture-detection, |
| rsna-breast-cancer-detection, tensorflow-speech-recognition-challenge, |
| tensorflow2-question-answering, tgs-salt-identification-challenge, |
| us-patent-phrase-to-phrase-matching, uw-madison-gi-tract-image-segmentation, |
| vesuvius-challenge-ink-detection, vinbigdata-chest-xray-abnormalities-detection. |
|
|
| Size-killed at the default prep shape (died 26-55 min in; need bigger |
| scratch/memory AND are per-pod-impractical like siim): 3d-object-detection, |
| cdiscount, contrails, h-and-m, herbarium-2020/21/22, icecube, |
| inaturalist-2019, iwildcam-2019/20, rsna-miccai, seti, siim-covid19. |
| "All of MLE-bench" will have to either solve streaming/shared storage for |
| these or document their exclusion. |
|
|
| ### Final K=27 state (2026-08-18) |
|
|
| Library: 139 error (post-lint) / 209 perf (92 causally-proven core) / 257 |
| runtime, from 27 source comps; eval side 37 comps, corpus v5 (347 states), |
| annotations v5 (69 literal positives, 99% agreement). Finals on the frozen |
| eval: error 0.595 strict / 0.810 lenient precision, library recall 0.054; |
| conceptual ungated 0.091/0.622 at 21x chance, gated 0.164/0.545 (12 true |
| explanations). Gate pass rate 92/179 (51% proven movers). Structural |
| finding: missing-import failures cannot be caught precisely without |
| per-package rubrics (universal templates are banned at curation now — the |
| sweep-only lint let wave 4 re-derive them 6 ways). The annotation-precision |
| vs causal-precision distinction matters for e2e: the eval punishes fires on |
| real-but-secondary patterns; the gate measures score-moving fixes directly. |
| e2e remains parked for Edward's explicit go. |
|
|
