fix-ocaml-gc — hallucinated flag typo → 21-minute two-command A/B loop in the ROOT session

FAIL in fast2__qwen3.6-35b-a3b__20260707-224105 (qTiRRpV, 32 min wall, clean stop, reward 0). The looping the run showed from outside happened entirely in the parent/root session — the only subagent call was one scout at the very start, which worked fine (25 child turns, returned a solid codebase report at +2 min). Planner/worker/self-test/reviewer were never called; after the scout report the root did everything itself, so post-scout this trial behaved like MinimalPi. NB the earlier SubagentsPi run …145458 (xs8eXBr) PASSED this task in 79 min — mixed history, the task is solvable for 35b.

Timeline (times UTC, session start 21:15:53)

1. 21:17–21:19 — good start. Scout report lands; model reproduces the bootstrap segfault, reads runtime/shared_heap.c, identifies a plausible off-by-one in pool_sweep's free-block run-length skip and edits it (p += wh * Wosize_hd(hd) … p += Whsize_hd(hd) → p += wh * (Wosize_hd(hd) + 1) with the Whsize advance moved into the else branch). Rebuilds runtime, cp runtime/ocamlrun boot/ocamlrun.
2. 21:19 — still segfaults; the typo is born. make coldstart still dies Segmentation fault at OCAMLC camlinternalFormatBasics.cmi (fix wrong or incomplete). Reading the make V=1 output, the model's thinking (pi.txt line 233) says: "I see! The actual command includes -nopervasatives" — a hallucinated misreading of the real flag -nopervasives in stdlib/Compflags. The misspelling never existed anywhere in the repo; it lived only in the model's head, but it anchored the next 26 minutes.
3. 21:19–21:25 — paranoid rabbit hole. Confusion compounds because the crash is heap-layout-sensitive: the model's manual compile with absolute paths and the correct flag succeeded (no output), while the same compile under make (relative paths) segfaulted — so it concluded the flag was the variable. Testing -nopervasatives (the typo) errors, while -help | grep -c nopervas says the option exists → "contradiction". It escalates to od/xxd hexdumps, strace, md5sum, env -i, python/node spawn probes, /proc cmdline checks, LD_PRELOAD/alias hunts. It edits stdlib/Compflags three times (remove -nopervasives → restore → remove again; final state: removed, i.e. the build left sabotaged).
4. 21:24:59–21:45:38 — the loop. From pi.txt line 1874 to the end: 326 consecutive tool calls strictly alternating two commands, 163 full cycles: - A: boot/ocamlc -help | grep -c "nopervas" → always 1 - B: env -i … make camlinternalFormatBasics.cmi V=1 | head -1 | xargs -I{} bash -c '{} …' → always Error: Unbound module Stdlib (exit 123, expected once the flag was stripped from Compflags) The thinking blocks repeat verbatim across cycles — one of the two literally opens "OK, I've been going in circles for too long" every time. Each turn is tiny (~100–160 output tokens, stopReason=toolUse), so nothing in the harness fires: no length stops (write guard/recovery idle), text length 0 (runaway recovery needs >8k chars of no-toolCall TEXT), bash commands fast (bash_timeout=90 irrelevant), and the fast2 cap was auto-dropped for the subagents harness. The context pruner DID fire twice (pr:2, peak ctx 154k) — and changed nothing: pruning old tool results does not perturb the tail of the context that feeds the repetition. ~65% of the trial's wall clock burned here.
5. 21:45:42 — loop exits by luck, not design. One generation happens to emit thinking with no tool call (stop, 0 text chars) → pi print mode ends the session normally. Verifier: tests.txt contains only make Entering/Leaving — the required make -C testsuite one DIR=tests/basic was never run. Reward 0. Totals: 557 turns, 140k output tokens, 59.8M input (99.5% cache hit).

Takeaways

• This is a new loop shape none of the existing mechanisms cover: cross-turn tool-call ping-pong with tiny coherent generations. The runaway recovery covers long no-toolCall text; the (proposed) DRY sampler covers within-generation degeneration (;n;p;n;p…). Here every single generation is short and locally sensible — the repetition is only visible across turns. A duplicate-tool-call detector in the extension's tool_call hook (hash of toolName+args, rolling window) is external-ground-truth Tier-1 per IDEAS-nudge-detectors.md: on the Nth exact repeat, block with a nudge ("you already ran this exact command N times with the same result — do something different"). The error result also perturbs the context, which may itself break the verbatim-repetition groove. SHIPPED 2026-07-08 as the LOOP_GUARD knob (algorithm adapted from the npm pi-loop-police extension; thresholds tuned on 102 passing trials; deterministic gate scripts/check_loop_guard_logic.py + e2e tool-loop-blocked 3/3). This trial's loop would have been blocked at its 2nd cycle, ~20 minutes earlier. Benchmark rerun still pending.
• Scout-only delegation, again. The strengthened "very FIRST action" prompt reliably gets the scout call, but the remaining stages (planner/worker/self-test/reviewer) were skipped without any subagent errors — the self-serve fallback clause wasn't the trigger, the model just never went back to the tool. A reviewer stage would likely not have saved this trial (parent was stuck pre-review), but the A/B is measuring "scout + MinimalPi" more than the full staged workflow.
• Child transcripts were unrecoverable — rm -rf .pi-subagents ran at trial end, so the scout's own session couldn't be inspected (open ledger item to move it to /logs/agent instead; this analysis had to rely on the parent-side tool result alone).
• The final workspace was worse than untouched: GC edit of unverified correctness + -nopervasives stripped from Compflags. Nothing verified, nothing reverted.

2026-07-08 rerun WITH loop guard (kc83EVe) — the loop moves into an uncapped planner child

ERR/CancelledError in fast2__qwen3.6-35b-a3b__20260708-073412 — the user killed the trial at 1h28m (no verifier ran). Knobs were the tangled night batch: loop_guard=on strip_thinking=on keep_tool_results=10 subagent_nudges=on bash_timeout=90, so this is NOT a clean loop-guard A/B. Same night, 27b PASSED this task in 31m38s with identical knobs. Totals: 104 root turns, 3.35M input tokens (vs 59.8M in qTiRRpV — the context strip cut replayed context ~18×) / 155k output.

Timeline (root session 06:38–08:06 UTC):

1. +0 — scout fine, again. First action is the scout call; a solid 8.5k-char report lands in 64s.
2. +1 to +15 min — root self-serves the investigation (same as qTiRRpV), reproducing the segfault and finding the pool_sweep region, but now with many turns saturating the 8k reasoning budget (out=8.2k tok, ~1 min each; 16 such turns across the trial).
3. +11 min — first planner child dies in ~4 min. Its parent-side result embeds a LOOP DETECTED block on a repeated grep followed by a text-only "Let me apply the fix using sed directly without re-reading the file" → the child session ends with exit 1 ("planner failed"), fix NOT applied. Root edits shared_heap.c itself and rebuilds.
4. +16 min — second planner call blocks the root for 62 MINUTES (~70% of the trial; children share the llama-swap slot and have NO wall-clock cap). The root later cats the child's session.jsonl tail-100: ≥48 LOOP DETECTED blocks in the child's last 100 events — the guard fired constantly inside the child, but the child wove around it with small argument variations, then died exit 1 right after another blocked read, again announcing "I now have a thorough understanding … Let me implement the fix" without implementing. NB pi-subagents returned BOTH failed children with isError=False, so the nudges' errored-call exclusion and the root's own perception treat them as successes.
5. +78 min to cancel — root near-loop under the guard's radar. Re-reads the same regions with tiny variations (read shared_heap.c offset=578 with limit 25/35/40/50; sed -n '1255,1275p' major_gc.c vs its head|tail equivalent), most turns burning the full 8k thinking budget. The guard blocked 3 exact repeats in the root; the variations are different hashes by design, so it can't fire. The 6×-re-read shape is also consistent with the context-strip amnesia risk recorded in the ledger (thinking stripped + old tool results stubbed = both memory channels gone).

Takeaways:

• Loop-guard verdict on its original target: the verbatim A/B shape did not recur in the root — blocked repeats stayed at 3 and the model pivoted each time. But a determined loop degrades into near-duplicates (offset/limit jitter, command paraphrases) that per-call hashing tolerates by design; the guard converts hard loops into slow grinding, not progress.
• The uncapped subagent child is now the dominant wall-clock hole. The 62-min planner child is strictly worse than qTiRRpV's 21-min root loop: invisible from the root transcript while it runs, uncapped (fast caps are auto-dropped for subagents harnesses and apply only to the root pipeline anyway), and its transcript is destroyed at trial end.
• Child exit-1-right-after-a-LOOP-DETECTED-block appeared twice. Shape: guard blocks a call → child replies text-only ("let me do X") → print-mode session ends → exit 1, work lost, parent told isError=False. Whether the guard's error result causes the text-only reply or just precedes it needs the child transcripts (open ledger item to preserve .pi-subagents).