📝 Gremlins MVP phase review

docs/workpad/brainstorm/2026-10-16-22-grotto-plan-structure.md

@@ -0,0 +1,54 @@
+# Grotto: plans need code structure — user's thoughts after the headless-forks build
+
+**Date**: 2026-10-16 22:41
+**Source**: the user, written out after reading the `headless-forks` prototype (4,155 lines in one file). Recorded by Igor, session [2026-10-15-21-grotto-work](../journals/2026-10-15-21-grotto-work.md). These are the user's thoughts, kept close to their words; they are not yet decisions.
+
+## The thoughts
+
+- **The gremlin would have helped here.** A trained implementer that knows the code, forked per block, is exactly what this build lacked: every block was a cold-start agent re-reading 5–6k lines of plans, digests, run log and code.
+- **Grotto should go back to putting some code in the plan.** Not super sophisticated, but at least the **structure of the code**: modules, the data model, the main interfaces. Plans without code (Spire 0.2.x) left the architecture to whoever built each block, and per-phase contract digests then invented it piecemeal.
+- **How to approach a problem:**
+  1. Make the **happy path** work first.
+  2. Then build **proper abstractions** around the problem.
+  3. **Iterate** over it.
+  4. Trust that an Opus agent can **easily throw out lots of code**. Deleting is cheap; don't protect what was written.
+- **Open question: how much code can an Opus agent write in one go?** (The user wants to know. Worth measuring, e.g. by having one agent write the minimal gremlins version from a structure-fixing spec.)
+- **Abstraction is also about sidestepping.** More side effects and special cases need space to grow into, and a good abstraction gives them that space instead of letting them spread through if-chains.
+- **"Could all this not be expressed simpler?"** For example, resolve complex ifs into a simple, elegant `match`, or move a class up a layer because that decouples the whole structure. Simplification is design work, and no stage of the current cycle does it: reviews hunt bugs, fixes add, nothing removes.
+- The user wonders whether this is partly their own fault, for being chaotic and having too many thoughts at once. *(Igor's note: the build's failure modes — no structure in the plan, cold starts, review loops that only add — are process failures, not the user's.)*
+
+## Correction and additions (user, 2026-10-16, later)
+
+- "How much Opus can throw out" meant **how much output it can generate**, not deleting code. Igor misread this above as "trust Opus to throw code away".
+- On deleting code, the user's actual view:
+  - Throwing code away is sometimes wise, **as long as you commit before throwing it out**. History is usually useful.
+  - All code teaches something. This prototype holds a lot of wisdom and logic, and the user doesn't want to downplay it. **It was just too much.**
+  - It would have helped to have a prototype first, and then use it to write the real code.
+- The user wants the whole build bundled into a report that honestly calls it a failure. The approval waits cost time, but they are not the main issue.
+- **Guidance hasn't found its sweet spot yet.** Open question: how big are the skills in text, how much of it is filler, and is each skill truly written for an agent, or does it regurgitate knowledge the model already has?
+
+## Steering sentences cut both ways (user, 2026-10-16)
+
+- "Keep it small", "happy path first" and "delete what isn't needed" are themselves dangerous: they can fire the other way, into cut corners, missing error handling and deleted tests or needed code.
+- Igor's take on safer framing (options, not decisions):
+  - Tie size to requirements, not adjectives. Each function or module traces to an acceptance box, and anything that doesn't gets a one-line reason in the hand-back.
+  - A size *estimate* in the plan that the builder must explain deviations from. A budget to justify against, not a cap to obey.
+  - "Happy path first" as **sequencing**: the happy path runs end to end before edge cases get built. It's not a value judgement against edge cases.
+  - Reviews report "unrequested surface" as a finding category with the decision left to Igor and the user. Reviewers don't delete on their own.
+  - Pair every push with its counterweight in the same sentence, e.g. "cover the failure paths the boxes name; add no others without a reason".
+
+## Answer: how much code can Opus 5.5 produce in one go?
+
+*(Igor, 2026-10-16, from the claude-api skill's model table)*
+- One response can hold up to **128K output tokens** (Opus 5.5's cap; values that large need streaming). Thinking tokens count against the same cap.
+- At a rough 10 tokens per line of Python, that is a ceiling of about **10–12k lines in one response**. In practice it's less: the thinking share, Claude Code's own output limit (configurable, possibly lower than the API cap; not checked here), and quality, which drops over very long single outputs.
+- All of gremlins.py (4,155 lines, ~45–50k tokens) would fit into a **single response, or two**.
+- Across a session, "one go" is effectively unbounded: an agent writes file after file over many turns within its 1M context.
+- So output volume was never the bottleneck. The day went to orientation, coordination and verification, not to typing.
+
+## Related
+
+- Journal open threads: "Process lessons to accrete" (budgets, a design/size criterion in reviews, cutting unrequested additions, a plan that fixes structure, re-planning when a premise falls).
+- [goals/drop-superpowers-0.2.2.md](../goals/drop-superpowers-0.2.2.md): grotto carries the design → plan → handoff procedure.
+- [reports/2026-10-15-22-spire-vs-superpowers-plan-and-build-experiment.md](../reports/2026-10-15-22-spire-vs-superpowers-plan-and-build-experiment.md): "code in the plan adds nothing" was measured on correctness and merge choice, not on design quality.
+- Code verdict on the prototype: reports/2026-10-16-22-gremlins-code-verdict.md (pending).

docs/workpad/goals/headless-forks.md

@@ -47,6 +47,29 @@ The Athanor learns plans, design and implementer reports, not code. For hard wor
 - **Agent-tool forks**: replaced. Complex blocks go to forks of the trained implementer, and fresh Agent-tool agents stay for mechanical or distant blocks. The Agent-tool fork path is dropped from athanor.md.
 - **Model**: always an explicit full model id. The fingerprint requires it anyway, which also sidesteps plan mode's silent Haiku→Sonnet upgrade. *(Igor's default, not asked; user may override.)*
 
+### Decided 2026-10-16, naming (user)
+
+- A headless worker launched by the helper is a **gremlin**. The skill becomes `spire:gremlins` and the helper `gremlins.py`; the env marker, state folder and ledger names follow.
+- The command that creates one is **`spawn`**. Forking the base (`--resume <base> --fork-session`) is one *way* to spawn. Keeping `spawn` separate from `fork` leaves room for other spawn methods later.
+- The trained session stays the **base**. "Mogwai" was considered and dropped (trademark-adjacent, a second invented word).
+- When: a mechanical rename block at the start of Phase 3, before the skill and procedure text is written, so the release ships with the final names.
+
+### Decided 2026-10-16, platforms (user)
+
+- 0.3.0 ships **Windows-only**. On any other platform, `where` fails closed (`ok: false` with a clear reason), and the Athanor falls back to the 0.2.2 shape (fresh agents, no gremlins). SKILL.md says so.
+- Linux testing is a follow-up (WSL Ubuntu and Docker are available on the dev host). macOS stays unsupported until someone can test it.
+
+### Amended 2026-10-16, release gating (user)
+
+- 0.3.0 is **not released from Windows alone**. The work stays on the `headless-forks` branch, which gets pushed but not merged. When the Windows phases are done, an Igor on a native Linux machine and one on a Mac check out the branch, test, fix their platform and lift the fail-closed gate for it. Only then is the branch merged and released. WSL is fine for development.
+- The Windows build still ends with a handoff document for those Igors (what to test, known POSIX gaps M14 and the /proc tree walk, the smoke recipe).
+- Strongly suggested by the user: pick this up as Rust work right away as well (see reports/2026-10-16-01-session-harness-app-forms.md). Not started yet.
+
+### Decided 2026-10-16, platform seam (user)
+
+- Phase 3 adds a refactor block. All platform-specific code (detached spawn, process table, tree kill, liveness, locks, path normalisation) moves behind one interface, with `WindowsPlatform` and `PosixPlatform` implementations. No scattered `IS_WINDOWS` branches stay outside it. The green Windows suite guards the refactor.
+- Plus: a path-form test matrix (`C:\…`, `C:/…`, MINGW `/c/…`, `/tmp/…`, UNC, WSL `/mnt/c/…`) and a WSL check: does the helper run under WSL Ubuntu, and does PATH interop wrongly resolve `claude` to the Windows exe? Findings feed the Linux and Mac handoff. WSL stays fail-closed unless it passes.
+
 ## Later
 
 - Dirigent harness / MCP tool takes over the helper's job ("stable for the constables").

docs/workpad/journals/2026-10-15-21-grotto-work.md

@@ -99,6 +99,141 @@
   - Also: B0 commits the docs on main first, then a worktree `.claude/worktrees/headless-forks`. The harness flagged a "settings-json" pattern in the report: it's only a mention of `.claude/settings.json` (U4), no instruction.
   - Open, for the user before Phase 4: U1 test via `--plugin-dir` vs direct update; U2 trial plan + arm C; U3 who merges and pushes; U4 Sonnet/Haiku ids in settings; U5 defaults (20 min orphan kill, $25 Phase 0 spend cap, worktree name).
   - **Igor decision for U3 within the user's "commit and push":** push the branch, don't merge to main. Merging installs 0.3.0 for every project via the marketplace. Recorded as unclear for the user.
+- B0 done: d373689 pushed (Haiku). Its reported duration was ~6.4 h wall clock, likely waiting on something (the user away overnight?); the actual work was 3 tool calls.
+- 08:15 — Into the Athanor: Phase 0 only (preflight stop gate + worktree). U5 defaults accepted, no push or merge by the Athanor, Read-tool hygiene passed on to its children.
+- User: the 6.4 h was the push waiting for their approval, not a hang. User asked whether the attacker still attacks against the code, not only conventions. Answer: yes. The conventions pass was added on top of the code attack, and the top findings were code- and harness-grounded (Bash default timeout, Windows rename semantics, the settings allow rule enabling fork-in-fork, igor/SKILL.md:112 TaskStop orphans, the P0.6 cache-prefix logic).
+- User: a separate Python console window popped up on their machine. That's Phase 0's P0.1 detach test (a detached supervisor spawned with console-creating flags). Told the Athanor: CREATE_NO_WINDOW / pythonw, add "no visible window" to the P0.1 pass criteria, retest, clean up leftover processes.
+- 09:55 — User asked what's running and why "$25". Igor checked the scratch state directly.
+  - The hour was P0.6, the cache-lifetime test, by design: two bases trained at 08:48; base A pinged at +50 min, both forked at +65 min. Result: A, pinged, had a full cache hit (ratio 1.0, fork delta $0.018); B, not pinged, missed (ratio 0.08, delta $0.69). This confirms the 1 h TTL and that a hit refreshes it. The run finished 09:54, and its python process (PID 34968, likely the visible window) has exited.
+  - Auth is OAuth/subscription: the Desktop's claude.exe 2.1.299, and the 1 h cache writes only happen on a subscription.
+  - The "$25" is the notional `total_cost_usd` that claude -p reports at API rates. It's a usage proxy against plan limits, not a bill. Igor's phrasing "spending cap" was misleading.
+- 12:17 — Phase 0 done: **GO**, all STOP items pass. Branch headless-forks commits 7421d3a, 83f6bac (not pushed).
+  - P0.1 passes on rung 3 (CIM launch, hidden window). The window fix was verified in 26 checks.
+  - P0.2: a 182k-token base forked with a ~1.0 cache ratio. P0.3: usage semantics clear. P0.4: parallel runs fine. P0.5: unlisted models get silently substituted, with a warning event. P0.6: TTL confirmed. P0.8: injection works, but `allowed-tools` didn't pre-approve in an untrusted dir (trusted case → Phase 4).
+  - Spend: $5.68 notional over 45 calls.
+  - Deviations logged for the reviewer: P0.6 started before P0.1(c) finished; 6 tool-less calls outside the clone; two runs on the PATH binary; the host suspended 10:13→12:16.
+  - Igor: no separate review for the preflight (its deviations go to the Phase 1 reviewer as flags). Decisions sent: rung 3 default, forks forbid run_in_background, the U4 model check keys on the warning, "no visible window" is permanent, the binary is always fingerprinted. Resumed the Athanor for Phase 1.
+- User is switching to auto mode: the stalls come from approval prompts they weren't there to click, not from sleep. Igor: there were 2 pushes on request (a7ce5db, d373689); the d373689 push stalled ~6.4 h. The Athanor never pushes. The cause of the 10:13→12:16 gap during Phase 0 is unknown; possibly a prompt, not a suspend as the Athanor guessed. Policy from now on: one push at the very end. Watch for auto-mode refusals of CIM launches or process kills in Phase 1.
+- 15:57 — Phase 1 back: the helper core in plugins/spire/skills/forks/ (cb65d88).
+  - 69 unit tests are green against a stub claude. The live smoke passed (forks hit the cache, fingerprint ok, kill leaves nothing alive, ledger and costs consistent, no window). Spend $0.49.
+  - The Athanor wrote its own contract digest for details the plan left open (flagged for the reviewer).
+  - The clock jumped again 12:31→15:42 during block 1.2, likely another approval prompt waiting.
+  - Dispatched a fresh `spire:reviewer` (pin) for Phase 1, including Phase 0's flags.
+- Phase 1 review (claude-opus-5-5[1m], 20b049e): 0 Critical, 3 Important, 16 Minor.
+  - I1: pre-answer errors misreported as model_refused (traced to the Athanor's own contract digest).
+  - I2: pid-reuse in the tree walk can kill unrelated processes (dwm/winlogon candidates exist on this host).
+  - I3: `continue` overstates warmth.
+  - Routed as one fix pass: I1–I3 plus the minors with real impact here (suspend-aware orphan watchdog, since the host suspended twice; lock deadline and race; dedup of the ledger; child guards; permission modes; a BASE_URL warning). The rest are deferred and logged. A fresh reviewer re-checks after the pass.
+- Fix pass done (7b9b748, 4515dbb, e60f94c): I1–I3, M1–M5 and M9 fixed, each with a test that fails on the old code. 86 tests green. M6–M8 and M10–M16 deferred with reasons. Residual flags: the I2 last-interval gap, an M2 put-back race, M3 stall/wall_s still counting suspended time and backwards jumps unhandled. Dispatched a fresh reviewer re-check (pin).
+- Phase 1 re-check (claude-opus-5-5[1m], 60fdea0): all 9 resolved; the new tests fail on the old code (20 failures, 14 errors); no weakening; residual flags accepted as Minor. One new Minor, R1: a kill between the registry and ledger writes loses the ledger line (fix: reconcile against results/ in Phase 2). **Phase 1 closed.** Resumed the Athanor for Phase 2 with R1, the Phase-2 deferred Minors and M10 decided per plan §4.3 (train accepts overrides).
+- Naming decided by the user: fork instance → **gremlin** (skill spire:gremlins, gremlins.py); creation command → **spawn** (forking is one spawn method, which leaves room for others); the trained session stays **base** (mogwai dropped: trademark-adjacent). Recorded in the goal. It will be sent to the Athanor with the Phase 3 go as the first, mechanical block; held back now so Phase 2 isn't disturbed mid-run.
+- 17:30 — Status check: Phase 2 on pace (2.1 16:57, 2.2 17:23, a child on the next block). Today's slowness was ~11 h of approval waits, a 1 h TTL test by design, and the review loop. forks.py is 3,420 lines (+3,020 test lines), mostly Windows process handling: input for the Rust app report (this belongs in a binary with dirigent_process).
+- User: and mac/linux are untested. Facts: the POSIX path is untested (M14: kill misses claude on POSIX; a dead root claims nothing without /proc). This host has WSL Ubuntu-20.04 (stopped) and Docker (Rancher) → Linux is testable here; macOS isn't. Igor's proposal: `where` fails closed on untested platforms, so the Athanor falls back to the 0.2.2 shape; plus a Linux test lane via WSL/Docker as a Phase 3 block or a follow-up.
+- User decided: 0.3.0 Windows-only, `where` fails closed elsewhere, Linux testing is a follow-up. Recorded in the goal; it goes into the Phase 3 brief alongside the rename.
+- User amended the release plan:
+  - Keep it on the branch, no 0.3.0 release from Windows alone. Igors on native Mac and Linux machines test and fix the branch afterwards, then it merges. WSL is fine for development.
+  - Recorded in the goal. Dismissed the post-merge Linux card (superseded). The Phase 3 brief adds a cross-platform handoff doc.
+  - The user strongly suggests picking it up as Rust work right away (not started; "for now continue here").
+  - Matches the U3 call already made: push the branch, don't merge.
+- User:
+  - Check whether WSL needs adjustments, and test uv under MINGW bash; path handling would expose anything too platform-specific.
+  - Wants platform-specific code modular, behind abstractions: a worthy refactor, could happen on the Linux box.
+- Igor checked:
+  - The Bash tool here *is* MINGW64 (Git Bash, MSYS 3.1.7), so all of P0/P1 already ran uv under MINGW. Open MINGW issue: M13, `/tmp`-style paths (in Phase 2).
+  - forks.py has no platform abstraction: one `IS_WINDOWS` flag and about 12 scattered `if IS_WINDOWS` branches (spawn, process table, tree kill, liveness, locks, paths).
+  - WSL is the POSIX path (currently fail-closed). Footgun to note: WSL interop can resolve `claude` to the Windows exe via PATH.
+- User decided: the platform seam goes here, as a Phase 3 block (WindowsPlatform/PosixPlatform behind one interface, a path-form test matrix, a WSL check), with the Windows suite as the guard. Recorded in the goal. Phase 3 brief queue so far: (1) gremlin/spawn rename, (2) platform seam + path matrix + WSL check, (3) Windows-only fail-closed `where`, (4) skill and procedure text, (5) cross-platform handoff doc, (6) 0.3.0 bump on the branch, no merge.
+- User: avoid frequent time-consuming test runs; implement first, test at the end. Sent to the Athanor mid-Phase 2: py_compile + touched test classes between blocks, the full suite once at phase end, live calls batched at the end. This also goes into the Phase 3 brief. Possible accretion for the implementation skill: "cheap gate" should explicitly exclude the full suite when it is slow.
+- User asked what's left for grotto. Igor: everything since the fork research has been Spire build-side work. Grotto (design/plan/handoff procedure, standalone storage) is untouched apart from the endorsed probe direction. A link noticed today: probe notes + plan = the training material for a gremlin base. Proposed to take grotto up in its own session after Phases 2–3.
+- Phase 2 back (571a3d6..3b1de6c): warmth and pings, rebase and re-train flags, usage rendering with R1 reconcile, plus all folded Minors. 130 tests green. Live smoke passed (rebase hit on the new base, a real ping restored warmth). Spend $0.47. The cadence instruction arrived after the last code change. Dispatched a fresh `spire:reviewer` (pin) for Phase 2, full suite once.
+- The Athanor is at ~515k tokens after P0–P2. User: switch it out at least per phase. Applies from Phase 3: a fresh Athanor per phase, booted from the run log, the trunk notes and the phase's brief. The previous one stays available for questions only. Accretion candidate for the Igor skill's "Athanor queuing" (today it says a fresh one only "when its context looks spent").
+- Phase 2 review (claude-opus-5-5[1m], 9564c22): 0 Critical, 2 Important, 14 Minor. Both Importants trace again to points the Athanor's own contract digest left undefined:
+  - I1: `delta_tokens` counts every named .md file, so it would force a rebase before every fork, and a re-train after 4.
+  - I2: pings have no phase, so keep-warm cost is missing from phase totals.
+  - Fix pass to the same Athanor (its last job; it builds no further phases): delta = brief + explicit delta notes only; pings take the phase of the base's latest event. Plus Minors 1, 2, 8–11.
+  - Igor note, a pattern: two phases running, the self-written contract digest was the source of every Important. Candidate rule: the digest goes to the reviewer *before* the build, or Igor sanity-checks it.
+- Phase 2 fix pass done (d2d5104, ba463fc, 94c1d8c):
+  - Fixed: I1 (delta = delta header + `--delta-note` + the `## Changes since base` section), I2 (pings carry the phase), Minors 1, 2, 8–11. 137 tests green, run once. The new tests fail on the old code (9 failures, 3 errors).
+  - The run log now has a "Successor boot" section for the Phase 3 Athanor.
+  - Dispatched a fresh reviewer re-check (pin). The old Athanor is retired from building.
+- Phase 2 re-check (claude-opus-5-5[1m], 7351c40): all 8 resolved, mutant-tested. New Minors N1–N5; N3 (stale binary after an update) and N4 (an in-flight rebase vs supersede) go into Phase 3. One full-suite failure: `LaunchTests.test_refusals`, where kill returned ok:false under load; it passed 3/3 alone. Logged as a flake; Phase 3 investigates. **Phase 2 closed.**
+- Dispatched a **fresh Athanor** for Phase 3 (pin). First turn is the contract digest only, then hand back for a check before building (a new process step, per the digest pattern). Scope: rename → platform seam + path matrix + WSL check → Windows-only gate → text → platform handoff → 0.3.0 bump on the branch; plus N3, N4 and the flaky test.
+- Phase 3 digest back (5092ed8, claude-opus-5-5[1m]):
+  - 8 blocks; full rename map; a 14-member platform interface; a 15×2 path matrix; the gate closed on all Posix; N3/N4/flake fixes; the WSL procedure; text per file; the release commit.
+  - Open choices C1–C20, among them: C11 `init` also gated; C12 a porting override env var; C16 kill verification ignoring pids that left or were renamed; no live calls in Phase 3.
+  - Risks flagged: the skill's `!` injection exiting 2 on closed platforms; a uv install in WSL that runs a download script.
+  - Dispatched a pre-build digest check (fresh reviewer, pin, ~15 min).
+- Digest check (claude-opus-5-5[1m], 52c5911): 1 BLOCKER, 12 ADJUST.
+  - B1: the GateTests design could never pass and its closed case passed for the wrong reason.
+  - Notable ADJUSTs: A1 the gate bypassable via spawn/train/pings on an adopted state dir; A2 the C16 kill check hiding real survivors (empty process table, macOS); A4 re-resolve switching installs; A7 "Windows-only in 0.3.0" wording contradicting the release gating.
+  - **The new pre-build step paid off at once**: several of these would have been Important after the build.
+  - Resumed the Athanor: amend the digest (dated section), then build 3.1–3.8.
+- 22:11 — Status: Phase 3 blocks 3.1–3.6 committed. Timeline: digest amendment 18:44; rename 20:24 (~1h40); seam 20:36; gate 20:39; N3/N4/kill 21:43 (~1 h); WSL check 21:57; text 22:06; references 22:10. Block 3.7 (handoff report) just started with a fresh child. 3.8 (README, version, the single full suite, release commit) remains, then the Phase 3 review.
+- User, angry: how can a rename take 1h40? Igor had rationalized it ("touches every file"). Facts from the run log:
+  - One Opus 1M agent did block 3.1 as an audit, not a rename. It threaded a new `method` field through job, result, ledger, list and R1, diffed all 191/200 assert lines one by one, classified every remaining "fork" hit, and re-aligned continuation lines, all on 3.4k + 3k lines.
+  - A sed rename plus one test run would have been ~10–15 min.
+  - **Igor's fault**: the brief and digest called it "mechanical" but specified a 10-part rename map and audit-grade checks, with no model downgrade and no timebox.
+  - Accretion candidate: mechanical blocks get a cheap model, a scripted transform and a timebox; the review checks them, the block doesn't self-audit.
+- User: timebox 3.7 and 3.8; the review is one focused pass, then push. Sent to the Athanor: 20 min each, no self-audit essays, one full suite run, failures recorded rather than looped on.
+- User, angry: "this happens all the time … not following orders … secret sauce to make every job expensive?" Igor's honest account: no hidden incentive, but a real pattern of Igor not constraining cost:
+  - every agent on Opus 1M;
+  - no time or token budgets in briefs;
+  - a review + fix + re-check loop per phase, plus a pre-build digest check Igor added on his own;
+  - audit-grade run logs accepted;
+  - the user's lean instructions ("implement first, test at the end", "proceed unless major") passed on late or diluted.
+  Commitment: budgets in every brief from now on, cheap models for mechanical work, no added process steps without asking.
+- User reframed: it isn't Igor's job to stop the nonsense. The implementation should plan and arrive at a well-designed product that fits the requirements. Spaghetti slop nobody understands keeps getting more common in recent weeks. Igor's hypotheses, discussed with the user, **not verified**:
+  1. Nothing in the cycle judges design: reviews hunt bugs, and "built but not asked for" lists get recorded, never cut.
+  2. Every fix adds flags and fields; nothing removes them.
+  3. The single-file stdlib constraint.
+  4. No one holds the whole code: about 10 agents with partial context, and the Athanor reads no code by design.
+  5. The timing matches 0.2.0 → 0.2.2, plans without code: the experiment measured correctness and merge choice, not design quality.
+- User: what do the 3,400 lines even do — an operating system? Measured: gremlins.py is now **4,155 lines** (+4,235 test lines).
+  - Rough split: process control (platform classes, tree kill, reap) ~580; detached supervisor and result conclusion ~460; the CLI parser and 11 commands ~650; registry lock ~200; warmth/rebase/drift ~240; launch, fingerprint, model and error classification ~190; usage and ledger ~150; the rest small helpers, constants, docstrings.
+  - **Key insight:** the detached supervisor (CIM launch, hidden windows, orphan watchdog, clock jumps, PID reuse guards, lock races) exists because of design R1 "don't block the Athanor". Yet Phase 0 found that a Bash call past its timeout is moved to the background *and its completion notice comes back*. The harness already does what the supervisor reimplements. Nobody re-planned after that finding.
+  - Also: Igor's own goal criteria (keep-warm with pings, rebase/re-train rules, drift detection, usage md rendering) were large; "small helper" was a label, not a requirement.
+- User: push as is, they want to see it. Pushed `headless-forks` at 0f31ef4 (3.1–3.7 done; 3.8 still running in the Athanor, so its commits will need a second push). Not merged.
+- User: arrive at a timely end; nothing left is essential. Stopped the Athanor mid-3.8 (it was starting the full suite; no processes left behind). Skipped the Phase 3 review. Committed the unfinished 3.8 changes (README line, version bump in both manifests) as WIP `ab1d945` and pushed. The branch `headless-forks` is the prototype record, **not for merge**.
+- Session closed here. Direction the user is weighing: a minimal rewrite, with blocking Bash calls plus `run_in_background` (the harness's own background and notifications), no detached supervisor, only the needed commands. Or straight to the Rust app.
+- 22:41 — User asked for a subagent verdict on the code. Dispatched general-purpose (opus, 25 min timebox): keep/delete/minimal version, plus a usability check (`where` + one tiny live happy-path smoke) → reports/2026-10-16-22-gremlins-code-verdict.md.
+- The user's thoughts on grotto (plans need code structure; happy path first, then abstractions, then iterate; Opus can throw code away; simplify via match and layering; how much can Opus write in one go?) are recorded in brainstorm/2026-10-16-22-grotto-plan-structure.md.
+- Code verdict back (claude-opus-5-5): reports/2026-10-16-22-gremlins-code-verdict.md.
+  - It works: a live happy path on sonnet-5-5 (init, train, spawn with a cache hit, usage, expire) ran clean for $0.09, nothing left running. It is careful and well tested, but 4–5× too big.
+  - About two thirds is detached-process policing; most of the rest is unrequested heuristics.
+  - Recommendation: keep stream parsing, usage and cache accounting, env scrub, the argv builder and templates; replace the supervisor with a blocking call under `run_in_background`; ~600–800 lines.
+  - Pre-rewrite check: does TaskStop on a backgrounded Bash call kill the claude.exe grandchild?
+- User corrections and asks:
+  - "throw out" meant output volume. Delete code only after committing; history is useful.
+  - The prototype holds wisdom; it was just too much; a prototype first would have helped.
+  - Wants a post-mortem that calls this a failure (approval waits aren't the main issue).
+  - Wants to know skill text size, filler, and whether the skills are written for agents.
+  - Brainstorm corrected. Dispatched two Opus agents in parallel (30 min timebox each): post-mortem → reports/2026-10-16-23-headless-forks-postmortem.md; guidance-text audit → reports/2026-10-16-23-spire-guidance-text-audit.md.
+- Post-mortem back (claude-opus-5-5): reports/2026-10-16-23-headless-forks-postmortem.md.
+  - ~12,700 lines in total (code, tests, process docs) vs ~1,100–1,300 needed. ~21 h wall clock, 11.6 h of it waits, **~9 active hours, which is the real failure**.
+  - Top causes:
+    1. The premise fell (Bash backgrounds long calls) and nobody re-planned.
+    2. The goal and design specified a large tool.
+    3. No size criterion, and reviews only add (+480 lines of fixes, ~25 unrequested items never cut).
+    4. No code structure in the plan.
+    5. Opus everywhere with no budgets.
+  - The 1.1 skeleton alone was 1,124 lines.
+  - **Igor's own miss, made explicit:** the Phase 0 hand-back stated the Bash-background finding, and Igor answered with "rung 3 default" instead of stopping to re-plan.
+- Igor proposed a gremlins MVP box list:
+  - train/spawn as blocking calls; the Athanor runs spawns under run_in_background; stop via TaskStop (5-min check first);
+  - usage from the result JSON; warmth reported only, no pings; rebase optional;
+  - no detach code, so it may be cross-platform; ~400–600 lines in a few modules;
+  - one agent, one go, happy path first, one boxes-and-deletion review.
+  - The user had asked: "ecosystem first" (inventory harness/stdlib/existing tools before building), which belongs in grotto's orientation probe. The user feels it's their fault for keeping the first drop; Igor: a rewrite is cheap now that the prototype exists.
+- Guidance audit back (claude-opus-5-5): reports/2026-10-16-23-spire-guidance-text-audit.md.
+  - ~25k words on main.
+  - Split: 42% agent instruction / 22% facts / 9% general knowledge / 23% filler / 4% stale.
+  - Planner, attacker and reviewer carry ~83% preloaded workpad + implementation text.
+  - Steering sentences match today's behaviour exactly: reviewer.md:22 "Answer every … flag … one by one", "Hunt …", run-log handoff fields with no length cap, attacker.md:25 asking for more scope.
+  - No size, happy-path or delete guidance anywhere.
+  - Stale text includes the athanor.md:32 Agent-tool fork and the zathras "Always pass model".
+- User: the MVP box list is good. Asked whether to use the current prototype to help implement it. Warned that "small / happy path first / delete what isn't needed" can backfire. Recorded the safer framing options in the brainstorm (trace to boxes, a size estimate to justify against, happy path as sequencing, unrequested surface as a finding for the user to decide).
+- User decided: build the MVP by **dogfooding** the prototype's happy path. Train a base on prototype + verdict + MVP spec, spawn one gremlin per module, fall back to a plain agent if the tool misbehaves, and don't fix the prototype. Dispatched in parallel: an MVP spec writer (opus, 20 min, ≤150 lines, the module structure fixed, the safer framing) → plans/2026-10-17-00-gremlins-mvp-spec.md; the TaskStop/claude.exe check (sonnet, 10 min).
+- TaskStop check (sonnet-5-5): TaskStop kills claude.exe and its bash wrappers. An in-flight grandchild command (sleep.exe) survives as an orphan and runs to completion. MVP decision: no kill command; document the orphan behaviour; a sweep is an open item. Sent to the spec writer.
 
 ## Adepts
 
@@ -116,8 +251,23 @@
 - Was the superpowers SDD controller's transcript summed in the experiment's token totals? Check the other project's audit.
 - Probe design (user-endorsed direction) → goal or grotto design document when document prep is done.
 - The user's original Athanor model (learns plans, not code; train one implementer, fork it per subsection) is now expressible via headless forks. Not decided.
-- The spawning reference (spawning-claude-code.md:56-64) has rows that today's research answers; not edited yet.
-
-## Open threads
+- The spawning reference (spawning-claude-code.md:56-64) has rows that today's research answers; edited on the headless-forks branch only.
+- **headless-forks branch** (pushed, ab1d945): a prototype, 4,155 + 4,235 lines, Phase 3 unreviewed, 3.8 unfinished, version bumped to 0.3.0 in WIP. Don't merge. Next step: decide between a minimal rewrite (a few hundred lines: train/spawn/wait/usage over blocking or `run_in_background` Bash calls) and the Rust app.
+- **Process lessons to accrete** into Spire (not done yet; the user ended the session):
+  - briefs carry time and token budgets;
+  - mechanical blocks get a cheap model and a scripted change;
+  - reviews get a design and size criterion, and unrequested additions are removed, not recorded;
+  - the plan fixes the module structure and interfaces;
+  - re-plan when a preflight finding removes a design premise (the Bash background finding vs R1);
+  - Igor adds no process steps without asking;
+  - a fresh Athanor per phase;
+  - the self-written contract digest gets checked before building.
+- **Grotto**: untouched apart from the probe direction. Take it up in its own session.
+- Other docs this session on main: goals/headless-forks.md, designs/2026-10-16-01-headless-forks.md, plans/2026-10-16-01/02, reports/2026-10-16-01-session-harness-app-forms.md.
 
 ## Graduation candidates
+
+- **Nested CLAUDE.md files don't load through Bash reads**, so agents in bypass or auto mode miss local conventions. Rationale: this explains the planner's convention miss, and it isn't obvious.
+- **Headless `claude -p --resume <id> --fork-session` forks a trained session from outside the caller.** The cache is shared only with identical launch flags; the cache lifetime is 1 h on a subscription and a hit refreshes it. Rationale: verified mechanics, costly to re-derive.
+- **A Bash tool call past its timeout is moved to the background, not killed, and its completion notice returns.** Rationale: it removes the need for homemade detached supervisors.
+- **Correctness-only review loops grow code without bound.** Rationale: the main lesson of this build.

docs/workpad/plans/2026-10-16-12-headless-forks-phase1-contract.md

@@ -1,121 +0,0 @@
-# Phase 1 contract digest — `spire:forks` helper core
-
-**Written by**: the Athanor, `claude-opus-5-5[1m]`, 2026-10-16 12:20 +0200, at Phase 1 intake.
-**What this is**: the brief both Phase 1 block owners build against. It does not replace the build plan; it pins the points the build plan, the plan, the design and the preflight report leave to the builder, so that blocks 1.1 and 1.2 agree. Where this file and the build plan disagree, tell the Athanor in your handoff note and follow the build plan.
-
-Sources, in order of precedence:
-
-1. Build plan `docs/workpad/plans/2026-10-16-02-headless-forks-build.md`: §4 (C1–C8, N1–N3, usage columns), §6 Phase 1 table.
-2. Preflight report `docs/workpad/reports/2026-10-16-09-headless-forks-preflight.md`: "Defaults Phase 1 must use" table (measured on this host).
-3. Coordinator decisions after Phase 0: in the run log `docs/workpad/reports/2026-10-16-08-headless-forks-run.md` (Phase 0 close, last bullet).
-4. Plan `docs/workpad/plans/2026-10-16-01-headless-forks.md`: §2 (runtime), §3 decisions 5–8, §4 (contracts), §7 Phase 1.
-5. Design `docs/workpad/designs/2026-10-16-01-headless-forks.md`: §3.2–§3.5, §4, §5 (only the threshold defaults and the warmth formula), §6, §7.
-
-Probe code from Phase 0 that you may reuse (read it, copy what helps; it is throwaway and not in git): `C:\Users\g4b\AppData\Local\Temp\claude\G--dev-projects-reliquary\42c87f82-5542-46aa-8d01-4166e3f0bcfe\scratchpad\headless-forks-p0\probes\` — `p0lib.py` (scrub, command line, stream parser, pid + creation-time liveness, job-object query, `visible_windows()`), `p01_launch.py` (rung 5 = CIM hidden), `p01_sup.py`, `p01_check.py` (tree snapshot, `taskkill`).
-
-## Files
-
-All inside `plugins/spire/skills/forks/`. Nothing else in the repo changes in Phase 1.
-
-| File | Block | Notes |
-|---|---|---|
-| `forks.py` | 1.1 skeleton, 1.2 the rest | One file, stdlib only, the exact PEP 723 header of plan §2. LF line endings. |
-| `preamble.md` | 1.1 (moved from 1.2: `init` hashes it) | Appended system prompt for every base and fork. Content below. |
-| `templates/train.md`, `templates/fork.md` | 1.2 | Prompt frames (design §2). `fork.md` carries the stale-snapshot sentence (R13). |
-| `tests/test_forks.py` | 1.1 starts, 1.2 extends | PEP 723, `unittest`, run as `uv run plugins/spire/skills/forks/tests/test_forks.py`. Imports `forks.py` by path (`importlib.util`). Stubs and temp dirs are created at test runtime under `tempfile`; nothing generated is committed. |
-
-## Command surface and exit codes (Phase 1)
-
-`where`, `init`, `train`, `fork`, `continue`, `wait`, `list`, `expire`, `kill`, internal `_supervise`. Phase 2 commands `rebase`, `usage`, `tick` exist in the dispatch and exit 2 with `{"error":"not implemented","phase":2}` until Phase 2. Every command except `where` takes `--run <run log .md>`.
-
-Exit codes: `0` ok · `2` usage error or refused · `3` `wait` condition not met at timeout · `4` `wait` condition met and at least one job in it did not end `ok` (C4).
-
-stdout: exactly one JSON object per call, newline-terminated. All diagnostics on stderr. Errors are JSON on stdout too (`{"error": "...", ...}`) with exit 2.
-
-## Paths
-
-- `--run`, `--brief`, `--cwd` accept relative, `G:\…`, `G:/…` and Git Bash `/g/…` forms (also `/c/…`). Normalise to an absolute Windows path with backslashes (on POSIX: `os.path.abspath`). Store and hash only the normalised form.
-- State dir = the run log path with `.md` removed plus `-forks`, as a sibling: `reports/2026-10-16-08-x-run.md` → `reports/2026-10-16-08-x-run-forks/`.
-- State dir contents: `registry.json`, `registry.lock`, `ledger.jsonl`, `.gitignore` (`raw/` and `*.lock`), `mcp-empty.json` (`{"mcpServers":{}}`), `jobs/<job>.json`, `briefs/<job>.md`, `notes/`, `results/<job>.json`, `logs/`, `raw/<job>.jsonl`, `raw/<job>.err`, `raw/<job>.env.json` (the child env; it is under `raw/` so it is never committed), `raw/<job>.sup.log` (supervisor's own stderr).
-- Job ids `j0001`, `j0002`, … per run.
-
-## State files (C3)
-
-- `registry.json`: `{"schema": 1, "config": {...}, "bases": {name: {...}}, "jobs": {job: {...index...}}, "run": {"last_orchestrator_call_at": iso, ...}}`. Writes only under `registry.lock` (create-exclusive; a lock older than 30 s is stale and may be broken), to a temp file then `os.replace`, retrying `PermissionError` at least 20 times, 50 ms apart. Readers retry the same way.
-- `jobs/<job>.json`: per-job runtime state — supervisor pid + creation time, claude pid + creation time, `heartbeat_at`, `turns`, `last_event_at`, `status` while running. Its only writer is that job's supervisor (except `kill`, which may write the final status if the supervisor is dead). Same atomic write with retries.
-- `ledger.jsonl`: append-only, appended under `registry.lock`.
-- Times are ISO 8601 with offset; one module function `_now()` returns epoch seconds and is the only clock (tests monkeypatch it).
-- PIDs are always stored with their creation time and compared as a pair (A19). Windows: `OpenProcess` + `GetProcessTimes`; POSIX: `/proc/<pid>/stat` start time when present, else pid only.
-
-## Launch fields (`init`; design §3.3, plan §4.3)
-
-`init --run R [--model ID] [--effort E] [--permission-mode M] [--tools CSV] [--allowed-tools ...] [--disallowed-tools ...] [--agent NAME] [--cwd DIR] [--binary PATH] [--parallel-cap N] [--orphan-after S] [--pings on|off] [--max-minutes N]` plus the thresholds below.
-
-- `model`: required full id matching `^claude-[a-z0-9-]+(\[1m\])?$`; aliases refused (exit 2).
-- `effort` default `high`; `permission_mode` default `dontAsk` (`plan` refused); `tools` default `Bash,Read,Edit,Write,Glob,Grep,Skill`; `allowed_tools` default = tools; `disallowed_tools` default `Bash(git push:*)`, `Bash(git rebase:*)`, `Bash(git reset --hard:*)`, `Bash(claude:*)`.
-- `mcp`: always `--strict-mcp-config --mcp-config <state>/mcp-empty.json`.
-- `append_system_prompt`: the skill's `preamble.md`, stored as path + sha256.
-- `agent`: optional name; stored with the sha256 of the resolved `<cwd>/.claude/agents/<name>.md` (refuse if not found).
-- `cwd`: default the git toplevel of the current directory (`git --no-optional-locks rev-parse --show-toplevel`), normalised.
-- `binary`: `--binary`, else `$CLAUDE_CODE_EXECPATH`, else `shutil.which("claude")`; stored as **absolute path** + `version` (`<binary> --version`, first token) + `size` + `mtime`. Launches always use this stored path, never PATH lookup.
-- `env.pinned`: `CLAUDE_CODE_PROMPT_CACHE_TTL=1h`, `DISABLE_AUTOUPDATER=1`.
-- Fingerprint hash: sha256 of canonical JSON (sorted keys, no spaces) of all launch fields above.
-- Config extras: `parallel_cap` 2, `orphan_after` 1200 s (N1), `pings` `on` (P0.6 passed; used in Phase 2), `ttl_s` 3600, `max_minutes` 90, `stall_after_s` 900, thresholds `rebase_commits` 6, `rebase_lines` 1500, `rebase_delta_tokens` 12000, `max_base_tokens` 250000, `max_rebases` 4.
-- Idempotent: re-running `init` with identical values succeeds and returns the config. Different values: allowed while no base exists (config replaced), refused with exit 2 once a base exists.
-- **C8 model admission** (rule measured in P0.5): read `availableModels` from `~/.claude/settings.json`, `<cwd>/.claude/settings.json`, `<cwd>/.claude/settings.local.json`. If no file has the key, admit. Otherwise admit iff some list contains the exact id, or the id without `[1m]`, or the id's family alias (`opus`, `sonnet`, `haiku`, `fable`, taken from the second dash-separated token of the id). Else exit 2 with a message naming the id and the files that hold lists, and saying the user must add the id. Never write a settings file.
-
-## `where` (G-where)
-
-Prints one JSON object: `script` (absolute path of `forks.py`), `python` (version, `executable`, `base_executable`), `uv` (version from `uv --version` if found, and `SCRIPTS_UV` if set), `binary` (resolved path, version, size, mtime, how resolved), `git` (resolved path and version), `spawn` (the constant naming the method: `cim-hidden` on Windows, `setsid` on POSIX), `scrub` (`drop`, `keep`, `pinned` lists, and `unknown`: host `CLAUDE_*`/`ANTHROPIC_*`/`CLAUDE_CODE_*` vars on neither list), `ok` (bool). Exit 0 when Python ≥ 3.10 and a binary resolves; otherwise exit 2 with `ok: false` and the reason. `where` never writes anything.
-
-## Env scrub (one constant; design §4 + plan §2 + P0.0)
-
-- Drop: the twelve Desktop vars (design §4), `CLAUDE_EFFORT`, `ANTHROPIC_MODEL`, `ANTHROPIC_DEFAULT_*_MODEL`, `ANTHROPIC_SMALL_FAST_MODEL`, `CLAUDE_CODE_SUBAGENT_MODEL`, `ENABLE_PROMPT_CACHING_1H`, `FORCE_PROMPT_CACHING_5M`, `CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL`, `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, `CLAUDE_CODE_USE_BEDROCK`, `CLAUDE_CODE_USE_VERTEX`, `VIRTUAL_ENV`, every `UV_*`; PATH entries under `VIRTUAL_ENV` or under `sys.prefix` when it differs from `sys.base_prefix`.
-- Keep: everything else, including `CLAUDECODE`, `CLAUDE_CODE_CHILD_SESSION`, `AI_AGENT`, `CLAUDE_PID`, `CLAUDE_CODE_GIT_BASH_PATH`, `PATH`, `HOME`/`USERPROFILE`.
-- Pinned on top: `CLAUDE_CODE_PROMPT_CACHE_TTL=1h`, `DISABLE_AUTOUPDATER=1`, `SPIRE_FORKS_CHILD=1` (N3), and `CLAUDE_CODE_EXECPATH=<the stored binary path>` (coordinator: so the 2.1.283 slip cannot recur).
-- The env is computed by the launching command (which has the real host env) and written to `raw/<job>.env.json`. The supervisor (which gets the registry default env from CIM) reads that file and passes exactly that env to `claude`.
-
-## Spawning (C6, P0.1, coordinator)
-
-- Windows, default and only Phase 1 method `cim-hidden`: the launching command runs `powershell -NoProfile -NonInteractive -Command` with `$si = New-CimInstance -ClassName Win32_ProcessStartup -ClientOnly -Property @{ShowWindow=[uint16]0}; $r = Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{CommandLine=$env:SPIRE_FORKS_CMD; CurrentDirectory=$env:SPIRE_FORKS_CWD; ProcessStartupInformation=$si}; "{0} {1}" -f $r.ReturnValue, $r.ProcessId` (command line and cwd passed through env vars, never interpolated). The `powershell` call itself is started with `CREATE_NO_WINDOW`. Non-zero `ReturnValue` → the job ends `failed`, reason `spawn_failed`.
-- Supervisor command line: `<interp> -I <abs forks.py> _supervise --run <run> --job <job>`, `<interp>` = `sys._base_executable` if it differs from `sys.executable`, else `sys.executable`. Under `-I` the script dir is not on `sys.path`; do not rely on it.
-- The supervisor redirects its own stdout/stderr to `raw/<job>.sup.log` at start (it has no inherited handles).
-- Every process the supervisor starts (`claude`) gets `CREATE_NO_WINDOW` (`0x08000000`). Never `DETACHED_PROCESS` or `CREATE_NEW_CONSOLE`.
-- POSIX: `subprocess.Popen(..., start_new_session=True)` from the launching command, stdio to files; kill by process group. Implement, keep simple; it is not tested on this host.
-- **No visible window** is an acceptance criterion: on Windows, the tests assert that no visible top-level window belongs to the supervisor or any descendant while a stubbed job runs (`EnumWindows` + `IsWindowVisible` + `GetWindowThreadProcessId`, as in `p0lib.visible_windows()`).
-
-## `claude` command line (fingerprint every time; flags are not inherited by forks)
-
-`<binary> -p --output-format stream-json --verbose --model M --effort E --permission-mode P --tools T --allowedTools A --disallowedTools D --strict-mcp-config --mcp-config <state>/mcp-empty.json --append-system-prompt-file <preamble> [--agent N]` plus per kind: `train` `--session-id <new uuid>`; `fork` `--resume <base session> --fork-session --session-id <new uuid>` (P0.7: honoured); `continue` `--resume <fork session>` (no fork flag); `ping` (Phase 2). Prompt on stdin from `briefs/<job>.md`. cwd = the base's cwd. List flags are passed comma-joined, as in the probes.
-
-## Supervision and results (1.2)
-
-- Stream parse: `system/init` (session id, runtime fingerprint: sorted tool names hash, `permissionMode`, plugin names + versions, agents, `apiKeySource`); each `assistant` event bumps `turns`/`last_event_at` (count messages by `message.id`); the first assistant event's `usage` gives the cache verdict; `system/informational` with `level: warning` whose content contains `is restricted` → model refused; `result` gives the totals.
-- Usage rule (P0.3): the four columns and the 1h/5m split from `result.usage`; `models_used` = keys of `result.modelUsage` whose counts grew against the session total before the call; cost Δ = `total_cost_usd` − the session total before the call (base cumulative for a fork, the fork's last total for `continue`, 0 for `train`); `usage_mismatch` flag when `result.usage` ≠ the `modelUsage` delta. Never sum stream events for output tokens. `turns` = `result.num_turns`.
-- Base context tokens = `input + cache_creation + cache_read` of the base's last assistant message (last stream event for that message id). Stored on the base at train end, with `base_commit` (`git --no-optional-locks rev-parse HEAD` in the cwd), training cost, cumulative `modelUsage`, `last_hit`.
-- Cache verdict (C5): first assistant event `cache_read` vs the base's context tokens: `hit` ≥ 0.9, `partial` > 0, `miss` = 0. `train` jobs get `cache: null`.
-- Warmth in Phase 1 (C1): `last_hit` = time of the first assistant event of the most recent call on this base or any of its forks; `warm_until = last_hit + ttl_s`; `margin = max(120, ttl_s/10)`; `base_state` warm / expiring / cold. `rebase_due` and `retrain_due` are `false`, `reasons: []`.
-- `cold_start` flag when the base was `cold` at launch, or the verdict is not `hit` and the fingerprint is `ok`.
-- Model refused: the warning event, or `models_used` not containing the requested id (compare including `[1m]`; P0.5: the `modelUsage` key carries the suffix) → status `failed`, reason `model_refused`.
-- Watchdogs: wall time > `max_minutes` → kill tree, `timeout`; no stream output for `stall_after_s` → flag `stalled` (not killed); non-empty `permission_denials` → flag `needs_attention`; `is_error` or non-zero exit → `failed` with a reason.
-- Heartbeat: the supervisor writes `heartbeat_at` at least every 30 s. `wait` and `list` mark a running job `lost` when its heartbeat is older than 120 s **and** its supervisor pid + creation time is dead; a ledger line with whatever was captured.
-- N1 orphan watchdog: `wait`, `fork`, `continue`, `train`, `list` (and Phase 2's `rebase`) update `run.last_orchestrator_call_at`. A supervisor whose job is running kills its `claude` tree when that is older than `orphan_after`; status `killed`, flag `orphaned`, ledger line.
-- N3: launching commands (`train`, `fork`, `continue`, and Phase 2's `rebase`/`tick` pings) exit 2 when `SPIRE_FORKS_CHILD` is set. `where`, `list`, `wait` (and `usage`) stay allowed.
-- N2: `fork --mode parallel` requires `--paths p…`; stored on the job and echoed as `paths` in the result. Sequential forks may pass it.
-- Parallel cap: at most `parallel_cap` running jobs of kind `fork`/`continue`; a launch over the cap exits 2.
-- Refusals (exit 2): fork from a base that is not `active` without `--force`; `continue` of a running job; `continue` of a non-fork job; any launch-field override on `fork`/`continue`; missing binary (stored path gone).
-- Binary re-check at every launch (version, size, mtime against the base record): a difference is reported as fingerprint drift `binary` in the result (Phase 2 turns it into `rebase_due`).
-- Fork delta header (prepended by the helper to the brief, inside `templates/fork.md`): `git --no-optional-locks log --oneline <base_commit>..HEAD` and `git --no-optional-locks diff --shortstat <base_commit>`.
-- Result object: exactly plan §4.2's fields, plus `paths` (N2), `reason` (null unless failed/killed/lost), `model_requested`. Written to `results/<job>.json`; the ledger line = design §6's shape + `status`, `flags`, `reason`.
-- `fork` launch return (C1): `{job, base, base_state, warm_until, rebase_due, retrain_due, reasons}`. `train` returns `{job, base, session_id}`; `continue` returns `{job}`.
-- `wait [job…] | --all [--any] [--timeout S]` (default 540, max 570): polls about every 2 s; returns `{done: [results not returned before], running: [{job, block, elapsed_s, last_event_s_ago, turns}], pings: []}`; exit per C4; marks returned results as delivered so each result is returned by at least one `wait`. `list` always shows every job and base.
-- `kill --job J` (and `expire` of a base with running jobs): snapshot the supervisor's whole process tree first (pids + creation times; use a Toolhelp32 snapshot via ctypes rather than PowerShell for speed), `taskkill /T /F /PID <supervisor>`, then kill any recorded pid still alive (sweep), verify none of the snapshot survives, set `killed`. A dead supervisor is handled too (kill the claude tree from the job file).
-- `expire --base B | --all`: mark `retired`; running jobs of that base are killed with the sweep (coordinator), flag `expired`.
-
-## `preamble.md` (content owned by 1.1; short)
-
-A headless implementer trained once and then forked per block; it may be resumed or forked later. Do the work yourself; never dispatch agents and never start `claude` or the forks helper. Never use `run_in_background` on Bash (coordinator decision): run every command in the foreground. Stage and commit by explicit paths only, and only when the brief says this fork commits. Write the handoff note to the path the brief names, in the run-log handoff-note format (`plugins/spire/skills/implementation/references/run-log.md`), stamping the exact model id. Gate and test output go to files under the state dir's `logs/` (`.txt`).
-
-## Not in Phase 1
-
-Warmth inference and pings, `rebase`, `rebase_due`/`retrain_due` reasons, `usage` rendering, `tick` (Phase 2). `SKILL.md`, athanor and implementation text (Phase 3). Version bump (Phase 3).

docs/workpad/plans/2026-10-16-16-headless-forks-phase2-contract.md

@@ -1,64 +0,0 @@
-# Phase 2 contract digest — `spire:forks` bookkeeping
-
-**Written by**: the Athanor, `claude-opus-5-5[1m]`, 2026-10-16 16:45 +0200, at Phase 2 intake.
-**What this is**: the brief the Phase 2 block owners (2.1, 2.2, 2.3) build against. It pins points the build plan, the plan and the design leave open, and folds in the Phase 1 review items the coordinator assigned to Phase 2. Precedence: build plan `plans/2026-10-16-02-headless-forks-build.md` (§4, §6 Phase 2) > coordinator decisions (below) > plan `plans/2026-10-16-01-headless-forks.md` §7 Phase 2 > design `designs/2026-10-16-01-headless-forks.md` §5–§6 > this digest's own choices. Where this digest conflicts with a higher source, follow the higher source and say so in your handoff note.
-
-Inputs to read besides those: the Phase 1 digest `plans/2026-10-16-12-headless-forks-phase1-contract.md` (still in force where not changed here), the Phase 1 review `reports/2026-10-16-16-headless-forks-phase1-review.md` (M6–M16, the P0.6 ping note), the re-check `reports/2026-10-16-17-headless-forks-phase1-recheck.md` (R1), the run log `reports/2026-10-16-08-headless-forks-run.md` (block notes and the fix pass), and the code `plugins/spire/skills/forks/`.
-
-## Coordinator decisions (2026-10-16, Phase 2 brief)
-
-- **R1**: a kill between the registry write and the ledger append can leave a finished job with no ledger line. `usage` reconciles the ledger against `results/` before aggregating: any result without a ledger line gets one appended, idempotently (dedupe on job id, under the lock). Cost is never under-counted.
-- **M6**: the runtime fingerprint also compares sorted `skills`, and identifies plugins without a `version` by the last segment of their `path`. Both become drift reasons.
-- **M7**: the fingerprint hash covers the mcp config **content** (`{"strict": true, "servers": {}}`), not its per-run path. The path stays in the config, outside the hash.
-- **M8**: widen the unit visible-window check: diff the visible `ConsoleWindowClass` / `CASCADIA_HOSTING_WINDOW_CLASS` windows before and during the job as well as the tree-pid check, add a positive control (a deliberately visible spawn that the check must detect, closed at once), and skip (not fail) when no desktop is present.
-- **M10**: follow plan §4.3. `train` accepts launch-field overrides (the same flags as `init`); the base records the launch fields it was trained with and their fingerprint hash. Every later launch on that base (`fork`, `continue`, `rebase`, pings) builds its command line from **the base's record**, not from the run config.
-- **M11**: a result's `note` is set only when the note file's mtime is at or after this job's start.
-- **M13**: Git Bash rooted paths that are not drive forms (`/tmp/x`, `/usr/…`): convert with `cygpath -w` when it is on PATH; if it is not, refuse with exit 2 and a message. Never silently map them onto the cwd's drive.
-- **M16**: rename the job-file progress counter `turns` to `messages`; the result and ledger keep `turns` = `result.num_turns`.
-- Keep a test for "an error after the requested model billed": the call billed the requested model, then the result is `is_error`; it must read `failed` with an error reason (`is_error` or the API-error reason), never `model_refused`. The Phase 1 fix pass changed the stub's `error` directive to bill nothing, so add a directive for the billed case.
-
-## Blocks
-
-| Block | Owner | Scope |
-|---|---|---|
-| 2.1 Warmth and keep-warm | fresh, `opus` | Warmth inference, pings, `tick`, `ttl_downgrade`, `cold_start` rule (C5), ping dedupe (C3d); plus M8, M16 and the billed-error test. |
-| 2.2 Rebase and re-train flags | fresh, `opus` | `rebase`, `templates/rebase.md`, `rebase_due`, `retrain_due` and their reasons, `binary_missing`; plus M6, M7, M10, M11, M13. |
-| 2.3 Usage rendering | fresh, `sonnet` | `usage --block/--phase --format json|md`; plus R1. |
-| 2.4 Phase tests, smoke | the Athanor; fallout to a fresh `opus` | G-unit, live smoke of plan §7 "Phase 2 tests and smoke". |
-
-## 2.1 Warmth and keep-warm (design §5)
-
-- **TTL inference** per base, from its calls (base and all its forks, continues and pings): `3600` if the most recent call wrote `ephemeral_1h` tokens, or read cache and the previous known TTL was 3600; `300` if it wrote only `ephemeral_5m`; else the configured `ttl_s` (3600 default). A call that wrote only `ephemeral_5m` sets flag `ttl_downgrade` on its result.
-- **last_hit**: unchanged from the Phase 1 fix (I3): train end; a fork's first assistant event; a ping's first assistant event. Never a continue.
-- **warm_until** = `last_hit + ttl`; **margin** = `max(120, ttl/10)` unless `init --warm-margin-s` sets it (a tunable threshold like the others; default unset = the formula). State: warm / expiring / cold as design §5.
-- **Ping** = `--resume <base session> --fork-session --session-id <new>`, prompt `Reply OK`, `--max-turns 1`, the base's launch record, kind `ping`, its own job id, ledger line, result. Pings do not count toward `parallel_cap` and never return through `wait`'s `done` as blocks do: they go to `wait`'s `pings: [...]` list (each ping result returned once). They are N3-refused under `SPIRE_FORKS_CHILD` like any launch.
-- **Ping rule**: base `active` **and** state `expiring` **and** the run had a running fork/continue job or a `wait` call in the last 10 min **and** pings since the base's last real (non-ping) call < `break_even` (`floor((write − read) / read)` with ratios 1h write 2.0, 5m write 1.25, read 0.1 → 19 at 1 h, 11 at 5 min) **and** `pings` is `on` in the config **and** no ping for this base is in flight.
-- **Ping dedupe (C3d)**: the decision and `ping_in_flight` (with the ping job id) are written on the base under the registry lock; other tickers skip a base that is in flight; the flag clears when the ping finishes (any status).
-- **Ping verdict**: a ping's cache verdict is computed like a fork's, but a `partial` ping still refreshes `last_hit` (P0.6: a 50-min ping re-created ~7.5k of the shared system prefix and still kept the base warm; on a small base that reads `partial`). Only a `miss` (cache_read 0) or a failed ping leaves `last_hit` alone and adds flag `ping_missed` to the ping's result.
-- **Tick**: one pass of the ping rule over all bases of the run. Runs inside every supervisor every 60 s and inside `wait` every 30 s; `tick --run R` runs one pass by hand (N3-refused in a fork). A ping is launched through the same CIM hidden spawn as any job.
-- **cold_start** (C5, already in Phase 1): keep; verify against the inferred TTL now.
-- **`init --pings on|off`** default `on` (P0.6 passed).
-- **M16**, **M8**, billed-error test: as above.
-- Tests (clock-injected): warm/expiring/cold boundaries at 1 h and 5 min (and with `--warm-margin-s`); ping eligibility incl. no ping without activity in the last 10 min, the cap at 19 and 11, `pings off`, in-flight dedupe across two tickers; TTL inference from 1h-only, 5m-only and read-only calls; `ttl_downgrade`; a stubbed ping end to end through `wait`'s `pings` list; partial ping refreshes, missed ping does not.
-
-## 2.2 Rebase and re-train flags (design §5, build plan 2.2)
-
-- **`rebase --run R --base B --as NEW --brief FILE [--phase N]`**: a fork of B whose prompt is `templates/rebase.md` (read the listed notes and diffs, do not edit code, update the trunk notes if the brief names a path, reply READY) + delta header + brief. On `ok`, its session becomes base `NEW` (`status: active`, `parent: B`, `lineage_rebases` = B's + 1, `base_commit` = HEAD at the end, context tokens from its last assistant message, its launch record = B's, unless a binary drift made the rebase run under the new binary: then the new binary is recorded); B becomes `superseded`. On failure B stays `active` and `NEW` is not created. `rebase` counts toward the cap and is N3-refused.
-- **rebase_due** reasons (on `fork`'s launch return, and in `list` per base): `phase_boundary` (the fork's `--phase` is greater than the highest phase of any fork from this base, or than the base's own phase), `commits:<n>` (commits since `base_commit` > `rebase_commits`), `lines:<n>` (`git --no-optional-locks diff --shortstat <base_commit>` insertions + deletions > `rebase_lines`), `delta_tokens:<n>` (chars / 4 of the delta header plus the notes listed in the brief > `rebase_delta_tokens`), `binary_drift` (stored binary version/size/mtime differ from the current file), `runtime_drift:<fields>` (the last call on this base reported `fingerprint: drift:<runtime fields>`, e.g. `skills`, `plugins` — M6).
-- **retrain_due** reasons: `defining:<fields>` — a fingerprint-defining field of the base (model, cwd, tools, permission mode, agent name or agent file sha, preamble sha) differs from what a launch would use now. "Now" means: the preamble and agent file re-hashed from disk; and for fields the base did **not** override at `train`, the run config. `init` may therefore change config values after bases exist (this replaces Phase 1's refusal): bases that did not override a changed field report `retrain_due`. Also `max_base_tokens:<n>` (the base's context tokens > `max_base_tokens`; measured from the transcript's last assistant line when the file exists, else from the stored context — P0.7), `rebases:<n>` (`lineage_rebases` ≥ `max_rebases`), `binary_missing` (the stored binary path is gone; launches refuse with exit 2 and this reason).
-- The flags are advisory: `fork` still launches when they are true (except `binary_missing`). The Athanor obeys them.
-- **M6, M7, M10, M11, M13**: as above.
-- Tests: each reason triggered separately (and only it), `fork`'s launch return lists the right `reasons[]`; `rebase` end to end with the stub (new base active, old superseded, fork from the new base gets `hit` against the new context); `train` with overrides (recorded per base; a fork of it uses the base's record); `init` changing the model after a base exists → that base `retrain_due: defining:model`; M7 hash stable across two runs; M11; M13 with and without `cygpath`.
-
-## 2.3 Usage rendering (design §6, build plan §4 "Usage md columns")
-
-- **`usage --run R [--block ID | --phase N] [--format json|md]`** (default json). N3: allowed in a fork. Before aggregating: R1 reconciliation (under the lock).
-- json: totals (`input`, `output`, `cache_creation` with 1h/5m, `cache_read`, `cost_usd` = sum of `cost_delta_usd`, calls) per kind (`train`, `rebase`, `fork`, `continue`, `ping`) and overall; `cold_starts` count; `cache_hit_ratio` = hits / (fork + continue + rebase calls with a verdict); `rows` = one per ledger line in scope.
-- md, `--block`: exactly one markdown table with the fixed header `| Block | Owner (model id from modelUsage) | Session | Commit | in | out | cache write | cache read | cost Δ |`, one row per call of that block (fork and its continues). Owner = `models_used` joined; Session = short session id (first 8); Commit = commits between the job's `head_at_launch` and its end HEAD (the supervisor must record `head_at_end`; add it if missing) for a sequential fork, `—` for a parallel one; numbers with thousands separators; cost Δ as `$0.0000`. Null usage (killed/lost) renders `—`.
-- md, `--phase`: the per-kind totals table (`| Kind | Calls | in | out | cache write | cache read | cost |` plus a total row), then one line each for cold starts, cache-hit ratio and the priced total.
-- stdout for `--format md` is exactly one markdown fragment (the plan §4.1 exception to the JSON rule); errors still JSON with exit 2.
-- Tests: md against a fixed ledger fixture (exact text), json totals, R1 reconciliation (a result with no ledger line gets exactly one line, a second `usage` adds none).
-
-## Not in Phase 2
-
-`SKILL.md`, the Athanor and implementation text, references, version bump (Phase 3). M12, M14, M15 and the post-exit-sweep / continue-frame parts of M16 are Phase 3 text.

docs/workpad/plans/2026-10-16-18-gremlins-phase3-contract.md

@@ -1,684 +0,0 @@
-# Phase 3 contract digest: `spire:gremlins` (rename, platform seam, text, release)
-
-**Written by**: the Athanor, `claude-opus-5-5[1m]`, 2026-10-16 18:31 +0200, at Phase 3 intake. Nothing is built in this turn.
-**What this is**: the brief the Phase 3 block owners build against. It pins every point that the build plan, the goal's later decisions and Igor's Phase 3 brief leave open: the rename map, the platform interface, the gate, the N3/N4/flake fixes, the WSL check, the text per file and the release. In the last two phases every Important finding came from a detail a digest left open, so this one tries to leave nothing open. Where a choice was mine, it is marked **(choice)** and listed again in §12 for Igor's check.
-
-**Precedence** (highest first):
-
-1. Igor's Phase 3 brief (2026-10-16, this turn): the six steps, N3, N4, the flaky test, the test cadence, "no push, no merge".
-2. The goal `docs/workpad/goals/headless-forks.md` **as on `main`** (the branch copy is older). Its sections "Decided … naming", "… platforms", "Amended … release gating" and "Decided … platform seam" override the build plan where they conflict.
-3. Build plan `docs/workpad/plans/2026-10-16-02-headless-forks-build.md` §4, §6 Phase 3, G-text.
-4. Plan `docs/workpad/plans/2026-10-16-01-headless-forks.md` §4, §7 Phase 3; design `docs/workpad/designs/2026-10-16-01-headless-forks.md` §2, §7, §8, §9.
-5. The Phase 1 and Phase 2 digests (`plans/2026-10-16-12-…-phase1-contract.md`, `plans/2026-10-16-16-…-phase2-contract.md`): they still describe the helper's behaviour, under the old names.
-6. This digest's own choices.
-
-If this digest conflicts with a higher source, follow the higher source and say so in your handoff note.
-
-**Standing rules for every child** (pass them on verbatim):
-
-- Read, Write and Edit for files; never `cat`, `sed`, `awk` or heredocs to read or change files, even when auto mode suggests Bash. `git mv` is allowed for the rename.
-- Do this yourself; do not dispatch further agents.
-- Commits use gitmoji (`docs/workpad/specs/commit-conventions.md`), stage explicit paths only, and carry **no** `Co-Authored-By` or other attribution lines. No push, no merge, no PR.
-- Between blocks: `uv run python -m py_compile <file>` plus only the test classes the block touched. The full suite runs once, at phase end (block 3.8).
-- No live `claude` calls in Phase 3 (see §12, choice C17).
-- Leave no processes running. Check by command line (`gremlins-test-`, `_supervise`, `poscontrol`, `claude-stub`), never by process name.
-- Stamp your exact model id in your handoff note. Append the note to the run log `docs/workpad/reports/2026-10-16-08-headless-forks-run.md` under "## Phase 3", in the run-log handoff-note format.
-- `docs/workpad/goals/` is read-only.
-
----
-
-## 1. Blocks
-
-| Block | Owner | Scope | Gate (between blocks) | Commit |
-|---|---|---|---|---|
-| **3.1** Rename | fresh, `opus` | §2: `forks` → `gremlins` everywhere in the skill, `fork` command → `spawn` with `method: "fork"`, env marker, state dir, kinds, JSON fields, templates, tests. Mechanical; no behaviour change. | py_compile of both .py files; the test classes `PathTests ScrubTests LockTests AtomicTests PidTests ProcessTreeTests InitTests CliTests RuleTests` plus `LaunchTests.test_train_spawn_continue_end_to_end` and `LaunchTests.test_refusals`; G-where; the residue grep of §2.8 | `🚚 gremlins: rename spire:forks to spire:gremlins (spawn, SPIRE_GREMLIN_CHILD)` |
-| **3.2** Platform seam and gate | fresh, `opus` | §3: `Platform` interface, `WindowsPlatform`, `PosixPlatform`, the path matrix, the Windows-only gate (§4), JSON shape changes of §3.6. | py_compile; `PathTests PathMatrixTests GateTests PidTests ProcessTreeTests LockTests CliTests SubprocessTests` and `LaunchTests.test_kill_tree test_no_visible_window test_detach_failed`; G-where; the seam grep of §3.7 | `♻️ gremlins: platform seam (WindowsPlatform, PosixPlatform) and path matrix`, then `🚩 gremlins: Windows-only gate in where and init` (two commits allowed) |
-| **3.3** N3, N4, kill flake | fresh, `opus` | §5 | py_compile; `InitTests`, the new N4 test, `LaunchTests.test_refusals test_kill_tree test_expire_kills_running_jobs` | `🐛 gremlins: init re-resolves the binary, late rebase of an inactive base, kill verification` |
-| **3.4** WSL check | the Athanor, own Bash (a probe, like Phase 0) | §6. Findings to the scratchpad; they feed 3.7. No repo change unless the WSL run finds a seam bug (then a fix commit by a fresh `opus`, logged). | none | none (run-log note only) |
-| **3.5** Procedure text | fresh, `opus` | §7.1–§7.4: `gremlins/SKILL.md` (new), `agents/athanor.md`, `implementation/SKILL.md`, `references/run-log.md` | G-text items 1–4, 6 (§9.2) | `🤖 gremlins: SKILL.md, Athanor procedure, implementation skill, run-log template` |
-| **3.6** Reference rows | fresh, `sonnet` | §7.5–§7.6: `references/spawning-claude-code.md`, `references/models.md` | every new row has one of the four statuses and a date | `🤖 implementation references: headless sessions and gremlins` |
-| **3.7** Platform handoff | fresh, `opus` | §8: `docs/workpad/reports/<YYYY-MM-DD-hh>-gremlins-platform-handoff.md` | none | `📝 Gremlins platform handoff for Linux and macOS` |
-| **3.8** README, version, phase tests, release | fresh, `sonnet`; fallout to a fresh `opus` | §9: README row, both manifests 0.3.0, full G-unit once, G-where, G-text in full, the release commit | G-text in full, G-unit, G-where | `🤖 Spire 0.3.0: trained implementer, gremlins per block (spire:gremlins)` with the changelog body |
-
-**Deviations from the build plan's Phase 3 table** (choice C1): the plan had 3.1 text, 3.2 rows, 3.3 release. Igor's brief adds the rename, the seam, the gate, the handoff and three fixes, in that order. Text comes after all code changes, so it is written against the final JSON. 3.3 is split from 3.2 so that the seam refactor lands green on its own before behaviour changes. The full suite runs once, in 3.8, before the release commit. If it is red: one fresh `opus` fallout agent, then one re-run.
-
-Run-log handoff notes: each block owner appends its own. The Athanor writes the 3.4 note and the Phase 3 close.
-
----
-
-## 2. Rename map (block 3.1)
-
-The goal: a launched worker is a **gremlin**; the command that creates one is **`spawn`**; forking the base's session is one spawn **method**, recorded as `method: "fork"`; the trained session stays the **base**. No compatibility aliases.
-
-**The rule for the word "fork" after the rename**: "fork" survives only for the Claude Code session mechanism (`--fork-session`, "a fork of the base's session", "forked") and as the value of `method`. It never names a command, a job kind, a worker, a field or a file.
-
-### 2.1 Files and paths
-
-| Old | New |
-|---|---|
-| `plugins/spire/skills/forks/` | `plugins/spire/skills/gremlins/` (`git mv`, so history follows) |
-| `forks.py` | `gremlins.py` |
-| `tests/test_forks.py` | `tests/test_gremlins.py` |
-| `templates/fork.md` | `templates/spawn.md` **(choice C2)**: templates are named after the command, as `train.md` and `rebase.md` are. A later spawn method adds its own template. |
-| `templates/train.md`, `templates/rebase.md`, `preamble.md` | same names, text updated (§2.6) |
-| State dir `<run log without .md>-forks/` | `<run log without .md>-gremlins/` (`state_dir_for`, `run_for_state`) |
-| Files inside the state dir (`registry.json`, `registry.lock`, `ledger.jsonl`, `jobs/`, `briefs/`, `notes/`, `results/`, `logs/`, `raw/`, `mcp-empty.json`, `.gitignore`) | unchanged |
-| Gates | G-unit `uv run plugins/spire/skills/gremlins/tests/test_gremlins.py`; G-where `uv run plugins/spire/skills/gremlins/gremlins.py where` |
-
-Delete stale `__pycache__/` folders under the old path if `git mv` leaves them (they are untracked).
-
-### 2.2 Module identifiers (`gremlins.py`)
-
-| Old | New |
-|---|---|
-| `ForksError` | `GremlinsError` |
-| `cmd_fork` | `cmd_spawn` |
-| `CHILD_MARKER = "SPIRE_FORKS_CHILD"` | `CHILD_MARKER = "SPIRE_GREMLIN_CHILD"` |
-| `SCRUB_PINNED = {…, "SPIRE_FORKS_CHILD": "1"}` | `{…, "SPIRE_GREMLIN_CHILD": "1"}` |
-| `spawn_supervisor` | `detach_supervisor` **(choice C3)**: "spawn" now means the command; starting the detached supervisor is "detach". Block 3.2 then moves its body into the platform (§3). |
-| `SPAWN_METHOD` | removed in 3.2 (`PLATFORM.detach_method`); in 3.1 rename it `DETACH_METHOD` so 3.1 stays green on its own |
-| CIM carrier env vars `SPIRE_FORKS_CMD`, `SPIRE_FORKS_CWD` | `SPIRE_GREMLIN_DETACH_CMD`, `SPIRE_GREMLIN_DETACH_CWD` (in `POWERSHELL_CIM` and its caller) |
-| local `forks_` in `phase_boundary` | `spawned_phases` |
-| `prog="forks.py"`, `"spire:forks helper …"` | `prog="gremlins.py"`, `"spire:gremlins helper …"` |
-| module docstring | rewritten for gremlins |
-
-### 2.3 Commands and flags
-
-| Old | New |
-|---|---|
-| `fork --base B --block X --brief F [--phase N] [--mode sequential\|parallel] [--paths …] [--max-minutes] [--max-budget-usd] [--force] [--delta-note PATH]…` | `spawn` with the same flags **plus** `--method fork` (choices: `fork`; default `fork`) **(choice C4)**. The flag exists so a later method is an additive change. |
-| `fork` in `COMMANDS`, `HANDLERS`, `--help`'s `commands` list | `spawn` |
-| `continue --job J` | unchanged; `J` must be a `spawn` job (error text "continue takes a spawn job") |
-| `train`, `rebase`, `wait`, `list`, `usage`, `expire`, `kill`, `tick`, `where`, `init`, `_supervise` | unchanged |
-| `CHILD_REFUSED` contains `"fork"` | contains `"spawn"` |
-| help texts: "Fork a base for one block.", "fork a base that is not active", "the files this fork may touch", "One more turn in a fork …", "working dir of base and forks", "(the phase whose forks it serves)", "(a fork and its continues)" | "Spawn a gremlin from a base for one block.", "spawn from a base that is not active", "the files this gremlin may touch", "One more turn in a gremlin (resume without --fork-session).", "working dir of the base and its gremlins", "(the phase whose gremlins it serves)", "(a spawn and its continues)" |
-
-### 2.4 JSON fields and values
-
-| Where | Old | New |
-|---|---|---|
-| job entry, result, ledger, `list` jobs | `kind: "fork"` | `kind: "spawn"` |
-| job entry, result, ledger, `list` job rows (`LIST_JOB_KEYS`) | (none) | `method`: `"fork"` on `spawn` jobs, `null` on every other kind **(choice C5)**. Always present, so result and ledger keep fixed key sets. `continue` jobs carry `null` (they resume, they do not fork). |
-| `spawn` launch return | `{job, base, base_state, warm_until, rebase_due, retrain_due, reasons}` | `{job, base, method, base_state, warm_until, rebase_due, retrain_due, reasons}` |
-| base record, `list` base rows (`LIST_BASE_KEYS`) | `forks: [job…]` | `gremlins: [job…]` |
-| `CAPPED_KINDS`, `HIT_KINDS`, `USAGE_KINDS`, `REAL_KINDS`, kind checks in `_conclude`, `phase_boundary`, `run_active`, `Supervisor.run` (`hit_written`), `finalize_job` (`head_at_end`) | `"fork"` | `"spawn"` |
-| `usage` json `kinds` keys; md phase table `Kind` cells | `fork` | `spawn` |
-| `usage` md hit-ratio fallback text | "n/a (no fork, continue or rebase call with a verdict)" | "n/a (no spawn, continue or rebase call with a verdict)" |
-| N3 refusal | "`%s` is refused inside a fork (%s is set); a fork may only run where, list, usage and wait" | "`%s` is refused inside a gremlin (%s is set); a gremlin may only run where, list, usage and wait" |
-| continue refusals | "the fork is still running", "the fork has no session" | "the gremlin is still running", "the gremlin has no session" |
-| spawn refusals | "--mode parallel needs --paths (the files this fork may touch)", "base is not active (use --force to fork it anyway)" | "… (the files this gremlin may touch)", "base is not active (use --force to spawn from it anyway)" |
-| `build_launch` refusal message | "forks never writes settings" | "gremlins never writes settings" |
-| `preamble.md missing next to forks.py` | | `… next to gremlins.py` |
-| reasons, flags, statuses, other keys | unchanged in 3.1 | (3.2 renames `spawn_failed` and `taskkill_rc`, §3.6) |
-
-`SCHEMA` stays `1` (nothing released; no registry from before the rename is read again) **(choice C6)**.
-
-### 2.5 Env vars
-
-| Old | New |
-|---|---|
-| `SPIRE_FORKS_CHILD` (N3 marker in the child env) | `SPIRE_GREMLIN_CHILD` |
-| `SPIRE_FORKS_CMD`, `SPIRE_FORKS_CWD` | `SPIRE_GREMLIN_DETACH_CMD`, `SPIRE_GREMLIN_DETACH_CWD` |
-| (new in 3.2) | `SPIRE_GREMLINS_UNSUPPORTED_OK` (§4) |
-
-### 2.6 Prompt text in the skill folder
-
-- `preamble.md` title `# Headless implementer (spire:gremlins)`. Body: "You run headless under `claude -p` in a Spire build: first as the trained base, then as gremlins spawned from it once per block (each a fork of the base's session). Any session of yours may later be resumed or forked again." Keep the other rules; "the forks helper (`forks.py`)" → "the gremlins helper (`gremlins.py`)"; "only when your brief says this fork commits" → "this gremlin commits".
-- `templates/spawn.md`: title `# Block ${block} (spire:gremlins)`; "You are a fork of base" → "You are a gremlin spawned from base `${base}` (a fork of its session; run log `${run}`)"; "## Rules for this fork" → "## Rules for this gremlin". The stale-snapshot sentence and every `${…}` placeholder stay.
-- `templates/train.md`: "(spire:gremlins)"; "This session is trained once and then forked, once per block; every fork starts from …" → "This session is trained once; then one gremlin per block is spawned from it by forking it, and every gremlin starts from …"; "Forks write handoff notes" → "Gremlins write handoff notes".
-- `templates/rebase.md`: "(spire:gremlins)"; "You are a fork of base" → "This session is a fork of base"; "every later fork of this build" → "every later gremlin of this build".
-- `commit_rule` strings in `cmd_spawn`: "This gremlin runs in parallel with other gremlins: do NOT commit …" and "This gremlin commits: …".
-
-### 2.7 Tests (`test_gremlins.py`)
-
-- Module variable `forks` → `gremlins`, `_load_forks` → `_load_gremlins`, `FORKS_PY` → `GREMLINS_PY`, `sys.modules["gremlins"]`.
-- Temp prefix `forks-test-` → `gremlins-test-` (`Base.setUp`, `tearDownModule`'s PowerShell filter `'gremlins' + '-test-'`, the M8 marker `gremlins-test-poscontrol-%d`).
-- Helpers: `fork` → `spawn`, `fork_marked` → `spawn_marked`, `fake_fork` → `fake_spawn`, `FORK_RESULT` → `SPAWN_RESULT`, `SESS_FORK` → `SESS_SPAWN`.
-- Test names: `test_train_fork_continue_end_to_end` → `test_train_spawn_continue_end_to_end`, `test_usage_rule_real_fork` → `test_usage_rule_real_spawn`, `test_allowed_inside_a_fork` → `test_allowed_inside_a_gremlin`; any other test name with `fork` the same way.
-- Assertions on strings change with the code ("inside a fork" → "inside a gremlin", `"fork"` kinds → `"spawn"`, `forks` key → `gremlins`). **No assertion is dropped or loosened**; every changed assertion line is listed in the handoff note (old → new).
-- Add one assertion each for `method`: the `spawn` launch return has `method == "fork"`; its result and ledger line have `method == "fork"`; a train/continue result has `method is None`.
-- The stub (`STUB_PY`) keeps `--fork-session` handling (it is the claude flag).
-
-### 2.8 Residue check (3.1 gate)
-
-`git grep -n -i "fork" -- plugins/spire/` after the block. Every remaining hit must fall in one of: the claude flag `--fork-session`; `method` values `"fork"` and the `--method` choices; prose about the session mechanism ("fork of the base's session", "forked"); the Agent-tool fork rows in `implementation/references/spawning-claude-code.md` and `athanor.md`/`implementation/SKILL.md` (those are Phase 3.5/3.6 text, untouched in 3.1). List the remaining hits in the handoff note with their category. `git grep -n "spire:forks\|forks\.py\|SPIRE_FORKS\|skills/forks" -- plugins/` must be empty.
-
-Workpad documents (`docs/workpad/…`) are history: none of them is renamed or edited, including this run log's title.
-
----
-
-## 3. Platform seam (block 3.2)
-
-All platform-specific code moves behind one interface in `gremlins.py` (one file stays the rule: stdlib only, PEP 723). It lives in one section between the markers `# --- platform seam: begin ---` and `# --- platform seam: end ---`.
-
-### 3.1 Selection
-
-```python
-def select_platform() -> "Platform":
-    return WindowsPlatform() if os.name == "nt" else PosixPlatform()
-
-PLATFORM = select_platform()
-```
-
-This is the only `os.name` test in the file. `IS_WINDOWS`, `CREATE_NO_WINDOW`/`_NOWIN` at module level, the module-level `ctypes` block, `_taskkill`, `_powershell`, `find_cygpath`, `cygpath_w`, `_GITBASH_DRIVE` and `POWERSHELL_CIM` all move into the classes. WSL is `PosixPlatform` (it is Linux).
-
-### 3.2 The interface
-
-```python
-class Platform:
-    name: str            # "windows" | "posix"
-    detach_method: str   # "cim-hidden" | "setsid"
-    supported: bool      # WindowsPlatform: True. PosixPlatform: False (the 0.3.0 gate, §4)
-
-    def describe(self) -> dict
-    def is_wsl(self) -> bool
-    @staticmethod
-    def norm_path(p: str, cwd: str | None = None) -> str
-    def popen_kwargs(self, new_group: bool = False) -> dict
-    def detach(self, argv: list[str], cwd: str, log_path: str) -> dict
-    def proc_ctime(self, pid: int) -> int | None
-    def epoch_to_ctime(self, t: float | None) -> int | None
-    def pid_alive(self, pid: int, ctime: int | None = None) -> bool
-    def process_table(self) -> list[tuple[int, int, str]]
-    def terminate(self, pid: int) -> bool
-    def tree_kill(self, pid: int) -> int | None
-    def restore_no_replace(self, src: str, dst: str) -> bool
-    def visible_windows(self) -> list[tuple[int, int, str, str]] | None
-```
-
-Semantics, per method. "As today" means the current body of the named function, moved without behaviour change.
-
-| Method | `WindowsPlatform` | `PosixPlatform` |
-|---|---|---|
-| `describe()` | `{"name": "windows", "sys_platform": sys.platform, "wsl": False, "supported": True, "detach": "cim-hidden"}` | `{"name": "posix", "sys_platform": sys.platform, "wsl": self.is_wsl(), "supported": False, "detach": "setsid"}` |
-| `is_wsl()` | `False` | `True` if `WSL_DISTRO_NAME` is set, or `/proc/sys/kernel/osrelease` contains `microsoft` (case-insensitive); unreadable → `False` |
-| `norm_path(p, cwd)` | the current Windows branch of `norm_path`, including M13's `cygpath -w` for Git Bash rooted non-drive paths, plus the WSL refusal of §3.4. Pure string logic except the cygpath call; must run on any host. `find_cygpath()` and `cygpath_w()` become static methods of this class. | the current POSIX branch, plus the refusals of §3.4. Pure; runs on any host. |
-| `popen_kwargs(new_group)` | `{"creationflags": 0x08000000}` (`CREATE_NO_WINDOW`), `new_group` ignored | `{"start_new_session": new_group}` |
-| `detach(argv, cwd, log_path)` | as today's CIM branch of `spawn_supervisor` (`powershell` with `CREATE_NO_WINDOW`, `Win32_ProcessStartup.ShowWindow=0`, command line and cwd through `SPIRE_GREMLIN_DETACH_CMD`/`_CWD`); `log_path` unused (the supervisor redirects itself) | as today's POSIX branch (`Popen(argv, cwd=cwd, stdin=DEVNULL, stdout/stderr=log file, start_new_session=True, close_fds=True)`) |
-| return of `detach` | `{"ok": True, "method": self.detach_method, "pid", "ctime"}` or `{"ok": False, "method", "detail"}` | same |
-| `proc_ctime(pid)` | `OpenProcess` + `GetProcessTimes` (FILETIME ticks), as today | `/proc/<pid>/stat` field 22, as today; `None` without `/proc` |
-| `epoch_to_ctime(t)` | FILETIME conversion, as today | `/proc/stat` `btime` × `SC_CLK_TCK`, as today; `None` without `/proc` |
-| `pid_alive(pid, ctime)` | as today (access denied → alive, creation time unverifiable) | as today (`os.kill(pid, 0)`; `PermissionError` → alive) |
-| `process_table()` | Toolhelp32 snapshot, as today | `/proc` walk, as today; `[]` without `/proc` (macOS: the known gap, §8) |
-| `terminate(pid)` | `OpenProcess(PROCESS_TERMINATE …)` + `TerminateProcess`, as today | `os.kill(pid, SIGKILL)`, as today |
-| `tree_kill(pid)` | `taskkill /T /F /PID <pid>` (System32 path), returns its exit code; `OSError`/`SubprocessError` → logged, `None` | `os.killpg(pid, SIGKILL)` with `OSError` suppressed; returns `None` |
-| `restore_no_replace(src, dst)` | `_retry(lambda: os.rename(src, dst))` (Windows rename never overwrites) | `os.link(src, dst)` then `os.remove(src)` |
-| `visible_windows()` | `EnumWindows` + `IsWindowVisible` + `GetWindowThreadProcessId` + class and title, i.e. the test helper `visible_windows()` moved into the helper **(choice C7)**: the user named "the window checks" as part of the seam | `None` (not applicable) |
-
-`ctypes` is loaded lazily inside `WindowsPlatform` (on first use by a process method or `visible_windows`), never at import or in `__init__`. So `WindowsPlatform()` and `PosixPlatform()` can both be constructed on any host, and the path matrix and the gate tests run everywhere.
-
-### 3.3 Module-level functions that stay (neutral code calls these)
-
-These keep their names and signatures, so the cross-platform logic and the existing tests' `mock.patch.object(gremlins, …)` keep working. Each is a thin delegate with no platform branch:
-
-- `norm_path(p, cwd=None, windows=None)`: `windows=True` → `WindowsPlatform.norm_path`, `False` → `PosixPlatform.norm_path`, `None` → `PLATFORM.norm_path`. (The parameter is a selector the tests use; it is not a platform check.)
-- `proc_ctime`, `epoch_to_ctime`, `pid_alive`, `process_table` → `PLATFORM.<same>`.
-- `pid_record`, `record_alive` unchanged (they call the delegates).
-- `terminate(rec)`: `if not record_alive(rec): return True`, then `PLATFORM.terminate(int(rec["pid"]))`.
-- `process_tree(rec, alive_until)`: unchanged logic; it must call the **module-level** `process_table`, `proc_ctime`, `pid_alive`, `epoch_to_ctime`, never `PLATFORM.` directly (`ProcessTreeTests` patch the module names).
-- `kill_tree(rec, extra, alive_until)`: unchanged logic; the one OS step becomes `rc = PLATFORM.tree_kill(int(r["pid"]))`.
-- `_run(...)`: `**PLATFORM.popen_kwargs()` instead of `creationflags=_NOWIN`.
-- `detach_supervisor(state, run, job)`: builds `argv = [supervisor_interpreter(), "-I", script_path(), "_supervise", "--run", run, "--job", job]` and returns `PLATFORM.detach(argv, cwd=state, log_path=raw_file(state, job, ".sup.log"))`. Tests patch `gremlins.detach_supervisor`.
-- `Supervisor.run`: the claude `Popen` takes `**PLATFORM.popen_kwargs(new_group=True)` (keeps today's POSIX `start_new_session=True` exactly; M14 is documented, not fixed).
-- `RegistryLock._restore(aside)`: `return PLATFORM.restore_no_replace(aside, self.path)`.
-
-Neutral already, and staying outside the seam: `_retry`/`PermissionError` retries (harmless on POSIX), `RegistryLock._try_create`'s `getattr(os, "O_BINARY", 0)`, `scrubbed_env` (`os.pathsep`), `_venv_prefixes`, `supervisor_interpreter`, `transcript_path`.
-
-### 3.4 Path-form matrix
-
-New test class `PathMatrixTests`: every row × both classes, pure (no filesystem), `WindowsPlatform.find_cygpath` patched. Windows cwd `G:\dev\proj`; POSIX cwd `/home/u/proj`.
-
-| # | Input | `WindowsPlatform.norm_path` | `PosixPlatform.norm_path` |
-|---|---|---|---|
-| 1 | `C:\x\y.md` | `C:\x\y.md` | refused **(choice C8)** |
-| 2 | `c:/x/y.md` | `C:\x\y.md` | refused |
-| 3 | `C:` / `C:x` (drive-relative) | as today (cwd-of-drive semantics via `ntpath`; record what it gives, assert it is absolute with drive `C:`) | refused |
-| 4 | `/c/x/y.md` (MINGW) | `C:\x\y.md` | `/c/x/y.md` |
-| 5 | `/c` | `C:\` | `/c` |
-| 6 | `/tmp/x` | with a fake cygpath: its `-w` output (`C:\Fake\tmp\x`); without cygpath: refused (M13) | `/tmp/x` |
-| 7 | `\\srv\share\x\y.md` (UNC) | `\\srv\share\x\y.md` | refused |
-| 8 | `//srv/share/x/y.md` | `\\srv\share\x\y.md` | `//srv/share/x/y.md` (`posixpath.normpath` keeps exactly two leading slashes) |
-| 9 | `/mnt/c/x/y.md` (WSL) | refused **(choice C9)**: "WSL path form on Windows; pass C:\… or /c/…" | `/mnt/c/x/y.md` |
-| 10 | `docs/a.md` | `G:\dev\proj\docs\a.md` | `/home/u/proj/docs/a.md` |
-| 11 | `docs\a.md` | `G:\dev\proj\docs\a.md` | refused (a backslash on POSIX is almost always a Windows path) |
-| 12 | `\rooted\a` | `G:\rooted\a` (the cwd's drive, as today) | refused |
-| 13 | `../z` | `G:\dev\z` | `/home/u/z` |
-| 14 | `  G:/x/y.md  ` | `G:\x\y.md` | refused |
-| 15 | `""` / `"  "` | refused | refused |
-
-"Refused" = `GremlinsError`, exit code 2, `payload["error"]` a sentence naming the form, `payload["path"]` the input. The POSIX refusals are: a drive form (`^[A-Za-z]:`), or any backslash. That is the only POSIX behaviour change in this phase, and it exists because the matrix needs a defined answer (a drive path silently joined onto the cwd is today's behaviour and is wrong).
-
-The existing `PathTests` stay (some become redundant; keep them, they are cheap).
-
-### 3.5 Tests that move or change
-
-- `visible_windows()`/`console_windows()` in the tests call `gremlins.PLATFORM.visible_windows()`; `test_no_visible_window` skips when it returns `None` or an empty list.
-- Tests that patch `find_cygpath` patch `gremlins.WindowsPlatform.find_cygpath` (a `staticmethod`).
-- `test_spawn_failed` becomes `test_detach_failed` (the reason is renamed, §3.6). It patches `detach_supervisor`; the fake return uses `"method": gremlins.PLATFORM.detach_method`, and it asserts `reason == "detach_failed"`.
-- `CliTests`/`SubprocessTests` `where` assertions: `out["platform"]["detach"] == "cim-hidden"` on Windows (replaces `out["spawn"]`).
-- Tests may still branch on the platform where they test platform behaviour; they use `gremlins.PLATFORM.name == "windows"` instead of their own `os.name` check, except the generated stub wrappers (`.cmd` vs `sh`) and `tearDownModule`'s PowerShell sweep, which may keep `os.name` (test-only code).
-
-### 3.6 JSON shape changes in 3.2
-
-| Where | Old | New | Why |
-|---|---|---|---|
-| `where` | `"spawn": "cim-hidden"` | removed; `platform.detach` carries it | "spawn" is now a command |
-| `where` | `"platform": "win32"` | `"platform": {name, sys_platform, wsl, supported, detach, override}` (`override` per §4) | the gate needs a structured answer |
-| `kill`, `expire.killed[]` | `taskkill_rc` | `tree_kill_rc` | platform-neutral key **(choice C10)** |
-| reason vocabulary | `spawn_failed` | `detach_failed` | **(choice C10)**: the supervisor's detach failed, for any kind; `spawn_failed` would read as "the spawn command failed" |
-
-### 3.7 Seam check (3.2 gate)
-
-`git grep -n -E "os\.name|sys\.platform|IS_WINDOWS|ctypes|_k32|taskkill|powershell|killpg|setsid|start_new_session|creationflags|cygpath|/proc" -- plugins/spire/skills/gremlins/gremlins.py`: every hit lies between the seam markers, except `sys.platform` inside `describe()` (also inside) and string mentions in docstrings/comments outside, which the handoff note lists. The green Windows suite is the refactor's guard (goal).
-
----
-
-## 4. Windows-only gate (block 3.2, second commit)
-
-- **Rule**: `PLATFORM.supported` is `True` only for `WindowsPlatform`. Linux, WSL (it is Linux) and macOS are `PosixPlatform`, which is `supported = False` in 0.3.0.
-- **Neutral helper** `platform_gate() -> str | None`: `None` when supported or overridden; else the reason: "spire:gremlins 0.3.0 runs on Windows only; this is <sys_platform><, WSL>. Use fresh agents for every block (the 0.2.2 shape); see SKILL.md, Platforms."
-- **`where`**: on a closed gate, `ok: false`, the reason joined into `reason`/`error` like the other reasons, exit 2. Everything else in the report is still filled (binary, uv, git, scrub), because the porting Igors need it.
-- **`init`**: refuses with exit 2, `{"error": "platform not supported", "reason": <the gate reason>, "platform": PLATFORM.describe()}` before any write **(choice C11)**. The goal names only `where`; refusing `init` makes "fail closed" mean the helper cannot be used, not only that it says so. Every other command needs `init`, so nothing launches on a closed platform.
-- **Override (porting aid)** **(choice C12)**: env `SPIRE_GREMLINS_UNSUPPORTED_OK=1` opens the gate for that call. `where` then reports `platform.override: true`, stays `ok: true` if nothing else fails, and adds a `warnings` entry ("platform gate overridden …; this platform is untested"). It exists so the Linux and macOS Igors (and the WSL check) can run the suite and the smoke before they lift the gate in code. It is documented in the handoff report, **not** in SKILL.md.
-- **Lifting the gate** is a code change: `PosixPlatform.supported` returns `True` for the tested `sys.platform` values (the handoff report says how).
-- **Tests** (`GateTests`): `WindowsPlatform().supported is True`; `PosixPlatform().supported is False` with `sys.platform` patched to `linux` and to `darwin`; with `gremlins.PLATFORM` patched to a `PosixPlatform` whose `is_wsl` returns `True` and with the override env removed: `where --binary <stub>` exits 2, `ok: false`, `reason` names "Windows only" and "WSL", `platform.supported` false; `init` exits 2 and creates no state dir; with the override env: `where` exits 0 with the warning, `init` proceeds. On the real Windows host: `where` has `platform.supported: true`, `override: false`.
-- `Base.setUp` sets `SPIRE_GREMLINS_UNSUPPORTED_OK=1` in its patched `os.environ` for every test **(choice C13)**, so the same suite exercises the POSIX code on WSL and on the porting hosts; `GateTests` remove it. On Windows the variable changes nothing.
-
----
-
-## 5. N3, N4 and the flaky kill test (block 3.3)
-
-### 5.1 N3: `init` re-run and the binary
-
-- On a re-run **without** `--binary`: if the stored `binary_resolved_by` is `"--binary"`, keep the stored path (an explicit pin). Otherwise re-resolve with `resolve_binary(None)` (`$CLAUDE_CODE_EXECPATH`, else PATH) **(choice C14)**. If re-resolution finds nothing, keep the stored path.
-- `init` output always carries `warnings: []`. It gets one entry when the binary path changes ("binary changed: <old> → <new> (resolved by <how>); existing bases keep their own binary record, new trainings use the new one") and one when re-resolution failed and the stored path was kept.
-- The change shows in `changed_fields` as `launch.binary.*` (it already would). Existing bases are untouched: they keep their own `launch.binary`, so a still-present old binary gives no drift and a vanished one gives `binary_missing` as today.
-- Tests (`InitTests`): a first init via `$CLAUDE_CODE_EXECPATH` = stub A, a re-run with the env pointing at stub B and only `--pings off` → path B, warning, `launch.binary.path` in `changed_fields`; a first init with `--binary A`, a re-run with the env at B → path A kept, no warning; the stored file deleted and the env unset, PATH without claude → stored path kept with the "could not re-resolve" warning (then `build_launch` refuses the missing file with exit 2, as today, which is loud).
-- `where` is unchanged (it takes no `--run`).
-
-### 5.2 N4: a rebase that ends after its base stopped being active
-
-- In `_rebase_succeeded`: when the old base's status is not `active` at finalise (a `train --supersedes` ended first; or an `expire` raced the kill), create NEW with the old base's status (`superseded` with the old base's `superseded_by` and `superseded_at` = this end time; or `retired` with `retired_at`), not `active` **(choice C15)**. The old base is left untouched (its `superseded_by` is **not** overwritten). The job entry records `rebase_inactive_parent: "<old> was <status> when the rebase ended"`.
-- The rebase result keeps `status: ok` (the call worked) and gets the new flag **`parent_inactive`**. Compute it in `_conclude` before the result is built (the base's status is known there).
-- So NEW gets no pings (status gate) and needs `--force` to spawn from, like any superseded base.
-- Test (`LaunchTests`): train B1; start `rebase --base B1 --as B1r` with a stub `sleep`; `train --base B3 --supersedes B1` that ends `ok` first; when the rebase ends: its result `ok` with `parent_inactive`; B1r `superseded`, `superseded_by == "B3"`; B1 `superseded_by == "B3"` unchanged; `ping_decision` for B1r reads `status:superseded`; `spawn` from B1r without `--force` exits 2.
-
-### 5.3 The flaky `LaunchTests.test_refusals` (`kill` returned `ok: false` under full-suite load)
-
-**Investigation** (bounded: about 15 minutes of wall time):
-
-1. First make the failure speak: `out = self.cmd("kill", "--job", j); self.assertTrue(out["ok"], out)`. (The assertion today discards the survivors.) This adds information, it loosens nothing.
-2. Try to reproduce under load: run `LaunchTests.test_refusals` alone 10 times while a CPU load runs (a handful of scratch-dir Python busy loops, recorded by pid and killed afterwards). **Never run two copies of the suite at once**: each `tearDownModule` kills every `gremlins-test-` process, including the other copy's.
-3. Classify each survivor from the kill output and a follow-up check of its pid:
-   - **(a) pid reuse**: the pid now belongs to a process that `OpenProcess` refuses (`ERROR_ACCESS_DENIED`), so `pid_alive` reports it alive with an unverifiable creation time. This is a product defect.
-   - **(b) slow exit**: the same pid and creation time is still alive after `KILL_VERIFY_S` and gone a little later (exit stalled under load). Timing.
-   - **(c) unkillable member**: `TerminateProcess` keeps failing for a real tree member. A product defect.
-
-**Fixes, decided now**:
-
-- **Always** (whether or not it reproduces) fix (a) in the neutral `kill_tree` verification: each sweep iteration takes one `process_table()`; a snapshot entry counts as a survivor only if `record_alive(p)` **and** the table still has that pid with the same `name` as in the snapshot. A pid that is gone from the table or now carries another name is dead **(choice C16)**. Reading the code shows (a) is a real false positive, rare or not. Test: a `kill_tree` unit test on a fake table (`ProcessTreeTests` style) where a snapshot pid reports alive (access denied) but the table shows another name → no survivor; same name → survivor.
-- If (b) is observed: raise `KILL_VERIFY_S` from 10 to 30 s (the loop exits as soon as everything is dead, so the normal case costs nothing). Keep the test assertion strict.
-- If (c) is observed: fix in `WindowsPlatform.terminate`/`tree_kill` with a failing test first, and flag it.
-- Record in the handoff note: reproduced or not, the class, the survivors' names, and which fix landed. If nothing reproduces, say so and say that only the (a) guard landed.
-
----
-
-## 6. WSL check (block 3.4; the Athanor's own Bash)
-
-Purpose (goal): does the helper run under WSL Ubuntu, and does PATH interop resolve `claude` to the Windows exe? WSL stays fail-closed regardless. Findings feed the handoff (3.7). No live `claude` calls; no WSL login is needed.
-
-Traps: Git Bash rewrites `/mnt/…` arguments, so every `wsl` call from Git Bash is prefixed `MSYS_NO_PATHCONV=1`. Never `wsl --shutdown` or `--terminate` (other WSL work on the host would die); the distro was `Stopped` at intake and idles back down by itself. Raw output goes to the session scratchpad `…\scratchpad\gremlins-wsl\` (not in git).
-
-Steps:
-
-1. **Inventory**: `wsl -d Ubuntu-20.04 -- bash -lc 'uname -a; head -3 /etc/os-release; command -v uv python3 python3.10 python3.11 python3.12 git; python3 --version; ls ~/.local/bin ~/.cargo/bin 2>/dev/null'`.
-2. **PATH interop**: `bash -lc 'type -a claude claude.exe; echo "$PATH" | tr : "\n" | grep -c ^/mnt/; cat /etc/wsl.conf 2>/dev/null; echo EXECPATH=${CLAUDE_CODE_EXECPATH-unset} WSL_DISTRO_NAME=$WSL_DISTRO_NAME'`. Record what `claude` resolves to (a `/mnt/c/…` Windows shim or `.exe`, a Linux install, or nothing) and whether `$CLAUDE_CODE_EXECPATH` crosses (it should not, without `WSLENV`).
-3. **uv / Python ≥ 3.10**: if uv is present, use it. Else, if a `python3.10+` is present, run the files with it directly (the PEP 723 header has no dependencies). Else install uv with the official installer (`curl -LsSf https://astral.sh/uv/install.sh | sh`, to `~/.local/bin`) **only if the Bash permission system lets the call through**. That is a download and execute, so it needs the user's approval through the permission prompt. If it is denied or blocked, record "not run: no Python ≥ 3.10 or uv in WSL; installing needs user approval", and the WSL check ends with steps 1–2.
-4. **Copy to ext4**: `cp -r /mnt/g/dev/projects/reliquary/.claude/worktrees/headless-forks/plugins/spire/skills/gremlins ~/gremlins-wsl-check/` (drvfs has different chmod, lock and rename semantics; the copy isolates the helper from them).
-5. **Runs**, each to a log file under `/mnt/c/Users/g4b/AppData/Local/Temp/claude/G--dev-projects-reliquary/42c87f82-5542-46aa-8d01-4166e3f0bcfe/scratchpad/gremlins-wsl/`:
-   - `uv run ~/gremlins-wsl-check/gremlins.py where`: expect exit 2, `ok: false`, the gate reason with "WSL", `platform.wsl: true`. Record the binary block (did it resolve the Windows `claude`, and does `--version` of it run through interop?).
-   - The same with `SPIRE_GREMLINS_UNSUPPORTED_OK=1`.
-   - `where` once from the drvfs path (`/mnt/g/…/gremlins.py`), to record any difference.
-   - The unit suite: `timeout 1200 uv run ~/gremlins-wsl-check/tests/test_gremlins.py -v`. Then `PathMatrixTests` and `GateTests` alone. Record pass/fail/error/skip per class and the first line of each failure, grouped by cause (`/proc`, `setsid` detach, `killpg`/M14, stub wrapper, git missing, chmod, locks, path refusals, timing).
-6. **Leftovers**: `ps -eo pid,args | grep -E "gremlins|_supervise|claude-stub" | grep -v grep`; kill only our own by pid. Then `rm -rf ~/gremlins-wsl-check` (our scratch copy).
-7. **Findings** → `…\scratchpad\gremlins-wsl\findings.md` (inventory, interop answer, `where` outputs, suite table, failure causes, what would need fixing). The Athanor writes the 3.4 run-log note; 3.7 cites the findings.
-
-If the WSL run shows a seam bug that also matters on Windows, or a crash in neutral code, a fresh `opus` fixes it with a test before 3.5 (logged as a deviation). POSIX-only failures are **not** fixed (the brief: "don't fix POSIX beyond what the seam needs"); they go into the handoff.
-
----
-
-## 7. Text changes per file (blocks 3.5 and 3.6)
-
-Write against the helper's real output: run `where`, `<command> --help` (one JSON object each) and read `_conclude`, `cmd_wait`, `cmd_list`, `kill_job`. The result fields and vocabularies listed in §7.1 are as built after 3.1–3.3; if the code differs, the code wins and the note says so.
-
-### 7.1 `plugins/spire/skills/gremlins/SKILL.md` (new; 3.5)
-
-Frontmatter (design §2 pattern, renamed):
-
-```yaml
----
-name: gremlins
-description: Trains one headless implementer (the base) per build and spawns gremlins from it, one per complex block, by forking the base's session (`claude -p --resume --fork-session`). Owns the command line, the prompt-cache bookkeeping and the usage ledger. Windows-only in 0.3.0. Loaded by the Athanor.
-allowed-tools: Bash(uv:*)
----
-!`uv run "${CLAUDE_SKILL_DIR}/gremlins.py" where`
-```
-
-Body, short (target 120–180 lines; the design says "Short"). Sections and the facts each must carry:
-
-1. **What and when.** The Athanor's build path for complex blocks: one base per build (trained early, reads the code, writes the trunk notes), one gremlin per complex block, fresh Agent-tool agents for mechanical or distant blocks. Claude Code only (Codex loads this skill too; it does not apply there). Words: base, gremlin, `spawn` (method `fork`), `continue`, `rebase`, ping.
-2. **Platforms.** Windows-tested. On any other platform (Linux, WSL, macOS) `where` reports `ok: false` with the reason and `init` refuses; then use fresh agents for every block (the 0.2.2 shape). Do not try to work around it.
-3. **Setup.** The injected `where` gives `script` (use that absolute path in every call) and `ok`. If `ok` is false, see Platforms or the reason. Projects need an allow rule `Bash(uv run:*)` (or `Bash(uv:*)`): the skill's `allowed-tools` did not pre-approve calls in a subagent (P0.8, untrusted dir; Phase 4 re-checks). `$SCRIPTS_UV` only on hosts without `uv` on PATH (A15). `init` once per run, with a full model id. A successor never re-runs `init` to "reset": `list` and adopt. A re-run changes only the flags given, except that it re-resolves the binary unless it was pinned with `--binary` (N3). `--warm-margin-s` must stay below the TTL (at 1 h, at most 1800 takes effect). Pass `--allowed-tools` together with `--tools` (Minor 12).
-4. **Commands** table, first column exactly ``| `<name>` |`` for: `where`, `init`, `train`, `spawn`, `continue`, `rebase`, `wait`, `list`, `usage`, `expire`, `kill`, `tick` (G-text 6 compares this set with `--help`'s `commands`). One line each: key flags and the return shape (`spawn` returns `{job, base, method, base_state, warm_until, rebase_due, retrain_due, reasons}`; `train` and `rebase` return `{job, base, session_id}` (+ `parent` for rebase); `continue` returns `{job}`). Every command except `where` takes `--run <run log .md>`. Exit codes 0 / 2 / 3 / 4. stdout is one JSON object (`usage --format md`: one markdown fragment).
-5. **Waiting.** Call `wait` from Bash with `timeout: 600000`; never omit it (C2). The Bash tool **backgrounds** a call that passes its timeout instead of killing it (P0.1). Loop `wait --all` until exit 0 or 4. Exit 3 means "call again", and `done` may already hold finished (also failed) results (C4). Pings come back in `pings`, never in `done`. `running[]` rows count `messages`; results and the ledger count `turns` (M16). A failed detach (`detach_failed`) shows up in the next `wait`, not in the launch return.
-6. **Results.** The result fields (`job, kind, method, base, block, phase, status, flags, fingerprint, session, parent_session, models_used, tokens{input, output, cache_creation, cache_creation_1h, cache_creation_5m, cache_read}, cost_delta_usd, cache, base_state, wall_s, turns, denials, note, raw, paths, reason, model_requested`). Statuses `ok|failed|timeout|killed|lost`. Reasons: `model_refused, usage_limit, overloaded, prompt_too_long, api_error, is_error, exit_code, no_result, detach_failed, launch_error, supervisor_error` (failed); `kill, expire, orphaned` (killed); `supervisor_dead` (lost); `null` otherwise (`timeout` too). Flags: `stalled, needs_attention, usage_mismatch, ttl_downgrade, cold_start, clock_jump, ping_missed, orphaned, expired, parent_inactive`. A cold base usually shows `partial`, because the shared system prefix stays warm (C5).
-7. **Rules (flags, not judgment).**
-   - `rebase_due` → `rebase --as <new> --phase <n>` before the next spawn; **always pass `--phase`**; `rebase` counts toward `parallel_cap`. `retrain_due` → `train` a new base with `--supersedes <old>`, else the old base keeps getting pings. `binary_missing` → launches refuse; train with the new binary. A cold base is still spawnable; coldness never triggers a re-train.
-   - Delta: attach handoff notes with `spawn --delta-note PATH` (repeatable). A `## Changes since base` section in a brief holds this gremlin's delta only; no line in it may start with `#` (also not inside fenced code: it ends the section, N1). When rebasing, attach every note written since the base's `trained_at` (shown by `list`), because a note older than that counts as known to the base whether or not it was given to it (N2).
-   - `continue` sends the brief without a frame: put the commit rule and the note path into it (M16).
-   - Sequential gremlins one at a time (Minor 13). Parallel only for disjoint blocks, with `--mode parallel --paths …` (N2); parallel gremlins never commit; the Athanor commits each block by the paths its note lists, one at a time.
-   - Nothing running at hand-back: `list` shows no running job other than pings (kind `ping`; a ping ends within 300 s and is not a leak, Minor 7). Otherwise `kill` it and flag it.
-   - `kill`: key on `ok` and `status`, not on `killed` or the exit code (M12). `killed: true, status: ok` means the job finished first; `ok: false` lists survivors (exit still 0): flag it.
-   - The orphan watchdog (N1): a gremlin is killed (`orphaned`) after `orphan_after` (default 1200 s) without an orchestrator call (`wait`, `spawn`, `continue`, `train`, `rebase`, `list`, `usage`). `kill` and `expire` do not count (Phase 1 M3), and a gremlin's own calls never do. So keep looping `wait` while gremlins run.
-   - Inside a gremlin, `SPIRE_GREMLIN_CHILD=1` is set and `train`, `spawn`, `continue`, `rebase`, `kill`, `expire`, `init`, `tick` refuse (N3); `where`, `list`, `usage`, `wait` work.
-   - Models: full ids only; `spawn` takes the base's model (no `--model`). Admission is "permissive at `init`, enforced at runtime" (M15): a substituted model ends `failed`/`model_refused`.
-   - After `claude` exits, its leftover descendants are killed, including daemons a commit may have started (`gpg-agent`, `git fsmonitor--daemon`); they restart on demand (M16).
-   - A re-train that supersedes a base while a rebase of it is running: the rebase's new base arrives superseded and its result carries `parent_inactive` (N4). Re-train first, or let the rebase finish.
-   - Never resume or fork a headless session by hand; never call `claude -p` yourself; never `SendMessage` or `TaskStop` a gremlin (`continue` and `kill` cover it).
-8. **State.** `<run log without .md>-gremlins/` next to the run log: what is committed at phase close (everything but `raw/` and lock files) and what the Athanor reads (`notes/`, `results/`, `logs/`).
-
-### 7.2 `plugins/spire/agents/athanor.md` (3.5)
-
-Design §8.4 plus build plan A7, A13, A23, plus the goal's decisions:
-
-- **Frontmatter `description`**: keep the furnace sentences and trigger phrases ("Fire up the Athanor", "into the Athanor with it"), the Opus pin, "may use the Agent (Task) tool", "does not plan, attack plans, or review its own output", and the non-build line. Replace "blocks in the foreground" with: "trains a headless base and spawns gremlins for complex blocks, fresh agents for mechanical ones, a cheap gate between blocks, tests once, a run log with usage — and hands back".
-- **`skills:`** add `spire:gremlins` (G-text 2).
-- **Line 23**: "otherwise orient via direct file reads" → "otherwise orient by reading plans, designs, reports and notes, not code".
-- **Intake (step 1)**: read the build plan, design, run log, trunk notes and the last review; check the branch. Remove "the code the phase touches. That reading is your trunk" (G-text 1). Then:
-  - If the run log header has a `Gremlins:` line, run `list` and adopt the active base. Never re-`init`, never re-train an active base (A7).
-  - Else run `where`. If `ok`: `init` (full model id = the plan's owner model for complex blocks; effort; the project's agent file if any), then `train` the base with a brief naming the plan, design, the phase's blocks, the areas to read and the trunk-notes path. The base writes the trunk notes. Add `Gremlins: <state dir>` to the run log header.
-  - If not `ok` (any non-Windows host): fresh agents for every block. A fresh agent reads the code the phase touches and writes the trunk notes **(choice C18)**; the Athanor still does not read code.
-  - Later phases: `rebase --as B<n+1> --phase <n>` with the delta (handoff notes, review findings, commit range).
-- **Step 2 (build the blocks)**: complex block in the trained area → `spawn` from the current base with a delta brief (block id and plan section, the handoff notes since the base as `--delta-note`, open review flags touching the block, the mode, the gate and test commands); then `wait` until done; read `notes/<block>.md` and the result. Mechanical or distant block → fresh Agent-tool agent in the foreground with the trunk notes. A complex block whose owner model differs from the base: a gremlin anyway (logged deviation) or its own base; never a model override (refused). Remove "a fork of yourself …" and the fork-behaviour sentence (G-text 1). Obey `rebase_due`/`retrain_due` as SKILL.md says.
-- **Step 3 (gate)**: the plan's command, output to a `.txt` under the state dir's `logs/`. Red → `continue --job <gremlin>` once with the log path; still red → flag it and go on per "what may stay broken".
-- **Mechanical check** after each block (replaces "read the fix's diff for loosened assertions"; G-text 1): commit present (`git log --oneline`); the evidence log exists and is not empty; `git diff --numstat <range> -- <test paths>`; removed assertion lines `git diff <range> -- <test paths> | grep -c '^-.*assert'` (pattern `assert` by default, A23). A non-zero count goes to the block's note as a question and into the reviewer flags.
-- **Step 4 (tests once)**: the Athanor runs the test command to a file under `logs/` (never through `tail`; the first run after a fresh worktree is a warm-up, rerun once). Fallout → a gremlin from the current base (or `continue` of the block that caused it) with the failing log as the delta. Parallel test runs are off unless the project says they are safe (A23 default).
-- **Step 5 (run log)**: block rows from `usage --block <id> --format md`; notes appended from `notes/`; phase close with `usage --phase <n> --format md` (per-kind table, cold starts, hit ratio, priced total) and every flag.
-- **Step 6 (hand back)**: `list` shows nothing running except pings. Do not `expire` the base: a review and fix pass within the TTL finds it warm, and later it is cold but still spawnable.
-- **Fix pass**: gremlins of the current base with the findings as the delta; `rebase_due` decides whether to rebase first.
-- **Dispatching**: add "You call `gremlins.py` from your own Bash, with the `script` path `where` printed; every `wait` with `timeout: 600000`." Keep the `SendMessage` and model rules. Add "never `SendMessage` or `TaskStop` a gremlin".
-- **Keepers**, new:
-  - "You do not read code; the base and its gremlins do. You read plans, notes, helper JSON, `git log --oneline`, `git diff --stat`/`--numstat` and gate summaries."
-  - "Nothing running at hand-back."
-  - Commit ownership (plan §4.4 / design §8.3): a sequential gremlin commits its block by explicit paths after its gate passes; parallel gremlins never commit, and the Athanor commits each block by the paths its note lists, one at a time; a fresh agent commits like a sequential gremlin; the Athanor commits the run log and the state dir (except `raw/` and locks) at phase close as `📝`. One committer at a time.
-- **"Tools, not the loop"** (line 60, A13): the fail-first test and the look one layer up become things the Athanor **writes into briefs**, not things it does.
-- **Deliverable**: add the priced usage totals and the base state (`list`: the active base, its warmth).
-- Remove every remaining mention of Agent-tool forks.
-
-### 7.3 `plugins/spire/skills/implementation/SKILL.md` (3.5)
-
-- **Line 40** "Each block commits and adds a short handoff note to the run log" → "Each block commits, and its owner writes a short handoff note (template: `references/run-log.md`): a gremlin writes `notes/<block>.md` and the Athanor appends it to the run log; a fresh agent writes into the run log directly."
-- **"Context: fresh, fork, or keep"** (lines 45–49) → heading "Context: fresh, trained, or keep"; keep the first paragraph ("Both extremes have failed …"). Replace "One option is trunk and forks …" with "trained implementer and gremlins": one base per build, trained early (it reads the code and writes the trunk notes), one gremlin per complex block spawned from it with a delta brief, the base rebased at phase boundaries or when the helper says so, fresh agents for mechanical or distant blocks. Mechanics in `spire:gremlins`. Windows-only in 0.3.0; elsewhere fresh agents throughout. No "a fork of the builder" (G-text 3).
-- **"Spawning and models"** (line 65ff): add "Gremlins run on the base's full model id; `spawn` takes no model override."
-- Line 12 (the inline rule) stays.
-
-### 7.4 `references/run-log.md` (3.5)
-
-- Header block gains `- Gremlins: <state dir> (or "none: <reason>")`. A successor finds the state dir there and adopts it (A7).
-- Per-phase block table → `| Block | Owner (model id from modelUsage) | Session | Commit | in | out | cache write | cache read | cost Δ |`, filled from `usage --block <id> --format md` for gremlin blocks. For a fresh-agent block: owner = the stamped model id, Session `—`, the usage cells `—`, and the harness's token total in the handoff note **(choice C19)**.
-- Phase close gains the `usage --phase <n> --format md` table and its three lines (cold starts, hit ratio, priced total), plus the base state from `list`.
-- Handoff note: same format for everyone. Gremlins write it to `notes/<block>.md`; the Athanor appends it.
-- "Trunk notes (written by the Athanor at intake)" → "Trunk notes (written by the base at training; by a fresh agent where gremlins are unavailable)".
-
-### 7.5 `references/spawning-claude-code.md` (3.6)
-
-Statuses only `verified`, `observed`, `assumed`, `unknown`, each with a date (build plan §2). Use the research doc `docs/workpad/research/2026-10-16-00-claude-headless-fork-sessions.md` for claim ids and the preflight report `docs/workpad/reports/2026-10-16-09-headless-forks-preflight.md` for Phase 0.
-
-- **Rules of thumb**: add "Complex blocks go to gremlins via `spire:gremlins`; never resume or fork a headless session by hand."
-- **Fork section (Agent tool)**: the rows of design §9's table, with its statuses and dates; the "unverified" row is replaced (that word is outside the vocabulary). Add a lead line: Spire no longer uses Agent-tool forks (goal decision 2026-10-16).
-- **Models**: add "Headless `--model` takes full ids, so gremlins pin by full id" (observed 2026-10-16, P0.5).
-- **New section "Headless sessions (`claude -p`)"**: every bullet of design §9's list as a row with its research id and date 2026-10-16. Plus, `observed 2026-10-16 (preflight report)`:
-  - P0.0: `uv run` adds `VIRTUAL_ENV` and a venv `Scripts` PATH head entry and no `UV_*`; stdout stays clean.
-  - P0.1: no job objects on this host; the Bash tool's stop kills by process tree; a supervisor created through CIM `Win32_Process.Create` survives the Bash call and the subagent's turn; an unhidden CIM spawn opens a visible Windows Terminal window (fix: `ShowWindow=0` plus `CREATE_NO_WINDOW` on every child); CIM children get the registry default user env, not the caller's.
-  - P0.1(d): the Bash tool backgrounds a call that passes its `timeout`, it does not kill it.
-  - P0.5: an unlisted model is substituted silently, with a `system/informational` warning.
-  - P0.8: an `!` injection runs in an Agent-tool subagent's skill preload; the skill's `allowed-tools` did not pre-approve later calls (untrusted dir; Phase 4 re-checks in a trusted project).
-
-### 7.6 `references/models.md` (3.6)
-
-Dated notes (2026-10-16), nothing removed:
-
-- "Context and block size": below the "trunk read at intake of about 100k–250k" line (kept), add that with gremlins the trunk read is the base's training (P0.2 base 182k; smoke base 23.7k), not the Athanor's context (A13).
-- "Future work": gremlins report per-call usage (`usage`); Agent-tool subagents still do not.
-- Plan mode upgrades Haiku to Sonnet silently; aliases map to versions per CLI release (research F2a–F2c).
-- Opus 5.5 may refuse a bare "run this blocking command" brief as pointless; say why it is wanted (observed 2026-10-16, Phase 0 trunk notes).
-
-### 7.7 Routed items checklist (the text owner ticks each one in the handoff note)
-
-| Item | Source | Lands in |
-|---|---|---|
-| `wait` with `timeout: 600000`; the Bash tool backgrounds past its timeout | C2, P0.1 | SKILL §5, athanor dispatching |
-| `kill`: key on `ok` and `status` | Phase 1 M12 | SKILL §7 |
-| Windows-tested; POSIX closed | M14, goal | SKILL §2, athanor intake |
-| C8 permissive at init, enforced at runtime | M15 | SKILL §7 |
-| Post-exit sweep kills daemons | M16 | SKILL §7 |
-| `continue` needs commit rule and note path in its brief | M16 | SKILL §7 |
-| `kill`/`expire` do not refresh the orchestrator stamp | Phase 1 M3 | SKILL §7 |
-| Never re-run `init` to reset; re-run changes only given flags; margin < TTL (≤ 1800 at 1 h) | Phase 2 Minor 8, Minor 2 | SKILL §3, athanor intake |
-| Always `--phase` on `rebase`; `rebase` counts toward the cap | flag 23, flag 1a | SKILL §7 |
-| `--delta-note`; `## Changes since base` is this gremlin's delta only | I1 | SKILL §7 |
-| No `#` lines inside the changes section, fenced code included | N1 | SKILL §7 |
-| Attach every note since `trained_at` to a rebase | N2 | SKILL §7 |
-| `train --supersedes` on a re-train | Minor 1 | SKILL §7 |
-| Pings carry their base's latest phase; a ping at hand-back is not a leak | I2, Minor 7 | SKILL §5, §7 |
-| Sequential gremlins one at a time | Minor 13 | SKILL §7 |
-| `--allowed-tools` with `--tools` | Minor 12 | SKILL §3 |
-| `messages` vs `turns` | M16 | SKILL §5 |
-| `Bash(uv run:*)` allow rule | P0.8 | SKILL §3 |
-| `detach_failed` only visible in `wait` | Phase 1 review | SKILL §5 |
-| N3 binary re-resolution; N4 `parent_inactive` | this phase | SKILL §3, §7 |
-
----
-
-## 8. Platform handoff report (block 3.7)
-
-File: `docs/workpad/reports/<YYYY-MM-DD-hh>-gremlins-platform-handoff.md` (stamp from `date` when written). Audience: an Igor on native Linux and one on macOS, each starting from a checkout of `headless-forks` (goal "release gating"). Sections:
-
-1. **Status**: 0.3.0 is Windows-tested; the gate (`where` ok:false, `init` refuses) is closed on every other platform; the branch is not merged until each platform is tested and its gate lifted. Branch, head, how to check it out.
-2. **The seam**: the `Platform` interface (method list from §3.2), where it lives, what `PosixPlatform` does today per method, and the delegates.
-3. **Running the gates there**: uv install, G-unit, G-where, the override env `SPIRE_GREMLINS_UNSUPPORTED_OK=1` (what it does, and that it is a porting aid only), and that the suite sets it itself.
-4. **Known POSIX gaps** (with code references):
-   - **M14**: `claude` runs in its own session (`popen_kwargs(new_group=True)` → `start_new_session`), so `tree_kill` (`killpg(<supervisor>)`) misses it; only the per-pid sweep catches it, and the sweep needs `process_table()`.
-   - **The `/proc` tree walk**: `process_table`, `proc_ctime` and `epoch_to_ctime` read `/proc`. On macOS all three come back empty or `None`, so `kill` kills only the supervisor and leaves `claude` running, `lost` cannot kill a leftover tree, and pid-reuse checks are pid-only.
-   - **Dead-root claims (I2)**: a dead root claims children only when `epoch_to_ctime` works (`/proc/stat` `btime`); without it, it claims nothing (safe, but leftovers survive).
-   - Locks: `restore_no_replace` uses `os.link` (needs hard links on the state dir's filesystem).
-   - Detach by `setsid`: survival across the Bash call and the subagent's turn is untested on POSIX (the Windows answer was CIM).
-   - The supervisor interpreter under a uv venv (`sys._base_executable` on POSIX), untested.
-   - Path refusals of §3.4 on POSIX.
-   - The env scrub list was built from the Windows Desktop host's vars.
-   - The transcript slug rule (`transcript_path`) was observed on Windows only.
-5. **WSL findings** (from 3.4): inventory, the interop answer (does `claude` resolve to the Windows binary, does `CLAUDE_CODE_EXECPATH` cross), `where` outputs, the suite table, failure causes.
-6. **What to test**: the unit suite; the path matrix; a live smoke in a scratch clone (the recipe of 7); kill with a hanging gremlin and a grandchild, checked by pid + start time; the orphan watchdog; `lost`; supervisor survival across the end of the Igor's or Athanor's turn; no stray terminal windows (macOS: none expected).
-7. **Smoke recipe**: Phase 1 and 2 smoke steps under the new names, as commands: `init` → `train B1 --phase 1` → `wait` → `spawn P1 --phase 1` (commits) → `wait` → `continue` → `spawn K1` + `kill` → `spawn P2a --phase 2` (expect `rebase_due: phase_boundary`) → `rebase --base B1 --as B2 --phase 2` → `spawn P2b` from B2 (expect `hit` against B2's context) → `init --warm-margin-s 1800` + wait for `expiring` and a ping (or skip) → `usage --phase 1 --format md` → `list` (nothing running). What each step must show; every `wait` with Bash `timeout: 600000`; expected spend about $0.5–1 on a small base.
-8. **How to lift the gate**: make `PosixPlatform.supported` true for the tested `sys.platform` (`linux`, `darwin`) with a test; fix the gaps that the smoke shows (at minimum M14 for the platform: run `claude` in the supervisor's process group, or kill both groups; a `ps`-based `process_table` on macOS); update SKILL.md's Platforms line, the handoff report and the changelog; run the full suite and the smoke; record it in a run log. Do not merge until both platforms are done (goal).
-9. **Not covered**: Docker (available on the dev host, not used); Rust follow-up (goal "Amended" note, not started).
-
----
-
-## 9. Release (block 3.8)
-
-### 9.1 Changes
-
-- `plugins/spire/README.md` skills table: one new row `gremlins`: "Trained headless implementer forked per block: the base, its gremlins, cache and usage bookkeeping. Windows-only in 0.3.0. Loaded by the Athanor." Nothing else in the README (A22).
-- `plugins/spire/.claude-plugin/plugin.json` and `plugins/spire/.codex-plugin/plugin.json`: `"version": "0.3.0"`. `.codex-plugin` gets only the bump (plan §5).
-
-### 9.2 G-text (updated for the new names)
-
-1. `git grep -n "fork of yourself\|That reading is your trunk\|read the fix's diff\|the code the phase touches" -- plugins/spire/agents/athanor.md` returns nothing.
-2. `spire:gremlins` is in athanor.md's frontmatter `skills:`.
-3. `git grep -n "a fork of the builder" -- plugins/spire/skills/implementation/SKILL.md` returns nothing.
-4. `gremlins/SKILL.md` contains `600000`, `SPIRE_GREMLIN_CHILD` and `--paths`.
-5. Both manifests read `0.3.0`.
-6. The set of command names in SKILL.md's Commands table (rows starting ``| `<name>` |``) equals `--help`'s `commands` list (which excludes `_supervise`). Checked with a short Python one-off from the scratchpad, output pasted in the note.
-7. G-unit and G-where pass.
-8. **New**: `git grep -n "spire:forks\|forks\.py\|SPIRE_FORKS\|skills/forks" -- plugins/` is empty (rename residue).
-9. **New**: the seam grep of §3.7.
-
-### 9.3 Phase-end tests
-
-Full G-unit **once** (about 150 s), to a log file in the scratchpad; then G-where. Red → one fresh `opus` fallout agent, then one re-run. Leftover-process check by command line afterwards.
-
-### 9.4 Release commit
-
-Message `🤖 Spire 0.3.0: trained implementer, gremlins per block (spire:gremlins)` **(choice C20)**: the build plan's title with the goal's names. Staged: README, both manifests (and nothing else). Body = the changelog, bullet style as `7c1ed39`, no attribution:
-
-- New skill `spire:gremlins` (`gremlins.py`, uv, stdlib only): train one headless base per build, spawn a gremlin per complex block by forking the base's session; full launch fingerprint; scrubbed env; per-call usage, priced cost delta and ledger; warmth and keep-warm pings; rebase / re-train flags; orphan watchdog; Windows CIM detach with no visible window.
-- Windows-only: `where` and `init` fail closed elsewhere; the Athanor falls back to fresh agents. Platform seam (`WindowsPlatform`, `PosixPlatform`) for the Linux and macOS ports; handoff report path.
-- Athanor procedure: plan-level Athanor (no code reads), base writes the trunk notes, gremlins for complex blocks, fresh agents for mechanical ones, mechanical diff checks, usage in the run log; the Agent-tool fork path is dropped.
-- implementation skill and references: trained implementer and gremlins; run-log table with usage columns; spawning reference rows for headless sessions and the Phase 0 observations; dated model notes.
-- Preflight report path; run log path.
-- Known follow-ups: Linux/macOS testing and gate lift (handoff report); Igor text (D4: `igor/SKILL.md:66`, `:112`); `## Build` keys (A23); README and `project.md` drift (A22); root `AGENTS.md`; Phase 4 install smoke and Phase 5 trial.
-
-Then a `📝` run-log commit with the 3.8 note and the Phase 3 close. **No merge, no push.** Fix-pass commits after the release commit stay 0.3.0 (A21).
-
----
-
-## 10. Test cadence and gates per block (summary)
-
-| After | Run |
-|---|---|
-| 3.1 | py_compile ×2; the classes listed in §1; G-where; residue grep |
-| 3.2 | py_compile; the classes listed in §1; G-where; seam grep |
-| 3.3 | py_compile; the classes listed in §1 |
-| 3.4 | WSL procedure (no Windows test run) |
-| 3.5, 3.6, 3.7 | G-text items of their files; no test run (no code change) |
-| 3.8 | full G-unit once; G-where; G-text in full |
-
-Between blocks the Athanor also reads each child's diff stat on the test file and counts removed assertion lines (`git diff <range> -- …/tests/ | grep -c '^-.*assert'`); every removed line must be explained in the note as a rename or a specified change.
-
----
-
-## 11. Not in Phase 3
-
-Fixing POSIX beyond the seam (M14, a macOS process table, POSIX survival): handoff only. The Igor follow-ups (D4). `## Build` project keys (A23). README drift beyond the `gremlins` row and `.claude/spire/project.md` (A22). Live smokes (Phase 4, after install). Merge and push (post-build, user). The deferred Phase 2 Minors 3, 4, 5, 6, 14 (trial tuning).
-
----
-
-## 12. Open choices made in this digest (for Igor's check)
-
-| Id | Choice | Alternative |
-|---|---|---|
-| C1 | Eight blocks: rename, seam+gate, fixes, WSL, text, references, handoff, release; text after all code | the build plan's three blocks with the new work folded in |
-| C2 | `templates/fork.md` → `templates/spawn.md` | `spawn-fork.md` (per method), or keep `fork.md` |
-| C3 | `spawn_supervisor` → `detach_supervisor`; "detach" for starting the supervisor | keep "spawn" for both |
-| C4 | `spawn --method fork` flag (only choice, default) | no flag until a second method exists |
-| C5 | `method` on every job, result, ledger line (`null` except spawn); job kind `spawn` | kind `gremlin`, or `method` only on spawn jobs |
-| C6 | Registry `SCHEMA` stays 1 | bump to 2 |
-| C7 | `visible_windows()` moves into the platform (the user listed "the window checks") | keep it test-only |
-| C8 | POSIX `norm_path` refuses drive forms and any backslash | silently join (today), or map via `wslpath` on WSL |
-| C9 | Windows `norm_path` refuses `/mnt/<d>/…` | map it to `<D>:\…` |
-| C10 | `taskkill_rc` → `tree_kill_rc`; reason `spawn_failed` → `detach_failed`; `where.spawn` → `where.platform.detach` | keep the old names |
-| C11 | `init` also refuses on a closed platform | gate in `where` only (the goal's letter) |
-| C12 | Porting override `SPIRE_GREMLINS_UNSUPPORTED_OK=1` (documented in the handoff, not SKILL.md) | none; porters edit the code to test |
-| C13 | The suite sets the override for every test; `GateTests` remove it | run the gated suite as-is on WSL (most tests would fail at `init`) |
-| C14 | N3: an `init` re-run re-resolves the binary unless it was pinned with `--binary`; a warning when it changes | `where --run` warns instead |
-| C15 | N4: the late rebase's new base takes the old base's inactive status; result flag `parent_inactive` | create nothing; or text only |
-| C16 | Kill verification drops snapshot pids whose table entry is gone or renamed (fixes access-denied pid reuse), applied even if the flake does not reproduce | change only the test |
-| C17 | No live `claude` calls in Phase 3 (the stub covers argv, env and the real CIM detach; the live smoke is Phase 4) | one small live smoke at phase end (about $0.3) |
-| C18 | Fallback where `where` is not ok: a fresh agent writes the trunk notes; the Athanor still reads no code | the Athanor reads code itself (the literal 0.2.2 shape) |
-| C19 | Run-log block rows for fresh agents: usage cells `—`, harness token total in the note | a second table for fresh agents |
-| C20 | Release title `🤖 Spire 0.3.0: trained implementer, gremlins per block (spire:gremlins)` | the build plan's title with the old name |
-| — | An `!` injection whose command exits 2 (`where` on a closed platform) is untested: it may fail the skill load on Linux/macOS. Flagged for Phase 4 and the porting Igors; the text keeps the plain form (design §2). | `… where \|\| true` (may break the `Bash(uv:*)` allow match) |
-| — | WSL uv install only through the permission prompt (download and execute); otherwise the WSL check stops at inventory and interop | install without asking (not allowed) |
-
----
-
-## Amendment after pre-build check (2026-10-16 18:44 +0200, the Athanor, `claude-opus-5-5[1m]`)
-
-Source: `docs/workpad/reports/2026-10-16-19-gremlins-phase3-digest-check.md` (`52c5911`, checker `claude-opus-5-5[1m]`). Igor: apply B1 and A1–A12 exactly as stated, plus the `kill`/`expire` timeout note; everything else (C1–C20) stands. **This section overrides the sections above where they conflict.** Block owners read it first.
-
-### B1. GateTests use a Windows-path fake platform (§4 "Tests")
-
-- The fake closed platform is a `WindowsPlatform` subclass (or the real `PLATFORM` with `supported` and `describe` patched) with `supported = False`, `is_wsl() → True`, `describe() → {"name": "posix", "sys_platform": "linux", "wsl": True, "supported": False, "detach": "setsid", "override": …}`. Path handling stays Windows, so `--binary C:\…`, `--run C:\…` and `script_path()` work on the host.
-- `init` on a closed gate asserts `error == "platform not supported"` (not just exit 2).
-- **The gate check is the first thing `init` does**, before `state_dir_for` and any `norm_path`.
-- The pure unit tests `PosixPlatform().supported is False` (with `sys.platform` patched to `linux` and `darwin`) and `WindowsPlatform().supported is True` stay as written.
-
-### A1. The gate also closes launches on an existing registry (§4, C11, §7.2)
-
-- The dispatcher refuses `train`, `spawn`, `continue`, `rebase` and `tick` on a closed gate (exit 2, `error: "platform not supported"`, `reason`, `platform`), in the same place as the N3 refusal.
-- The tick inside `wait` and inside the supervisor launches no pings on a closed gate (`tick_pass` returns early, nothing written).
-- Athanor intake (§7.2): run `where` **first**, then adopt (`list`) if the run log has a `Gremlins:` line. If `where` is not ok, use fresh agents even when a state dir exists.
-- New `GateTests` case: a registry present (made with the gate open), gate closed → `spawn` exits 2 with `error == "platform not supported"` and no job entry is written.
-
-### A2. C16 is narrowed (§5.3)
-
-`kill_tree`'s verification drops a snapshot pid as dead **only** when one of these holds:
-
-- the table (from the module-level `process_table()`) is **non-empty** and lacks the pid; or
-- the snapshot name is known (not `None`), the table's name for that pid differs, **and** `proc_ctime(pid)` is `None` (the unverifiable case, class (a)).
-
-In every other case `record_alive` decides, as today. Tests (fake table, module-level patches): an empty table keeps the survivor; a snapshot name `None` keeps it; a differing name with a verifiable ctime leaves the decision to `record_alive`; the class (a) case (non-empty table, other name, ctime `None`) drops it.
-
-### A3. N3 tests split (§5.1)
-
-- Stored file present, `$CLAUDE_CODE_EXECPATH` unset, PATH without claude: stored path kept, the "could not re-resolve" warning shown, exit 0.
-- Stored file deleted: exit 2, `claude binary not found` (today's loud failure).
-
-### A4. N3 re-resolves through the stored source only (§5.1, C14)
-
-Re-resolve only through the source the stored path came from: `CLAUDE_CODE_EXECPATH` from `$CLAUDE_CODE_EXECPATH`, `PATH` from a PATH lookup. A `--binary` pin is kept. If the stored source gives nothing now, keep the stored path and warn. Never cross sources. Add a test: stored via EXECPATH, re-run with EXECPATH unset and a different `claude` on PATH → stored path kept, warning.
-
-### A5. Path matrix row 3 (§3.4)
-
-`C:` and `C:x` on `WindowsPlatform`: **refused**, as today ("cannot normalise path"). On `PosixPlatform`: refused (drive form).
-
-### A6. C18 wording (§7.2)
-
-The fallback line in athanor.md reads: "a fresh agent reads the code the blocks change and writes the trunk notes". The phrase "the code the phase touches" must not appear (G-text 1).
-
-### A7. No version number in the platform wording
-
-Release gating keeps 0.3.0 unreleased until Linux and macOS lift their gates, so no text ties "Windows-only" to a version.
-
-- SKILL.md description (§7.1) and Platforms section, README row (§9.1): "Windows-tested; other platforms fail closed until tested (see Platforms)". Drop "Windows-only in 0.3.0" everywhere, including §7.3's implementation-skill line.
-- Gate reason (§4): "spire:gremlins is not tested on <sys_platform><, WSL> yet; use fresh agents for every block (see SKILL.md, Platforms)."
-- Release commit body (§9.4): "tested on Windows; Linux and macOS gated pending the platform handoff (<path>)".
-- Handoff §8.8 lists every place a porter updates when lifting a gate: `PosixPlatform.supported`, the gate tests, SKILL.md (description and Platforms), the README row, athanor.md's fallback line if wording changes, the handoff report itself, and the changelog of the release that ships it.
-
-### A8. Three more routed text items (§2.6, §7.1, §7.7)
-
-- (a) `preamble.md` no longer points at `plugins/spire/skills/implementation/references/run-log.md` (it does not resolve in other projects). Block 3.1 **inlines the handoff-note format** in `preamble.md`: the fields `Model`, `Start / end` (from `date`), `Done`, `Deviations from plan`, `Flagged for review`, `Left for later`, `Expected broken`, `Commits`, as a short bullet template.
-- (b) SKILL §6/§7: `stalled` together with `clock_jump` is a host suspend, not a hung gremlin; `wait` again before acting.
-- (c) SKILL §6: an action per failure reason. `model_refused` → the model id is not admitted (`availableModels`), the user must change settings. `usage_limit` → plan usage hit; stop launching, flag it, hand back. `overloaded`, `api_error` → transient; `continue` once later, else flag. `prompt_too_long` → the base is too large; re-train or rebase smaller. `is_error`, `exit_code`, `no_result` → read `raw/<job>.err` and the note, `continue` once, else flag. `detach_failed`, `launch_error`, `supervisor_error` → helper or host problem; flag it, do not retry blindly.
-- Add these three rows to the §7.7 checklist.
-
-### A9. Vacuous `-forks` assertions (§2.7)
-
-The existing `assertFalse(os.path.exists(… "-forks"))` lines (`test_forks.py:155`, `:934`, `:1011`, `:1079`, and any other literal state-dir suffix in the tests) must derive the path from `gremlins.state_dir_for(run)` (or `forks`' equivalent at the time of the change), never from a literal suffix. List them in the 3.1 handoff note.
-
-### A10. Residue categories outside the skill (§2.8)
-
-New category: **"Igor text (D4) and non-session meanings: leave untouched"**. It covers `plugins/spire/skills/igor/SKILL.md:66`, `igor/references/mindset.md:11`, `igor/references/harness-notes.md:3` and `implementation/references/superpowers.md:36` (repository forks). 3.1 neither edits these lines nor reports them as residue.
-
-### A11. `where` catches path refusals (§4)
-
-`cmd_where` catches a `GremlinsError` from `resolve_binary` (and from the binary's `norm_path`) into `binary.error` and `reasons`, so a closed-gate `where` always carries the gate reason and the full report. Test: `where --binary <a path the platform refuses>` → exit 2, `binary.error` set, the report's other keys present.
-
-### A12. `platform.override` defined (§4)
-
-- `override = (env set) and not PLATFORM.supported`. On Windows, `CliTests` assert `override: false` even though C13 sets the env.
-- `PosixPlatform.describe()` reads `self.supported`, never a literal, so lifting the gate is one change.
-- `platform_gate()` reads `PLATFORM.describe()` (and `PLATFORM.supported`), never `sys.platform`, so it passes the seam grep.
-
-### Naming fix (check note on C12)
-
-The porting override is **`SPIRE_GREMLIN_UNSUPPORTED_OK`** (singular prefix, like `SPIRE_GREMLIN_CHILD` and `SPIRE_GREMLIN_DETACH_*`). Every mention of `SPIRE_GREMLINS_UNSUPPORTED_OK` above means this name.
-
-### Other check notes applied
-
-- **`kill`/`expire` timeout** (check note on C16 (b)): SKILL §7 tells the Athanor to call `kill` and `expire` from Bash with a long `timeout` (600000, as for `wait`): `expire` kills its jobs one after another, each verify can take up to `KILL_VERIFY_S`, and the Bash tool backgrounds a call past its timeout.
-- No local variable may be named `platform` in `gremlins.py` (the module imports `platform`).
-- C15: set `parent_inactive` only when NEW is actually created, not on the `rebase_conflict` early return.
-- C13: the handoff (§8.3) says that a green suite on Linux says nothing about the gate; only `GateTests` cover it.
-- C17: Phase 4 must smoke the renamed helper before anything ships (the handoff and the run log say so).

docs/workpad/plans/2026-10-17-00-gremlins-mvp-spec.md

@@ -0,0 +1,140 @@
+# Gremlins MVP: implementation spec
+
+- Date: 2026-10-17 · Author model: claude-opus-5-5 · Timebox: 20 min, one agent
+- Inputs: [code verdict](../reports/2026-10-16-22-gremlins-code-verdict.md) (§3 keep, §5 minimal), [post-mortem](../reports/2026-10-16-23-headless-forks-postmortem.md) RC1–RC4, [brainstorm](../brainstorm/2026-10-16-22-grotto-plan-structure.md) "Steering sentences cut both ways"
+- Prototype: `.claude/worktrees/headless-forks/plugins/spire/skills/gremlins/gremlins.py` @ `ab1d945` (cited as `P:<line>`)
+
+**How to read this.** Every module, function and CLI command names the acceptance box (B1–B8) it serves. Anything that serves no box carries a one-line reason, or it is out. The builder does the same in the hand-back: code that traces to no box gets a one-line reason, and a missing failure path that a box names counts as a gap. Size figures are **estimates to justify deviations against, not caps**. Going over is fine with a reason, and so is coming in under, as long as no box's failure path was dropped to get there.
+
+## Acceptance boxes
+
+| | Box |
+|---|---|
+| B1 | `train` creates a base with one blocking `claude -p` call and returns its session id. The launch fingerprint (binary, full model id, flags, cwd, appended prompt) is stored once. |
+| B2 | `spawn` forks the base (`--resume <base> --fork-session`) with a brief, as one blocking call that reuses the fingerprint verbatim, so the prompt cache hits. |
+| B3 | Several gremlins run at once. The orchestrator runs each `spawn` through Bash `run_in_background` and gets the completion notice. The helper has no detach or supervisor code. |
+| B4 | `TaskStop` on the Bash call stops a gremlin. Verified on Windows 2.1.299, so there is no `kill` command (see §7 for the orphaned in-flight command). |
+| B5 | Usage per call comes from the result JSON: the real model from `modelUsage`, four token columns, and the cost delta against the base. One appended JSON line per call in a ledger. |
+| B6 | Warmth is reported only (last cache hit, TTL left). No pings. |
+| B7 | `rebase` resumes the base without forking and passes a short summary of the changes. Optional, tiny. |
+| B8 | No platform-specific process code: Windows Git Bash, WSL, Linux, macOS. The env scrub stays. |
+
+## 1. Ecosystem inventory: what already exists, so the helper must not rebuild it
+
+| Provider | Gives us | So the helper does NOT build |
+|---|---|---|
+| Harness | Bash `run_in_background` with a completion notice that carries stdout. A call that passes its timeout moves to the background and keeps running (post-mortem RC1). `TaskStop`. The orchestrator's own task list. | detach, supervisor, `wait`, heartbeats, the orphan watchdog, reaping of lost jobs, a "running jobs" poller (B3, B4) |
+| `claude -p` | `--session-id <uuid>` (id known before launch), `--resume … --fork-session`, `--append-system-prompt-file`, `--strict-mcp-config`, `--output-format stream-json --verbose`. Its events: `system/init`; `assistant` with per-request `usage`; `result` with `session_id`, `usage`, `modelUsage`, `total_cost_usd`, `is_error`, `api_error_status`. Session storage. Price maths. | price tables, transcript reading, cost computation, session bookkeeping beyond the ids (B1, B2, B5) |
+| Python stdlib | `subprocess.Popen` plus `terminate()` (portable), `signal`, `json`, `uuid`, `argparse`, `string.Template`, `os.replace`, `shutil.which` | ctypes, CIM, Toolhelp32, pid-reuse guards, process-tree walks, a lock manager (B8) |
+| uv | an interpreter for a PEP 723 script with no dependencies (`uv run --script`) | interpreter discovery (`supervisor_interpreter`) |
+| git | `log` / `diff --shortstat` for the change summary | its own change tracking (B7) |
+
+Concurrency without locks (B3): each job writes only its own `jobs/<J>.json`. Only `train` and `rebase` write `bases/<B>.json`. The ledger is append-only, one `write()` per line. Warmth is **derived** from the ledger (B6), so spawns never write base files.
+
+## 2. Module structure (`plugins/spire/skills/gremlins/`)
+
+Entry point: `gremlins.py`, a PEP 723 script with `dependencies = []` that puts its own directory on `sys.path` and imports the package `grm/`. Run it as `uv run --script gremlins.py <cmd> …`. The templates and `preamble.md` stay where they are.
+
+| Module | Purpose | Public functions | Boxes | Est. lines |
+|---|---|---|---|---|
+| `grm/store.py` | state-dir layout, atomic JSON, ledger append, run/base/job records | `state_dir(run) -> Path`; `read_json(p) -> dict\|None`; `write_json(p, obj)`; `ledger_append(run, line: dict)`; `ledger_lines(run) -> list[dict]` | B1, B3, B5 | 70 |
+| `grm/launch.py` | fingerprint, env scrub, binary lookup, argv | `resolve_binary(explicit=None) -> str\|None`; `scrubbed_env(binary, environ=None) -> dict`; `build_fingerprint(*, binary, model, effort, cwd, agent, preamble_path) -> dict`; `train_argv(fp, sid) -> list`; `fork_argv(fp, base_sid, sid) -> list`; `resume_argv(fp, base_sid) -> list` | B1, B2, B7, B8 | 110 (40 are the kept scrub constants) |
+| `grm/stream.py` | stream reader and accounting (pure functions, no IO) | `StreamState.feed(ev, t)`; `classify(ss, exit_code, stopped) -> (status, reason)`; `usage_from_result(result, before_mu, cost_before) -> dict`; `api_error_reason(res)`; `cache_verdict(first_usage, base_ctx)`; `infer_ttl(tokens, prev)`; `warmth(last_hit_ts, ttl_s, now) -> dict` | B2, B5, B6 | 170 |
+| `grm/call.py` | the only subprocess code: run one `claude -p` in the foreground, tee the stream to `raw/<J>.jsonl`, forward a stop | `run_claude(argv, prompt: str, env, cwd, raw_path, on_start) -> (StreamState, exit_code, stopped: bool)` | B1–B4, B8 | 60 |
+| `grm/cli.py` | argparse plus the commands; each command is one record → call → record sequence | `main(argv) -> int`; `cmd_init/train/spawn/rebase/status(args) -> dict` | all | 200 |
+| `tests/` | see §6 | | | about 300 |
+
+**Total: about 610 lines of code** (the verdict estimated 600–800).
+
+`call.py` details:
+- The prompt goes in on stdin, which avoids the Windows argv length limit.
+- `on_start(child_pid)` records the pid in the job file.
+- A handler for SIGTERM and SIGINT, plus `getattr(signal, "SIGBREAK", None)`, calls `child.terminate()` and sets `stopped`. Reason for the `getattr`: it is the one portable way to see Ctrl-Break on Windows, and it is not process code.
+- It uses stream-json rather than `--output-format json`. Reason: the first `assistant` usage is the only way to prove the B2 cache hit, and a stopped call (B4) leaves a partial trace behind.
+
+### Data model
+
+- **`run.json`** (B1; written once by `init`, never rewritten):
+
+  ```
+  {run, created, fingerprint: {binary, binary_version, model: "claude-opus-5-5[1m]", effort,
+   permission_mode, tools, agent, cwd, append_prompt: {path, sha256}, mcp_config, env_pinned},
+   argv: [...full fingerprinted argv...], fp_hash}
+  ```
+
+  Spawn reuses `argv` **as stored** (B2) and only appends `--resume/--fork-session/--session-id`.
+- **`bases/<B>.json`** (B1, B7):
+
+  ```
+  {base, session_id, train_job, commit, trained_at, context_tokens, model_usage, cost_cumulative_usd, ttl_s, rebases}
+  ```
+
+- **`jobs/<J>.json`** (B3, B4):
+
+  ```
+  {job, kind: train|spawn|rebase, base, session_id, status: running|ok|error|stopped, reason,
+   started, ended, child_pid, raw, note, cache, result_excerpt}
+  ```
+
+- **`ledger.jsonl`**, one line per finished or stopped call (B5):
+
+  ```
+  {ts, run, job, kind, base, session_id, model, models_used,
+   tokens: {input, output, cache_creation, cache_read, cache_creation_1h, cache_creation_5m},
+   cost_delta_usd, cost_cumulative_usd, cache, status, wall_s}
+  ```
+
+  `model` is `models_used[0]` from the `modelUsage` delta. The 1h/5m split stays because `infer_ttl` needs it (B6).
+- **Warmth** (B6): the last ledger line for base B whose `tokens.cache_read > 0` gives `last_hit`. The ttl is `infer_ttl` over that line's tokens. Output: `{base_state: warm|expiring|cold, warm_until, ttl_left_s}`.
+
+## 3. Reuse from the prototype (copy, then strip review-ID comments)
+
+| Into | Prototype source | Change |
+|---|---|---|
+| `stream.py` | `StreamState` P:1459–1522, `context_tokens` P:1525, `usage_from_result` P:1573–1601 (+`MU_FIELDS` P:158), `_API_ERROR_TEXT`/`api_error_reason` P:1604–1637, `cache_verdict` P:1640 (+`CACHE_HIT_RATIO` P:153), `infer_ttl` P:1650, `wrote_only_5m` P:1663, `base_warmth` P:1675–1690 (+`TTL_1H/5M` P:137) | `base_warmth` becomes `warmth(last_hit, ttl, now)`, margin `max(120, ttl/10)`, with no `warm_margin_s`. Round costs once, at 6 decimals (verdict §6 rounding finding). |
+| `stream.py` `classify` | the if-chain inside `_conclude` P:1771–1790 | rewrite it as one `match` over `(stopped, exit_code, ss.result, api_error_reason(...))` |
+| `launch.py` | `ENV_PINNED_LAUNCH`, `SCRUB_*` P:86–109, `scrub_class` / `_venv_prefixes` / `_under` / `scrubbed_env` P:1235–1282, `resolve_binary(_via)` P:1309–1335, `claude_argv` P:2652–2665, `canonical_json` / `_sha256_*` P:240–250 | drop `scrub_report`/`scrub_unknown` (only `where` uses them); `norm_path` becomes `os.path.abspath` |
+| `store.py` | `_retry`, `atomic_write_bytes`, `write_json_atomic`, `read_bytes_retry` P:829–866; `ledger_append` P:1046–1059 | the ledger append drops its `RegistryLock` precondition and per-job dedupe: one call writes once |
+| `cli.py` | `render_template` P:1738; `delta_header` P:2677–2697 + `git` P:1214 | used as is |
+| files | `templates/{train,spawn,rebase}.md`, `preamble.md` | remove `${commit_rule}` and `${mode}` from `spawn.md`. Reason: the default rule contradicted no-commit briefs (verdict §3), so the brief now carries commit instructions. |
+
+Do not port: `Platform`/`WindowsPlatform`/`PosixPlatform`, `RegistryLock`, `Supervisor`, `SupClock`, `reap_lost`, `kill_tree`/`process_tree`, ping and `tick`, `due_flags` and the drift checks, `wait`, `where`, `model_admission`, `--method`.
+
+## 4. CLI surface (`G = uv run --script gremlins.py`; every command prints one JSON object on stdout)
+
+- `G init --run R --model M [--effort E] [--cwd D] [--agent A] [--binary P]` writes `run.json` with the fingerprint and the rendered preamble (B1). It refuses to overwrite an existing run.
+- `G train --run R --base B --brief F` makes one blocking call with `--session-id`, then writes `bases/B.json` and prints `{status, session_id, cost, …}` (B1).
+- `G spawn --run R --base B --job J --brief F` makes one blocking fork with the spawn template plus `delta_header` and prints `{status, cache, note, cost, …}` (B2, B3, B5). Reason for the delta: a fork knows only the base's commit, and it reuses B7's function.
+- `G rebase --run R --base B --brief F` resumes the base without a fork; the prompt is the rebase template + `delta_header` + the brief. Afterwards it updates `bases/B.json` from the result. It warns when jobs of B are still marked `running` (B7).
+- `G status --run R [--job J]` shows bases with their warmth, plus the job records (B6; B3 for reading a result again).
+- There is no `kill` command. B4 was verified on Windows with 2.1.299: `TaskStop` on the backgrounded Bash call kills `claude.exe` and its bash wrappers.
+- Out of the MVP, each with its reason: `continue` (no box), `ping` (B6 says no), `usage` aggregation (no box; the ledger lines are greppable), `list`/`wait`/`expire` (the harness covers them).
+
+## 5. Build order (sequencing, not a ranking of value)
+
+1. `store` + `launch` + `stream` (ported) + `call` + `init`/`train`/`spawn`. **Gate:** a live run of `init → train → spawn` shows `cache: hit` and two ledger lines with real model, tokens and cost delta. Nothing else gets built before this gate passes.
+2. B3: two `spawn`s via `run_in_background` at once; both notices arrive, two job files, two ledger lines.
+3. B6: `status` with warmth.
+4. B4: the stop-signal path in `call.py`, then one live `TaskStop` on a backgrounded `spawn` to confirm the job ends without a ledger line and nothing beyond an in-flight command survives.
+5. B7: `rebase`.
+6. B8: run step 1's gate on one non-Windows host (WSL is enough).
+
+## 6. Tests (stdlib `unittest`; a fake `claude` = `[sys.executable, tests/fake_claude.py]` written into `run.json["argv"]`)
+
+The tests cover the happy paths and the failure paths each box names. Add no other tests without a one-line reason.
+
+- **Happy (B1, B2, B5):** `train` stores the base with the session id from `--session-id`. `spawn`'s argv starts with the stored `argv` byte for byte, then `--resume <base> --fork-session`. The ledger line has `model`, four token columns and `cost_delta = total − base cumulative`.
+- **B1 failures:** the binary is missing (error before launch, no job file); a non-zero exit or no `result` event gives `status: error` and no base file; an API error maps through `api_error_reason`.
+- **B2 failures:** unknown base gives an error with no launch; first-usage `cache_read` of 0 gives `cache: miss`, which is reported, not an error.
+- **B3:** two `spawn`s in parallel threads give two job files and two whole ledger lines.
+- **B4:** SIGTERM to a helper running a fake that sleeps leaves the child gone, the job `stopped`, and the partial raw file kept.
+- **B5:** `modelUsage` with two models gives both in `models_used`; a missing `total_cost_usd` gives `cost_delta: null`.
+- **B6:** no hit gives `cold`; 5m-only writes give `ttl_s` 300; a hit at `now − ttl + 60` gives `expiring`.
+- **B7:** the rebase argv has `--resume` and no `--fork-session`; the base record takes the result's `session_id`.
+- **B8:** the scrub drops `SCRUB_DROP` and `UV_*`, sets the pinned vars, and removes venv PATH entries.
+
+## 7. Open risks per box
+
+- **B4 (verified, with a known leftover).** `TaskStop` kills `claude.exe` and its bash wrappers. A command the gremlin had in flight (in the check, a `sleep 120` run through the gremlin's Bash) **survives as an orphan and runs to its own end**. That is accepted for the MVP. A later sweep is an open item, outside MVP scope; a full tree kill would need a Job Object, and B8 forbids that. On a hard kill, the helper's signal handler may never run, so the job file can stay `running` with no ledger line. The orchestrator knows which calls it stopped, so `status` reports the record as written. Reason the handler stays anyway: on POSIX and with Ctrl-C it does run, and it costs about 10 lines.
+- **B7.** Resuming without a fork may give the session a new id in `-p` mode. Take `session_id` from the result; never assume it stays the same. A `spawn` started during a `rebase` forks a session that is still being written. The helper only warns; keeping them apart is the orchestrator's job.
+- **B2.** A cache hit needs more than the same argv: the same env pins, the same cwd, and a system prompt that does not change (for example, the date rolls over at midnight). The helper reports `cache`; it does not prevent misses.

docs/workpad/reports/2026-10-16-08-headless-forks-run.md

@@ -1,812 +0,0 @@
-# Run log — Trained implementer, forked per block (`spire:forks`)
-
-- Plan: `docs/workpad/plans/2026-10-16-01-headless-forks.md`  ·  Build plan: `docs/workpad/plans/2026-10-16-02-headless-forks-build.md`
-- Branch: `headless-forks` (worktree `.claude/worktrees/headless-forks`)  ·  Start commit: `d373689`
-- Trunk notes: `docs/workpad/reports/2026-10-16-08-headless-forks-trunk-notes.md`
-- Athanor: `claude-opus-5-5[1m]` (installed Spire 0.2.2 shape)  ·  Session journal: Igor's, `docs/workpad/journals/2026-10-15-21-grotto-work.md` (not touched by the Athanor)
-- Forks: none yet (the helper does not exist until Phase 1)
-
-## Phase 0 — Preflight (STOP gate)
-
-| Block | Owner (model id) | Commit | Tokens (if known) |
-|---|---|---|---|
-| 0 Preflight probes and report | the Athanor, `claude-opus-5-5[1m]`, own Bash | `7421d3a` (+ this hash fill-in) | probe calls: $5.68 over 45 calls (client estimate, sum of per-call deltas); the Athanor's own tokens unknown |
-
-### Block 0 — Preflight probes and report
-
-- Model: `claude-opus-5-5[1m]`
-- Start / end: 2026-10-16 08:16:26 +0200 / 2026-10-16 12:16 +0200 (last probe 10:13:01; `date` jumped from 10:13 to 12:16 across two consecutive commands, cause unknown, likely host suspend)
-- Done: Worktree `.claude/worktrees/headless-forks` created on new branch `headless-forks` from `d373689`. Throwaway probes written and run from the Athanor's own Bash in the session scratchpad (`…\scratchpad\headless-forks-p0\`, not in git): P0.0–P0.8 in the build plan's amended order (P0.0, P0.1, start P0.6 detached via the P0.1 rung, P0.2–P0.5, P0.7, P0.8 while it ran, then collect P0.6). Preflight report `docs/workpad/reports/2026-10-16-09-headless-forks-preflight.md` with verdict, per-item results and the Phase 1 defaults. Nothing in `plugins/` changed.
-- Deviations from plan:
-  - P0.6 was started once P0.1's rung 3 had passed (a), (b) and (d), before (c)'s 15 minutes were up, so the TTL clock started earlier. (c) passed later at 08:39–08:45; had it failed, P0.6 would have died with it and been restarted.
-  - The scratch clone is `git clone --local --no-hardlinks` (hardlinks fail from `G:` to `C:`). Same content, same `.claude/settings.json`.
-  - P0.5's model cases ran first in a copy of the project settings (`$P0\p05-cwd`), which turned out to be an **untrusted workspace** (project `permissions.allow` ignored). To get a trusted `availableModels` reading, five tool-less "Reply OK" calls ran with cwd = `G:\dev\projects\reliquary` (trusted) and one in the worktree (trust check). They cannot edit anything (`--tools ""`), but they are live calls outside the scratch clone, against plan decision 4's letter. They left transcripts under the reliquary project slug in `~/.claude/projects/`. The unlisted-family case was run through `--settings '{"availableModels":[…]}'` instead, because reliquary lists all four family aliases.
-  - P0.5's `--agent` test and P0.8 ran in separate scratch dirs (`p05-cwd`, `p08-cwd`) instead of the clone, so adding an agent and a skill could not change P0.2's prefix while it ran.
-  - P0.1 (d): the Bash tool no longer kills a call at its timeout; it backgrounds it. (d) was produced with `TaskStop` on the backgrounded call, which kills the process tree. Recorded in the report.
-  - The P0.5 effort-cache case ran inside the P0.2 probe (a `--effort medium` fork of the P0.2 base) instead of a separate base.
-- Flagged for review:
-  - The P0.1 verdict rests on the strict reading of (d) (launcher still alive when the Bash call is stopped). Rung 1 survives when the launcher has already exited (`r1-dprime`). Rung 3 is the ladder's answer; the reviewer may want to weigh rung 1 plus an exit-first launcher against rung 3's CIM env handling.
-  - `r3-main` and `r3-tkill` ran PATH `claude` 2.1.283 (CIM env lacked `CLAUDE_CODE_EXECPATH`); survival evidence is unaffected, the binary is.
-  - P0.8 ran in an untrusted workspace; the pre-approval "no" may differ in a trusted project.
-  - Effort: a different effort did not miss the cache; whether `--effort` took effect is unobservable.
-  - A fork that backgrounds a Bash command can leave an orphan process after `claude` exits (seen once on 2.1.283).
-  - P0.6: the 50-min ping read only 0.916 of A's context (re-created 7,463 tokens, about the size of the shared system/tool prefix). Still a hit by C5 and the later fork read 1.0004; cause not isolated.
-  - Visible windows (coordinator's message 09:52, user report): every rung-3 supervisor before the fix (P0.1 `r3-*`, the P0.2 and P0.6 probes) opened a visible console window (Windows Terminal) on the user's desktop. "No visible window" was added to P0.1's pass criteria and the surviving variant retested with `Win32_ProcessStartup.ShowWindow=0` for the supervisor and `CREATE_NO_WINDOW` for every child: no window in 26 checks (plus 3 on an informational Popen `CREATE_NO_WINDOW` variant), including during `claude` → `bash` → `PING`; (a)–(d) and the tree-kill pass again. A positive control (`r3-wincontrol`, 15 s) showed the detector does see the old window. Recorded in the preflight report §P0.1.
-  - `$P0\raw\p01\` was not cleaned between runs; `r3-kill2` finished unobserved during a 20-minute `git clone` (08:24–08:45).
-- Left for later: the Phase 1 defaults listed at the top of the preflight report. Survival of a rung-3 supervisor across the Athanor's hand-back is untested (Phase 1 smoke).
-- Expected broken: nothing (no product code yet).
-- Commits: `7421d3a` (report, run log, trunk notes), then a one-line follow-up filling in this hash. Probe commits in the scratch clone only (`64dbefa`, `9bfefb7`, `bb5514d`, `0f72edb`, `9d3ddc1`), not in this repo.
-
-### Phase 0 close
-
-- Gate: none named for Phase 0 (probes only, no code in the repo). Every STOP item checked against its criterion in the report.
-- Tests: not applicable (no product code). Probe results and raw paths in the report.
-- Flags for the reviewer:
-  - Block 0: every deviation and flag above, one by one.
-  - Block 0: check the report's numbers against `$P0\raw\` (summaries `*.summary.json`, `p03-usage.json`, `p02\state.json`, `p06\state.json`, `p07\p07.json`, `p08\p08.json`, `p01\<tag>\check-*.json`).
-- Not run / untested: survival past the end of the Athanor's turn; what effort changes; a trusted-workspace P0.8.
-- Spend: $5.68 client estimate over 45 calls (trigger $25 not hit), plus three killed calls without a result (cents).
-- Leftover processes: none. Swept at 10:13–12:16 by command line (`headless-forks-p0`, `p01_sup`, `p01_sleeper`, `p06_ttl`, `p02_base`) and by name (`PING`, `sleep`); the only hits were the Athanor's own Bash. One orphan was killed by hand earlier (`sleep.exe` pid 31372, from `r3-kill`).
-- Open questions (for Igor and the user; none blocks Phase 1):
-  - U4 is moot for reliquary: the `sonnet`/`haiku` aliases in `availableModels` admit their full ids. An unlisted model is substituted silently, not refused; C8's runtime `model_refused` must key on the `system/informational` warning or a `modelUsage` mismatch.
-  - The Bash tool backgrounds instead of killing at its timeout. C2's `timeout: 600000` rule stays, but A2's failure mode ("killed with no JSON") is now "backgrounded, notification to the subagent". Does the Phase 3 text want a line on it?
-  - Rung 3 adds a PowerShell dependency (about 0.3 s per launch) and an env hand-off file. Rung 1 with a launcher that exits first would avoid both but dies if its launcher is in a stopped tree (e.g. pings launched from `wait`). The plan's ladder picks rung 3; the reviewer may weigh it.
-  - P0.8: injection works in a subagent preload, pre-approval does not (untrusted dir). SKILL.md needs the allow-rule note; the trusted-project case is for Phase 4.
-  - Forks that background a Bash command leave orphans after `claude` exits. Suggested default: a preamble line forbidding `run_in_background` in forks; Phase 1 decides.
-- Verdict: **GO** (see the preflight report header).
-- Status: provisional until review, fix pass and re-check close. Igor makes the GO/STOP call.
-- Igor, 2026-10-16 ~12:18: Phase 0 accepted, GO, no separate review; the Phase 0 deviations go to the Phase 1 reviewer as handoff flags. Coordinator decisions: rung 3 hidden is the launch default (rung 1 only with a documented clean case); the fork preamble forbids `run_in_background`; `kill`/`expire` also sweep the fork's process tree; the model check keys on the warning event / `modelUsage` mismatch; "no visible window" is a permanent acceptance criterion in unit and smoke gates where testable; the binary is always the fingerprinted absolute path, and the env passed via CIM carries `CLAUDE_CODE_EXECPATH` or the explicit binary path.
-
-## Phase 1 — Helper core
-
-Intake 2026-10-16 12:18 +0200, Athanor `claude-opus-5-5[1m]`. Start commit `83f6bac`.
-
-| Block | Owner (model id) | Commit | Tokens (if known) |
-|---|---|---|---|
-| 1.1 Skeleton, state, `where`, `init` | fresh general-purpose agent, `opus` alias, stamped `claude-opus-5-5[1m]` | `d36ac2f`, `85d1e14` | 211,075 subagent tokens (harness total) |
-| 1.2 Launch and supervise | fresh general-purpose agent, `opus` alias, stamped `claude-opus-5-5[1m]` | `009a252`, `8f2c7d3` | 337,053 subagent tokens (harness total); harness duration 11,929 s |
-| 1.3 Phase tests, smoke | the Athanor, `claude-opus-5-5[1m]`, own Bash; no fallout agent needed | this run-log commit | smoke calls $0.49 client estimate (+ the killed fork, no result) |
-
-Gate after 1.1 (Athanor, 12:29): G-unit `Ran 52 tests … OK`, exit 0; G-where exit 0, one JSON object. `--effort` values checked against `claude --help` 2.1.299 (low, medium, high, xhigh, max): match.
-
-### Block 1.1 — Skeleton, state, where, init
-
-- Model: `claude-opus-5-5[1m]`
-- Start / end: Fri Oct 16 12:20:48 +0200 2026 / Fri Oct 16 12:28:49 +0200 2026 (`date`; tests and gates finished by the end time, the note and commit followed)
-- Done: New `plugins/spire/skills/forks/forks.py` (plan §2 PEP 723 header, stdlib only, LF): argparse dispatch for all 13 commands; exit codes 0/2/3/4 as constants; stdout = exactly one JSON object per call (argparse errors, `--help` and uncaught exceptions included); path normalisation (relative, `G:\`, `G:/`, `/g/…`, `/c/…`; POSIX `abspath`); state dir `<run without .md>-forks` with `.gitignore` (`raw/`, `*.lock`), `mcp-empty.json`, `jobs/ briefs/ notes/ results/ logs/ raw/`; `registry.json` `"schema": 1`; `RegistryLock` (create-exclusive, stale after 30 s, token-checked release); atomic temp-then-`os.replace` with `PermissionError` retries (40 × 50 ms) for writers and readers; `ledger_append` (caller holds the lock); `_now()` / `_iso()`; `pid_record` / `pid_alive` / `proc_ctime` (Windows `OpenProcess` + `GetProcessTimes`, POSIX `/proc/<pid>/stat`); `git()` always `git --no-optional-locks`; scrub constants (`SCRUB_DROP`, `SCRUB_DROP_PATTERNS`, `SCRUB_KEEP`, `SCRUB_PINNED` + `CLAUDE_CODE_EXECPATH`) and `scrubbed_env(binary)`; `supervisor_interpreter()` (C6); `SPAWN_METHOD` (`cim-hidden` / `setsid`); `where`; `init` (all launch fields and defaults, fingerprint sha256 of canonical JSON, config extras incl. `orphan_after` 1200 and `pings` on, idempotency, C8 admission, all validation before any write). Launching and Phase 1 commands return `{"error":"not implemented","block":"1.2"}`, Phase 2 ones `{"phase":2}`, exit 2. New `preamble.md` (digest content, short). New `tests/test_forks.py` (PEP 723 + `unittest`, imports `forks.py` by path, 52 tests: path forms, state-dir derivation, scrub, lock contention in-process and across processes, stale-lock recovery by `at`, by mtime and under an injected `_now`, safe release after takeover, replace while a reader holds the target (retried, `attempts > 1` asserted on Windows), registry schema, ledger, pid + ctime, `init` defaults / idempotency / change before and after a fake base / bad model ids / `plan` / unknown mode and effort / missing binary / agent, C8 exact / `[1m]` strip / family alias / no list / unlisted → exit 2 naming the files with settings untouched, `where` via `uv run` with a stub and with the host binary, error-case stdout invariant via `uv run`, unknown command, not implemented, `--help`, internal error, N3 guard). Stub binary generated at test runtime in `tempfile` (`.cmd` on Windows); `USER_SETTINGS_PATH` monkeypatched to a temp file, so no test reads `~/.claude`.
-- Gates:
-  - G-unit `uv run plugins/spire/skills/forks/tests/test_forks.py` → exit 0, `Ran 52 tests in 3.173s` / `OK`.
-  - G-where `uv run plugins/spire/skills/forks/forks.py where` → exit 0; stdout 1 line, a JSON object, `ok: true` (binary `CLAUDE_CODE_EXECPATH` 2.1.299, Python 3.13.1, uv 0.5.13, git 2.34.1.windows.1, `spawn: cim-hidden`). uv's `Reading inline script metadata…` line goes to stderr.
-- Deviations from plan (digest):
-  - Argument sets for the 1.2 commands are already declared in argparse from the digest (`train --base --brief [--block --phase]`, `fork --base --block --brief [--phase --mode --paths --max-minutes --max-budget-usd --force]`, `continue --job --brief [--max-minutes]`, `wait [jobs] --all --any --timeout`, `expire --base|--all`, `kill --job`, `_supervise --job`). 1.2 may change them.
-  - The N3 guard is already in the dispatch for `train`, `fork`, `continue`, `rebase` (exit 2 before "not implemented" when `SPIRE_FORKS_CHILD` is set); `tick` left for Phase 2.
-  - `--help` returns `{"help": …, "commands": […]}` on stdout with exit 0 (keeps the invariant). Unknown extra arguments are a usage error (exit 2), except on the Phase 2 stubs, which tolerate them until Phase 2.
-  - Uncaught exceptions: exit 2, `{"error":"internal error","type","detail"}`, traceback on stderr (the digest defines no code for it).
-  - `init` takes more flags than the digest lists: `--ttl-s`, `--stall-after-s`, and one per threshold (`--rebase-commits`, `--rebase-lines`, `--rebase-delta-tokens`, `--max-base-tokens`, `--max-rebases`). Thresholds sit nested under `config.thresholds`. Config also carries `binary_resolved_by` and `model_admission` (how, not what; ignored by the change comparison).
-  - `where` takes an optional `--binary` (tests use a stub) and also reports `python.supervisor_interpreter`, `platform`, `scrub.drop_patterns`; on failure it carries both `reason` and `error`.
-  - `preamble.md` adds two lines beyond the digest: "nobody can answer a question mid-run" and "never push, rebase or reset" (mirrors the deny list).
-- Flagged for review:
-  - `--effort` is restricted to `low|medium|high|xhigh|max` and `--permission-mode` to `default|acceptEdits|dontAsk|bypassPermissions|auto` (`plan` refused). Both sets are assumed, not checked against `claude --help`.
-  - Fingerprint launch dict: `model, effort, permission_mode, tools, allowed_tools, disallowed_tools, mcp {strict, config path}, append_system_prompt {path, sha256}, agent {name, path, sha256} | null, cwd, binary {path, version, size, mtime}, env.pinned` (only the two TTL/autoupdater vars; `SPIRE_FORKS_CHILD` and `CLAUDE_CODE_EXECPATH` are added at launch by `scrubbed_env`, outside the hash). The mcp config path is per run, so the hash differs between runs by construction.
-  - `--allowed-tools` / `--disallowed-tools` are repeatable lists and each value is also split on commas outside parentheses (`Bash(a,b)` stays one rule).
-  - Stale-lock breaking re-reads the lock and removes it only if unchanged; two breakers racing still have a narrow window. Release removes the lock only if its token is still ours. Lock wait is 45 s (longer than the 30 s stale age).
-  - C8: an unreadable or invalid settings file is skipped with a stderr note; `availableModels: []` counts as a list that admits nothing.
-  - Host env has `ANTHROPIC_BASE_URL`; it is on neither list, so it is kept for the child and listed under `scrub.unknown` by `where` (the P0 probes kept it too and auth worked). The coordinator may want it on a list.
-  - `pid_alive` treats `ERROR_ACCESS_DENIED` from `OpenProcess` as alive with an unverifiable creation time.
-  - Git Bash paths whose first segment is not a single letter (`/tmp/x`) are treated as rooted on the cwd's drive, not mapped to Git's install dir.
-  - The model regex is the digest's; it admits ids like `claude-sonnet` with no version.
-- Left for later: everything the digest assigns to 1.2 (templates, launch, supervise, results, ledger lines, `wait`/`list`/`expire`/`kill`, no-visible-window test, `run.last_orchestrator_call_at`); Phase 2 commands.
-- Expected broken: `train`, `fork`, `continue`, `wait`, `list`, `expire`, `kill`, `_supervise` exit 2 "not implemented" (block 1.2); `rebase`, `usage`, `tick` (Phase 2).
-- Commits: `d36ac2f` (code, tests, preamble, this note), then a one-line follow-up filling in this hash.
-
-### Block 1.2 — Launch and supervise
-
-- Model: `claude-opus-5-5[1m]`
-- Start / end: Fri Oct 16 12:31:01 WEDT 2026 / Fri Oct 16 15:48:45 WEDT 2026 (`date`; the host clock read 12:31 at my first call and 15:42 at the first manual run, so the span includes a jump like the one Phase 0 saw; the gates ran 15:47:38–15:48:30)
-- Done: `forks.py` gains `train`, `fork`, `continue`, `wait`, `list`, `expire`, `kill`, `_supervise`. Launch writes the job (registry index, status `created`) under the lock, `briefs/<job>.md` (template + brief) and `raw/<job>.env.json` (scrubbed env with `CLAUDE_CODE_EXECPATH` = stored binary and `SPIRE_FORKS_CHILD=1`), then spawns `<base interp> -I forks.py _supervise --run --job` through `powershell` (`CREATE_NO_WINDOW`) → CIM `Win32_Process.Create` with `ShowWindow=0`, command line and cwd passed in `SPIRE_FORKS_CMD`/`SPIRE_FORKS_CWD`; `ReturnValue` ≠ 0 ends the job `failed`/`spawn_failed`. The supervisor redirects its stdio to `raw/<job>.sup.log`, starts `claude` with exactly the env file and `CREATE_NO_WINDOW` (stored absolute binary path, full fingerprinted command line every call, `--session-id` on train and fork, `--resume … --fork-session` on fork, `--resume` only on continue, `--max-budget-usd` passed through), feeds the prompt on stdin, parses the stream (`StreamState`: init, message ids, first/last assistant usage, `system/informational` restriction warning, result), and is the only writer of `jobs/<job>.json` (heartbeat every 10 s). Watchdogs: `max_minutes` → kill tree, `timeout`; `stall_after_s` of no stdout → flag `stalled`; N1 orphan check every 1 s → kill tree, `killed` + `orphaned`; restriction warning → kill tree, `failed`/`model_refused`. Finalising (`finalize_job`, once, under the lock): `results/<job>.json` (plan §4.2 fields + `paths`, `reason`, `model_requested`), ledger line (design §6 + `status`, `flags`, `reason`), registry update (status, cumulative cost and `modelUsage` for the session, base `last_hit`; on train: base `active` with `base_commit`, context tokens, training cost, cumulative `modelUsage`, runtime fingerprint). Usage rule, `usage_mismatch`, cache verdict, `cold_start`, C1 warmth, fingerprint `ok|drift:<fields>` (launch: `binary`, `append_system_prompt`, `agent`; runtime: `tools`, `permissionMode`, `plugins`, `agents`, `apiKeySource` against the base's init). `wait` per C4, `list` (all bases with warmth, all jobs, running info), `lost` reaper (heartbeat > 120 s and supervisor pid + ctime dead), `kill` (Toolhelp32 tree snapshot with ctimes → `taskkill /T /F` → sweep with `TerminateProcess` by pid + ctime → verify up to 10 s), `expire` (retire, kill running jobs of the base, flag `expired`). Refusals: N2, N3, cap, launch-field overrides on fork/continue (each field accepted by the parser only to be refused), base not active without `--force`, continue of a running or non-fork job, missing binary (`reason: binary_missing`), base name taken. New `templates/train.md` and `templates/fork.md` (stale-snapshot sentence, delta header from `git --no-optional-locks log --oneline <base_commit>..HEAD` and `diff --shortstat <base_commit>`, commit rule per mode, note path, logs dir). `preamble.md` unchanged. Tests: 17 new (69 total): a generated stream stub `claude` (`stub/claude.cmd` → base interpreter `-I stub.py`, behaviour per call from `@stub …` lines in the brief, sessions kept beside it so resume/fork report cumulative `modelUsage` and `total_cost_usd`), real CIM launches with the stub as `--binary`, `RuleTests` on the real P0.2 seq-1 numbers, and a module-end check that no process whose command line contains the tests' temp prefix survives.
-- Gates:
-  - G-unit `uv run plugins/spire/skills/forks/tests/test_forks.py` → exit 0, `Ran 69 tests in 52.001s` / `OK` (suite wall 52 s; two earlier full runs at 68 tests: 51.7 s each, OK).
-  - G-where `uv run plugins/spire/skills/forks/forks.py where` → exit 0, stdout one line, a JSON object, `ok: true`, `spawn: cim-hidden`, binary 2.1.299.
-  - Leftover processes after the gates: none. Checked by command line (`forks-test-`, `_supervise`, my manual scratch run `b12-manual`) via `Get-CimInstance Win32_Process`, not by name; also asserted by the suite's `tearDownModule`.
-  - Manual check (scratch run in the session scratchpad, stub binary): the supervisor's parent is `WmiPrvSE.exe`; its tree is python → conhost, cmd (claude) → conhost, python stub → python grandchild; `kill` snapshot 6 pids, `taskkill_rc` 0, no survivors.
-- Deviations from plan:
-  - `fork --max-minutes` and `continue --max-minutes` take a positive float (the tests use 0.06 min); `init --max-minutes` stays an integer.
-  - `fork`/`continue` also run the `lost` reaper before the cap check (the digest names `wait` and `list`), so a dead supervisor cannot block the cap.
-  - The `lost` reaper kills the job's leftover `claude` tree (from the job file) before marking it `lost`; the digest only says to mark it.
-  - On the restriction warning the supervisor kills `claude` at once instead of letting the substituted model finish (saves the spend; the result still reads `failed`/`model_refused`).
-  - After `claude` exits, the supervisor sweeps any descendants of it that are still alive (the "backgrounded `sleep 240`" trap); logged in `sup.log`.
-  - `train` takes no launch-field overrides (the design's table allows them; the plan's invariant and the digest do not); they are usage errors there.
-- Flagged for review (semantics the digest left open):
-  - `wait --all` = every job not yet *settled*; a job is settled when it was in the condition of a `wait` that returned 0 or 4. `done` holds only results not delivered before. So the mixed case gives 3 (failed result in `done`), then 4 when the rest finish (the failed job stays in the condition without being returned again), then 0 on an empty set. Explicit job lists use the same delivery marks. `--any`: met when any member has finished (or the set is empty); exit 4 if any finished member is not `ok`. `wait` with neither jobs nor `--all` is a usage error; `--timeout` > 570 is refused (exit 2).
-  - `reason` vocabulary: `model_refused`, `is_error`, `exit_code`, `no_result`, `spawn_failed`, `launch_error`, `supervisor_error` (failed); `kill`, `expire`, `orphaned` (killed); `supervisor_dead` (lost). `timeout` has `reason: null` (the digest: null unless failed/killed/lost). Details go to the registry's `reason_detail` (shown by `list`), not into the result or ledger.
-  - Precedence when deciding a finished call: model refused > no result (`exit_code` if non-zero, else `no_result`) > `is_error` > non-zero exit. A model is "refused" when the warning appeared or the requested id (with `[1m]`) is not among the `modelUsage` keys that grew; extra models do not count.
-  - Without a `result` event (killed, lost, died): `tokens` are all `null`, `cost_delta_usd` `null`, `models_used` `[]`, `turns` = distinct assistant message ids seen; cache verdict still from the first assistant event if one arrived.
-  - `last_hit` for a train is the time of its **last** assistant event (the full prefix is written there); for fork/continue the first, written to the base as soon as it arrives. A continue refreshes its base's `last_hit`.
-  - `base_state` is `null` for train jobs; `cold_start` is only computed for fork/continue (a train is always cold).
-  - `continue` sends the brief as given (no template; there is no `templates/continue.md`). Its `parent_session` is the fork's parent (the base session); its cost and `modelUsage` "before" are the fork session's last cumulative totals (updated by every continue), falling back to the base's when the fork has none (a killed fork: the delta then includes the killed fork's spend).
-  - `note` = `notes/<block>.md` (block sanitised) if that file exists when the job ends, else `null`; `fork.md` tells the fork that path. Train jobs have `note: null`.
-  - A failed training leaves the base `failed`; `train` may reuse a name only when that base is `failed`.
-  - `kill` of a job that is no longer running exits 0 with `killed: false` and its status; survivors after the 10 s sweep give `ok: false` (exit still 0).
-  - A `kill` that lands while the supervisor holds the registry lock to finalise leaves a stale lock (broken after 30 s) and, in a narrow window, a duplicate ledger line. `kill` marks `kill_requested` first; a supervisor that finalises after that records `killed` unless the call ended `ok`.
-  - `wait` updates `last_orchestrator_call_at` at its start and end only (a 570 s wait stays under the 1200 s `orphan_after`).
-  - Stall is measured on any stdout line, not only parsed JSON events.
-  - `process_tree` follows parent pids through dead processes (so orphans of a dead `claude` are found) but stops at a node whose pid now belongs to a process with another creation time; this reuse guard is not exercised by a test.
-  - `spawn_failed` shows up in `wait`, not in the launch return (the launch return is C1's fixed shape).
-- Not tested: the POSIX path (`setsid` spawn, process-group kill, `/proc` tree) — written, never run; `--agent` drift (only the code path, no test); a real `claude` (no test spends tokens; Phase 1.3 smoke); supervisor survival across the end of the orchestrator's turn (1.3).
-- Left for later: warmth inference, pings, `rebase`, `rebase_due`/`retrain_due` reasons, `usage`, `tick` (Phase 2); `SKILL.md` (Phase 3).
-- Expected broken: `rebase`, `usage`, `tick` exit 2 "not implemented" (Phase 2).
-- Commits: `009a252` (code, tests, templates, this note), then a one-line follow-up filling in this hash.
-
-### Block 1.3 — Phase tests and live smoke
-
-- Model: `claude-opus-5-5[1m]` (the Athanor, own Bash)
-- Start / end: 2026-10-16 15:50:01 +0200 / 15:55:50 +0200 (`date`)
-- Done:
-  - Gates after 1.2 (15:50): G-unit exit 0, `Ran 69 tests in 52.065s`, OK; G-where exit 0. Leftover-process check by command line (`_supervise`, the tests' temp prefix, `stub`): none.
-  - Live smoke per plan §7 "Phase 1 tests and smoke", in the scratch clone (`…\scratchpad\headless-forks-p0\clone`, HEAD `9d3ddc1`, clean), run log `…\headless-forks-p0\smoke1\2026-10-16-15-smoke-run.md`, state dir beside it. Every `wait` ran from Bash with `timeout: 600000`. Briefs in `…\smoke1\brief-*.md`.
-    - `init --model claude-opus-5-5 --cwd <clone>` → exit 0; binary via `CLAUDE_CODE_EXECPATH` (2.1.299); admission "exact id in the clone's `.claude/settings.json`".
-    - `train --base B1` (read 3 Spire files, no edits) → `wait --all` exit 0: `ok`, 11.6 s, base context 23,676, cost $0.2129.
-    - `fork --block S1` (sequential; write, `git diff --check`, commit, note) → `wait --all` exit 0: `cache: hit`, `fingerprint: ok`, `models_used: ["claude-opus-5-5"]`, note `notes/S1.md`, clone commit `38e2605`, cost Δ $0.0878.
-    - `fork --block S2` → `wait --all` exit 0: `hit`, `ok`, same model, note `notes/S2.md`, commit `447b6cd`, cost Δ $0.0953.
-    - `continue --job j0002` (append a line, commit) → `wait --all` exit 0: `ok`, commit `a54bb59`, cost Δ $0.0955 (= its raw `total_cost_usd` 0.39614 − S1's 0.30066).
-    - `fork --block K1` (long read loop) → `wait j0005 --timeout 25` exit **3** (`running`, 5 turns) → `kill --job j0005`: snapshot supervisor `python.exe` 25952, `conhost.exe` 11208, `claude.exe` 29560, `conhost.exe` 5932; `taskkill_rc` 0; `survivors: []`. Independent check by pid + creation time: all four dead. Command-line sweep (`smoke1`, `_supervise`, the clone path): nothing. → `wait --all` exit **4** (`killed`, `reason: kill`, tokens and cost `null`).
-    - `list` → `…\smoke1\list-final.json`.
-  - First-request cache reads (raw streams): S1, S2, K1 each 23,674 of the base's 23,676 (0.9999); the continue 27,192 (the fork's own longer prefix).
-  - All five streams ran `claude_code_version` 2.1.299. `raw/j0002.env.json` carries `CLAUDE_CODE_EXECPATH` (the 2.1.299 path) and `SPIRE_FORKS_CHILD=1`, and none of `CLAUDE_CODE_MESSAGING_TOKEN`, `VIRTUAL_ENV`, `CLAUDE_EFFORT`.
-  - **No visible window**: checked during S1, the continue and K1 (supervisor + `claude.exe` + 2 `conhost.exe` each): no visible window of the tree, no visible console or Windows Terminal window on the desktop.
-  - Ledger vs results (`…\probes\smoke_ledger.py`): 5 ledger lines, 5 result files; for every job, `status`, `flags`, `tokens`, `cost_delta_usd`, `cache`, `fingerprint`, `models_used`, `session`, `parent_session`, `turns`, `kind`, `block`, `base` are equal in both; every cost Δ equals the raw `total_cost_usd` difference.
-  - Phase-end tests (15:55): G-unit exit 0, `Ran 69 tests in 51.915s`, OK; G-where exit 0.
-- Smoke results (from the ledger):
-
-| Job | Kind | Block | Status | Cache | Fingerprint | Models used | in | out | cache write (1h) | cache read | Cost Δ | Turns | Wall s |
-|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
-| j0001 | train | — | ok | — | ok | claude-opus-5-5 | 4 | 1,004 | 23,674 | 16,913 | $0.2129 | 4 | 11.6 |
-| j0002 | fork | S1 | ok | hit | ok | claude-opus-5-5 | 12 | 1,452 | 3,518 | 152,790 | $0.0878 | 6 | 18.6 |
-| j0003 | fork | S2 | ok | hit | ok | claude-opus-5-5 | 12 | 1,670 | 3,885 | 154,044 | $0.0953 | 6 | 23.1 |
-| j0004 | continue | S1 | ok | hit | ok | claude-opus-5-5 | 12 | 1,777 | 3,263 | 168,958 | $0.0955 | 8 | 20.1 |
-| j0005 | fork | K1 | killed (`kill`) | hit | ok | — | — | — | — | — | — | 6 | 26.0 |
-
-  Ledger file: `…\headless-forks-p0\smoke1\2026-10-16-15-smoke-run-forks\ledger.jsonl` (5 lines; not committed, it is scratch).
-- Deviations from plan: none in the smoke steps. The plan's "kill leaves no `claude` process behind" was checked by recorded pid + creation time (A18) and by a command-line sweep, not by process name.
-- Flagged for review:
-  - `jobs/<job>.json` `turns` counts assistant message ids (2 for the training) while the result's `turns` is `num_turns` (4). Only the result/ledger value is reported; the job-file field is a progress counter. Harmless, but two meanings under one name.
-  - The `continue` result's cache verdict is computed against the **base** context (27,192 / 23,676 → `hit`); its `parent_session` is the base session, not the fork it continues (1.2's documented choice).
-  - Supervisor survival across the end of the Athanor's turn is still untested: every smoke job finished or was killed inside this turn (the procedure forbids hand-back with running jobs anyway).
-  - The smoke base is small (23,676 tokens); the large-base behaviour was covered in P0.2, not re-run through the helper.
-- Left for later: Phase 2 (warmth inference, pings, `rebase`, `usage`, `tick`).
-- Expected broken: `rebase`, `usage`, `tick` exit 2 "not implemented" (Phase 2).
-- Commits: no code; only the run-log commit that adds this note and the Phase 1 close (`📝 Headless forks Phase 1: smoke results and phase close`).
-
-### Phase 1 close
-
-- Gate: G-where after 1.1, 1.2 and at phase end — exit 0 each time, one JSON object.
-- Tests: G-unit at phase end (15:55) — exit 0, 69 tests, 51.9 s. Live smoke — all plan §7 Phase 1 criteria met (above). No fallout block was needed, so no fix agent ran.
-- Flags for the reviewer (each with its block):
-  - Phase 0 (handed over by Igor as flags for this review): every deviation and flag in "Block 0" and "Phase 0 close" above — P0.6 started before P0.1 (c) finished; `--no-hardlinks` clone; six tool-less calls outside the clone (main checkout, worktree); separate scratch dirs for `--agent` and P0.8; (d) produced with `TaskStop` because the Bash tool backgrounds at timeout; effort case run inside P0.2; rung-3 runs `r3-main`/`r3-tkill` on 2.1.283; P0.8 in an untrusted dir; effort unobservable; orphan background command; P0.6 ping read 0.916; visible windows before the fix and the retest; the 20-min clone; the clock jump.
-  - 1.1: `preamble.md` written in 1.1 instead of 1.2 (the digest moved it: `init` hashes it).
-  - 1.1: every deviation and "Flagged for review" line of its note — argparse sets declared early; N3 guard in the dispatch; `--help` as JSON; internal-error exit 2; extra `init` flags and nested thresholds; `where --binary`; two extra preamble lines; effort/permission-mode value sets (effort checked against `claude --help` 2.1.299 by the Athanor: match); per-run mcp path in the fingerprint hash; comma-splitting outside parentheses; stale-lock race window; invalid settings skipped, `[]` admits nothing; `ANTHROPIC_BASE_URL` kept and listed as unknown; access-denied treated as alive; `/tmp`-style paths; the permissive model regex.
-  - 1.2: every deviation and "Flagged for review" line of its note — float `--max-minutes`; lost reaper before the cap and killing the leftover tree; immediate kill on the restriction warning; post-exit descendant sweep; no overrides on `train`; `wait --all` "settled" semantics; the reason vocabulary (timeout has `reason: null`); precedence of failure reasons; null usage without a result; train `last_hit` from its last event; continue without template, its parent session and cost basis; note detection; failed-base name reuse; `kill` of a finished job; the kill/finalise race (stale lock, possible duplicate ledger line); `last_orchestrator_call_at` at wait start/end only; stall on any stdout line; pid-reuse guard untested; `spawn_failed` only visible in `wait`.
-  - 1.2: not tested — POSIX path, `--agent` drift, pid-reuse guard.
-  - 1.3: the four flags in its note.
-  - Phase 1 as a whole: the contract digest `docs/workpad/plans/2026-10-16-12-headless-forks-phase1-contract.md` (commit `670401d`) is an Athanor-written brief that pins semantics the build plan left open (state layout, CIM command, scrub additions incl. `CLAUDE_CODE_EXECPATH` and `SPIRE_FORKS_CHILD`, reason fields, the `init` idempotency rule, C8 admission rule). The reviewer should check it against the build plan rather than take it as given.
-- Not run / untested: supervisor survival past the Athanor's hand-back; POSIX; a large base through the helper; `stalled` with a real `claude` (stub only); `lost` with a real `claude` (stub only).
-- Spend (Phase 1): live smoke $0.49 client estimate (`total_cost_usd` of the four completed calls' deltas; the killed fork reported none). Unit tests spend nothing (stub). Subagent tokens: 1.1 211,075; 1.2 337,053 (harness totals); the Athanor's own unknown.
-- Processes at hand-back: none from this phase (command-line sweep at 15:54, and the suite's own teardown check).
-- Status: provisional until review, fix pass and re-check close.
-
-### Phase 1 fix pass
-
-- Model: `claude-opus-5-5[1m]` (fixer, own tools, no agents dispatched)
-- Start / end: Fri Oct 16 16:11:40 WEDT 2026 / Fri Oct 16 16:27:01 WEDT 2026 (`date`; this note and its commit followed)
-- Review: `docs/workpad/reports/2026-10-16-16-headless-forks-phase1-review.md`. Fixed: I1, I2, I3, M1, M2, M3, M4, M5, M9. Not touched (deferred by the Athanor): M6, M7, M8, M10–M16.
-- Done, per finding (each test fails on the unfixed `20b049e` helper; checked by running the new tests against it in a scratch copy: 18 failures, 11 errors, 0 passes):
-  - **I1** — `_conclude`: `model_refused` only on the restriction warning, or when `models_used` is non-empty and lacks the requested id. New `api_error_reason(result)` sets `usage_limit` (429, or "usage limit"/"rate limit"/"hit your limit"/"API Error: 429"), `overloaded` (529 / "overloaded"), `prompt_too_long`, `api_error` (any other status, or "API Error" text); `reason_detail` = `api_error_status <n>: <first 200 chars of result/error text>`. Precedence: model refused > no result > API error > `is_error` > non-zero exit. Stub: `error` now bills nothing (no assistant events, empty `modelUsage` delta); new `apierr=<status>` and `errtext=<words_with_underscores>`. Tests: `RuleTests.test_api_error_reason`, `LaunchTests.test_api_errors_are_not_model_refused` (each new reason end to end + substitution still `model_refused`), `LaunchTests.test_failures_flags_and_drift` (its `error` case is now the empty-delta path and still reads `is_error`).
-  - **I2** — `process_tree(rec, alive_until)`: for a dead root, a direct child is taken only if its creation time is after the root's recorded one and at most `alive_until` + 1 s (the job-file times are whole-second ISO). No recorded ctime or no `alive_until` → a dead root claims nothing. Below a claimed (live, pid + ctime verified) child the old rule applies. The live-root path is unchanged. New `epoch_to_ctime` (Windows FILETIME; POSIX `/proc/stat` btime × CLK_TCK) and `last_alive_at(rt)` (later of `heartbeat_at`, `ended_at`). `kill_tree` passes `alive_until` through; `reap_lost` and `kill_job` pass the job file's last-alive time; the supervisor's own calls pass `time.time()`. Tests: `ProcessTreeTests` (fake process table, `process_table`/`proc_ctime`/`pid_alive` patched, nothing real touched): `test_dead_root_claims_only_children_from_its_lifetime` (reused-pid child after the heartbeat and a pre-job process with the dead pid as stale ppid are not claimed, the genuine child and its later child are), `test_dead_root_without_bounds_claims_nothing`, `test_live_root_unchanged`, `test_reap_lost_bounds_by_heartbeat`.
-  - **I3** — only a fork's first assistant event (supervisor, `hit_written = kind != "fork"`) and the training's last event (`_conclude`) refresh the base's `last_hit`; a continue no longer does. Test: `LaunchTests.test_continue_leaves_base_last_hit` (also checks a following fork still refreshes it).
-  - **M3** — new `SupClock`: a tick gap > `CLOCK_JUMP_S` (60 s; the tick is 0.25 s) is a jump; gap minus one tick is left out of the `max_minutes` elapsed time, and the orphan watchdog counts from the later of the last orchestrator call and the jump (one more `orphan_after`). A jump is logged to `sup.log` (stderr) and adds flag `clock_jump`. Tests: `RuleTests.test_sup_clock_jump`; `LaunchTests.test_clock_jump_not_orphaned_or_timed_out` (a real `Supervisor` run in-process under an injected `_now` that jumps 2 h one second into a 3 s stub call, `orphan_after` 600, `--max-minutes 1`: ends `ok` with `clock_jump`, jump logged; the unfixed helper ends it `timeout`).
-  - **M2** — a lock is stale only when its holder pid + ctime is dead, or it is older than `LOCK_ABANDONED_S` = 300 s (every critical section is a few small JSON read-modify-writes: ms, at worst seconds of `PermissionError` retries; 300 s is two orders above that and only matters for a holder that cannot be judged). Breaking: rename the lock to a unique `registry.<hex>.broken.lock`, delete it only if its content is the one judged stale, else put it back without overwriting (Windows `rename`, POSIX `link` + `unlink`). A failed break falls through to the deadline check and the sleep. `LOCK_STALE_S` is gone. Tests: `LockTests.test_unbreakable_stale_lock_respects_deadline` (rename/remove of the lock raise `PermissionError`: returns "registry locked" within the 0.5 s deadline; the unfixed helper spins), `test_fresh_lock_taken_during_break_survives` (a fresh lock swapped in at the moment of the break survives; no `.broken.lock` left), `test_dead_holder_lock_broken_at_once`, `test_abandoned_lock_broken_by_age`.
-  - **M1** — `finalize_job` writes the result, then the registry (the once-only guard), then the ledger line; `ledger_append` skips a job that already has a line (under the lock) and starts a new line after a torn last line. Test: `AtomicTests.test_ledger_append_dedupes_by_job`.
-  - **M4** — `CHILD_REFUSED` adds `kill`, `expire`, `init` (exit 2, message names the command and "inside a fork"). `stamp_orchestrator`/`touch_orchestrator` do nothing when `SPIRE_FORKS_CHILD` is set (all five stamp sites go through them). Tests: `CliTests.test_child_refuses_kill_expire_init`, `CliTests.test_child_does_not_stamp_orchestrator`.
-  - **M5** — `PERMISSION_MODES` = `acceptEdits, auto, bypassPermissions, manual, dontAsk, plan`; `plan` still refused; `default` is now "unknown permission mode" (its `allowed` list omits `plan`). Test: `InitTests.test_permission_modes_match_2_1_299`.
-  - **M9** — `ANTHROPIC_BASE_URL` on `SCRUB_KEEP`. `where` always carries `warnings` (list); one entry when the variable is set and, trailing slash and case ignored, not `https://api.anthropic.com`; exit stays 0. Test: `CliTests.test_where_warns_on_base_url` (unset, default, default with slash, a gateway URL).
-- Behaviour changes to existing tests:
-  - `LockTests.test_stale_lock_broken` → `test_dead_holder_lock_broken_at_once`: the lock is fresh but its holder is dead (a dead-holder lock is now broken at once, no 30 s wait). The old fixture's `pid: 1` without ctime would be "alive" on POSIX.
-  - `test_garbage_stale_lock_broken_by_mtime` and `test_stale_under_injected_clock_and_safe_release`: the age bound is `LOCK_ABANDONED_S` (300 s) instead of `LOCK_STALE_S` (30 s).
-  - `test_fresh_lock_not_broken`: the holder is this live process (pid 1 is dead on Windows, which now means stale); it also checks a fresh garbage lock is not broken.
-  - `ScrubTests.test_unknown`: `ANTHROPIC_BASE_URL` is no longer in `scrub.unknown` (it is `keep`).
-  - Stub `error` directive: bills nothing (previously billed three turns to the requested model). `test_failures_flags_and_drift` expectations unchanged.
-  - The `timeout` `reason_detail` reads "run time over max_minutes" (was "wall time"); no test asserts it.
-- Gates:
-  - G-unit `uv run plugins/spire/skills/forks/tests/test_forks.py` → exit 0, `Ran 86 tests in 68.942s` / `OK` (16:25:33–16:26:42; was 69 tests / 52 s).
-  - G-where `uv run plugins/spire/skills/forks/forks.py where` → exit 0, one line, one JSON object, `ok: true`, `spawn: cim-hidden`, binary 2.1.299 via `CLAUDE_CODE_EXECPATH`, `warnings: []`.
-  - Leftover processes: none (16:27, `Get-CimInstance Win32_Process` by command line: the tests' temp prefix, `_supervise`, the scratch copy of the old helper); also the suite's `tearDownModule`.
-  - No live `claude` calls (stub only).
-- Flagged for the re-check:
-  - I2: children a dead root spawned in the last heartbeat interval (up to 10 s before it died) are not claimed. Missing a few is the price of never killing an unrelated process. The supervisor's post-exit sweep is unaffected (it passes `time.time()`).
-  - I2: on POSIX without `/proc/stat`, `epoch_to_ctime` is None, so a dead root claims nothing there.
-  - M2: one residual case. Waiter A renames a lock aside, finds a fresh lock L2 (not the stale one), and tries to put it back. If a third waiter C created a lock in that microsecond gap, the restore fails: L2 stays aside (logged, named `registry.<hex>.broken.lock`, matched by `.gitignore`'s `*.lock`) and both L2's holder and C believe they hold the lock. The old code could delete a fresh lock outright in the two-waiter case. `release` is still check-then-remove (token read, then `os.remove`), as before; not in this pass.
-  - M3: the stall measure (`quiet`) still uses the wall clock, so a suspend also sets `stalled` (a flag, no kill). `wall_s` in the result stays wall time, suspend included. A backwards clock jump is not treated as a jump.
-  - M3: `kill`/`expire` still do not refresh the orchestrator stamp. That is for the Phase 3 text, as the review says.
-  - I1: the text patterns are a heuristic over `result`/`error`/`errors`; the status code wins when present. A result with `is_error: false` and no `api_error_status` is never classified.
-  - M9: an empty `ANTHROPIC_BASE_URL` counts as "set, not default" and warns.
-- Commits: `7b9b748` (code and tests), then this note's commit.
-
-### Phase 1 fix pass — Athanor check and deferred Minors
-
-- Athanor `claude-opus-5-5[1m]`, 2026-10-16 16:28 +0200 (`date`). Fixer: fresh general-purpose agent, `opus` alias, stamped `claude-opus-5-5[1m]`, 258,611 subagent tokens (harness total).
-- Gates re-run by the Athanor: G-unit exit 0, `Ran 86 tests in 67.444s`, OK; G-where exit 0, one JSON object, `ok: true`, `warnings: []`. Leftover processes by command line (`_supervise`, the tests' temp prefix, `smoke1`): none.
-- Diff check of `20b049e..7b9b748` on `tests/test_forks.py`: one removed assertion line, `scrub_unknown(...) == ["ANTHROPIC_BASE_URL", "CLAUDE_CODE_NEW_THING"]`, replaced by `== ["CLAUDE_CODE_NEW_THING"]`; that is M9's specified change. The lock tests were renamed or rebased on the new staleness rule, which is M2's specified change. No other assertion was removed or loosened.
-- Deferred Minors (not fixed in this pass; coordinator's instruction):
-  - **M6** (runtime fingerprint ignores `skills`, versionless plugins): drift detection is Phase 2 work (`rebase_due`/`retrain_due` inputs); fix it there with the drift reasons.
-  - **M7** (per-run `mcp-empty.json` path in the hash): no cache effect; hash content instead of path when the trial needs cross-run comparison (Phase 5).
-  - **M8** (visible-window unit check is tree-scoped, no positive control, fails without a desktop): the smoke used the global detector; widen the unit check in Phase 2's test pass.
-  - **M10** (`train` refuses launch-field overrides; plan §4.3 allows them): a contract decision for the Phase 2 plan (`retrain_due` needs an input path); not a Phase 1 defect.
-  - **M11** (note detection by existence only): low impact; compare mtime against job start in Phase 2.
-  - **M12** (`kill` report shapes `killed:true,status:ok` and `ok:false` with exit 0): Phase 3 text keys on `ok` and `status`.
-  - **M13** (Git Bash `/tmp`-style paths land on the cwd's drive): the Athanor always passes drive-form paths; `cygpath` or refusal in Phase 2.
-  - **M14** (POSIX kill misses `claude`; no `/proc` on macOS): POSIX is out of the tested scope; SKILL.md says "Windows-tested, POSIX untested" (Phase 3).
-  - **M15** (C8 admission is the union of three files; untrusted dirs untested): SKILL.md records "permissive at init, enforced at runtime" (Phase 3); the runtime warning check backstops it.
-  - **M16** (two meanings of `turns`; post-exit sweep breadth; `continue` brief without frame): rename the job-file field in Phase 2; the other two are Phase 3 text.
-- Status: fix pass done; re-check of I1–I3 by a fresh reviewer is Igor's call.
-- Igor, 2026-10-16: re-check clean (`docs/workpad/reports/2026-10-16-17-headless-forks-phase1-recheck.md`, `60fdea0`); the fixer's residual flags accepted as Minor; Phase 1 closed. Phase 2 folds in R1 (new), M6, M7, M8, M10 (decision: follow plan §4.3, `train` takes overrides), M11, M13, M16 and a billed-error test.
-
-## Phase 2 — Bookkeeping
-
-Intake 2026-10-16 16:41 +0200, Athanor `claude-opus-5-5[1m]`. Start commit `60fdea0`. Contract digest for the block owners: `docs/workpad/plans/2026-10-16-16-headless-forks-phase2-contract.md` (Athanor-written; pins the ping, rebase, retrain and usage semantics left open, and the folded items).
-
-Deviation from the build plan's block table: M8, M16 and the billed-error test go to 2.1; M6, M7, M10, M11, M13 to 2.2; R1 to 2.3 (each lands in the block that already touches that code). `init` may change config after bases exist (Phase 1 refused it) because, with M10, that is the input path for `retrain_due: defining:<fields>`. `init --warm-margin-s` is added as a tunable so the smoke can reach `expiring` without a 54-minute wait.
-
-| Block | Owner (model id) | Commit | Tokens (if known) |
-|---|---|---|---|
-| 2.1 Warmth and keep-warm | fresh general-purpose agent, `opus` alias, stamped `claude-opus-5-5[1m]` | `fff43a0`, `db6f068` | 320,462 subagent tokens (harness total) |
-| 2.2 Rebase and re-train flags | fresh general-purpose agent, `opus` alias, stamped `claude-opus-5-5[1m]` | `5fda2e2`, `9cd98b5` | 350,639 subagent tokens (harness total) |
-| 2.3 Usage rendering | fresh general-purpose agent, `sonnet` alias, stamped `claude-sonnet-5-5` | `4b92b51`, `45b4c55` | 187,248 subagent tokens (harness total) |
-
-Gate after 2.1 (Athanor, 16:59): G-unit exit 0, `Ran 102 tests in 84.544s`, OK; G-where exit 0. Diff check `571a3d6..fff43a0` on the tests: three removed assertion lines; the window assertions moved into the widened `test_no_visible_window` (M8), and the `running[]` key set changed `turns` → `messages` (M16). Nothing loosened.
-
-Gate after 2.2 (Athanor, 17:25): G-unit exit 0, `Ran 112 tests in 120.036s`, OK; G-where exit 0. Diff check `4446827..5fda2e2` on the tests: four removed assertion lines, all in the former `test_changed_values_after_base_refused` (now `..._allowed`), the specified change of `init` after a base exists; the `/tmp` path case moved to the M13 tests. Nothing loosened.
-
-Gate after 2.3 (Athanor, 17:36): G-unit exit 0, `Ran 130 tests in 130.584s`, OK; G-where exit 0. Diff check `c2ce3f4..4b92b51` on the tests: the removed assertions are the `usage` "not implemented" test (specified: `usage` is now implemented); `usage` joined `test_commands_need_init`. Nothing loosened.
-
-**Test cadence (user instruction via Igor, received 17:36, effective from here on):** no repeated full-suite runs. Between blocks a cheap gate only (`uv run python -m py_compile` on `forks.py`, plus at most the test classes the block touched); children do the same. The full suite (about 130 s now) runs once at phase end, and again only if that run fails and something is fixed. Live calls only where a criterion cannot be proven offline, batched at the end. Up to this point every block gate in Phases 1 and 2 had been a full G-unit run (the earlier default); the 17:36 run after 2.3 is the last code change of Phase 2 so far and serves as the phase-end full run unless the smoke forces a fix.
-
-### Block 2.1 — Warmth and keep-warm
-
-- Model: `claude-opus-5-5[1m]`
-- Start / end: Fri Oct 16 16:42:41 WEDT 2026 / Fri Oct 16 16:57:23 WEDT 2026 (`date`; the end is the code commit, this note followed)
-- Done (`forks.py`, `tests/test_forks.py`):
-  - **TTL inference** (`infer_ttl`): after every call on a base that has a `result` (train, fork, continue, ping; failed calls that billed too), `base.ttl_s` = 3600 if it wrote `ephemeral_1h`, 300 if it wrote only `ephemeral_5m`, else the previous known value; `base.ttl_from` = that job. With nothing known, warmth uses the config's `ttl_s`. **`ttl_downgrade`** on a result whose call wrote 5m and no 1h tokens (any kind).
-  - **Warmth** (`base_warmth`): ttl = the base's inferred TTL, else config; margin = `init --warm-margin-s` when set (new config key `warm_margin_s`, default `null`), else `max(120, ttl/10)`. Output gains `ttl_s`, `margin_s` (so `list` base rows show them; `fork`'s launch return keeps its fixed shape). `list` base rows also show `ttl_from`, `ping_in_flight`. `cold_start` (C5) now follows the inferred TTL through `base_state_at_launch`.
-  - **Ping rule** (`ping_decision`): `pings` on → base `active` with a session → state `expiring` → no ping in flight → activity → `pings_since_real_call < break_even`; the first failing condition is the `why` (`pings_off`, `status:<s>`, `state:<s>`, `in_flight:<job>`, `no_activity`, `cap:<n>/<be>`). `break_even` in integer hundredths: 19 at 1 h, 11 at 5 min (floats give 18 for 1.9/0.1).
-  - **Pings** (`tick_pass`): kind `ping`, own job id, `--resume <base session> --fork-session --session-id <new> --max-turns 1`, prompt `PING_PROMPT` = `Reply OK`, launch fields from `launch_record(base, cfg)`, the same CIM hidden spawn, result and ledger line through the normal finaliser. Cache verdict as a fork's; `ok` + `hit`/`partial` refreshes `last_hit` to the ping's first assistant event (at finalise); a `miss`, a failed/killed/lost ping, or no assistant event adds `ping_missed` and leaves `last_hit`. Not in the cap (`_running_capped` already counts only fork/continue).
-  - **C3(d)**: the decision, the job entry and `base.ping_in_flight = <job>` are written in one locked registry write; the finaliser clears the mark (any status); a mark whose job is no longer running does not block.
-  - **Tick**: in every supervisor every `TICK_SUP_S` = 60 s (first after 60 s); in `wait` at its start and every `TICK_WAIT_S` = 30 s (skipped inside a fork); `tick --run R` by hand (new command, N3-refused: `tick` added to `CHILD_REFUSED`; out of the not-implemented set). Tick failures inside `wait`/the supervisor are logged, never raised (`safe_tick`).
-  - **`wait`**: stamps `run.last_wait_at` (start and end; not from a fork); `--all` excludes pings; naming a ping job is exit 2; `pings` = every finished ping result of the run not returned before (each once, also on exit 3); pings never enter `done` or the exit code.
-  - **M16**: the job file's progress counter is `messages`; `wait`'s `running[]` entries and `list`'s running job rows carry `messages` too. Result, ledger and registry `turns` stay `num_turns`.
-  - **M8**: new `test_no_visible_window` (Windows; skipped when `EnumWindows` sees no visible window): positive control = a `CREATE_NEW_CONSOLE` python with `SW_SHOWMINNOACTIVE` and a marker title, detected as a new `ConsoleWindowClass`/`CASCADIA_HOSTING_WINDOW_CLASS` window (or one with the marker title), then killed at once and its window checked gone; then, during a hanging fork with a grandchild, 5 samples of (a) no visible window owned by any pid of the job's tree, (b) no console/Terminal window that was not there before the launch. The old window lines left `test_kill_tree_and_no_visible_window`, now `test_kill_tree` (its kill and CIM-parent assertions unchanged).
-  - **Billed error**: stub directive `billed` (with `error` or `apierr=<n>`: the requested model bills its turns, then the result is an error); `test_error_after_requested_model_billed`: `failed`/`is_error` and `failed`/`api_error`, `models_used` = the requested id, cost Δ > 0, never `model_refused`.
-  - Stub also honours `--max-turns` and a `ttl=5m` directive (writes land in `ephemeral_5m`).
-  - Tests: 16 new (102 total). `WarmthTests` (pure, injected clock): boundaries at 1 h and 5 min (inferred and configured), `--warm-margin-s` override at both TTLs; TTL inference 1h-only, 5m-only, both, read-only (prev 3600 / 300 / none), nothing; `ttl_downgrade`; `break_even`; eligibility per state, status, `pings off`; activity window (wait 599/601 s, running fork/continue, ended 590/610 s, train/ping do not count); caps 19 and 11 (failed pings count, other bases' do not, a real call resets); in flight and stale in-flight; pings not in the cap. `TickTests` (real state dir and lock, spawn and binary check stubbed): two concurrent tickers that both judged the base eligible launch exactly one ping (barrier inside the binary check), third ticker skips, finalise clears the mark, next tick pings again; `tick` command JSON and N3 refusal; nothing-to-do pass takes no lock; binary missing skips. `LaunchTests`: M8, billed error, TTL downgrade + `cold_start` against the inferred 300 s + back to 3600, ping end to end (launched by `wait`'s tick, returned once in `pings`, argv, `partial` refreshes; `tick` by hand: `miss` and failed ping → `ping_missed`, `last_hit` unchanged; mark cleared; three ledger lines), tick cadence in `wait` (≥ 3 calls, none in a fork) and in an in-process supervisor (≥ 3 calls; job file has `messages`, not `turns`).
-- Gates:
-  - G-unit `uv run plugins/spire/skills/forks/tests/test_forks.py` → exit 0, `Ran 102 tests in 86.227s` / `OK` (16:53:54); second run exit 0, `Ran 102 tests in 84.680s` / `OK` (16:55:42–16:57:07). No new test skipped on this host (M8 ran).
-  - G-where `uv run plugins/spire/skills/forks/forks.py where` → exit 0, one line, one JSON object, `ok: true`, binary 2.1.299, `warnings: []`.
-  - Leftover processes: none (`Get-CimInstance Win32_Process` by command line: the tests' temp prefix, `_supervise`, `poscontrol`; only the sweep itself matched); also the suite's `tearDownModule`.
-  - No live `claude` calls (stub only).
-- Existing tests changed (none loosened):
-  - `CliTests.test_phase2_not_implemented`: `tick` removed (implemented now); `test_commands_need_init` gains `tick`.
-  - `LaunchTests.test_kill_tree_and_no_visible_window` → `test_kill_tree` without the window block; the window assertions moved, widened, into `test_no_visible_window`; `assertGreater(len(all_windows), 0)` became a skip (M8's specified change).
-  - `LaunchTests.test_wait_exit_codes`: `running[0]` key set has `messages` instead of `turns` (M16).
-  - Stub: `error` still bills nothing unless `billed` is given.
-- Deviations from plan (digest):
-  - TTL after a read-only call (or one with no cache activity) keeps the previous known TTL, also when that was 300. The digest's literal rule gives the configured `ttl_s` there (3600). A read of a 5-minute entry keeps it a 5-minute entry, and reporting 3600 would show a 5-minute base as warm for an hour (no ping, an unannounced cold start). With nothing known, the configured `ttl_s` applies, as the digest says.
-  - M16 goes beyond the job file: `wait`'s `running[]` and `list`'s running rows say `messages`, because they expose the same counter. This changes the Phase 1 digest's `running: [{…, turns}]` shape.
-  - Pings read launch fields via `launch_record(base, cfg)` = `base.launch` if present, else `cfg.launch`. No base has its own record until 2.2 (M10); `fork`/`continue` still build from `cfg.launch` and are 2.2's to switch.
-  - `wait` ticks at its start as well as every 30 s, so every `wait` call is a tick point (short waits would otherwise never tick).
-  - `wait` refuses an explicit ping job id (exit 2) instead of silently routing it.
-- Flagged for review (semantics I chose):
-  - Activity: a fork/continue job running now or ended within 600 s, or `run.last_wait_at` within 600 s. `tick --run` by hand is not activity and does not stamp `last_orchestrator_call_at`.
-  - "Pings since the last real call" is by job number (launch times have whole seconds); every ping status counts.
-  - `break_even` uses the 1 h write ratio for any TTL > 300, the 5 min one otherwise.
-  - Ping job: `PING_MAX_S` = 300 s wall limit, `block`/`phase` null, cost and `modelUsage` basis = the base's cumulative (like a fork), cwd = the launch cwd, `head_at_launch` null.
-  - The binary check for a ping runs before the lock (subprocess `--version`); a missing binary skips that base with `why: binary_missing` and records no job. A base that turns eligible between the unlocked look and the locked one waits for the next tick.
-  - The supervisor's tick runs in its own loop, synchronously: a ping launch holds that loop for the CIM spawn (1–3 s). The supervisor's `os.environ` is the child env (`SPIRE_FORKS_CHILD=1`), so `tick_pass` has no N3 check of its own; N3 is enforced by the `tick` command and by `wait` skipping its tick in a fork.
-  - A supervisor ticks first after 60 s: jobs shorter than that never tick from their supervisor (`wait` covers them).
-  - `last_hit` from a ping is set at finalise, not as the first event arrives (the refresh depends on the final status and the verdict).
-  - The TTL is inferred from every call with a `result`, failed ones included; killed/lost calls (no result) leave it.
-  - M8: the positive control is minimised and not activated (`SW_SHOWMINNOACTIVE`, still `IsWindowVisible`) so it does not take focus. The desktop-wide diff fails the test if the user opens a console or Terminal window during the ~1 s sample window.
-  - In-process supervisor test prints a `ResourceWarning` for the `claude` stdout pipe that `Supervisor.run` never closes (pre-existing, harmless in the real detached supervisor).
-- Not tested: a ping launched by a supervisor's own tick end to end (the supervisor's tick is tested with a recording `tick_pass`; the launch path is the same function, tested from `wait`'s tick and `tick --run`); real `claude` with `--max-turns 1` through the helper (P0.6 used it by hand); POSIX.
-- Left for later: `rebase`, `rebase_due`/`retrain_due` reasons, per-base launch records (2.2); `usage` (2.3).
-- Expected broken: `rebase`, `usage` exit 2 "not implemented" (2.2, 2.3).
-- Commits: `fff43a0` (code and tests), then this note's commit.
-
-### Block 2.2 — Rebase and re-train flags
-
-- Model: `claude-opus-5-5[1m]`
-- Start / end: Fri Oct 16 17:01:30 WEDT 2026 / Fri Oct 16 17:23:20 WEDT 2026 (`date`; the end is the code commit, this note followed)
-- Done (`forks.py`, `templates/rebase.md` (new), `tests/test_forks.py`):
-  - **`rebase --run R --base B --as NEW --brief FILE [--phase N] [--max-minutes] [--max-budget-usd]`**: a fork of B (`--resume <B session> --fork-session --session-id <new>`, B's launch record), prompt `templates/rebase.md` (absorb the listed notes and diffs, do not change code or commit, update the trunk notes if the brief names a path, reply `READY`) + delta header + brief. Returns `{job, base: NEW, parent: B, session_id}`. On `ok` the finaliser creates NEW (`active`, `parent`, `lineage_rebases` = B's + 1, `base_commit` = HEAD at the end, `context_tokens` from the last assistant message, `launch` = B's record with the binary it ran under, `fingerprint`, `overrides` inherited, `phase` = `--phase`, `last_hit` = the call's last assistant event, `runtime_fingerprint` of the call, cost cumulative, `rebase_job`) and sets B `superseded` (`superseded_by`). Any other status: B stays `active`, NEW is never created. Counts toward `parallel_cap` (`CAPPED_KINDS`), N3-refused, refuses launch-field overrides, a non-active B, an existing (non-failed) NEW, a NEW a running rebase will create, a B already being rebased; `train` also refuses a name a running rebase will create. Cache verdict and `cold_start` as a fork's (against B's context); its first event refreshes B's `last_hit`.
-  - **`rebase_due` reasons** (`due_flags`): `phase_boundary`, `commits:<n>` (`git rev-list --count <base_commit>..HEAD` > `rebase_commits`), `lines:<n>` (`git diff --shortstat <base_commit>` insertions + deletions > `rebase_lines`), `delta_tokens:<n>` ((delta header + listed notes) chars // 4 > `rebase_delta_tokens`), `binary_drift`, `runtime_drift:<fields>`. **`retrain_due` reasons**: `defining:<fields>`, `max_base_tokens:<n>`, `rebases:<n>` (≥ `max_rebases`), `binary_missing`. On `fork`'s launch return (fixed shape, `reasons` = rebase reasons then retrain reasons) and per active base in `list`. `fork`, `continue` and `rebase` refuse `binary_missing` with exit 2 (the refusal carries `reason`, `retrain_due: true`, `reasons: ["binary_missing"]`), `train` refuses with `reason: binary_missing` when its binary is gone, and a tick skips the base (`why: binary_missing`, as in 2.1).
-  - **`init` after bases exist** is allowed (replaces Phase 1's refusal): the config is replaced, the output gains `bases`; a base without its own record (from before 2.2) first gets the old config as its record. This is the input path of `defining:`.
-  - **M10**: `train` takes `--model --effort --permission-mode --tools --allowed-tools --disallowed-tools --agent --cwd --binary` as overrides, validated by the same `build_launch` as `init` (alias refusal, plan refusal, C8 admission, agent file, binary). The base stores `launch` (its record), `fingerprint` (hash of it) and `overrides` (sorted field names given). `fork`, `continue`, `rebase` and pings build their command line, cwd, delta header and `model_requested` from `launch_record(base)`.
-  - **M6**: the runtime fingerprint adds sorted `skills`; a plugin without a version is `name@path:<last path segment>` (`name@` with no path). A reference without `skills` (a pre-M6 base) is not compared on it. Drift shows as `runtime_drift:<fields>`.
-  - **M7**: `fingerprint_hash` hashes `fingerprint_view(launch)`: the mcp entry becomes its content `{"strict": true, "servers": {}}`; the path stays in the config. Same launch → same hash in any run.
-  - **M11**: entries record `created_ts` (precise); a result's `note` is set only when the note's mtime ≥ `created_ts` − 2 s (`NOTE_MTIME_SLACK_S`, for coarse Windows file times).
-  - **M13**: a `/`-rooted path that is not a drive form (`/tmp/x`, `/usr/...`) goes through `cygpath -w` (`find_cygpath()`, patchable); no cygpath or a failing one → exit 2 naming the path. Native `\x` keeps its Windows meaning; `//server/...` is untouched.
-  - Stub: the init event carries a versionless `skill-creator` plugin and `skills`; directives `nover=<segment>`, `skill=<name>`.
-  - Tests: 10 new (112 total). `PathTests`: M13 without cygpath (refusals, drive forms unaffected, `init --run /tmp/...` exit 2 with nothing on the cwd's drive) and with a fake cygpath (called with `-w`, drive forms skip it, failing cygpath refused, the real cygpath on this host does not give `G:\tmp\x`). `InitTests`: M7 (two runs, different mcp paths, equal hash; same hash from a second process; content counts). `RuleTests`: M6 (versionless path segment, skills, order-insensitive, pre-M6 reference), M11 boundaries. `LaunchTests`: every reason alone through `fork`'s launch return (clones of a trained base, spawn stubbed for the fork launches; `runtime_drift` from a real stub fork; `max_base_tokens` from the stored context and from a synthetic transcript with a 64-byte tail window; `binary_missing` refusal) and the base-level ones in `list`; `train` overrides recorded and used by fork and continue, `init` model change → `defining:model` only on the base that did not override it, override validation; M11 end to end (old note, note written during the job, continue); `rebase` end to end (phase boundary → rebase → new base active / old superseded → fork of the new base `hit` against the new context → failed rebase leaves the base active, nothing created → refusals, N3 → binary drift recorded by the next rebase); rebase in the cap, blocking a second rebase and a `train` of its name, killed → base active, nothing created.
-- Gates:
-  - G-unit `uv run plugins/spire/skills/forks/tests/test_forks.py` → exit 0, `Ran 112 tests in 119.326s` / `OK` (17:18); final run exit 0, `Ran 112 tests in 120.043s` / `OK` (17:21:09–17:23:10), after the `phase_boundary` change below. No test skipped on this host.
-  - G-where `uv run plugins/spire/skills/forks/forks.py where` → exit 0, one line, one JSON object, `ok: true`, binary 2.1.299, `warnings: []`, `spawn: cim-hidden`.
-  - Leftover processes: none (`Get-CimInstance Win32_Process` by command line: the tests' temp prefix, `_supervise`, `poscontrol`; only the sweep's own shell matched); also the suite's `tearDownModule`.
-  - No live `claude` calls (stub only).
-- Existing tests changed (none loosened; each is a specified change):
-  - `InitTests.test_changed_values_after_base_refused` → `test_changed_values_after_base_allowed`: the digest lets `init` change config after a base exists, so the exit-2 / "base exists" / bytes-unchanged assertions became: exit 0, `changed`, `launch.effort` in `changed_fields`, `bases == ["B1"]`, config updated, the record-less base got the old config as its record. The "identical values → unchanged" check stays (now also bytes-equal).
-  - `PathTests.test_windows_forms`: the case `/tmp/x → G:\tmp\x` removed (M13 forbids it); the two new M13 tests cover that input.
-  - `CliTests.test_phase2_not_implemented`: `rebase` removed (implemented); `test_commands_need_init` gains `rebase`.
-  - `LaunchTests.test_train_fork_continue_end_to_end`: the note `notes/1.1.md` is now written right after the fork launches (the fork gets `sleep=1`), because M11 counts only notes written during the job; its assertions are unchanged.
-  - `LaunchTests.test_refusals`: the launch-field override loop also covers `rebase`.
-- Deviations from plan (digest):
-  - The new base always records the binary the rebase ran under (current version/size/mtime). Without drift that equals B's record, so this is the digest's rule written once.
-  - `rebase` returns train's shape plus `parent`.
-  - None against the build plan.
-- Flagged for review (semantics I chose):
-  - `phase_boundary`: the literal "or" — the fork's phase > the highest phase of the base's forks, **or** > the base's own phase; a side that is unknown does not count; integer phases only. So forks of phase 2 from a base of phase 1 keep reporting it until a rebase. Fork jobs of any status count; continues and rebases do not. A rebased base's phase is `rebase --phase`, else `null` (not inherited).
-  - `delta_tokens`: "notes listed in the brief" = every `*.md` token in the brief that resolves to an existing file (absolute; else under the base's cwd; else under the state dir), each once; the brief itself is not counted. `list` (no brief) counts the delta header only.
-  - `lines` is the working tree against `base_commit` (uncommitted changes count), as `git diff --shortstat <base_commit>` gives.
-  - `runtime_drift`: "the last call on this base" = the highest job number with this base that reported an init event, any kind but `train` (forks, continues, pings, rebases); calls without an init event (killed early, spawn failed) are skipped. Stored per job as `runtime_drift` (null when no init).
-  - `defining:` field names: `model, cwd, tools, permission_mode, agent, append_system_prompt` (the preamble is reported as `append_system_prompt`, as the existing launch drift names it), comma-joined in one reason. Effort, allowed/disallowed tools and binary are not defining (the digest's list). The agent is re-hashed from `<cwd a launch would use>/.claude/agents/<name>.md`; a missing file differs.
-  - `max_base_tokens`: transcript `<~/.claude/projects>/<cwd with non-alphanumerics → '-'>/<session>.jsonl` (`CLAUDE_PROJECTS_DIR` overridable), read from the tail (256 KiB, growing ×4); stored context when absent. Only tested with a synthetic transcript.
-  - `list` computes the flags for `active` bases only (others `false` / `[]`); per active base 4 git calls, plus one `--version` per distinct binary path.
-  - `train`: a field not given comes from the config at train time; the whole record is rebuilt and re-validated even without overrides (C8 admission runs again; the binary's current version/size/mtime are recorded). `--tools` alone does not re-derive `allowed_tools`. There is no way to clear the config's agent on `train`. Train results no longer report `drift:binary` against the init config (the base records the binary it trained with).
-  - A rebase that ends `ok` after its NEW name was taken by another base (only possible through a failed-name `train`) creates nothing, leaves B active and notes `rebase_conflict` on the job entry. Untested.
-  - A rebase's first event refreshes B's `last_hit` also when the rebase then fails (it read B's prefix). NEW's `training_cost_usd` is the rebase's cost delta; its forks' cost basis is the rebase's cumulative total.
-  - Rebase jobs are not "activity" for the ping rule (2.1's rule unchanged: fork/continue running or ended in 10 min, or a `wait`).
-  - M11's 2 s slack: a note written up to 2 s before the job was created still counts.
-  - M7: the hash view uses the constant empty server set (the helper always writes `mcp-empty.json` itself). Registries from before 2.2 get a new `fingerprint` value on the next changed `init`.
-  - M13: paths in a brief that would need cygpath and cannot be converted are skipped by `delta_tokens`, not refused.
-- Not tested: the `rebase_conflict` path; `defining:` for `agent`, `append_system_prompt`, `cwd`, `tools`, `permission_mode` (only `model` is tested end to end; the comparison code is shared); `train --cwd`/`--agent`/`--binary` overrides; a base from before 2.2 in `list`/`fork`; a real transcript; `rebase` with a real `claude`; POSIX.
-- Left for later: `usage` (2.3).
-- Expected broken: `usage` exits 2 "not implemented" (2.3).
-- Commits: `5fda2e2` (code, template and tests), then this note's commit.
-
-### Block 2.3 — Usage rendering
-
-- Model: `claude-sonnet-5-5`
-- Start / end: Fri Oct 16 17:27:48 WEDT 2026 / Fri Oct 16 17:35:17 WEDT 2026 (code commit; this note follows)
-- Done: `usage --run R [--block ID | --phase N] [--format json|md]` in `forks.py` (the "not implemented" stub is gone; `--block` and `--phase` are mutually exclusive; `PHASE2_COMMANDS` is now empty, so `usage` no longer tolerates unknown arguments).
-  - **R1**: `reconcile_ledger` runs first in every `usage`. It lists `results/*.json`; when every one has a ledger line it returns without taking the lock. Otherwise, under the registry lock, it re-reads the ledger and appends a line for each result without one (`ledger_append` dedupes on job id). The line is rebuilt from the result plus its registry entry (`started`, `ended`, `binary`, `cost_cumulative_usd`; `None` when there is no entry) and carries `"reconciled": true`. Corrupt result files are skipped with a stderr note. The json output lists the job ids appended in `reconciled`.
-  - json: `kinds` (all five, zeros when unused: `calls`, `input`, `output`, `cache_creation`, `cache_creation_1h`, `cache_creation_5m`, `cache_read`, `cost_usd`), `total`, `cold_starts`, `cache_hits`, `cache_verdicts`, `cache_hit_ratio` (hits / fork+continue+rebase calls with a verdict; `null` when none), `rows` = the ledger lines in scope in job order, `scope`, `reconciled`.
-  - md `--block`: one table with the fixed header, one row per call of the block (fork, its continues); thousands separators, `$0.0000`, session first 8 chars, null usage renders `—`. md `--phase` (and no scope): the per-kind table (kinds with calls only) plus a `total` row, then three bullets: cold starts, cache-hit ratio `h/n (p%)`, priced total.
-  - **Commit column**: the short hashes (7) of `git rev-list --reverse <head_at_launch>..<head_at_end>` in the job's cwd, comma-joined; `—` for a parallel fork, for no commits, or when either HEAD or git is unavailable.
-  - **`head_at_end`**: new registry job field. The supervisor passes `_git_head(cwd)` to `finalize_job(head_at_end=...)` after claude exits (all kinds); `finalize_job` reads HEAD itself for a fork/continue that is killed or lost.
-  - `--format md` stdout is written as UTF-8 bytes on `sys.stdout.buffer` (the header's `Δ` is not in cp1252); errors stay one JSON object, exit 2. `usage` is allowed under `SPIRE_FORKS_CHILD`.
-- Tests (new `UsageTests`, 18; one added to `LaunchTests`): md `--block` and `--phase` against a fixed ledger fixture (exact text), parallel Commit `—`, null usage `—`, unknown block (header only), json totals per kind and overall and by scope, errors stay JSON, N3, UTF-8 under `PYTHONIOENCODING=ascii:strict`, R1 (one line for a result without one, none for a result that has one, none on a second `usage`; no registry entry; torn ledger tail; waits for a held lock; no lock when nothing is missing; corrupt result), and `head_at_end` end to end with the stub (a commit made during a sequential fork shows in the Commit cell).
-- Existing tests changed (none loosened): `CliTests.test_phase2_not_implemented` removed (its only case was `usage`, now implemented); `test_commands_need_init` gains three `usage` cases (it asserts exit 2, one JSON line, and no state dir created).
-- Gates: G-unit `uv run plugins/spire/skills/forks/tests/test_forks.py` — exit 0, 130 tests, 131 s; G-where `forks.py where` — exit 0, one JSON line; leftover-process check by command line (`forks-test-` prefix, `_supervise`) — none.
-- Deviations from plan: none against the build plan or the digest. The Commit column lists hashes (build plan: "lists the commits"); the digest says "commits between", which I read the same way.
-- Flagged for review (semantics I chose):
-  - A whole-run `usage --format md` (no scope) renders the phase layout (table + three bullets).
-  - Call counts include calls with null usage (killed, lost): they add to `calls` and nothing to the sums. The cache-hit denominator counts only calls that have a verdict.
-  - The md phase table omits kinds with zero calls; the json `kinds` always has all five.
-  - `ledger_from_result` for a reconciled line takes `ended` from the registry entry, else from the result file's mtime; `cost_cumulative_usd` is `None` when the entry has no `cost_cum_usd`. R1 also reconciles a result whose registry entry still reads `running` (kill between the result write and the registry write); the later finaliser/`reap_lost` then finds its ledger line present and appends none.
-  - `usage` stamps `last_orchestrator_call_at` like `list` (via `touch_orchestrator`; a fork's call does not).
-  - `head_at_end` is HEAD of the job's cwd when the call ended, so with several forks on one tree it can include another fork's commit; only a sequential fork's Commit column is shown for that reason.
-- Not tested: `usage` over a ledger with `rebase` calls (same code path as the other kinds); a real `claude` run; POSIX.
-- Left for later: none for 2.3.
-- Expected broken: none.
-- Commits: `4b92b51` (code and tests), then this note's commit.
-
-### Block 2.4 — Phase tests and live smoke
-
-- Model: `claude-opus-5-5[1m]` (the Athanor, own Bash; no fallout agent needed)
-- Start / end: 2026-10-16 17:36:23 +0200 / 17:44:04 +0200 (`date`)
-- Phase-end tests: the full G-unit ran once after the last code change of Phase 2 (17:36, after 2.3): exit 0, `Ran 130 tests in 130.584s`, OK; G-where exit 0. No code changed after it, so per the new cadence it was not re-run.
-- Live smoke per plan §7 "Phase 2 tests and smoke", scratch clone (HEAD `a54bb59`, clean), run log `…\headless-forks-p0\smoke2\2026-10-16-17-smoke2-run.md`, model `claude-opus-5-5`, every `wait` from Bash with `timeout: 600000`, briefs in `…\smoke2\brief-*.md`:
-  - `init` (defaults) → `train B1 --phase 1` → `wait` exit 0: `ok`, base context 23,676, $0.2099.
-  - `fork P1 --phase 1` (commit) → `wait` exit 0: `hit` (first read 23,674), clone commit `9002b6a`, $0.0997.
-  - `fork P2a --phase 2` from B1 → launch return `rebase_due: true`, `reasons: ["phase_boundary"]` (it ran anyway, as the flags are advisory: `hit`, $0.0163).
-  - `rebase --base B1 --as B2 --phase 2` → `wait` exit 0: `ok`, kind `rebase`, first read 23,674 (B1's prefix), $0.0336. `list`: B1 `superseded` (`superseded_by: B2`), B2 `active`, `parent: B1`, `lineage_rebases: 1`, `base_commit` `9002b6a`, context 25,279.
-  - `fork P2b --phase 2` from B2 (commit) → `wait` exit 0: `hit`, first read **25,277 of B2's 25,279**, `rebase_due: false`, clone commit `a0837be`, $0.0951.
-  - Ping: `init --warm-margin-s 3500` (config change after bases exist: `changed_fields: ["warm_margin_s"]`) so B2 turns `expiring` 100 s after its last hit. A `wait` at 17:41:57 ticked and launched ping `j0006` (`base_state: expiring` at launch); the next `wait` returned it in `pings` (not `done`): `ok`, `hit`, first read 25,277, $0.0087. B2's `last_hit` moved 17:40 → 17:42:00, state back to `warm`. A second ping `j0007` at 17:43:5x: `ok`, `hit`, $0.0052.
-  - `usage --phase 1 --format md`, `--phase 2`, `--block P1`, `--block P2b`, and json for the whole run all exit 0; outputs saved in `…\smoke2\usage-*.md|json`. Phase 1 md:
-
-    | Kind | Calls | in | out | cache write | cache read | cost |
-    |---|---|---|---|---|---|---|
-    | train | 1 | 4 | 855 | 23,674 | 16,913 | $0.2099 |
-    | fork | 1 | 12 | 1,888 | 3,892 | 153,622 | $0.0997 |
-    | total | 2 | 16 | 2,743 | 27,566 | 170,535 | $0.3096 |
-
-    Cold starts 0, cache-hit ratio 1/1, priced total $0.3096. Block P1 row: `| P1 | claude-opus-5-5 | eb446d8f | 9002b6a | 12 | 1,888 | 3,892 | 153,622 | $0.0997 |` (the Commit cell is the fork's real commit). Phase 2: rebase 1 ($0.0336), fork 2 ($0.1114), total $0.1450, hit ratio 3/3. Whole run (json, before the second ping): 6 calls, $0.4633, `reconciled: []`.
-  - All seven calls ran 2.1.299. **No visible window**: checked during ping `j0007` (supervisor, `claude.exe`, a `git.exe` child, three `conhost.exe`): no visible window of the tree and none on the desktop.
-  - Processes after the smoke (17:44, by command line `_supervise`, `forks-test-`, `smoke2`, `poscontrol`): none.
-- Deviations from plan: the "let one base sit into expiring" step used the new `init --warm-margin-s` tunable (3500 s) instead of a 54-minute wait; the cache itself stayed on its real 1 h TTL, so the pings were real hits.
-- Flagged for review:
-  - Pings have `phase: null`, so `usage --phase N` leaves them out; they appear only in the whole-run `usage`. The phase-close table therefore under-reports keep-warm cost unless the whole-run figure is pasted too.
-  - The superseded B1 still shows `base_state: expiring` in `list` (computed for every base); no ping went to it (`status` gate), as expected.
-  - Ping `j0006` read 25,277 of B2's 25,279 (`hit`); the P0.6 partial-ping case was not reproduced live (a 1-hour wait); the unit tests cover it.
-- Commits: run log only (this note and the Phase 2 close).
-
-### Phase 2 close
-
-- Gate: G-where exit 0 after every block; between-block gates were full G-unit runs until the 17:36 cadence instruction (logged above).
-- Tests: G-unit once at phase end (17:36) — exit 0, 130 tests, 130.6 s. Live smoke — every plan §7 Phase 2 criterion met (above). No fallout block.
-- Flags for the reviewer (each with its block; details in the notes):
-  - Digest: `docs/workpad/plans/2026-10-16-16-headless-forks-phase2-contract.md` is Athanor-written and pins the ping rule details, the rebase/retrain reason vocabulary, `init` accepting changes after bases exist (replacing Phase 1's refusal), `--warm-margin-s`, and the block assignment of the folded items. Check it against the build plan.
-  - 2.1: read-only calls keep the previous TTL even when it was 300 (deviates from the digest's literal rule); `messages` also renames `wait`/`list` running fields; pings use the base's record if present; `wait` ticks at its start; naming a ping job in `wait` exits 2; activity definition (`run.last_wait_at`, fork/continue in the last 600 s); ping counting by job number, every status counts; `break_even` uses the 1 h ratio above 300 s; ping wall limit 300 s; a missing binary skips the base; the supervisor's tick pauses its loop 1–3 s; a ping's `last_hit` set at ping end; the M8 positive control opens minimised; a pre-existing `ResourceWarning` (stdout pipe left open in `Supervisor.run`); untested: a ping launched by a supervisor's own tick, a real `--max-turns 1` call through the helper (the smoke now covers this: `j0006`, `j0007`), POSIX.
-  - 2.2: `rebase` returns train's shape plus `parent`; the new base always records the binary the rebase ran under; `phase_boundary` follows the digest's "or" literally; a rebased base's phase is `--phase`; `delta_tokens` counts existing `*.md` paths in the brief; `lines` includes uncommitted changes; "last call" for `runtime_drift`; `defining:` field set (effort and allow/deny lists are not defining); the transcript read from the tail; `list` computes flags for active bases only (the smoke shows `rebase_due: false` on the superseded B1, consistent); `train` re-validates the whole record; a rebase's first event refreshes the old base's `last_hit` even if the rebase then fails; M11 has 2 s slack; untested: `rebase_conflict`, `defining:` for fields other than model, `train --cwd/--agent/--binary` overrides, bases created before 2.2, a real transcript, POSIX.
-  - 2.3: call counts include killed/lost calls; the md phase table omits zero-call kinds; R1 also reconciles a result whose registry entry still reads `running`; `usage` stamps the orchestrator call (not from a fork); `head_at_end` can include another fork's commit, so Commit is only shown for sequential forks; untested: a ledger with `rebase` calls (the smoke now covers this: phase 2 md has a `rebase` row), a real run (covered by the smoke), POSIX.
-  - 2.4: the three flags in its note.
-- Not run / untested: the partial-ping refresh live; supervisor survival past the Athanor's hand-back; POSIX; a large base through the helper.
-- Spend (Phase 2): live smoke $0.4685 client estimate (7 calls: train, 3 forks, rebase, 2 pings). Unit tests spend nothing. Subagent tokens: 2.1 320,462; 2.2 350,639; 2.3 187,248 (harness totals); the Athanor's own unknown.
-- Processes at hand-back: none.
-- Status: provisional until review, fix pass and re-check close.
-
-### Phase 2 fix pass
-
-- Model: `claude-opus-5-5[1m]` (fixer, own tools, no agents dispatched)
-- Start / end: Fri Oct 16 17:58:54 WEDT 2026 / Fri Oct 16 18:10:44 WEDT 2026 (`date`; the end is the code commit, this note followed)
-- Review: `docs/workpad/reports/2026-10-16-18-headless-forks-phase2-review.md`. Fixed: I1, I2, Minors 1, 2, 8, 9, 10, 11. Not touched: Minors 3–7, 12–14.
-- Done, per finding (every new or changed test fails on the unfixed `9564c22` helper: the 11 touched tests run against it in a scratch copy with the new test file give 9 failures and 3 errors; the one that passes there, `test_tick_runs_in_wait_and_supervisor`, prints the `ResourceWarning`):
-  - **I1** `delta_tokens` — `_NOTE_REF`/`listed_notes` (the "every `.md` path in the brief" scan) are gone. New rule (Athanor decision): chars/4 of (a) the delta header, (b) the notes attached with the new repeatable `fork --delta-note PATH` (also on `rebase`) whose mtime is after the base's `trained_at`, (c) the body of a `## Changes since base` section of the brief (case-insensitive heading, up to the next level-1/2 heading). Files a brief only names and the rest of the brief never count. All attached notes go into the prompt after the delta header, each under `#### \`<path>\`` (rendered into the existing `${delta}` of `templates/fork.md` and `templates/rebase.md`; the template files are unchanged). An unreadable note is refused (exit 2). Entries record `delta_notes`. `list` still counts the delta header alone. Test: `LaunchTests.test_delta_tokens_counts_only_what_the_base_does_not_know` (a brief naming two 80k-char docs in the cwd and an 80k `notes/1.1.md`, one also as an absolute path: nothing due; a 60k attached note: `delta_tokens` and the note with its path in the prompt's delta section; a small note: nothing; a missing note: exit 2; the same note against a base with `trained_at` after its mtime: nothing; a 60k `## Changes since base` section: `delta_tokens`, the same text under `## Background`: nothing; `rebase --delta-note` carries the note in its prompt, and the new base's forks no longer count it).
-  - **I2** ping phase — `ping_phase(reg, base)`: the phase of the latest (by job number) train/fork/continue/rebase job on the base that has one, else the base's own phase, else null; `tick_pass` records it on the ping entry, so result, ledger and `usage --phase N` carry it. Test: `TickTests.test_ping_carries_the_phase_and_counts_in_usage_phase` (fallbacks; a phase-2 fork after a phase-less train → ping phase 2; finalised `ok` with cost Δ $0.0123; `usage --phase 2` json lists it with the cost in `kinds.ping` and `total`, md has the `ping` row, the total row and `Priced total: $0.0123`; `--phase 1` has no rows).
-  - **Minor 1** — `train --supersedes BASE` (repeatable). Refused at launch (exit 2, before and again under the lock): an unknown name (`unknown base`, `bases`, `option`), the new base's own name. The names are stored on the training base (`supersedes`); when the training ends `ok`, each named base that is `active` becomes `superseded` with `superseded_by`, `superseded_at`. A failed training changes nothing. Test: `LaunchTests.test_train_supersedes` (refusals; a failed training leaves B1 active; an ok one supersedes B1 and B0, leaves the failed B2 alone; B1's ping decision reads `status:superseded`; a fork of B1 needs `--force`).
-  - **Minor 2** — `init` refuses an effective `warm_margin_s` ≥ the effective `ttl_s` (exit 2, nothing written; also a re-run that lowers `ttl_s` under the current margin). `base_warmth`: a configured margin is capped at the base's TTL / 2 (the formula is unchanged). Tests: `InitTests.test_warm_margin_must_be_below_ttl`, `WarmthTests.test_margin_capped_at_half_the_ttl` (TTL 300, margin 600: `warm`, `margin_s` 150 one second after the hit; `expiring` and a ping at 150 s).
-  - **Minor 8** — every `init` flag defaults to None. First init: the defaults as before (`--model` missing → exit 2, `error: usage`, as argparse said). Re-run: an omitted flag keeps its current value, launch fields (model, effort, permission mode, tools, allow/deny lists, agent name, cwd, binary path with its `binary_resolved_by`) and run-wide settings (`parallel_cap`, `orphan_after`, `pings`, `ttl_s`, `warm_margin_s`, `max_minutes`, `stall_after_s`, each threshold). `init` reads the config before validating and refuses (exit 2) if it changed before the locked write. Test: `InitTests.test_rerun_keeps_omitted_settings` (a re-run with only `--warm-margin-s` keeps `pings off`, `parallel_cap` 3, `orphan_after` 1500, `rebase_commits` 9, the model, effort and tools; `changed_fields == ["warm_margin_s"]`; a later `--pings on` alone lists `["pings"]`; a first init without `--model` writes nothing).
-  - **Minor 9** — `UsageTests.test_r1_waits_for_the_registry_lock` calls `reconcile_ledger` directly in a thread and also checks that no line was appended while it is blocked, and exactly one after. Confirmed it can fail: a scratch runner (`m9_nolock.py`) patched `forks.RegistryLock` to a no-op only when called from `reconcile_ledger` (the test's own lock stays real): the test fails (`[['j0010']] != []`).
-  - **Minor 10** — `Supervisor.run` closes `p.stdout` after `reader.join` when the reader thread has ended. `test_tick_runs_in_wait_and_supervisor` no longer prints the `ResourceWarning` (run alone and in the full suite; the full log has no warning line).
-  - **Minor 11** — the ledger stays append-only. `usage` takes `status`, `flags` and `reason` from `results/<job>.json` when any differs from the ledger line (tokens and cost stay the ledger's) and lists those jobs in the json's new `status_from_result` (always present). The aggregates use the result's flags (`cold_starts`). Test: `UsageTests.test_status_from_result_when_it_changed_after_the_ledger_line`.
-- Existing tests changed (none loosened; each is a specified change):
-  - `WarmthTests.test_boundaries_1h_and_5m`: margin 900 at a base TTL of 300 was `expiring` from the hit on; it is now capped at 150 (`warm` at 0 and 149 s, `expiring` at 150 and 299 s, `cold` at 300 s, `margin_s` 150). The 1 h cases are unchanged.
-  - `WarmthTests.test_ping_rule_states_status_and_pings_off`: the margin-3600 case pinged at T0+100; with the cap (1800 at 1 h) it pings at T0+1800 and reads `state:warm` at T0+1799.
-  - `UsageTests.test_r1_waits_for_the_registry_lock`: see Minor 9 (stronger).
-  - `LaunchTests.test_ping_end_to_end_through_wait`: `--warm-margin-s 3600` is now refused; uses 1800 with the last hit set 2000 s back instead of 100 s. Its assertions are unchanged.
-  - `LaunchTests.test_due_reasons_each_alone`: the 60k note trips `delta_tokens` when attached with `--delta-note`; the brief that only names it now asserts nothing due (I1). Its `delta_tokens` assertions are unchanged.
-- Gates:
-  - G-unit `uv run plugins/spire/skills/forks/tests/test_forks.py`, run once (18:08:03–18:10:23): exit 0, `Ran 137 tests in 139.525s`, `OK`, no skip, no warning line (130 → 137: 7 new tests).
-  - G-where `uv run plugins/spire/skills/forks/forks.py where`: exit 0, one line, one JSON object, `ok: true`, `spawn: cim-hidden`, binary 2.1.299 via `CLAUDE_CODE_EXECPATH`, `warnings: []`.
-  - Leftover processes (18:10, `Get-CimInstance Win32_Process` by command line: `forks-test-`, `_supervise`, `poscontrol`): none.
-  - No live `claude` calls (stub only).
-- Flagged for the re-check:
-  - I1: every attached note goes into the prompt; only those newer than `trained_at` count. `trained_at` has whole seconds, so a note written in the same second as the training or rebase end counts as new (the safe side).
-  - I1: the `## Changes since base` section does not depend on the base; a brief reused after a rebase with a large section still trips the flag. The Athanor writes that section per base.
-  - I2: the rebase job belongs to the old base, so a rebased base's pings take its forks' phase or its own phase (`rebase --phase`). Pings recorded before this fix keep `phase: null`.
-  - Minor 2: the smoke's `init --warm-margin-s 3500` would now be refused; at a 1 h TTL the effective margin is at most 1800. The Phase 3 text and any smoke recipe must use that.
-  - Minor 8: on a re-run, `--tools` alone keeps the current `allowed_tools` (it does not re-derive it, like `train`, Minor 12). What `init` reads from disk (binary version, size and mtime; preamble and agent hashes) is re-read on every run as before, so it can still show in `changed_fields` when those files changed. A set `warm_margin_s` or agent cannot be cleared back to none by `init`.
-  - Minor 10: the pipe is closed only when the reader ended within `READER_JOIN_S`; otherwise it is left as before.
-  - Minor 11: a reconciled ledger line is not rewritten; only `usage`'s view changes. The md block table does not show status, so only the json `rows` and the aggregates' flags show it.
-- Commits: `d2d5104` (code and tests), then this note's commit.
-
-### Phase 2 fix pass — Athanor check, deferred Minors, recorded deviation
-
-- Athanor `claude-opus-5-5[1m]`, 2026-10-16 18:13 +0200 (`date`). Fixer: fresh general-purpose agent, `opus` alias, stamped `claude-opus-5-5[1m]`, 297,949 subagent tokens (harness total).
-- Cheap gate by the Athanor (test cadence: the fixer ran the full suite once at its end, 137 tests, 139.5 s, OK; not repeated): `uv run python -m py_compile …/forks.py` exit 0; G-where exit 0. Leftover processes by command line: none.
-- Diff check `9564c22..d2d5104` on the tests: two removed assertion lines. `done[0]["reconciled"] == ["j0010"]` became `done == [["j0010"]]` plus a check that the line is absent while the lock is held and present exactly once after (Minor 9: stronger). `assert_due(fake_fork("Bd"))` for a brief that names the big note is kept as a not-due assertion, and the due case moved to `--delta-note` (I1: specified change). The changed warm-margin tests follow Minor 2's cap. Nothing loosened.
-- **Recorded deviation (review flag 1a)**: the Phase 2 digest put `rebase` into `parallel_cap` (`CAPPED_KINDS`, `forks.py`), while plan §4.3's invariant names only `fork`/`continue`. Stricter and harmless (a rebase is a fork of the base doing real work); the Phase 2 block notes and close wrongly said "no deviation against the build plan". The Phase 3 text should state that `rebase` counts toward the cap.
-- **Athanor decision in the fix brief (I1)**: the coordinator offered `--delta-note` or a designated brief section; both were built. The whole brief is **not** counted, because a brief's own text does not depend on the base and so a rebase could never clear it; only the delta header, attached notes newer than the base's `trained_at`, and a `## Changes since base` section count. The fixer flags that the section itself is base-independent (a reused brief with a large section keeps tripping the flag); the Phase 3 text should say the section is for this fork's delta only.
-- Deferred Minors (not fixed; coordinator's instruction), with reasons:
-  - **3** (failed/missed ping retried every tick with no backoff): bounded by the `break_even` cap that counts failed pings; a backoff is a tuning item for the trial (Phase 5).
-  - **4** (`partial` ping that re-wrote most of the prefix carries no `cold_start`): accounting nuance; P0.6 shows such a ping still keeps the base warm. Revisit with real trial numbers.
-  - **5** (a `continue`'s `cold_start` follows the base's warmth): Phase 1 rule; affects only the `cold_starts` count in `usage`. Fix together with Minor 4 when the trial tunes warmth.
-  - **6** (a slow synchronous tick can read as a clock jump in the supervisor): unlikely (needs > 60 s of tick work); move the tick into a thread when it is next touched.
-  - **7** (the last `wait` before hand-back can launch a ping that `list` shows as running): Phase 3 text: pings end within `PING_MAX_S` (300 s) and are not "running jobs" for the hand-back rule; or `list` reports them separately.
-  - **12** (`train --tools` / `init --tools` do not re-derive `allowed_tools`): Phase 3 text tells the Athanor to pass `--allowed-tools` with `--tools`; a code change can follow if the trial hits it.
-  - **13** (two sequential forks can overlap under `parallel_cap` 2 and share Commit cells): Phase 3 text: run sequential forks one at a time.
-  - **14** (warmth shown for superseded/retired bases; untested ping-from-supervisor-tick, `defining:` fields other than model, unreachable `rebase_conflict`; the M8 desktop diff can flake): cosmetic or covered by shared code paths; Phase 4 smoke exercises the supervisor tick live.
-- Status: fix pass done; a re-check of I1 and I2 by a fresh reviewer is Igor's call.
-
-## Successor boot — state at the end of Phase 2 (for the Phase 3 Athanor)
-
-Written by the Athanor (`claude-opus-5-5[1m]`), 2026-10-16 18:15 +0200, as its last job (Igor: Phase 3 goes to a fresh Athanor).
-
-- **Branch / checkout**: `headless-forks` in `G:\dev\projects\reliquary\.claude\worktrees\headless-forks`. HEAD after this note's commit; Phase 2 fix pass code at `d2d5104`. Nothing pushed or merged.
-- **Read in this order**: the build plan §6 Phase 3 and §4 (`docs/workpad/plans/2026-10-16-02-headless-forks-build.md`); the trunk notes (`reports/2026-10-16-08-headless-forks-trunk-notes.md`, incl. its "State for Phase 3" section); the two contract digests (`plans/2026-10-16-12-…-phase1-contract.md`, `plans/2026-10-16-16-…-phase2-contract.md`; they describe what the helper actually does, beyond the build plan); the Phase 1 and Phase 2 reviews and the Phase 1 re-check (`reports/2026-10-16-16-…`, `-17-…`, `-18-…`) for the items routed to "Phase 3 text"; this run log's block notes for exact semantics.
-- **What exists**: `plugins/spire/skills/forks/forks.py` (commands `where`, `init`, `train`, `fork`, `continue`, `rebase`, `wait`, `list`, `usage`, `expire`, `kill`, `tick`, internal `_supervise`), `preamble.md`, `templates/train.md`, `templates/fork.md`, `templates/rebase.md`, `tests/test_forks.py` (137 tests, about 140 s). No `SKILL.md` yet; manifests still 0.2.2.
-- **Gates**: G-unit `uv run plugins/spire/skills/forks/tests/test_forks.py`; G-where `uv run plugins/spire/skills/forks/forks.py where`; G-text per build plan §6 Phase 3. Test cadence (user rule): `py_compile` plus touched test classes between blocks, the full suite once at phase end.
-- **Items routed to the Phase 3 text** (collected from the reviews; each must land in `SKILL.md` or `athanor.md`):
-  - `wait` from Bash with `timeout: 600000` (C2); the Bash tool **backgrounds** a call that passes its timeout (P0.1), it does not kill it.
-  - `kill` result: key on `ok` and `status`, not `killed` or the exit code (Phase 1 M12).
-  - "Windows-tested; POSIX untested" (M14); C8 is "permissive at `init`, enforced at runtime" (M15); the post-exit sweep also kills daemons a fork started (`gpg-agent`, fsmonitor), which restart on demand (M16).
-  - `continue` sends the brief without a frame: put the commit rule and the note path into continue briefs (M16).
-  - `kill`/`expire` do not refresh the orchestrator stamp (Phase 1 M3); a fork's own `list`/`wait` never does.
-  - Never re-run `init` from a successor to "reset"; a re-run changes only the flags given (Phase 2 Minor 8); `--warm-margin-s` must stay below the TTL (at 1 h, at most 1800).
-  - Always pass `--phase` to `rebase` (review flag 23); `rebase` counts toward `parallel_cap`.
-  - Delta: attach handoff notes with `fork --delta-note PATH`; a `## Changes since base` section is for this fork's delta only (I1).
-  - Re-train: `train --supersedes <old base>` (Minor 1), else the old base keeps getting pings.
-  - Pings: they belong to the latest phase of their base and show in `usage --phase` (I2); a ping running at hand-back is not a leak (Minor 7).
-  - Sequential forks one at a time (Minor 13); pass `--allowed-tools` with `--tools` (Minor 12).
-  - `wait`/`list` running rows say `messages`; results and ledger say `turns` (M16).
-  - Projects need a `Bash(uv run:*)` (or `Bash(uv:*)`) allow rule: skill `allowed-tools` did not pre-approve in a subagent (P0.8, untrusted dir; Phase 4 re-checks in a trusted project).
-- **Open, not for Phase 3 code**: supervisor survival across an Athanor hand-back (Phase 4); POSIX; a large base through the helper; the partial-ping refresh live.
-- **Scratch** (not in git; safe to ignore): `C:\Users\g4b\AppData\Local\Temp\claude\G--dev-projects-reliquary\42c87f82-5542-46aa-8d01-4166e3f0bcfe\scratchpad\headless-forks-p0\` — probes, raw Phase 0 streams, the scratch clone (untrusted workspace; holds smoke commits), `smoke1\`, `smoke2\`.
-
-## Phase 3 — Rename to gremlins, platform seam, text, release
-
-Intake 2026-10-16 18:23 +0200, a fresh (successor) Athanor, `claude-opus-5-5[1m]`. Start commit `7351c40`. Booted per "Successor boot" above, the trunk notes' "State for Phase 3", the goal as on `main` (naming, platforms, release gating, platform seam decisions), the build plan §6 Phase 3 and the Phase 2 re-check.
-
-- First turn, by Igor's instruction: contract digest only, nothing built. Digest: `docs/workpad/plans/2026-10-16-18-gremlins-phase3-contract.md`. It pins the rename map, the `Platform` interface, the path matrix, the Windows-only gate, the N3/N4 fixes, the flaky-kill investigation, the WSL procedure, the text per file and the release; its §12 lists the 20 choices the higher sources left open, for Igor's check before the build turn.
-- Block plan (digest §1): 3.1 rename, 3.2 seam and gate, 3.3 N3/N4/kill flake, 3.4 WSL check (the Athanor), 3.5 procedure text, 3.6 reference rows, 3.7 platform handoff, 3.8 README, version, full suite, release commit. Deviation from the build plan's three-block Phase 3 table, with the reason in the digest.
-- Trunk notes get a Phase 3 section at the start of the build turn.
-
-### Block 3.1 — Rename to gremlins
-
-- Model: `claude-opus-5-5[1m]` (fresh block owner, own tools, no agents dispatched)
-- Start / end: Fri Oct 16 18:44:53 WEDT 2026 / Fri Oct 16 20:24:21 WEDT 2026 (`date`; the end is the code commit, this note followed)
-- Done (digest §2 plus amendment A8(a), A9, A10):
-  - `git mv plugins/spire/skills/forks → gremlins`, `forks.py → gremlins.py`, `tests/test_forks.py → tests/test_gremlins.py`, `templates/fork.md → templates/spawn.md`. The untracked `__pycache__` dirs moved with the folder and were deleted.
-  - `gremlins.py`: `GremlinsError`, `cmd_spawn`, `detach_supervisor` (body unchanged), `DETACH_METHOD` (`where` keeps its `spawn` key), `CHILD_MARKER`/`SCRUB_PINNED` `SPIRE_GREMLIN_CHILD`, CIM carrier vars `SPIRE_GREMLIN_DETACH_CMD`/`_CWD` (in `POWERSHELL_CIM` and its caller), state dir suffix `-gremlins` (`state_dir_for`, `run_for_state`), `spawned_phases` in `phase_boundary`, `prog="gremlins.py"`, "spire:gremlins helper", module docstring, `_diag` prefix `gremlins:`. Command `spawn` (in `COMMANDS`, `HANDLERS`, `CHILD_REFUSED`) with `--method {fork}` (default `fork`; constant `SPAWN_METHODS`). Job kind `spawn` in `REAL_KINDS`, `CAPPED_KINDS`, `USAGE_KINDS`, `HIT_KINDS` and every kind check (`_conclude` cache/cold_start/holder/hit, `finalize_job` head_at_end, `phase_boundary`, `run_active`, `Supervisor.run` hit_written, `cmd_continue`). New `method` field: `_new_entry` default `None`, `spawn` sets `args.method`; carried in the result, the ledger line, the R1 reconciled ledger line (`ledger_from_result`) and `LIST_JOB_KEYS`; the `spawn` launch return is `{job, base, method, base_state, warm_until, rebase_due, retrain_due, reasons}`. Base key `gremlins` (train, `_rebase_succeeded`, `cmd_spawn`, `LIST_BASE_KEYS`). Help texts, refusals, N3 message, `usage` md fallback text, "gremlins never writes settings", "preamble.md missing next to gremlins.py" per §2.3/§2.4. Continuation lines re-aligned after the longer exception name.
-  - Prompt text: `preamble.md` per §2.6 with the handoff-note format inlined as a bullet template (A8(a); the pointer to `implementation/references/run-log.md` is gone); `templates/spawn.md`, `train.md`, `rebase.md` per §2.6 (every `${…}` placeholder and the stale-snapshot sentence kept); `commit_rule` strings per §2.6.
-  - Tests per §2.7: `gremlins`/`_load_gremlins`/`GREMLINS_PY`/`sys.modules["gremlins"]`, prefix `gremlins-test-` (setUp, `tearDownModule` filter `'gremlins' + '-test-'`, the M8 marker), helpers `spawn`, `spawn_marked`, `fake_spawn`, `SPAWN_RESULT`, `SESS_SPAWN`; test names `test_train_spawn_continue_end_to_end`, `test_usage_rule_real_spawn`, `test_allowed_inside_a_gremlin`. Also renamed for clarity (fakes of the detach, not of `spawn`): `TickTests` local `spawn` → `fake_detach`, `dead_spawn` → `dead_detach`. The stub's `--fork-session` handling is unchanged.
-- Changed assertion lines (old → new). The rest of the 191 removed / 200 added `assert` lines differ only by the mechanical identifier rename (`forks.` → `gremlins.`, `ForksError` → `GremlinsError`, `self.fork(` → `self.spawn(`, `fork_marked`, `fake_fork`, `FORK_RESULT`, `SESS_FORK`, `FORKS_PY`, `spawn_supervisor` → `detach_supervisor`, `SPAWN_METHOD` → `DETACH_METHOD`); checked by normalising those and diffing the removed against the added assert lines:
-  - A9 (vacuous state-dir checks now derived from `state_dir_for`): `PathTests.test_gitbash_rooted_without_cygpath` `os.path.exists(drive + "\\tmp\\forks-m13-x-run-forks")` → `os.path.exists(gremlins.state_dir_for(drive + "\\tmp\\gremlins-m13-x-run.md"))` (run name `/tmp/forks-m13-x-run.md` → `/tmp/gremlins-m13-x-run.md`); `CliTests.test_commands_need_init` and `CliTests.test_child_refuses_kill_expire_init` `run_log[:-3] + "-forks"` → `gremlins.state_dir_for(run_log)`; `SubprocessTests.test_error_case_stdout_invariant` `os.path.join(self.tmp, "x-run-forks")` → `gremlins.state_dir_for(run_log)`. No other literal state-dir suffix in an `exists` check. The two `PathTests.test_state_dir_*` expected values (they test `state_dir_for` itself) stay literal: `…-x-run-forks` → `…-x-run-gremlins`.
-  - N3 text, 6 lines: 5 × `assertIn("inside a fork", …)` → `assertIn("inside a gremlin", …)` (`CliTests.test_child_refuses_launching`, `test_child_refuses_kill_expire_init`, `TickTests.test_tick_command_and_n3`, `LaunchTests.test_refusals`, `test_rebase_end_to_end`), and 1 × `assertNotIn("inside a fork", …)` → `assertNotIn("inside a gremlin", …)`. The refused command in those argv lists: `"fork"` → `"spawn"`.
-  - Env marker, 3 lines: `env["SPIRE_FORKS_CHILD"]` → `env["SPIRE_GREMLIN_CHILD"]` (`ScrubTests.test_scrubbed_env`, the end-to-end test, the ping end-to-end test); the stub's `ENV_KEYS` entry likewise (not an assertion line).
-  - Kind values: `r2["kind"] == "fork"` → `"spawn"`; `list(out["kinds"]) == ["train", "rebase", "fork", "continue", "ping"]` → `[…, "spawn", …]`; `k["fork"][x]` → `k["spawn"][x]`; `k["fork"]["cost_usd"]` → `k["spawn"]["cost_usd"]`; `out["kinds"]["fork"]["calls"]` → `out["kinds"]["spawn"]["calls"]`; `js["kinds"]["fork"]["cache_read"]` → `js["kinds"]["spawn"]["cache_read"]`; R1 `(ln["kind"], …) == ("fork", …)` → `("spawn", …)`; `assertIn("| fork | 2 |", …)` → `"| spawn | 2 |"`. Non-assert lines feeding exact-match assertions: the `UsageTests` fixture kinds `"fork"` → `"spawn"` (j0002, j0004, j0005), the md phase table rows `| fork | 2 | …` and `| fork | 1 | …` → `| spawn | … |`, the fallback `n/a (no fork, …)` → `n/a (no spawn, …)`; `_new_entry(…, "fork", …)` / `add_job(reg, "fork", …)` → `"spawn"` in `ProcessTreeTests.test_reap_lost_bounds_by_heartbeat`, `WarmthTests`, `TickTests`, `UsageTests`.
-  - Template text: `prompt.index("## Rules for this fork")` → `"## Rules for this gremlin"`.
-  - Key sets, tightened (one key added each): end-to-end train result `set(r) == {…}` gains `"method"`; spawn launch return `set(f_out) == {…}` gains `"method"`.
-  - Added (§2.7 `method`): `f_out["method"] == "fork"` (launch return); `r2["method"] == "fork"` (spawn result); `r["method"] is None` (train result); `r3["method"] is None` (continue result); ledger: the per-result loop now also compares `kind` and `method`, plus `[led[j]["method"] …] == [None, "fork", None]`; `list` job rows `[(kind, method)] == [("train", None), ("spawn", "fork"), ("continue", None)]`; `lst["bases"][0]["gremlins"] == [fj]`; R1 reconciled line `ln["method"] == "fork"` (fixture result and entry carry `method: "fork"`).
-  - Tightened: the end-to-end "continue of a non-spawn job" refusal also asserts `out["error"] == "continue takes a spawn job"` (was exit code only).
-  - None dropped or loosened.
-- Gates:
-  1. `uv run python -m py_compile …/gremlins.py …/tests/test_gremlins.py`: exit 0.
-  2. `uv run plugins/spire/skills/gremlins/tests/test_gremlins.py PathTests ScrubTests LockTests AtomicTests PidTests ProcessTreeTests InitTests CliTests RuleTests LaunchTests.test_train_spawn_continue_end_to_end LaunchTests.test_refusals`: exit 0, `Ran 76 tests in 14.182s`, `OK`. Extra (classes this block edited outside the gate list, not the full suite): `UsageTests TickTests WarmthTests`: exit 0, `Ran 32 tests in 6.612s`, `OK`. Logs in the session scratchpad `…\scratchpad\gremlins-3.1\`.
-  3. G-where `uv run plugins/spire/skills/gremlins/gremlins.py where`: exit 0, one line, `ok: true`, `spawn: cim-hidden`, `scrub.pinned.SPIRE_GREMLIN_CHILD: "1"`, binary 2.1.299 via `CLAUDE_CODE_EXECPATH`, `warnings: []`. Also checked: `--help` lists `spawn`; `spawn --method clone` exits 2 (`invalid choice … (choose from fork)`).
-  4. Residue: `git grep -n "spire:forks\|forks\.py\|SPIRE_FORKS\|skills/forks" -- plugins/` is empty. `git grep -n -i "fork" -- plugins/spire/`, every hit classified:
-     - claude flag `--fork-session`: `gremlins.py:161`, `:1953`, `:2761`, `:2894`, `:3076`; `test_gremlins.py:1096`, `:1149`, `:1150` (the stub), `:1907`, `:2452`, `:2473`, `:3055`, `:3499`.
-     - `method` value `"fork"` and the `--method` choices: `gremlins.py:6`, `:161`, `:163`, `:1941`, `:1942`; `test_gremlins.py:2252`, `:2268`, `:2285`, `:2418`, `:2426`, `:2435`, `:2486`, `:2493`.
-     - prose about the session mechanism: `gremlins.py:6` ("a fork of the base's session"), `:1942`, `:1980` (rebase help: "Fork a base's session …"), `:2867` (rebase docstring: "a fork of B"); `preamble.md:3`; `templates/rebase.md:3`; `templates/spawn.md:3`; `templates/train.md:3`; `test_gremlins.py:1485` ("forked session"), `:2467` ("a continue resumes, it does not fork").
-     - Agent-tool fork rows (3.5/3.6 text, untouched): `agents/athanor.md:32`; `implementation/SKILL.md:45`, `:49`; `implementation/references/spawning-claude-code.md:3`, `:56`, `:60`–`:64`.
-     - A10 (Igor text and non-session meanings, untouched): `igor/SKILL.md:66`, `igor/references/harness-notes.md:3`, `igor/references/mindset.md:11`, `implementation/references/superpowers.md:36`.
-  5. Leftover processes (20:24, `Get-CimInstance Win32_Process` by command line `gremlins-test-` or `_supervise`): none (only the query's own shell and PowerShell).
-  - No live `claude` calls (stub only).
-- Deviations from plan:
-  - `ledger_from_result` (R1 reconciliation) also carries `method` (from the result), so a reconciled line keeps the fixed key set of §2.4. Not named in §2.4, follows from "always present".
-  - `_diag` stderr prefix `forks:` → `gremlins:` (not in the map; a residue otherwise).
-  - Test-only renames beyond §2.7 (`fake_detach`, `dead_detach`), because both fake `detach_supervisor`, not `spawn`.
-- Flagged for review:
-  - Help text of `where` still says "spawn method" and the key is still `spawn`; 3.2 replaces both with `platform.detach`.
-  - `spawn_failed` and `taskkill_rc` are unchanged (3.2 renames them); `test_spawn_failed` is as it was apart from the identifier rename.
-  - Test continuation lines that were aligned under `forks.` are now 3 columns off (`gremlins.` is longer); cosmetic, left as they are to keep the diff mechanical. `gremlins.py` was re-aligned.
-  - `git status` shows `preamble.md` and `templates/train.md` as delete + add (their text changed by more than git's rename threshold); `git log --follow -M30%` finds them.
-  - The renamed small templates change only text the digest names; the `${…}` placeholder set is unchanged in all three.
-- Left for later: 3.2 (`where` shape, `detach_failed`, `tree_kill_rc`, platform seam); SKILL.md and the other Phase 3 text (3.5, 3.6); workpad documents keep the old names (history, per digest §2.8).
-- Expected broken: nothing known. The full suite was not run (it runs once in 3.8); `SubprocessTests` and the rest of `LaunchTests` were not run in this block.
-- Commits: `01c4bc8` (rename), then this note's commit.
-
-### Block 3.2 — Platform seam and gate
-
-- Model: `claude-opus-5-5[1m]` (fresh block owner, own tools, no agents dispatched)
-- Start / end: Fri Oct 16 20:26:43 WEDT 2026 / Fri Oct 16 20:39:15 WEDT 2026 (`date`; the end is the gate commit, this note followed)
-- Done (digest §3.1–§3.7 and §4, with amendment B1, A1, A5, A7, A11, A12 and the `SPIRE_GREMLIN_UNSUPPORTED_OK` naming fix):
-  - **Seam** (`gremlins.py`, one section between `# --- platform seam: begin ---` and `# --- platform seam: end ---`): `Platform` (interface; shared `describe()` built from `name`, `sys.platform`, `is_wsl()`, `supported`, `detach_method`; shared `pid_alive` = platform `_running(pid)` + the creation-time check), `WindowsPlatform` (`supported = True`, `cim-hidden`; ctypes/kernel32/`PROCESSENTRY32W` loaded lazily in `_win()` on the first process or window call, never at import or in `__init__`; `find_cygpath`, `cygpath_w`, `norm_path`, `_powershell`, `_taskkill` static; `POWERSHELL_CIM`, `CREATE_NO_WINDOW`, the FILETIME epoch and the Win32 constants are class attributes), `PosixPlatform` (`setsid`; `supported` is a property `sys.platform in TESTED_SYS_PLATFORMS`, the tuple empty, so lifting the gate is one change; `is_wsl` = `WSL_DISTRO_NAME` or `microsoft` in `/proc/sys/kernel/osrelease`), `select_platform()` (the only `os.name` test), `PLATFORM`. Bodies moved without behaviour change; `restore_no_replace` now carries the `OSError → False` that `_restore` had.
-  - **Delegates** per §3.3: `norm_path(p, cwd, windows)` (selector over the two classes' static `norm_path`), `proc_ctime`, `epoch_to_ctime`, `pid_alive`, `process_table` → `PLATFORM.…`; `terminate(rec)` → `record_alive` then `PLATFORM.terminate`; `kill_tree` → `PLATFORM.tree_kill`; `_run` and `Supervisor.run` → `**PLATFORM.popen_kwargs()` / `(new_group=True)`; `detach_supervisor` builds the argv and returns `PLATFORM.detach(argv, cwd=state, log_path=<raw>/<job>.sup.log)`; `RegistryLock._restore` → `PLATFORM.restore_no_replace`. `process_tree` unchanged (module-level names, so `ProcessTreeTests` patches still bite). `IS_WINDOWS`, `DETACH_METHOD`, `CREATE_NO_WINDOW`/`_NOWIN`, the module ctypes block are gone.
-  - **Path refusals** (§3.4, A5): Windows refuses `/mnt/<d>/…` ("WSL path form on Windows; pass C:\... or /c/..."); `C:`/`C:x` stay refused ("cannot normalise path", as today); POSIX refuses a drive form ("Windows drive path form on POSIX; …") and any backslash ("backslash in a path on POSIX (a Windows path form); …"). "empty path" refusals now carry `path` (the input).
-  - **JSON renames** (§3.6): `where.spawn` removed → `where.platform` = `{name, sys_platform, wsl, supported, detach, override}`; `kill`/`expire.killed[]` `taskkill_rc` → `tree_kill_rc`; reason `spawn_failed` → `detach_failed`; `where` help "… git, env scrub, platform".
-  - **Gate** (second commit, §4 + amendments): neutral helpers `gate_overridden()` (A12: env `SPIRE_GREMLIN_UNSUPPORTED_OK == "1"` and not `PLATFORM.supported`), `platform_report()` (`describe()` + `override`), `platform_gate()` (reads only `PLATFORM.supported`/`describe()`; A7 reason "spire:gremlins is not tested on <sys_platform><, WSL> yet; use fresh agents for every block (see SKILL.md, Platforms)."), `require_platform()` (`{"error": "platform not supported", "reason", "platform"}`, exit 2). `where`: gate reason first in `reasons`, everything else still filled; override → `warnings` gets `GATE_OVERRIDE_WARNING`. A11: `where` catches a `GremlinsError` from `resolve_binary` into `binary.{path: null, how, error, given}` and `reasons`. `init`: `require_platform()` is its first line (B1). Dispatcher (A1): `GATED_COMMANDS = train, spawn, continue, rebase, tick` refused after the N3 check. `tick_pass` returns `{"pinged": [], "bases": []}` at once on a closed gate (covers the tick in `wait` and in the supervisor).
-  - **Tests**: `PathMatrixTests` (new, 5 tests: all 15 rows (17 inputs) × both classes, pure: `WindowsPlatform.find_cygpath` and `_run` faked, the fake asserts it is only ever called as cygpath `-w`; row 6 without cygpath; the delegate selector; both classes built on any host with `_api` still `None`). `GateTests` (new, 8 tests): `supported` flags (`WindowsPlatform` True; `PosixPlatform` False under `sys.platform` `linux` and `darwin`, `describe()["supported"]` follows), `is_wsl` (env, osrelease with/without `microsoft`, unreadable), the exact gate reason and the override, the host `where` (Windows: supported, no override, no warnings), closed `where` (exit 2, reason, the full platform dict, binary still filled), closed `init` (exit 2, `error == "platform not supported"`, no state dir; a non-`.md` `--run` still gets the gate error, so the gate precedes `state_dir_for`), override (`where` exit 0 with the one warning, `init` creates the registry), and A1 (registry made with the gate open; closed: `spawn`, `train`, `continue`, `rebase`, `tick` exit 2 `platform not supported`, registry unchanged and `jobs == {}`; `tick_pass` returns without reading the registry; `list` and `wait` still work, `pings == []`). The fake closed platform (B1) subclasses the host's own platform class (a `WindowsPlatform` here) with `supported = False`, `is_wsl() → True` and the posix/linux/WSL `describe()`. `CliTests` gains `test_where_platform` (A12: `override: false` with C13's env set; Windows: the exact platform dict) and `test_where_refused_binary_path` (A11). `Base.setUp` sets `SPIRE_GREMLIN_UNSUPPORTED_OK=1` (C13); `GateTests.setUp` pops it. `visible_windows()` in the tests → `gremlins.PLATFORM.visible_windows() or []`; `test_no_visible_window` skips on `None`/empty. `find_cygpath` patches → `gremlins.WindowsPlatform`. `test_spawn_failed` → `test_detach_failed`. Platform-behaviour branches use `WIN_PLATFORM = gremlins.PLATFORM.name == "windows"`; `IS_WINDOWS = os.name == "nt"` stays for the generated wrappers, the stub drift lines, the module-end sweep, `AtomicTests`' sharing-violation check (not in this block's classes) and `PathMatrixTests`' `select_platform` reference check.
-- Changed assertion lines (old → new; `git diff 065afcb..e9f1b06 -- …/tests/ | grep -c '^-.*assert'` = 5):
-  - `SubprocessTests.test_where_via_uv_stub`: `assertEqual(out["spawn"], "cim-hidden" if IS_WINDOWS else "setsid")` → `assertEqual(out["platform"]["detach"], "cim-hidden" if WIN_PLATFORM else "setsid")` plus a new `assertNotIn("spawn", out)` (§3.5/§3.6: specified change, tightened).
-  - `LaunchTests.test_detach_failed`: `("failed", "spawn_failed")` → `("failed", "detach_failed")`; ledger `["spawn_failed"]` → `["detach_failed"]` (§3.6 rename). The fake's `"method": gremlins.DETACH_METHOD` → `gremlins.PLATFORM.detach_method` (not an assertion line).
-  - `CliTests.test_where_warns_on_base_url`: `assertEqual(out["warnings"], [])` → `assertEqual(out["warnings"], gate_warning(out))`; `assertEqual(len(out["warnings"]), 1, …)` → `assertEqual(len(out["warnings"]), 1 + len(gate_warning(out)), …)` plus a new `assertEqual(out["warnings"][1:], gate_warning(out))`. `gate_warning(out)` is `[]` unless `platform.override` is true, which never happens on Windows (A12), so on this host both assertions are exactly the old ones; on a porting host under C13 they demand exactly the one override warning instead of failing by construction. Not loosened.
-  - Non-assertion fixture change: `ProcessTreeTests.test_reap_lost_bounds_by_heartbeat`'s fake `kill_tree` returns `"tree_kill_rc"` instead of `"taskkill_rc"`.
-  - None dropped or loosened.
-- Gates:
-  1. `uv run python -m py_compile …/gremlins.py …/tests/test_gremlins.py`: exit 0.
-  2. `uv run plugins/spire/skills/gremlins/tests/test_gremlins.py PathTests PathMatrixTests GateTests PidTests ProcessTreeTests LockTests CliTests SubprocessTests TickTests LaunchTests.test_kill_tree LaunchTests.test_no_visible_window LaunchTests.test_detach_failed LaunchTests.test_train_spawn_continue_end_to_end`: exit 0, `Ran 63 tests in 15.577s`, `OK` (no skips; `test_no_visible_window` ran with its positive control). The same list without `GateTests` passed at the seam commit (`Ran 53 tests in 15.457s`, OK). Extra, because the gate touches `init`, the dispatcher and `tick_pass`: `InitTests WarmthTests LaunchTests.test_refusals`: exit 0, `Ran 32 tests in 5.025s`, OK. Logs in the session scratchpad `…\scratchpad\gremlins-3.2\`.
-  3. G-where `uv run plugins/spire/skills/gremlins/gremlins.py where`: exit 0, one JSON line, `ok: true`, `platform: {"name": "windows", "sys_platform": "win32", "wsl": false, "supported": true, "detach": "cim-hidden", "override": false}`, no `spawn` key, `warnings: []`, binary 2.1.299 via `CLAUDE_CODE_EXECPATH`.
-  4. Seam grep §3.7 (`git grep -n -E "os\.name|sys\.platform|IS_WINDOWS|ctypes|_k32|taskkill|powershell|killpg|setsid|start_new_session|creationflags|cygpath|/proc" -- …/gremlins.py`): markers at `:267` and `:734`; every hit lies between them (`:271`, `:272`, `:282`, `:286`, `:368`–`:399`, `:405`–`:444`, `:466`–`:486`, `:501`–`:544`, `:560`–`:569`, `:585`–`:596`, `:608`–`:729`; `sys.platform` only in `Platform.describe` `:286` and `PosixPlatform.supported` `:615`, `os.name` only in `select_platform` `:729`). No hit outside, in code, comments or docstrings (the two comment/docstring mentions outside were reworded: the supervisor's `os.environ.clear()` comment and `kill_job`'s docstring say "tree-kill").
-  5. Leftover processes (20:39, `Get-CimInstance Win32_Process` by command line `gremlins-test-`, `_supervise`, `poscontrol`, `claude-stub`): none.
-  - No live `claude` calls (stub only).
-- Deviations from plan:
-  - The fake closed platform subclasses `type(gremlins.PLATFORM)`, not `WindowsPlatform` by name: on Windows it is a `WindowsPlatform` subclass exactly as B1 asks; on a POSIX host it keeps POSIX path handling, so `GateTests` also run on WSL and the porting hosts.
-  - `GateTests` assert the A7 wording ("not tested on linux, WSL", "fresh agents"), not §4's "Windows only" (A7 supersedes it).
-  - The override opens only on the exact value `1` (§4 says "`=1`"); any other value is "not set".
-  - `PosixPlatform.supported` is a property over an empty `TESTED_SYS_PLATFORMS` tuple instead of a literal `False` (§4: "lifting the gate … returns True for the tested `sys.platform` values"); `describe()` reads it (A12).
-  - `pid_alive` is shared in `Platform` (range check and creation-time check) over a per-platform `_running(pid)`; the interface method is the same, the logic is today's.
-  - `where.binary` on an A11 refusal carries `given` (the refused input) besides `path: null`, `how` and `error`.
-  - `where`'s gate-overridden warning is a fixed constant `GATE_OVERRIDE_WARNING` (tests compare it exactly).
-- Flagged for review:
-  - `GATED_COMMANDS` leaves `kill` and `expire` open on a closed gate (A1 names only train/spawn/continue/rebase/tick); a porter can still stop jobs started under the override. `wait` and `list` stay open too, and `_supervise` is not gated (nothing reaches it on a closed gate except a job launched under the override).
-  - Under the override the gremlin's own env (scrubbed) still carries `SPIRE_GREMLIN_UNSUPPORTED_OK` (unknown vars pass the scrub), so a supervisor's tick on a porting host pings as the orchestrator would; irrelevant on Windows. The 3.7 handoff may want to say so.
-  - `PathTests.test_posix_forms` and the other old `PathTests` stay unchanged (§3.4: redundant but kept).
-  - `AtomicTests` keeps its `IS_WINDOWS` check (sharing-violation retry is file-system behaviour; not one of this block's classes).
-- Left for later: 3.3 (N3, N4, the kill-verification guard on `kill_tree`), the platform handoff text (3.7: the seam, `TESTED_SYS_PLATFORMS`, the override and its env-leak note above, M14), SKILL.md's Platforms section (3.5). The `!` injection with a `where` that exits 2 on a closed platform remains untested (digest §12).
-- Expected broken: nothing known. The full suite was not run (it runs once in 3.8); `ScrubTests`, `AtomicTests`, `RuleTests`, `UsageTests` and the rest of `LaunchTests` were not run in this block.
-- Commits: `25d0358` (seam and path matrix), `e9f1b06` (gate), then this note's commit.
-
-### Block 3.3 — N3, N4, kill flake
-
-- Model: `claude-opus-5-5[1m]` (fresh block owner, own tools, no agents dispatched)
-- Start / end: Fri Oct 16 20:41:17 WEDT 2026 / Fri Oct 16 21:43:31 WEDT 2026 (`date`; the end is the code commit, this note followed)
-- Done (digest §5 with amendment A2, A3, A4 and the C15 note):
-  - **N3** (`gremlins.py`): `resolve_binary` now walks `BINARY_SOURCES = ("CLAUDE_CODE_EXECPATH", "PATH")` through the new `resolve_binary_via(how)` (one source only; same lookup and order as before). New `rerun_binary(stored, how, warnings)`, used by `build_init_config` on a re-run without `--binary`: a stored source `--binary` (or none recorded) keeps the stored path; `CLAUDE_CODE_EXECPATH` / `PATH` re-resolve through that source only (A4, never the other one); nothing found there keeps the stored path with the warning "could not re-resolve the claude binary through <source>; kept the stored path <path>"; a different path (compared `os.path.normcase`d) replaces it with "binary changed: <old> → <new> (resolved by <source>); existing bases keep their own binary record, new trainings use the new one". `init` output always carries `warnings` (list). The change shows in `changed_fields` as `launch.binary.*` (unchanged logic); a base keeps its own `launch.binary`. A vanished stored file still fails loud (`claude binary not found`, exit 2) when nothing re-resolves it.
-  - **N4**: new `_rebase_target_free(reg, entry)` (the existing "name free or failed" rule, shared). `_rebase_succeeded`: when the old base is not `active` at finalise, NEW is created with the old base's status (`superseded` with the old base's `superseded_by` and `superseded_at` = this end time; `retired` with `retired_at` = this end time), the old base is left untouched (its `superseded_by` is not overwritten), and the job entry gets `rebase_inactive_parent: "<old> was <status> when the rebase ended"`. `_conclude` adds the flag `parent_inactive` before the result is built, only when the rebase ended `ok`, the base is not active **and** `_rebase_target_free` holds (so not on the `rebase_conflict` early return, C15 note). Status stays `ok`.
-  - **Kill verification (A2)**: `kill_tree`'s sweep takes one module-level `process_table()` per iteration and asks the new `snapshot_survivor(p, table)`: dead if the table is non-empty and lacks the pid, or if the snapshot name is known, the table names the pid differently and `proc_ctime(pid)` is `None` (class (a)); otherwise `record_alive` decides, as before. Survivors are still terminated only from that list. `KILL_VERIFY_S` stays 10 (no (b) observed).
-  - **Tests** (`test_gremlins.py`): `LaunchTests.test_refusals`' kill assertion now prints the output. `InitTests`: `test_rerun_reresolves_execpath`, `test_rerun_keeps_a_binary_pin`, `test_rerun_without_a_source_keeps_the_stored_path` (A3 first case), `test_rerun_with_the_stored_file_gone_fails_loud` (A3 second case), `test_rerun_never_crosses_sources` (A4, both directions: EXECPATH-stored with only a PATH claude → kept + warning; PATH-stored with EXECPATH set → re-resolved by PATH); helpers `named_stub` (a `claude.cmd` for PATH lookups), `bare_init`, `rerun`, `path_only`, `stored_binary`. `ProcessTreeTests` (fake table, module-level patches; `terminate`, `process_tree`, `PLATFORM.tree_kill` faked, nothing real touched): `test_kill_verify_pid_reused_by_unopenable_process_is_dead` (class (a)), `…_pid_gone_from_a_nonempty_table_is_dead`, `…_same_name_unverifiable_survives`, `…_empty_table_keeps_the_survivor`, `…_unknown_snapshot_name_keeps_the_survivor`, `…_other_name_with_readable_ctime_is_record_alive` (the four A2 cases plus two). `LaunchTests.test_late_rebase_of_a_superseded_base` (N4 per §5.2, plus a second rebase whose new name is taken before it ends: `ok`, no `parent_inactive`, `rebase_conflict` set, nothing replaced). `RuleTests.test_late_rebase_of_a_retired_base` (pure: the `expire` race, NEW `retired`, old untouched). The stream stub gained a `gate=NAME` directive (first turn waits, at most 120 s, for `<stub dir>/NAME`), so the late-rebase ordering is deterministic rather than timed.
-- Fail-first check: the new tests run against a scratch copy of the pre-change `gremlins.py` (`git archive HEAD` of the skill dir with the new test file, under `…\scratchpad\gremlins-3.3\pre\`): `Ran 14 tests`, `FAILED (failures=3, errors=6)`. Failing: all four new N3 behaviour tests except the A3 loud case (errors: `KeyError: 'warnings'`), `test_init_creates_state_and_config` (`warnings` missing), both class-(a)/gone-pid kill tests (`([900051], [900051, 900051, 900051]) != ([], [])`), the retired unit test (no `_rebase_target_free`), the N4 launch test (`'parent_inactive' not found in []`). Passing on the old code, as intended (guards of unchanged behaviour): `test_rerun_keeps_a_binary_pin`'s path logic, `test_rerun_with_the_stored_file_gone_fails_loud`, and the four A2 "keep the survivor" cases. To see past the `KeyError`, the N3 tests also ran against the old code with only `"warnings": []` added to `init`'s output: `Ran 6`, `failures=3` (`test_rerun_reresolves_execpath`: path stays A; `…_without_a_source_…`: no warning; `…_never_crosses_sources`: no warning); pin, loud case and the always-present key pass.
-- Kill flake (§5.3): **not reproduced**. 16 hidden Python busy loops (`gremlins33_busyload.py` in `…\scratchpad\gremlins-3.3\`, 16 logical CPUs, pids 37364 13568 38608 18780 29236 8852 20324 33132 18960 36196 35980 3244 15556 35944 15476 38032, started 21:36:17, all confirmed running, killed by pid with `taskkill /F` after the runs). `LaunchTests.test_refusals` alone, 10 sequential runs (never two suites at once), against the **pre-change** helper (so a class-(a) survivor would not be hidden by the new guard) with scratch-only instrumentation in that copy's `kill_tree` (on survivors: table name, `proc_ctime`, `_running`, a terminate retry, and up to 30 s of follow-up liveness, to a diag file): 10 of 10 `OK` (19.4, 19.4, 65.6, 23.3, 20.2, 31.3, 23.3, 27.8, 20.1, 23.0 s), no diag line written, so no survivor in any of the 20 kills. Class: none observed; survivor names: none. Fix landed: only the A2 guard; `KILL_VERIFY_S` unchanged; nothing for (c). The reproduction took about 6 minutes of the 15-minute bound.
-- Changed assertion lines (old → new; `git diff 11c1085..62eef3b -- …/tests/ | grep -c '^-.*assert'` = 1):
-  - `LaunchTests.test_refusals`: `self.assertTrue(self.cmd("kill", "--job", j)["ok"])` → `out = self.cmd("kill", "--job", j)` + `self.assertTrue(out["ok"], out)` (§5.3 step 1; same check, adds the message).
-  - Added: `InitTests.test_init_creates_state_and_config` `assertEqual(out["warnings"], [])`; every assertion of the new tests above.
-  - None dropped or loosened.
-- Gates:
-  1. `uv run python -m py_compile …/gremlins.py …/tests/test_gremlins.py`: exit 0.
-  2. `uv run plugins/spire/skills/gremlins/tests/test_gremlins.py InitTests ProcessTreeTests RuleTests LaunchTests.test_refusals LaunchTests.test_kill_tree LaunchTests.test_expire_kills_running_jobs LaunchTests.test_late_rebase_of_a_superseded_base`: exit 0, `Ran 51 tests in 15.423s`, `OK` (`RuleTests` because this block added a test there). Logs in `…\scratchpad\gremlins-3.3\` (`gate.txt`, `pre-run.txt`, `pre-mutant.txt`, `repro-1.txt` … `repro-10.txt`).
-  3. G-where `uv run plugins/spire/skills/gremlins/gremlins.py where`: exit 0, one JSON line, `ok: true`, `platform.supported: true`, `override: false`, `warnings: []`, binary 2.1.299 via `CLAUDE_CODE_EXECPATH`.
-  4. Leftover processes (21:43, `Get-CimInstance Win32_Process` by command line `gremlins-test-`, `_supervise`, `poscontrol`, `claude-stub`, `gremlins33_busyload`): none.
-  - No live `claude` calls (stub only).
-- Deviations from plan:
-  - The reproduction ran against the pre-change helper with scratch instrumentation (the brief says only "run `test_refusals` alone"): with the A2 guard in place a class-(a) survivor would have been dropped silently, so the classification needed the old code. The repo test file (with the printing assertion) was used as is.
-  - N4 test: the ordering "train ends first" is made deterministic with a new stub directive `gate=NAME` instead of a stub `sleep`; and the test also covers the `rebase_conflict` path of the C15 note (a second base, B2, rebased to a name taken by a `clone_base` before the gate opens).
-  - N4 retired branch: `retired_at` of NEW is this end time (§5.2 names the field, not its value; `superseded_at` is the end time too).
-  - The test asserting "B1 untouched" compares B1's lineage fields (`status`, `superseded_by`, `superseded_at`): `_conclude` still records the rebase's first request as a hit on B1 (`last_hit`, `ttl_s`, `ttl_from`), as for any rebase; that is unchanged behaviour, not part of N4.
-  - `test_rerun_never_crosses_sources` compares PATH-resolved paths `os.path.normcase`d: on Windows `shutil.which` spells the extension from `PATHEXT` (`claude.CMD`). The helper compares stored and re-resolved paths the same way, so a case-only difference is no change and no warning.
-- Flagged for review:
-  - `snapshot_survivor` compares names exactly (both sides come from the same Toolhelp32 snapshot API, so they agree for one process); a POSIX `/proc` table gives `comm`, which a process can change itself (a `prctl` rename would count as "another name", but only with an unreadable creation time, which POSIX gives only without `/proc`, where the table is empty and the rule does not apply).
-  - `rerun_binary` treats a missing `binary_resolved_by` (no registry written before Phase 1's field existed is expected) like a pin: kept, no warning.
-  - `init` warnings are not written to the registry; only the call that changed the binary reports it.
-  - The stub's `gate` waits at most 120 s and then goes on; a test that never opens its gate gets a late `ok` instead of a hang.
-- Left for later: SKILL.md text for N3 (re-run re-resolves unless pinned), N4 (`parent_inactive`) and the `warnings` key on `init` (block 3.5, digest §7.1 items 3 and 7 already name them); the full suite (3.8).
-- Expected broken: nothing known. The full suite was not run (it runs once in 3.8); `CliTests`, `GateTests`, `TickTests`, `UsageTests` and the rest of `LaunchTests` were not run in this block (a grep of the tests' key-set assertions, `assertEqual(set(…), …)`, finds none on `init` output, so the new `warnings` key breaks no exact-shape check; the new job-entry key `rebase_inactive_parent` is not in `LIST_JOB_KEYS` or the result).
-- Commits: `62eef3b` (code and tests), then this note's commit.
-
-### Block 3.4 — WSL check
-
-- Model: `claude-opus-5-5[1m]` (the Athanor, own Bash)
-- Start / end: Fri Oct 16 21:45:00 WEDT 2026 / 21:56 (`date`; suite 21:46:26–21:53:00)
-- Done: digest §6 procedure on helper commit `4d8af02` (after 3.1–3.3), copied to ext4 (`~/gremlins-wsl-check`, removed afterwards). Raw logs in the session scratchpad `…\scratchpad\gremlins-wsl\` (`where-*.json`, `suite.txt`, `matrix-gate.txt`, `zombie_probe.py`). The harness refused a separate `findings.md` there, so the findings are recorded here; block 3.7 cites this note.
-- **Inventory**: the distro is registered as `Ubuntu-20.04` but runs **Ubuntu 22.04.5 LTS** (upgraded in place); kernel 6.18.54.1-microsoft-standard-WSL2. uv 0.6.8 was already at `~/.local/bin/uv`, so nothing was installed and no download happened. System `python3` 3.10.12; `uv run` picked a managed CPython 3.13.2. git 2.34.1. `/proc` present; `osrelease` contains `microsoft`; `WSL_DISTRO_NAME=Ubuntu-20.04`.
-- **PATH interop**: 73 PATH entries under `/mnt/` (the Windows PATH appended; no `/etc/wsl.conf`). `claude` (no extension) is **not found**; `claude.exe` resolves to `/mnt/c/Users/g4b/.local/bin/claude.exe` (the Windows PATH binary, 2.1.283); `…/AppData/Roaming/npm` is on PATH but holds no `claude` shim. So `shutil.which("claude")` does not pick the Windows exe on this host, and `where` reports "no claude binary". But `--binary /mnt/c/…/claude.exe` is accepted: `claude.exe --version` runs through interop, and with the override `where` reports `ok: true` for a Windows binary under a Linux helper. `CLAUDE_CODE_EXECPATH` does not cross (unset; `WSLENV` empty).
-- **`where`**: gate closed → exit 2, `ok: false`, `platform {name: posix, sys_platform: linux, wsl: true, supported: false, detach: setsid, override: false}`, the A7 gate reason, then "no claude binary". With `SPIRE_GREMLIN_UNSUPPORTED_OK=1` and no binary: exit 2 (no binary). With the override and `--binary` the Windows exe: exit 0, the override warning. From the drvfs path: the same answer (`script` is the `/mnt/g/…` path). `supervisor_interpreter` resolves to the uv-managed base interpreter. Cosmetic: the reasons join gives `.;` (the gate reason ends with a period).
-- **Unit suite** (override set by `Base.setUp`, C13): `Ran 165 tests in 393.103s`, **FAILED (failures=9, skipped=3)**. Skips as expected (`test_no_visible_window`, `PathTests.test_state_dir_windows_forms`, `SubprocessTests.test_where_via_uv_host_binary`). `PathMatrixTests` and `PathTests` pass on Linux. Failures by cause:
-  1. **A zombie supervisor counts as alive** (`LaunchTests.test_kill_tree`, `test_refusals`, `test_expire_kills_running_jobs`, `test_lost`, `test_orphan_watchdog`, `test_rebase_counts_toward_cap`). The tests launch in-process, so the test process is the supervisor's parent; a killed supervisor stays a zombie (`Z`), `os.kill(pid, 0)` succeeds on it, so `pid_alive` reads it alive and `kill` reports `ok: false` with the supervisor as the only survivor. Confirmed by `zombie_probe.py` (kill-0 alive, `/proc` state `Z`; dead after reaping). In production the launching CLI exits at once, so the supervisor is reparented and reaped, but `PosixPlatform.pid_alive` should treat state `Z` as dead. POSIX item for the porter; not fixed.
-  2. **`GateTests.test_closed_gate_on_existing_registry`** fails on any non-Windows host (its "gate open" setup ran without the override). Portable test bug: fixed in 3.4a.
-  3. **`LaunchTests.test_delta_tokens_counts_only_what_the_base_does_not_know`**: the precondition `trained_at > note mtime` fails when both fall in the same whole second (faster host). Timing assumption that can flake on Windows too: fixed in 3.4a.
-  4. **`LaunchTests.test_timeout_and_stalled`** expects a tree of ≥ 3 processes; on Linux the stub's `sh` wrapper `exec`s python, one process fewer than Windows' `cmd.exe` layer. Platform-shaped expectation; porter's item.
-- `PathMatrixTests GateTests PathTests` alone: 23 tests, 1 failure (cause 2), 1 skip.
-- Leftovers: none in WSL (`ps` by args; no `/tmp/gremlins-test-*`). No `wsl --shutdown`/`--terminate`. Trap recorded: `wsl -d X -- bash -lc '…'` expands `$?` in an outer shell (every exit read 0); `wsl -e bash -lc` gives the real codes.
-- Deviations: the WSL run found two portable test bugs, fixed by a fresh agent in 3.4a (digest §6 allows a fix for neutral code); the POSIX-only failures are left for the handoff.
-- Flagged for review: a Windows `claude.exe` under a Linux helper is accepted with `--binary` (a porter should refuse `/mnt/<d>/…*.exe` under WSL); zombie liveness; the tree-size expectation.
-- Commits: none for 3.4 itself (this note is committed with the 3.4/3.4a run-log commit).
-
-### Block 3.4a — Portable test fixes from the WSL check
-
-- Model: `claude-opus-5-5[1m]` (fresh block owner, own tools, no agents dispatched)
-- Start / end: Fri Oct 16 21:54:58 WEDT 2026 / Fri Oct 16 21:57:20 WEDT 2026 (`date`; the end is after the test commit, this note followed)
-- Done (tests only, `gremlins.py` unchanged):
-  - **`GateTests.test_closed_gate_on_existing_registry`** (WSL cause: the "gate open" `init` was refused on Linux, since `GateTests.setUp` pops `SPIRE_GREMLIN_UNSUPPORTED_OK` and the host is unsupported). The setup `init` now runs inside `mock.patch.dict(os.environ, {UNSUPPORTED_OK_ENV: "1"})`, so the gate is open on any host (on Windows the env is ignored, A12); a new assertion inside checks `platform_gate()` is `None` there, and one after it checks the env is gone again. Then `close_gate()` and every closed-gate assertion exactly as before (each of `spawn`, `train`, `continue`, `rebase`, `tick`: exit 2, one JSON line, `error == "platform not supported"`, the A7 reason, `platform.supported` false; registry `jobs == {}` and unchanged; `tick_pass` reads no registry; `list` and `wait` still work).
-  - **`LaunchTests.test_delta_tokens_counts_only_what_the_base_does_not_know`** (WSL cause: `trained_at` has whole seconds, so B2's rebase ending in the same second the note was written gave `trained_at < mtime`). Right after the large note is written, its mtime is set with `os.utime` to now − 30 s and B1's `trained_at` (via `set_registry`) to now − 60 s, with a new precondition assertion `B1.trained_at < note mtime`. So B1 predates the note (the note counts for B1), `Bk` (cloned at `mtime + 60`) still postdates it, and B2's rebase, which ends at now or later, postdates it by at least 29 s on any host speed. `trained_at` is read by the helper only in `new_to_base` (and `list`'s copy of the field), so moving B1's is invisible to every other check in the test. Every assertion of the test is unchanged, including `assertGreater(_ts(B2.trained_at), mtime)` (now deterministic, not removed).
-- Changed assertion lines (old → new; `git diff 4d8af02..2257e89 -- …/tests/ | grep -c '^-.*assert'` = 1):
-  - `GateTests.test_closed_gate_on_existing_registry`: `self.assertEqual(code, 0, out)` → the same line, indented into the `with` block (the setup `init` runs under the override env).
-  - Added: `self.assertIsNone(gremlins.platform_gate())` (gate open during setup), `self.assertNotIn(gremlins.UNSUPPORTED_OK_ENV, os.environ)` (env gone before the gate closes), and in the delta test `self.assertLess(gremlins._ts(self.reg()["bases"]["B1"]["trained_at"]), os.path.getmtime(note))`.
-  - None dropped or loosened.
-- Gates:
-  1. `uv run python -m py_compile plugins/spire/skills/gremlins/tests/test_gremlins.py`: exit 0.
-  2. Windows: `uv run plugins/spire/skills/gremlins/tests/test_gremlins.py GateTests LaunchTests.test_delta_tokens_counts_only_what_the_base_does_not_know`: exit 0, `Ran 9 tests in 4.643s`, `OK`.
-  3. WSL (`MSYS_NO_PATHCONV=1 wsl -d Ubuntu-20.04 -e bash -lc '… cp -r …/skills/gremlins ~/g34a && cd ~ && uv run ~/g34a/tests/test_gremlins.py GateTests LaunchTests.test_delta_tokens_counts_only_what_the_base_does_not_know; echo exit=$?; rm -rf ~/g34a'`): `Ran 9 tests in 1.485s`, `OK`, `exit=0` (before this block both tests failed there, `suite.txt` lines 234–251).
-  4. Leftover processes (21:56; Windows `Get-CimInstance Win32_Process` by command line `gremlins-test-`, `_supervise`; WSL `pgrep -af "gremlins-test-|_supervise|g34a"`): none (only the query itself). No `wsl --shutdown`/`--terminate`.
-  - No live `claude` calls (stub only).
-- Deviations from plan:
-  - The WSL findings file named in the brief (`…\scratchpad\gremlins-wsl\findings.md`) does not exist; the folder holds `suite.txt`, `matrix-gate.txt`, the `where-*` probes and `zombie_probe.py`. The two causes were taken from the brief and confirmed from `suite.txt`'s tracebacks.
-  - Fix 1 uses the override env (the brief's first option), not a fake supported platform: it keeps the host's own platform class and path handling for the `init`, as the WSL run of `test_override` already showed works.
-- Flagged for review:
-  - Product (not changed, per the brief): `trained_at` is written with `timespec="seconds"` (truncated), and `new_to_base` counts a note when `mtime > trained_at`. A note written in the same whole second as, but before, a training's or rebase's end therefore still counts as new to that base: a spurious `delta_tokens` reason right after a rebase that absorbed it. It errs towards rebasing, never towards missing a note, and needs sub-second timing to happen in real use, so I left it; a fix would be a fractional `trained_at` or comparing against `trained_at + 1`.
-- Left for later: the POSIX-only failures from the WSL suite (`test_kill_tree`, `test_refusals`, `test_expire_kills_running_jobs`, `test_rebase_counts_toward_cap`: zombie root counted alive; `test_lost`, `test_orphan_watchdog`: supervisor liveness; `test_timeout_and_stalled`: tree size 2 < 3) go into the platform handoff, untouched here.
-- Expected broken: nothing known. Only the two classes/tests above ran; the full suite runs once in 3.8.
-- Commits: `2257e89` (tests), then this note's commit.
-
-### Block 3.5 — Procedure text
-
-- Model: `claude-opus-5-5[1m]` (fresh block owner, own tools, no agents dispatched)
-- Start / end: Fri Oct 16 21:59:12 WEDT 2026 / Fri Oct 16 22:06:33 WEDT 2026 (`date`; the end is the text commit, this note followed)
-- Done (digest §7.1–§7.4 with amendment A1, A6, A7, A8(b)(c), the `kill`/`expire` timeout note, N3/N4 and `init` `warnings`), written against the helper as built at `1de1029` (`where`, `--help` and every `<command> --help` run; `_conclude`, `_rebase_succeeded`, `cmd_wait`, `cmd_list`, `kill_job`, `cmd_expire`, `cmd_init`, `cmd_where`, `cmd_spawn`, `cmd_continue`, `cmd_rebase`, `cmd_tick`, `api_error_reason`, `due_flags`, the dispatcher and the supervisor's flag/reason sites read):
-  - `plugins/spire/skills/gremlins/SKILL.md` (new, 120 lines): frontmatter per §7.1 with the A7 description ("Windows-tested; other platforms fail closed until tested (see Platforms)"), `allowed-tools: Bash(uv:*)`, the `!` injection `` !`uv run "${CLAUDE_SKILL_DIR}/gremlins.py" where` ``. Sections: What and when, Platforms, Setup, Commands (table + a first-phase call sequence), Waiting, Results (fields, statuses, reasons, flags, an action per failure reason, `stalled`+`clock_jump`), Rules (flags, not judgment), State.
-  - `plugins/spire/agents/athanor.md`: description per §7.2 (furnace sentences, triggers, Opus pin, Agent tool, "does not plan …", non-build line kept; "blocks in the foreground" replaced); `skills:` + `spire:gremlins`; line 23 "orient by reading plans, designs, reports and notes, not code"; intake runs `where` first, then adopts (`list`) on a `Gremlins:` line, else `init` + `train` (the base writes the trunk notes), and on a closed gate fresh agents even with a state dir, "a fresh agent reads the code the blocks change and writes the trunk notes" (A1, A6); step 2 spawn/fresh-agent routing, model-mismatch rule, `rebase_due`/`retrain_due`; gate to `logs/`, `continue` once; the mechanical check (A23 default pattern `assert`); tests once to `logs/`, parallel test runs off by default; run log from `usage`; hand back with nothing running, no `expire`; fix pass by gremlins; dispatching (`script` path, `timeout: 600000`, never `SendMessage`/`TaskStop` a gremlin); keepers (no code reads, nothing running, one committer at a time with the commit table); "Tools, not the loop" as things written into briefs (A13); deliverable gains priced usage and base state. Every Agent-tool fork mention is gone (`grep -i fork` on the file: no hit).
-  - `plugins/spire/skills/implementation/SKILL.md`: line 40 per §7.3; "Context: fresh, trained, or keep" with the trained-implementer-and-gremlins paragraph, A7 platform wording (no version); "Spawning and models" gains the full-model-id line. Line 12 unchanged.
-  - `plugins/spire/skills/implementation/references/run-log.md`: header `- Gremlins: <state dir> (or "none: <reason>")` plus the adopt sentence (A7); the 9-column block table with the gremlin / fresh-agent fill rule (C19); phase close gains the usage table lines and the base state; the handoff note "same format for everyone" sentence; the trunk-notes heading per §7.4.
-- Checklist (§7.7 plus the amendment's rows), each with where it landed:
-  - [x] `wait` with `timeout: 600000`; the Bash tool backgrounds past its timeout — SKILL Waiting (bullet 2), athanor Dispatching (bullet 1).
-  - [x] `kill`: key on `ok` and `status` — SKILL Rules (`kill:` bullet).
-  - [x] Windows-tested; POSIX closed — SKILL description and Platforms; athanor intake (`where` not ok bullet); implementation SKILL Context.
-  - [x] C8 permissive at init, enforced at runtime — SKILL Rules (Models bullet).
-  - [x] Post-exit sweep kills daemons — SKILL Rules (after `claude` exits).
-  - [x] `continue` needs commit rule and note path in its brief — SKILL Rules.
-  - [x] `kill`/`expire` do not refresh the orchestrator stamp — SKILL Rules (orphan watchdog bullet).
-  - [x] Never re-run `init` to reset; re-run changes only given flags; margin < TTL (≤ 1800 at 1 h) — SKILL Setup (bullets 3–5); athanor intake (adopt bullet).
-  - [x] Always `--phase` on `rebase`; `rebase` counts toward the cap — SKILL Rules (`rebase_due` bullet) and the `--phase` paragraph under Commands.
-  - [x] `--delta-note`; `## Changes since base` is this gremlin's delta only — SKILL Rules (Delta bullet).
-  - [x] No `#` lines inside the changes section, fenced code included — SKILL Rules (Delta bullet).
-  - [x] Attach every note since `trained_at` to a rebase — SKILL Rules (Delta bullet); `list` row note in the Commands table.
-  - [x] `train --supersedes` on a re-train — SKILL Rules (`retrain_due` bullet).
-  - [x] Pings carry their base's latest phase; a ping at hand-back is not a leak — SKILL Waiting (pings bullet), Rules (nothing running bullet).
-  - [x] Sequential gremlins one at a time — SKILL Rules; athanor step 2.
-  - [x] `--allowed-tools` with `--tools` — SKILL Setup (last bullet).
-  - [x] `messages` vs `turns` — SKILL Waiting.
-  - [x] `Bash(uv run:*)` allow rule — SKILL Setup (bullet 2).
-  - [x] `detach_failed` only visible in `wait` — SKILL Waiting (last bullet).
-  - [x] N3 binary re-resolution; N4 `parent_inactive` — SKILL Setup (re-run bullet, with `init`'s `warnings`), Rules (re-train-during-rebase bullet), Results flags.
-  - [x] A8(b) `stalled` with `clock_jump` is a host suspend; `wait` again before acting — SKILL Results (last paragraph).
-  - [x] A8(c) an action per failure reason — SKILL Results ("What to do per failure reason", all eleven `failed` reasons, plus `timeout` and `lost`).
-  - [x] A8(a) handoff format inlined in `preamble.md` — block 3.1 (not this block's file; checked present).
-  - [x] `kill`/`expire` with a long Bash timeout — SKILL Rules; athanor Dispatching.
-  - [x] A1 intake order (`where` first, then adopt; closed gate → fresh agents even with a state dir) — athanor intake; SKILL Platforms names the A1 refusals.
-  - [x] A6 fallback wording — athanor intake, verbatim.
-  - [x] A7 no version in platform wording, "Windows-only in 0.3.0" dropped everywhere — SKILL description and Platforms, implementation SKILL Context, athanor intake.
-- Code vs digest (the code wins; no conflict found, these are additions the digest did not spell out): `where` on a closed gate carries `error` (= `reason`) besides `reason`; `rebase` returns `base` = the new name and `parent` = the old one; `tick` returns `{state, pinged, bases}`; `list`'s `running` includes pings; the `stalled` flag reaches only the result (the registry entry's `flags` are written at finalise), so while a job runs the text points at `running[].last_event_s_ago`; `usage` does stamp the orchestrator (the digest's list is right); `continue` also refuses at `parallel_cap`; a failed base's name is reusable by `train`.
-- Gates (G-text items for these files):
-  1. `git grep -n "fork of yourself\|That reading is your trunk\|read the fix's diff\|the code the phase touches" -- plugins/spire/agents/athanor.md`: nothing (exit 1).
-  2. `spire:gremlins` in athanor.md's frontmatter `skills:` (`athanor.md:20`).
-  3. `git grep -n "a fork of the builder" -- plugins/spire/skills/implementation/SKILL.md`: nothing (exit 1).
-  4. `gremlins/SKILL.md` contains `600000` (3 lines), `SPIRE_GREMLIN_CHILD` (1) and `--paths` (3).
-  6. Commands table vs `--help` (`…\scratchpad\gtext6_commands.py`, run with `uv run --no-project python … <worktree>`), output:
-     ```
-     SKILL.md Commands table: ['where', 'init', 'train', 'spawn', 'continue', 'rebase', 'wait', 'list', 'usage', 'expire', 'kill', 'tick']
-     --help commands:         ['where', 'init', 'train', 'spawn', 'continue', 'wait', 'list', 'expire', 'kill', 'rebase', 'usage', 'tick']
-     duplicates in table:     []
-     in table, not in help:   []
-     in help, not in table:   []
-     EQUAL
-     note: rows of that form anywhere in SKILL.md: 12 (other tables use other first columns)
-     ```
-  - A7: `git grep -n "0\.3\.0" -- plugins/spire/skills/gremlins/SKILL.md plugins/spire/agents/athanor.md plugins/spire/skills/implementation/`: nothing (exit 1, run after the commit so the new file is tracked). Also no "Windows-only" in the four files.
-  - No test run (no code change). No live `claude` calls. No processes started.
-- Deviations from plan:
-  - Beyond §7.1's list, SKILL.md adds: a first-phase call sequence under Commands; the `--phase` paragraph (the helper takes it as optional; the text says always pass it on `spawn` and `rebase`); the due-flag reason vocabulary from `due_flags`; actions for `timeout` and `lost`; "a failed `train` is trained again, a failed `rebase` leaves the old base active"; "no injected report → treat as `ok: false`" (plan §7 3.1 asks for the fallback when `where` fails).
-  - The per-reason actions are a bullet list, not a table: a table whose rows start ``| `model_refused` |`` would match G-text 6's row pattern and break the set check in 3.8.
-  - athanor.md fills two gaps the digest left: a fresh-agent block's red gate gets one fresh fix agent with the log; without a state dir the gate log goes next to the run log; the fallback header line is `Gremlins: none: <reason>` (run-log template, §7.4). The intake step order is now 7 steps (intake, build, gate, check, tests, run log, hand back).
-  - SKILL.md is 120 lines, the low end of the target; most bullets are long lines.
-- Flagged for review:
-  - SKILL Platforms keeps "(the 0.2.2 shape)" from §7.1: a version number, but naming the old procedure, not tying "Windows-only" to a release (A7's concern). Drop it if the reviewer reads A7 more strictly.
-  - "N1" names two different items, as in the digest: the orphan watchdog (build plan §4 N1) and the `#`-line rule (Phase 2 review N1); "N2" likewise (parallel `--paths`, and notes since `trained_at`). The text labels each where it appears.
-  - The `!` injection with `where` exiting 2 on a closed platform is still untested (digest §12); the text's fallback is "no report → treat as not ok".
-  - `rebase_due`/`retrain_due` arrive on a `spawn` that has already launched; the text says to act "before the next spawn".
-  - The fallback trunk notes: athanor.md says a fresh agent writes them "at the first phase"; later phases on a closed platform keep them as the plan's notes (no update rule given by the digest).
-- Left for later: 3.6 (`spawning-claude-code.md`, `models.md`), 3.7 (handoff), 3.8 (README row with the A7 wording, manifests, full suite, G-text in full); the Igor text (D4) stays out of scope.
-- Expected broken: nothing known.
-- Commits: `a5dfaef` (text), then this note's commit.
-
-### Block 3.6 — Reference rows
-
-- Model: `claude-sonnet-5-5` (fresh block owner, own tools, no agents dispatched)
-- Start / end: Fri Oct 16 22:08 WEDT 2026 / Fri Oct 16 22:10:07 WEDT 2026 (`date`; the end is the text commit, this note followed)
-- Done (contract §7.5, §7.6 and the amendment, A7; the Read, Edit and Write tools only):
-  - `plugins/spire/skills/implementation/references/spawning-claude-code.md`: intro and the `verified` definition now cover docs and local-test sources; Rules of thumb gains the gremlins line; Models gains the "headless `--model` takes full ids" row (observed 2026-10-16, P0.5); the Fork table is retitled "Fork (Agent tool)" with the lead line (no Agent-tool forks, goal decision 2026-10-16) and the design §9 rows with statuses and dates, the "unverified" row replaced by an `observed 2026-10-15` row; new section "Headless sessions (`claude -p`)" with one row per design §9 bullet item, each with its research id and date 2026-10-16, plus a second table of the five Phase 0 observations (P0.0, P0.1 in several rows, P0.1(d), P0.5, P0.8), each `observed 2026-10-16 (preflight report, …)`.
-  - `plugins/spire/skills/implementation/references/models.md`: dated notes only, nothing removed: trunk read is the base's training (below the kept 100k–250k line), the `usage` future-work update, and a "Notes added 2026-10-16" section (plan mode Haiku to Sonnet, alias by version, Opus 5.5 and bare blocking briefs).
-- Gates:
-  1. Status check: every new or changed row in `spawning-claude-code.md` (Models row; Fork rows; all Headless rows) carries one of `verified`, `observed`, `assumed`, `unknown` plus a date (Grep of all table rows, read through). Rows without the four statuses: none among new or changed rows. Pre-existing, unchanged rows that still lack them: the "What the `opus` alias resolves to" row (`unknown.`, undated) and the "Context window of the bare pin" row (`resolved 2026-10-05`).
-  2. `git grep -n "unverified" -- plugins/spire/skills/implementation/references/spawning-claude-code.md`: nothing (exit 1).
-  3. `git grep -n "spire:forks" -- plugins/`: nothing (exit 1).
-  - No test run (text only). No live `claude` calls. No processes started.
-- Deviations from plan:
-  - §7.5 says a CIM supervisor "survives the Bash call and the subagent's turn". The preflight report only shows survival of the stopped Bash call (all checks inside one turn) and lists survival past the hand-back under "Not tested / open". The row says what was observed, and a separate `unknown 2026-10-16` row records the hand-back survival (Phase 4 smoke). Contract wording was not copied.
-  - Statuses taken from the research doc's own marks where they are weaker than the design's list implied: `6b` (no count against parent caps) `assumed`; the invisibility row `assumed` (design says so); `6e` and the plan-mode upgrade `observed`; "does the nested pipe reach the host" and "which var gates the Artifact tools" `unknown`.
-  - Two Agent-tool fork questions the old `unknown` row asked besides fork-of-fork (foreground return, preloaded skills) stay as one `unknown 2026-10-16` row.
-  - The `verified` definition in the file intro was widened (docs and local tests), since the headless rows rest on them.
-  - Version numbers appear only for CLI/docs facts (`2.1.283`, `v2.1.242`), none for Spire platform wording (A7).
-- Flagged for review:
-  - The `observed 2026-10-15` "fork not offered" row cites the agent-type lists of 2026-10-05 and 2026-10-15 only via design §9; I did not re-check those lists.
-  - `--system-prompt-snapshot` (`--help` 2.1.283) is taken from design §9; the research doc itself does not mention it.
-  - The "smoke base 23.7k" figure in models.md is the contract's number (§7.6); I did not re-measure it.
-- Left for later: 3.7 (handoff), 3.8 (README row, manifests, full suite, G-text in full).
-- Expected broken: nothing known.
-- Commits: `813327a` (references), then this note's commit.
-
-### Block 3.7 — Platform handoff report
-
-- Model: `claude-opus-5-5[1m]` (fresh block owner, own tools, no agents dispatched)
-- Start / end: Fri Oct 16 22:10 WEDT 2026 / Fri Oct 16 22:18:36 WEDT 2026 (`date`; the end is the report commit, this note followed)
-- Done: new `docs/workpad/reports/2026-10-16-22-gremlins-platform-handoff.md`, written per digest §8 and the amendment (A7, the `SPIRE_GREMLIN_UNSUPPORTED_OK` name, the C13 and C17 notes) against the code at `485cc66`. Sections: 1 Status (release gating restated, branch and checkout, no live call under the new names yet, Phase 4 smoke still required); 2 The seam (markers `:267`/`:734`, the seam grep, `PosixPlatform` per member with lines, the delegates, the gate functions); 3 Running the gates (uv, G-unit, G-where, the override and that `Base.setUp` sets it, the C13 note that only `GateTests` cover the gate and that `test_supported_flags` is the one test pinning the real POSIX value); 4 Known POSIX gaps (M14, the `/proc` walk on macOS, dead-root claims, zombie liveness, the ≥ 3 tree expectation, `os.link` locks, `setsid` survival, the supervisor interpreter, path refusals, the scrub list and the override passing it, the Windows-only `tearDownModule` check, a Windows `claude.exe` accepted under WSL, the transcript slug, the `!` injection with a failing `where`, the `.;` join); 5 WSL findings (inventory, interop, `where` table, suite table, the four causes and which 3.4a fixed); 6 What to test (12 items); 7 Smoke recipe (15 steps as commands with what each must show, briefs, tree recording, every `wait`/`kill`/`expire` with Bash `timeout: 600000`, spend about $1, $0.6–1.5); 8 How to lift the gate (11 places, per A7, including WSL's `sys.platform` being `linux`); 9 Not covered.
-- Deviations from plan:
-  - §8.4's "M14: `kill` leaves `claude` running on macOS" (from the Phase 1 review) is stated more narrowly. By the current code `kill_job` passes the `claude` record as an extra root to `kill_tree`, so the sweep kills `claude` itself by pid; what survives on macOS is `claude`'s descendants. The report says so and asks the macOS porter to check it.
-  - Beyond §8's list, §4 adds items found while reading the code, each marked "from the code": the supervisor's own kills spin `KILL_VERIFY_S` on a zombie `claude` before `p.wait()`; pid-only checks without `/proc` can `killpg` a reused pid (the most dangerous macOS gap); `tearDownModule`'s leftover check is Windows-only; lock staleness is pid-only on macOS.
-  - §8 lists two more places that carry the platform wording besides A7's list: `implementation/SKILL.md:49` and `implementation/references/spawning-claude-code.md:75`.
-  - No CHANGELOG file exists; the report says the changelog is the release commit body and that a lift must not rewrite it (the merge or release commit carries the corrected platform line).
-- Flagged for review:
-  - The goal's platform, release-gating and seam decisions are uncommitted edits in the main checkout (`git status` there shows `docs/workpad/goals/headless-forks.md` modified; its last commit is `d373689`). A porter checking out the branch cannot read them; the report restates them. Igor may want to commit the goal on `main`.
-  - `headless-forks` had no upstream at writing (not pushed); the report's checkout lines assume the user pushes it.
-  - Lifting `linux` also opens WSL (`sys.platform` is `linux` there); the report leaves to the Linux Igor and the user whether `supported` should also require `not is_wsl()`.
-  - The changelog problem above: the 3.8 release commit body will say "Linux and macOS gated", and nothing on the branch can correct it without a new commit or a merge message.
-  - The smoke recipe's steps 13–15 (orphan, lost, survival) are new live steps that never ran on Windows either (Windows covered orphan and lost with the stub only, survival not at all).
-- Left for later: 3.8 (README row, manifests, full suite, G-text in full, release commit). The report's §1 tells porters to read the Phase 3 close for anything after it.
-- Expected broken: nothing (text only). No test run, no live `claude` calls, no processes started.
-- Commits: `95e6496` (report), then this note's commit.

docs/workpad/reports/2026-10-16-08-headless-forks-trunk-notes.md

@@ -1,53 +0,0 @@
-# Trunk notes — headless forks build (`spire:forks`)
-
-Written by the Athanor (`claude-opus-5-5[1m]`) at Phase 0, 2026-10-16. For fresh agents and a successor Athanor. A page, not a design.
-
-## Where things are
-
-- Build plan (authoritative): `docs/workpad/plans/2026-10-16-02-headless-forks-build.md`. Plan: `plans/2026-10-16-01-headless-forks.md`. Design: `designs/2026-10-16-01-headless-forks.md` (runtime amendment at the end: Python under uv). Research: `research/2026-10-16-00-claude-headless-fork-sessions.md`.
-- Run log: `docs/workpad/reports/2026-10-16-08-headless-forks-run.md`. Preflight report (Phase 0 output, the Phase 1 defaults): `docs/workpad/reports/2026-10-16-09-headless-forks-preflight.md`.
-- Checkout: worktree `G:\dev\projects\reliquary\.claude\worktrees\headless-forks`, branch `headless-forks`, cut from `d373689`.
-- Phase 0 probes and raw streams (throwaway, not in git): `C:\Users\g4b\AppData\Local\Temp\claude\G--dev-projects-reliquary\42c87f82-5542-46aa-8d01-4166e3f0bcfe\scratchpad\headless-forks-p0\` — `probes/` (code Phase 1 may reuse: `p0lib.py` scrub, command line, stream parser, Windows pid+ctime liveness, job-object query; `spawn3.py` CIM spawn), `raw/` (streams, summaries), `clone/` (scratch clone, untrusted workspace).
-- New code goes to `plugins/spire/skills/forks/` only (`forks.py`, `preamble.md`, `templates/`, `tests/test_forks.py`). Nothing else in `plugins/` changes before Phase 3.
-
-## Host facts that shape the helper (measured, see the preflight report)
-
-- `uv` 0.5.13 at `~/.local/bin/uv`; `uv run <abs>/script.py` picks CPython 3.13.1 from a cached archive venv. `sys.executable` is the venv `Scripts\python.exe`; `sys._base_executable` is the real interpreter. A `pyproject.toml` or a `.python-version = 3.9` in the cwd is ignored. uv writes one line to stderr, nothing to stdout. Inside `uv run` the env gains `VIRTUAL_ENV` and a PATH head entry `<venv>\Scripts`; no `UV_*` vars.
-- No job objects anywhere (Bash tool, uv, supervisors: `IsProcessInJob` false). The Bash tool's stop kills by **process tree** (parent links). A supervisor whose launcher is still alive dies with the Bash call; one spawned through CIM (`Win32_Process.Create`) is parented to `WmiPrvSE.exe` and survives.
-- **No visible windows.** An unhidden CIM spawn opens a Windows Terminal window on the user's desktop (user report). Spawn the supervisor with `Win32_ProcessStartup.ShowWindow=0` and every child of it with `CREATE_NO_WINDOW` (`0x08000000`); never `DETACHED_PROCESS`/`CREATE_NEW_CONSOLE`. Tests check it.
-- CIM-spawned processes get the **registry default user env**, not the caller's (no `CLAUDE_CODE_EXECPATH`, no Git Bash PATH). The env for `claude` must be shipped explicitly (file next to the job) and the binary path must be absolute.
-- A Bash call that exceeds its `timeout` is **moved to the background**, not killed; its completion notification reached this subagent. Keep the `timeout: 600000` rule anyway.
-- Two binaries: PATH `claude` 2.1.283, `$CLAUDE_CODE_EXECPATH` 2.1.299 (Desktop). Pin the latter.
-- Host `CLAUDE_EFFORT=high` today (the research saw `medium`); scrubbed anyway.
-- Only `G:/dev/projects/reliquary` is trusted in `~/.claude.json`; the worktree inherits trust (no warning); the scratch clone does not (project `permissions.allow` ignored, stderr says so).
-
-## Invariants Phase 1 must keep
-
-- stdout = exactly one JSON object; diagnostics and uv chatter on stderr.
-- Usage: fork `result.usage` equals the `modelUsage` delta against the base, field for field; cost delta = `total_cost_usd` minus the base's cumulative total. Stream assistant events carry interim `output_tokens`; never sum them.
-- Cache verdict from the **first** assistant event; base context = input + cache creation + cache read of the base's last assistant message (stream and transcript agree).
-- Every git call `git --no-optional-locks`.
-
-## Known traps
-
-- `git clone --local` from `G:` to `C:` cannot hardlink; use `--no-hardlinks`.
-- Opus 5.5 may refuse a bare "run this blocking command" brief as pointless; say why it is wanted.
-- A fork whose Bash tool backgrounds a command leaves that command running after `claude` exits (seen: `sleep 240`, orphaned). `kill` by tree cannot reach it once `claude` is gone.
-- Unlisted models are not refused: Claude Code substitutes a permitted model and emits a `system/informational` warning. Detect it; do not trust `init.model` alone.
-
-## State for Phase 3 (added 2026-10-16 18:15 +0200, end of Phase 2)
-
-- Phases 0–2 are built, reviewed and fixed (Phase 2 fix pass `d2d5104`; its re-check is Igor's call). The helper is complete for Phase 3's purposes: every command in build plan §6 G-text item 6 is in the dispatch (`where init train fork continue rebase wait list usage expire kill tick`, internal `_supervise`).
-- Phase 3 changes only text (`forks/SKILL.md`, `agents/athanor.md`, `implementation/SKILL.md`, `references/*`, README) and the two manifests. The run log's "Successor boot" section lists every review item routed to the Phase 3 text; treat that list as part of the brief.
-- The real JSON and exit codes to write the text against: run `where`, and `<command> --help` (prints one JSON object). The contract digests describe result fields, reasons and flags as built.
-- Live smoke references for numbers and shapes: `…\headless-forks-p0\smoke1\` (Phase 1) and `…\smoke2\` (Phase 2: rebase, pings, `usage` md).
-
-## Phase 3 (added 2026-10-16 18:45 +0200, Phase 3 Athanor `claude-opus-5-5[1m]`)
-
-- The brief for every Phase 3 block is the digest `docs/workpad/plans/2026-10-16-18-gremlins-phase3-contract.md`, **including its closing "Amendment after pre-build check" section, which wins over the sections above it**. The check that produced it: `docs/workpad/reports/2026-10-16-19-gremlins-phase3-digest-check.md`.
-- The skill is renamed in block 3.1: `plugins/spire/skills/forks/` → `plugins/spire/skills/gremlins/` (`gremlins.py`, `tests/test_gremlins.py`). From 3.1 on, the gates are G-unit `uv run plugins/spire/skills/gremlins/tests/test_gremlins.py [Class …]` and G-where `uv run plugins/spire/skills/gremlins/gremlins.py where`. A single class runs as `uv run …/test_gremlins.py ClassName` or `ClassName.test_name`.
-- Words: the trained session is the **base**; a headless worker spawned from it is a **gremlin**; the command is `spawn` (job kind `spawn`, `method: "fork"`); env marker `SPIRE_GREMLIN_CHILD`; state dir `<run log without .md>-gremlins/`.
-- Code map of `forks.py` before the rename (line numbers at `7351c40`): constants `:40-180`; paths and cygpath `:270-345`; atomic files and `RegistryLock` `:380-570`; ledger `:593-623`; processes (ctypes, ctime, liveness, table, tree, kill) `:626-895`; `_run`/`git` `:898-918`; scrub `:920-991`; binary/uv/python `:994-1077`; C8 `:1080-1127`; stream, usage, cache, warmth `:1130-1372`; job files, templates, `spawn_supervisor` `:1374-1460`; `_conclude`/`_rebase_succeeded`/`finalize_job` `:1463-1670`; orchestrator stamp, `reap_lost`, `kill_job` `:1684-1786`; argparse `:1794-1990`; `where`/`init` `:1998-2235`; launches `:2238-2927`; ping/tick `:2930-3112`; `Supervisor` `:3115-3338`; `wait`/`list`/`kill`/`expire` `:3341-3496`; `usage` `:3499-3728`; dispatch `:3731-3787`.
-- Test classes: `PathTests ScrubTests LockTests AtomicTests PidTests ProcessTreeTests InitTests CliTests SubprocessTests RuleTests WarmthTests TickTests UsageTests LaunchTests` (the last uses the real CIM detach and the stream stub; slow). Full suite about 150 s; run it only in block 3.8.
-- Test cadence (user): py_compile plus the touched test classes between blocks; the full suite once at phase end. No live `claude` calls in Phase 3.
-- File rule (user): Read, Write and Edit for files; never `cat`/`sed`/heredocs to read or change files.

docs/workpad/reports/2026-10-16-09-headless-forks-preflight.md

@@ -1,187 +0,0 @@
-# Preflight report — headless forks, Phase 0
-
-**GO** — every STOP item passed (P0.0 uv, P0.1 detach on rung 3 hidden, P0.2 large base, P0.3 usage); P0.4 and P0.6 passed too, so the parallel cap stays 2 and pings default on.
-
-- **Date**: 2026-10-16, 08:16–12:16 +0200 (times from `date`; probing ended 10:13, the clock jumped from 10:13 to 12:16 between two consecutive commands, cause unknown)
-- **Run by**: the Athanor, model id `claude-opus-5-5[1m]`, from its own Bash (Agent-spawned subagent of the Desktop session, Windows 10, Git Bash)
-- **Build plan**: [plans/2026-10-16-02-headless-forks-build.md](../plans/2026-10-16-02-headless-forks-build.md) §6 Phase 0 (amends plan §7 Phase 0)
-- **Branch / checkout**: `headless-forks` in `.claude/worktrees/headless-forks`, from `d373689`
-- **Raw files** (not in git): `C:\Users\g4b\AppData\Local\Temp\claude\G--dev-projects-reliquary\42c87f82-5542-46aa-8d01-4166e3f0bcfe\scratchpad\headless-forks-p0\` — `$P0` below. Probe code in `$P0\probes\`, streams and summaries in `$P0\raw\<item>\`.
-- **Binary under test**: `$CLAUDE_CODE_EXECPATH` = Desktop `claude.exe` 2.1.299 (PATH `claude` is 2.1.283; used once by accident, noted at P0.1).
-- **Spend**: **$5.68** client estimate (`total_cost_usd`), summed as per-call deltas over 45 calls by `$P0\probes\spend.py`; plus three killed `claude` calls that wrote no result (`r3-kill3`, `r3-kill5`, `r5-kill`, a few cents). Limit was $25 before P0.2 completed; $4.87 had been spent by 08:55, after P0.2–P0.5, P0.7 and P0.8.
-
-## Defaults Phase 1 must use
-
-| Topic | Default | From |
-|---|---|---|
-| Spawn rung | **Rung 3, hidden**: the launcher creates the supervisor through CIM with a hidden window: `powershell -NoProfile -NonInteractive -Command "$si = New-CimInstance -ClassName Win32_ProcessStartup -ClientOnly -Property @{ShowWindow=[uint16]0}; Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{CommandLine=…; CurrentDirectory=…; ProcessStartupInformation=$si}"`, reading `ReturnValue` and `ProcessId`. Launch cost about 0.3 s. Without `ShowWindow=0` the supervisor opens a **visible console window** (Windows Terminal tab titled with the interpreter path; user report and positive control). | P0.1 |
-| No visible windows | Every child the supervisor starts (`claude`, any helper process) is spawned with `CREATE_NO_WINDOW` (`0x08000000`), never `DETACHED_PROCESS` or `CREATE_NEW_CONSOLE` (a console-less parent makes each console child open its own window). `claude`'s Bash children inherit the hidden console: no window seen with a 10-process tree (`claude.exe` → `bash.exe` ×3 → `PING.EXE`, 4 `conhost.exe`). Phase 1 tests and the smoke check "no visible window of the tree" (EnumWindows + IsWindowVisible on the tree's pids, plus visible `ConsoleWindowClass`/`CASCADIA_HOSTING_WINDOW_CLASS` windows). | P0.1 retest |
-| Supervisor env | CIM gives the child the registry default user env, not the caller's. The launcher writes the full scrubbed child env into the job's state (e.g. `jobs/<job>.json` or a sidecar) and the supervisor passes exactly that env to `claude`. The binary path is stored absolute (it is in the fingerprint anyway). | P0.1 |
-| Interpreter | `sys._base_executable` (differs from `sys.executable` under `uv run`: venv launcher `…\archive-v0\<id>\Scripts\python.exe` vs `…\uv\python\cpython-3.13.1-…\python.exe`), with `-I`. `-I` drops the script dir from `sys.path`; the supervisor must not rely on it. | P0.0, C6 |
-| Kill | `taskkill /T /F /PID <supervisor>`; verify by recorded pid + creation time. | P0.1 |
-| Scrub additions (uv) | Drop `VIRTUAL_ENV`; drop PATH entries under `VIRTUAL_ENV` or `sys.prefix` (one entry: `<venv>\Scripts`, prepended). uv sets no `UV_*` vars here; dropping `UV_*` stays as a guard. Keep `PYTHONDONTWRITEBYTECODE` (host-set, not uv). | P0.0 |
-| `where` must report (host `CLAUDE_CODE_*` and kin on neither list) | `CLAUDE_CODE_SESSION_ATTENDED`, `CLAUDE_CODE_DISABLE_CRON`, `CLAUDE_CODE_EAGER_FLUSH`, `CLAUDE_CODE_SIMPLE`, `CLAUDE_CODE_EMIT_TOOL_USE_SUMMARIES`, `CLAUDE_CODE_ORGANIZATION_UUID`, `CLAUDE_CODE_ACCOUNT_UUID`, `CLAUDE_CODE_USER_EMAIL`, `CLAUDE_CODE_OAUTH_SCOPES`, `CLAUDE_CODE_DISABLE_TERMINAL_TITLE`, `CLAUDE_CODE_STARTUP_FAILURE_RESULTS`, `CLAUDE_AGENT_SDK_MCP_NO_PREFIX`, `CLAUDE_PREVIEW_CLASSIFIER_FLOOR`, `DISABLE_MICROCOMPACT`. All were inherited (kept) in every probe call and auth worked. | P0.0 env listing |
-| Usage rule | Per call: the four columns and the 1h/5m split come from the `result` event's top-level `usage` (`input_tokens`, `output_tokens`, `cache_creation_input_tokens`, `cache_read_input_tokens`, `cache_creation.ephemeral_1h_input_tokens` / `ephemeral_5m_input_tokens`). For a fork this equals the `modelUsage` delta against the base's cumulative `modelUsage`, field for field (7 of 7 forks). `models_used` = the `modelUsage` keys whose counts grew. Cost Δ = `total_cost_usd` − the session total before the call (= the `modelUsage[m].costUSD` delta, 7 of 7). Never sum stream assistant events for `output_tokens`: they carry interim counts (seq forks: 102 summed vs 1,448 real). | P0.3 |
-| `usage_mismatch` | Compare `result.usage` with the `modelUsage` delta (they agreed exactly here). | P0.3 |
-| Cache verdict input | First assistant event's `usage` (input and cache fields are final there). Base context = `input + cache_creation + cache_read` of the base's last assistant message; the stream and the transcript give the same number (182,204). | P0.2, P0.7 |
-| Parallel cap | **2** (P0.4 passed). | P0.4 |
-| Pings | **on** by default (`init --pings on`): a ping 50 min after the base's last hit kept it warm to 65 min (P0.6 pass). A ping can itself re-create part of the prefix (7,463 of 88,571 here) and still count as a hit. | P0.6 |
-| Fingerprint fields | Keep all launch fields of design §3.3. **Effort** stays pinned but is not cache-defining: a `--effort medium` fork of a `high` base read 182,202 of 182,204 tokens from cache, same as the control. `init` has no effort field (`per_turn_effort_active: true` only). | P0.5 |
-| Model ids | Full ids accepted; `[1m]` accepted (`init.model` and the `modelUsage` key both read `claude-opus-5-5[1m]`; `message.model` reads `claude-opus-5-5`). Compare `models_used` with the requested id including the suffix. | P0.5 |
-| `availableModels` rule (C8, D5) | A requested id is **admitted** if a list contains the id itself or its family alias (`opus`, `sonnet`, `haiku`, `fable`); no list in user/project/local settings admits everything. An id that is not admitted is **not refused**: Claude Code silently runs a permitted model and emits `{"type":"system","subtype":"informational","level":"warning","content":"Model \"<id>\" is restricted by your organization's settings. Using <other> instead."}`. So `init` applies the admit rule (exit 2 per C8), and at runtime the supervisor treats that event, or a `modelUsage` key ≠ the requested id, as `failed`, reason `model_refused`. In reliquary all four family aliases are listed, so every full id is admitted (U4 is moot for Sonnet and Haiku). | P0.5 |
-| Injection (R4) | `!` injection **ran** in an Agent-tool subagent's preload (probe `where` called 4.8 s after the headless launch). `allowed-tools: Bash(uv:*)` did **not** pre-approve the subagent's later `uv run …/probe.py ping` (denied: "This command requires approval"). SKILL.md must tell projects to add a `Bash(uv run:*)` (or `Bash(uv:*)`) allow rule; reliquary has `Bash(uv:*)`. Caveat: the probe dir was an untrusted workspace. | P0.8 |
-| Fork session ids | `--session-id <uuid>` with `--resume <base> --fork-session` is honoured: the fork gets that id. The helper may pre-assign fork ids. | P0.7 |
-
-## Results per item
-
-| Item | Result | Variant / notes |
-|---|---|---|
-| P0.0 uv | **pass** | (a) repo cwd, (b) `pyproject.toml` cwd, (c) `.python-version = 3.9` cwd: all rc 0, stdout one JSON line, Python 3.13.1 in all three, no `.venv`/`uv.lock` created. |
-| P0.1 detach | **pass, rung 3 hidden** | Rungs 1 and 2 failed (d). Rung 3 passed (a)–(d) and the tree-kill but showed a visible console window (fails the added "no visible window" criterion). Rung 3 with `ShowWindow=0` and `CREATE_NO_WINDOW` children passed (a), (b), (d), the tree-kill and "no visible window"; (c) passed (1,000 s, no window in 24 checks). |
-| P0.2 large base | **pass** | Base 182,204 context tokens, three sequential forks each read 182,202 on the first request (0.99999), no compaction. |
-| P0.3 usage | **pass** | Rule above; reproducible on 7 forks (1, 3 and 7 turns). |
-| P0.4 parallel | **pass** | No `index.lock`, both edits intact, both first requests 0.99999; the Athanor gated and committed both. |
-| P0.5 flags and models | **pass (all accepted)** | Table below. |
-| P0.6 TTL | **pass** | A's fork at 65 min after a 50-min ping: 1.0004; B's fork at 65 min without ping: 0.080 (`partial`). |
-| P0.7 transcripts | **recorded** | Message usage present on every assistant line; copied base messages keep `message.id` and `uuid`; R6 honoured. |
-| P0.8 injection proxy | **injection yes, pre-approval no** | Informational; fallback text applies. |
-| Spend trigger | **not hit** | $5.68 total; $4.87 by 08:55 (P0.2 long done) |
-
-STOP criteria (plan decision 1, build plan §6): P0.0 pass, P0.1 pass (rung 3), P0.2 pass, P0.3 pass. No STOP. No fallback beyond the ladder was needed; rung 3 needed the hidden-window fix added after the coordinator's message.
-
----
-
-## P0.0 uv
-
-- Probe: `$P0\probes\p00_probe.py`, the plan §2 PEP 723 header. Command: `uv run "C:/…/probes/p00_probe.py"` from the Athanor's Bash. Raw: `$P0\raw\p00\`.
-- uv 0.5.13 (c456bae5e 2024-12-27). Python chosen: CPython 3.13.1, the cached archive venv `C:\Users\g4b\AppData\Local\uv\cache\archive-v0\1V7ITIfzQwCDPBZsZhb9M`. The same venv in all three cwds.
-- (a) cwd = worktree; (b) cwd = `$P0\p00-pyproject` with `[project]` (deps `requests`, hatchling build): no sync, no `.venv`, no `uv.lock`; (c) cwd = `$P0\p00-pyver` with `.python-version` = `3.9` (3.9.16 is installed): 3.13.1 chosen, `requires-python >= 3.10` wins.
-- stdout: exactly the probe's one line in every run. stderr: one line, `Reading inline script metadata from …`.
-- Latency: warm 125–134 ms (5 runs); cold uv cache (fresh `UV_CACHE_DIR`) 532 ms. The first-ever run in the real cache was not timed (the first probe call warmed it).
-- Env diff Bash → inside `uv run`: added `VIRTUAL_ENV` (= the archive venv); PATH gains `<venv>\Scripts` at the head; no `UV_*`; `PYTHONDONTWRITEBYTECODE=1` is host-set (present in Bash too).
-- Resolved tools inside `uv run`: `git` = `C:\Program Files\Git\mingw64\bin\git.EXE` (2.34.1.windows.1), `claude` = `C:\Users\g4b\.local\bin\claude.EXE` (2.1.283), `uv` = `C:\Users\g4b\.local\bin\uv.EXE`, `python` = the venv's.
-- `sys.executable` = `…\archive-v0\1V7ITIfzQwCDPBZsZhb9M\Scripts\python.exe`; `sys._base_executable` = `C:\Users\g4b\AppData\Roaming\uv\python\cpython-3.13.1-windows-x86_64-none\python.exe` (C6 applies).
-
-## P0.1 detach
-
-Probes: `p01_launch.py` (run under `uv run`, spawns the supervisor by rung), `p01_sup.py` (supervisor: ticks every 10 s, a python sleeper child, `claude -p` calls at given offsets), `p01_check.py` (pid + creation-time liveness, CIM descendant snapshot, `taskkill /T /F`). Raw: `$P0\raw\p01\<tag>\` (`launch.json`, `state.json`, `tick.log`, `sleeper.log`, `check-*.json`, `claude*.jsonl`).
-
-Job objects: `IsProcessInJob` was **false** for the `uv run` launcher and for every supervisor, so `CREATE_BREAKAWAY_FROM_JOB` had nothing to break from (A5's premise does not hold on this host today).
-
-What the Bash tool does: a call that exceeds its `timeout` (5 s and 8 s tried) is **not killed**; it is moved to the background ("Command did not complete within its 5s timeout and was moved to the background"), and its completion notification arrived in this subagent. To get the "killed Bash call" of (d), the backgrounded task was stopped with `TaskStop`, which kills the **process tree by parent links**.
-
-| Rung | Tag | (a) uv exits | (b) Bash call ends | (c) ≥ 15 min, growing, completes | (d) Bash call killed (launcher still alive) | Tree-kill |
-|---|---|---|---|---|---|---|
-| 1 `DETACHED_PROCESS\|CREATE_NEW_PROCESS_GROUP\|CREATE_BREAKAWAY_FROM_JOB` (`0x1000208`) | `r1-main`, `r1-tkill` | pass | pass | pass: 1,020 s, ticks 1→3→12→103 over checks at 08:21:04, 08:21:28, 08:23:02, 08:45:23; `claude` at +20 s and +935 s both `P01-OK` | **fail**: supervisor and sleeper dead at the first check after `TaskStop` (08:21:28) | — |
-| 2 same without breakaway (`0x208`) | `r2-tkill` | — | — | — | **fail** (same) | — |
-| 3 CIM `Win32_Process.Create` | `r3-main`, `r3-tkill`, `r3-kill5` | pass | pass | pass: 1,020 s, ticks 2→103, `claude` at +20 s and +933 s both `P01-OK` | **pass**: alive after `TaskStop`; parent is `WmiPrvSE.exe` (pid 34932) | **pass**: 8 processes (`claude.exe` → `bash.exe` ×3 → `PING.EXE`, `conhost.exe` ×2, sleeper) all dead by pid + creation time; no `PING.EXE` left |
-
-**Retest for visible windows (coordinator's message, 09:52; user saw a Python console window on the desktop).** Criterion added to P0.1: no visible window from the supervisor or any descendant. Window check: `EnumWindows` + `IsWindowVisible` for the tree's pids, plus any visible `ConsoleWindowClass` / `CASCADIA_HOSTING_WINDOW_CLASS` window.
-
-| Variant | Tag | Visible window | (a) | (b) | (c) | (d) | Tree-kill |
-|---|---|---|---|---|---|---|---|
-| Rung 3 as first run (positive control, 15 s) | `r3-wincontrol` | **yes**: Windows Terminal window (`CASCADIA_HOSTING_WINDOW_CLASS`, pid 19872) titled `…\cpython-3.13.1-…\python.exe` | — | — | — | — | — |
-| Rung 3 hidden: `Win32_ProcessStartup.ShowWindow=0`; supervisor children `CREATE_NO_WINDOW` | `r5-main`, `r5-tkill`, `r5-kill` | **none**, checked 26 times incl. during a `claude` call and during `claude` → `bash` → `PING` | pass | pass | pass: 1,000 s, ticks 1→101 over 24 checks 09:55:54–10:13:01, `claude` at +20 s and +935 s both `P01-OK`, done | pass (alive after `TaskStop` at 09:56:31, check 09:56:43) | pass: 11 processes dead by pid + creation time, no `PING.EXE` left |
-| Popen `CREATE_NO_WINDOW\|CREATE_NEW_PROCESS_GROUP\|CREATE_BREAKAWAY_FROM_JOB`, children `CREATE_NO_WINDOW` (informational) | `r6-win` | none (3 checks incl. a `claude` call) | pass | pass | not run | not run; expected to fail like rungs 1/2 (same parentage) | not run |
-
-So the earlier visible windows came from every rung-3 supervisor before the fix (`r3-*`, and the P0.2 and P0.6 probes, which were launched with the same unhidden CIM call), and presumably (not measured) from the console children of the rung-1/2 `DETACHED_PROCESS` supervisors (sleeper, `claude`), which get a new console each when the parent has none.
-
-Also recorded:
-
-- `r1-dprime` (informational): rung 1 with the launcher already exited, then the Bash call stopped while a later process ran → supervisor **survived**. Rung 1 dies only while its launcher is alive in the stopped tree. That matters for the helper because `wait` stays alive while it would launch pings; rung 3 avoids the question.
-- CIM env: a CIM-created process gets the registry default user env. 58 of the Bash env's variables were missing, among them every `CLAUDE*` var, `CLAUDE_CODE_EXECPATH`, `HOME`, `MSYSTEM`, Git's PATH entries (`$P0\raw\p01\wmi-env.json`). Effect seen: `r3-main` and `r3-tkill` (spawned before the fix) ran PATH `claude` 2.1.283 instead of 2.1.299. Fixed in the probe by shipping `env.json`; `r3-kill2`…`r3-kill5` and P0.2/P0.6 ran 2.1.299.
-- Kill-test retries: `r3-kill` (2.1.283) let the harness background `sleep 240` and exited; the backgrounded `sleep.exe` was left **orphaned** after `claude` exited (killed by hand, pid 31372). `r3-kill2` was missed (the scratch clone took 20 min, 08:24→08:45, and the target finished). `r3-kill3` killed before the Bash child existed. `r3-kill4`: Opus 5.5 declined a bare blocking `ping` as pointless. `r3-kill5` with an honest brief: pass (above).
-- Spend in P0.1: about $0.20 (killed calls `r3-kill3`/`r3-kill5` wrote no result and are not counted).
-
-## P0.2 large base
-
-- Probe `p02_base_forks.py`, run detached via `spawn3.py` (rung 3, still unhidden then: it showed a console window while it ran). cwd = scratch clone `$P0\clone` (`git clone --local --no-hardlinks` of `d373689`; `--no-hardlinks` because `G:`→`C:` cannot hardlink). Raw: `$P0\raw\p02\`.
-- Fingerprint: `--model claude-opus-5-5 --effort high --permission-mode dontAsk --tools Bash,Read,Edit,Write,Glob,Grep,Skill --allowedTools <same> --disallowedTools "Bash(git push:*),Bash(git rebase:*),Bash(git reset --hard:*),Bash(claude:*)" --strict-mcp-config --mcp-config $P0\mcp-empty.json --append-system-prompt-file $P0\preamble-probe.md`, `--output-format stream-json --verbose`, prompt on stdin, scrubbed env (design §4 + `VIRTUAL_ENV` + venv PATH), `CLAUDE_CODE_PROMPT_CACHE_TTL=1h`, `DISABLE_AUTOUPDATER=1`.
-- Base `d7c7a3aa-dfd5-40df-87f2-ccc82e49a369`: read 42 files (all `plugins/spire/**/*.md` plus 7 workpad docs) with Read, 43 turns, 74.7 s, context **182,204** tokens (last message: 2 + 45,677 created + 136,525 read), all writes `ephemeral_1h`, cost $1.6298, no compaction event.
-
-| Fork | Turns | First request: cache read / created | Ratio | Cost Δ | Commit (clone) |
-|---|---|---|---|---|---|
-| seq 1 | 7 | 182,202 / 1,242 | 0.99999 | $0.3116 | `64dbefa` |
-| seq 2 | 7 | 182,202 / 1,247 | 0.99999 | $0.3091 | `9bfefb7` |
-| seq 3 | 7 | 182,202 / 1,259 | 0.99999 | $0.3029 | `bb5514d` |
-
-Each fork read `plugins/spire/CLAUDE.md`, wrote `scratch/p0-fork-<k>.md`, ran `git diff --check`, `git add`, `git commit`, `git log`, and replied with its hash. No denials. No re-run needed.
-
-## P0.3 usage
-
-Analysis `p03_usage.py` → `$P0\raw\p03-usage.json`.
-
-- The `result` event carries `usage`, `modelUsage`, `total_cost_usd`, `num_turns`, `is_error`, `permission_denials` (plus `subagent_stats`, `terminal_reason`, timing fields). `usage` also has `iterations[]` and `output_tokens_details.thinking_tokens`; `modelUsage[m]` has `costUSD`, `contextWindow` (1,000,000 for `claude-opus-5-5` here), `canonicalModel`, `costBasis`.
-- On every fork (seq 1–3, par 1–2, two 1-turn forks) `result.usage` == `modelUsage` delta vs the base for all four columns, and `total_cost_usd` delta == `modelUsage.costUSD` delta. Example seq 1: input 14, output 1,448, created 3,113 (all 1h), read 1,288,193; cost Δ $0.311559.
-- Summing stream assistant events (last event per message id) matches input and both cache columns but not output (102 vs 1,448): stream events carry interim `output_tokens`.
-- `num_turns` ≠ assistant messages on the base (43 vs 7 message ids): turns count tool round trips, several Read calls share one message. The helper's `turns` should come from `num_turns`.
-
-## P0.4 parallel
-
-Two forks launched together from the base (`par1`, `par2`, threads in the same probe), each writing `scratch/p0-par-<k>.md` and running `git status`, no commits. No `index.lock` in either stream; both files intact (3 lines each); both first requests 182,202 read (0.99999). The Athanor then gated (`git add -N` + `git diff --check`, rc 0) and committed each file by explicit path: clone `0f72edb`, `9d3ddc1`.
-
-## P0.5 flags and models
-
-Probe `p05_flags.py` → `$P0\raw\p05\`. Tool-less calls (`--tools ""`) unless noted.
-
-| Check | Outcome | Default |
-|---|---|---|
-| `--effort` with `CLAUDE_EFFORT` scrubbed | accepted; not visible in `init`; a `medium` fork of the `high` base hit 0.99999 like the `high` control | keep pinned; not cache-defining |
-| `--strict-mcp-config` + empty config | `mcp_servers: []`, no `mcp__*` tools (the claude.ai Docs connector is gone) | keep |
-| `Skill` in `--tools` | accepted; `init.tools` lists it | keep |
-| `[1m]` in `--model` | accepted; `init.model` and `modelUsage` key `claude-opus-5-5[1m]` | keep |
-| `apiKeySource` | present, `"none"` (OAuth) | check stays |
-| `--agent p0agent` (project `.claude/agents/p0agent.md`) + `--append-system-prompt-file` | both markers quoted (`AGENT-MARKER-3KX`, `PREAMBLE-MARKER-7Q4`); control without `--agent` quoted none | keep |
-| agent `tools: Read` vs `--tools Bash,Read` | `init.tools` = `["Read"]`: the intersection | the agent file can only narrow `--tools` |
-| `claude-opus-5-5` (listed) | runs as asked | — |
-| `claude-sonnet-5-5`, `claude-haiku-5-5` (unlisted full ids, aliases listed), trusted checkout | run as asked | admitted via family alias |
-| `claude-opus-4-6` (bare; only `[1m]` form listed), trusted checkout | runs as asked | admitted via `opus` |
-| unlisted family | none exists (all four aliases listed); **skipped** in project settings, tested via `--settings` instead ↓ | — |
-| `--settings '{"availableModels":["claude-opus-5-5"]}'`, request `claude-sonnet-5-5` | **substituted**: ran `claude-opus-5-5` with the `system/informational` warning quoted above | `model_refused` |
-| same list, request `claude-opus-5-5` | runs | — |
-| `--settings '{"availableModels":["opus","sonnet"]}'`, request `claude-sonnet-5-5` | runs as asked | alias admits full id |
-
-Trust: in untrusted dirs (scratch clone, `$P0\p05-cwd`, `$P0\p08-cwd`) stderr says "Ignoring 36 permissions.allow entries from .claude/settings.json: this workspace has not been trusted". `G:/dev/projects/reliquary` is trusted; a tool-less call in the worktree printed no warning (trust is inherited by subdirectories). Project agents still load in untrusted dirs. The model rows marked "trusted checkout" ran tool-less in `G:\dev\projects\reliquary` (deviation, logged in the run log).
-
-## P0.6 TTL
-
-Probe `p06_ttl.py`, detached via `spawn3.py` (rung 3, unhidden at the time) at 08:48:45. cwd = `$P0\ttl-cwd` (empty, not a git repo), the P0.2 fingerprint (same tools, mode, preamble, strict MCP, TTL pinned 1h). Training content was passed in the prompt (no tools used): A = five orbit/dirigent research and report files, B = six superpowers research and report files from the clone; "reply READY". Raw: `$P0\raw\p06\` (`state.json`, `train*.jsonl`, `ping*.jsonl`, `fork*.jsonl`).
-
-| Step | Elapsed since base's first event | First request: cache read / created | Ratio to base context | Cost Δ |
-|---|---|---|---|---|
-| train A (`9c2fa6d6-…`) | — | 0 / 88,569 (all 1h) | context 88,571 | $0.7086 |
-| train B (`79af9c73-…`) | — | 7,469 / 85,406 | context 92,877 | $0.6848 |
-| ping A (`Reply with only: OK`, `--max-turns 1`) | 3,004.6 s (50.1 min) | 81,144 / 7,463 | 0.916 | $0.0760 |
-| fork A | 3,904.9 s (65.1 min), 15 min after the ping | 88,607 / 0 | **1.0004** | $0.0178 |
-| fork B (no ping) | 3,902.7 s (65.0 min) | 7,469 / 85,444 | **0.080** | $0.6851 |
-
-- **Pass**: A's fork ≥ 0.9 × A's context after the 50-min ping; B's fork < 0.5 × B's context. B shows `partial` (the 7,469-token shared prefix stayed warm, as A4/C5 predicted).
-- A's fork read more than A's context (88,607 > 88,571) because the ping's identical prompt was cached too.
-- The ping itself re-created 7,463 tokens instead of reading them (0.916, still a hit by C5). That size matches the shared system/tool prefix (7,469). Cause not isolated; it did not stop the ping from refreshing the base prefix.
-- Economics: a cold start (fork B) cost $0.685; ping + warm fork cost $0.094. One ping pays for itself many times over at this base size.
-
-## P0.7 transcripts (informational)
-
-`p07_transcripts.py` → `$P0\raw\p07\p07.json`.
-
-- Transcript dir = `~/.claude/projects/<cwd with every non-alphanumeric → '-'>/` (exists for the clone).
-- Base transcript: 128 lines, 46 assistant lines, **all 46 carry `message.usage`**; several lines per message id (one per content block). Base context from the transcript's last assistant line = 182,204 = the stream's number. `max_base_tokens` can be read from transcripts.
-- Fork seq 1 transcript: all 7 base message ids and all 106 base `uuid`s are present (copied unchanged), under the fork's own `sessionId`; no `fork*` field. Dedupe by message id works for the trial.
-- R6: `--session-id f2806537-… --resume <tiny base> --fork-session` → `init.session_id` and `result.session_id` both `f2806537-…`; the fork recalled the base's word.
-
-## P0.8 injection and pre-approval proxy (informational)
-
-`p08_inject.py` in `$P0\p08-cwd` (copy of the project settings with `Bash(uv:*)`/`Bash(uvx:*)` removed; skill `forkprobe` with `allowed-tools: Bash(uv:*)` and `` !`uv run "${CLAUDE_SKILL_DIR}/probe.py" where` ``; agent `forkprobe` preloading it). Headless `claude -p --tools Task,Bash --permission-mode default --allowedTools Task,Agent` dispatched `forkprobe`. Raw: `$P0\raw\p08\`.
-
-- Injection in the subagent: **yes**. The reply quoted `{"probe": "forkprobe", "marker": "INJECT-MARKER-W9P", …}`; `probe-calls.log` shows one `where` call 4.8 s after launch.
-- Pre-approval: **no**. `permission_denials` holds the subagent's `uv run "…\probe.py" ping` ("This command requires approval").
-- Wall time: 13.7 s for the whole run; the injection completed within the first 4.8 s.
-- Caveat: the dir is an untrusted workspace (its project allow list was ignored anyway, which is what the probe needed). Whether `allowed-tools` pre-approves in a trusted project is untested; Phase 4 checks it with the real plugin.
-
-## Not tested / open
-
-- Survival of a rung-3 supervisor past the **end of the Athanor's turn** (all checks were inside one turn). Parentage under `WmiPrvSE.exe` makes a tree-kill from the agent impossible, so it is expected to hold; Phase 1's smoke can confirm it across a hand-back.
-- What effort actually changes (no observable in `init` or in a 1-turn reply).
-- Why the 50-min ping re-created 7,463 prefix tokens.
-- `rate_limit_event` lines in every stream carry plan utilisation (`five_hour` 0.02, `seven_day` 0.56 this morning). Not used by the plan; a cheap input for R11 if Phase 1 wants it.
-- Whether the Desktop's orphaned background Bash tasks (fork backgrounding a command) can be prevented by flags; the default is a preamble line.

docs/workpad/reports/2026-10-16-16-headless-forks-phase1-review.md

@@ -1,326 +0,0 @@
-# Phase 1 review: headless forks (`spire:forks` helper core)
-
-- **Reviewer model id**: `claude-opus-5-5[1m]` (fresh; did not plan, attack, build or smoke this phase)
-- **Date**: 2026-10-16 16:08 +0200 (`date`)
-- **Scope**: Phase 1 commits `670401d..cb65d88` on `headless-forks`, plus the Phase 0 flags (`7421d3a`, `83f6bac`; Phase 0 had no separate review)
-- **Read**: build plan `plans/2026-10-16-02-headless-forks-build.md` (§4, §6 Phase 0/1), plan `plans/2026-10-16-01-headless-forks.md` (§2, §3, §4, §7), design `designs/2026-10-16-01-headless-forks.md` (§2–§7), preflight report `reports/2026-10-16-09-headless-forks-preflight.md`, run log `reports/2026-10-16-08-headless-forks-run.md`, contract digest `plans/2026-10-16-12-headless-forks-phase1-contract.md`, and all of `plugins/spire/skills/forks/` (`forks.py`, `preamble.md`, `templates/`, `tests/test_forks.py`).
-- **Counts**: Critical 0 · Important 3 · Minor 16
-
-## Gates I ran
-
-| Gate | Result |
-|---|---|
-| G-unit `uv run plugins/spire/skills/forks/tests/test_forks.py` | exit 0, `Ran 69 tests in 52.473s`, `OK` |
-| G-where `uv run plugins/spire/skills/forks/forks.py where` | exit 0; stdout is one JSON object, `ok: true`, `spawn: cim-hidden`, binary 2.1.299 via `CLAUDE_CODE_EXECPATH`; uv's line on stderr |
-| Scope fence | `git diff --stat 83f6bac..cb65d88`: only the 5 files under `plugins/spire/skills/forks/` plus the run log and the digest. No attribution lines in any Phase 1 commit body. |
-| Leftover processes after my runs | none (`tasklist` python.exe: none) |
-
-Probes I ran (scratchpad, read-only, no `claude` calls):
-
-- `p1review_refused.py`: `_conclude` on an `is_error` result whose `modelUsage` did not grow → `failed model_refused` (finding I1).
-- `p1review_tree.py`: `process_tree()` on dead-root records whose pid equals a live process's stale parent pid. On this host right now, 5 such pid values exist. One claims `csrss.exe`/`winlogon.exe`/`dwm.exe`, one claims `dirigent-watchdog.exe`/`dirigent-web.exe`, and one claims `OneDrive.Sync.Service.exe` (finding I2; the probe kills nothing).
-- `claude --help` (2.1.299, no API call): `--effort` choices `low, medium, high, xhigh, max`; `--permission-mode` choices `acceptEdits, auto, bypassPermissions, manual, dontAsk, plan` (finding M5).
-- Spot check of Phase 0 numbers against raw files: `raw/p06/state.json` (ping A 0.91615, fork A 1.00041, fork B 0.08042, cost Δs) and `raw/p02/seq1.summary.json` (first read 182,202, result usage 14 / 1,448 / 3,113 / 1,288,193, cost 1.9413766). Both match the preflight report. `raw/p01/r3-wincontrol/check-*.json` matches the positive-control row too.
-
----
-
-## Findings
-
-### Critical
-
-None.
-
-### Important
-
-**I1. Any error that happens before the model answers is reported as `model_refused`.** `forks.py:1200`
-
-```python
-if ss and (ss.refused or (res and requested not in models_used)):
-    status, reason = "failed", "model_refused"
-```
-
-A call whose request is rejected still emits a `result` event (`is_error: true`). Examples: the plan usage limit, an overload after retries, an API error on the first request, a prompt that is too long. For a fork, the restored `modelUsage` is cumulative, so nothing grows and `models_used` is `[]`. The requested id is then "not in" an empty list. My probe confirms it: `failed model_refused models_used [], requested claude-opus-5-5`.
-
-*Failure scenario:* a fork launched near the subscription limit (R11) gets a 429. The result reads `model_refused`, and the Phase 3 procedure will route that reason to "the user must add the id to `availableModels`". That is the wrong remedy for the most likely error on a subscription.
-
-*Source:* the contract digest. The preflight report states the rule as "that event, **or a `modelUsage` key ≠ the requested id**", which means a substitution: some other key grew. The digest (§Supervision, "Model refused") loosened it to "`models_used` not containing the requested id".
-
-*Fix direction:*
-- Infer a refusal from `modelUsage` only when `models_used` is non-empty and lacks the requested id.
-- Otherwise fall through to `is_error` / `exit_code`, and consider carrying `result.api_error_status` (present in the real result keys, `raw/p02/seq1.summary.json`) into `reason_detail`.
-
-*Test gap:* the stub's `error` directive still bills the requested model, so no test covers this case.
-
-**I2. Walking the tree of a dead root can claim and kill unrelated processes.** `forks.py:622-652` (`process_tree`). It is reached through `reap_lost` (`:1355-1356`, called by `wait`, `list`, `fork`, `continue`) and `kill_job` (`:1383`) whenever the recorded supervisor or `claude` is already dead.
-
-When the root is dead, `proc_ctime(root)` is `None`, so the reuse guard at `:641` does not fire. Every live process whose parent pid equals the recorded pid is then taken as a child if it was created at or after the root's recorded creation time. The children of a dead process keep its pid as their `ppid`. So the walk also matches this sequence: the pid was reused by a later process, that process started something and exited. The time guard does not separate the two cases, because the later processes are by definition newer.
-
-*Failure scenario:*
-1. The host reboots (Windows Update), or the supervisor crashes, while a fork runs. The registry still says `running`.
-2. The next `list`/`wait`/`fork` (a successor Athanor's first call) reaps the job and calls `kill_tree(rt["claude"])`.
-3. If any live process's dead parent had that pid, it and its whole subtree are `TerminateProcess`ed.
-
-After a reboot every process is newer than the record, so the time guard filters nothing. My read-only probe found 5 such pid values on this host now. They claim, among others:
-- `dwm.exe`/`winlogon.exe` (pid 5572's orphans);
-- the Dirigent watchdog and web server;
-- the OneDrive sync service.
-
-The chance per event is low, because the recorded pid has to match one of a handful of stale ppids. The damage is severe. The pid-reuse guard is the item 1.2 flagged as untested.
-
-*Fix direction:* when the root is dead, bound descendants by the last time the job was known alive: child `ctime` ≤ the job file's `heartbeat_at` (or `ended_at`). Alternatively, have the supervisor record the `claude` subtree (pid + ctime) on each heartbeat, and kill only recorded pairs once the root is gone. The supervisor's immediate post-exit sweep (`:2183`) is safe as it is (milliseconds after exit).
-
-**I3. A `continue` moves the base's `last_hit` forward, so warmth is overstated.**
-- `forks.py:2144`: `hit_written = e["kind"] == "train"`, so `continue` bumps the base at its first event.
-- `:1277`: `_conclude` bumps it again with `ss.first_at` for every non-train kind.
-
-Design §5 states the conservative assumption on purpose: "only a request that reads exactly the base prefix (a fork's first request) refreshes it; later requests in a fork read longer prefixes". A continue's first request reads the fork's own, longer prefix. The smoke shows exactly that: 27,192 read against a base of 23,676. That hits the fork's cache entry, not necessarily the base's.
-
-*Failure scenario:*
-1. Base trained at 10:00; fork S1 at 10:05 (refreshes the base); S1 ends 10:20.
-2. `continue S1` at 10:50 reads S1's warm prefix, and the helper sets the base's `last_hit` to 10:50.
-3. The real base entry expires at about 11:05. The helper reports the base `warm` until 11:44.
-4. Phase 2's ping rule fires only in `expiring`, so it skips the ping. The next fork at 11:10 cold-starts at about 1.9 × prefix: $0.69 against $0.09 in P0.6.
-
-The run log lists this as a choice ("A continue refreshes its base's `last_hit`"). The digest's "or any of its forks" left it open, but the design did not.
-
-*Fix:* bump the base only for `fork` (and Phase 2 pings), or only when the first `cache_read` is within the base context plus a small margin.
-
-### Minor
-
-**M1. A kill during finalisation can leave a stale lock and a duplicate ledger line.** (flagged by 1.2) `forks.py:1297-1307`, `:1377-1390`.
-
-*Scenario:* `kill_job` sets `kill_requested`. Meanwhile `claude` exits on its own, and the supervisor enters `finalize_job`. `taskkill /T` lands between `ledger_append` and `write_registry`. The lock is then stale for 30 s. `kill_job`'s own `finalize_job` breaks the lock, still sees `running`, and appends a second ledger line (`ok`, then `killed`). The window is milliseconds.
-
-*Why it matters later:* Phase 2's `usage` would double-count the cost.
-
-*Fix:* write the registry status before the ledger line (the registry is the once-only guard), and/or make `usage` dedupe by `job`.
-
-**M2. The stale-lock break has a race and a hot loop.** `forks.py:414-423`.
-
-- Two waiters can both judge the lock stale. One removes it and recreates it. The other's `os.remove` can then delete the new lock, because check-then-remove is not atomic. (Flagged; the window is very narrow.)
-- The stale branch `continue`s with no sleep and no deadline check. If `os.remove` keeps raising `PermissionError` (an antivirus or sync client holding the file, or a read-only attribute), `acquire` spins at 100 % CPU forever and the call never prints its JSON.
-
-*Fix:*
-- Add the deadline check and the sleep to that branch.
-- Treat a lock as stale only when its holder's pid + ctime is dead (the content already records both), or when its age is far beyond any critical section.
-
-**M3. N1 and `max_minutes` use wall-clock time, so a host suspend kills every running fork as `orphaned`.** `forks.py:2155`, `:2173`.
-
-This run's log records two multi-hour clock jumps: 10:13→12:16 in Phase 0, and a 3.3 h span in 1.2. After a resume, each supervisor sees `now - last_orchestrator_call_at > 1200` within 1 s and kills its tree before the Athanor's `wait` can touch the stamp. The same happens if the Athanor's own turn stalls for more than about 10 min between waits (API backoff).
-
-*Fix (cheap):* if the supervisor's loop observes a tick gap far larger than `SUP_TICK_S` (say > 60 s), reset the orphan baseline to "now" and grant one more `orphan_after`.
-
-*Phase 3 text:* say that `kill`/`expire` do not refresh the stamp.
-
-**M4. N3 leaves two gaps.** `forks.py:119` (`CHILD_REFUSED`), `:2248`, `:2302`.
-- A fork may still run `kill`, `expire --all` and `init`. `expire --all` from a fork kills every sibling and itself.
-- `list` and `wait` from a fork refresh `last_orchestrator_call_at`. A fork whose orchestrator died can therefore keep its own watchdog alive by polling `list`.
-
-The build plan lists only `where`, `list`, `usage` and `wait` as allowed.
-
-*Fix:*
-- Refuse `kill`, `expire` and `init` under `SPIRE_FORKS_CHILD`.
-- Skip the orchestrator stamp when the marker is set.
-
-**M5. The `--permission-mode` value set is stale against 2.1.299.** `forks.py:64`. (Answers the 1.1 flag.)
-
-2.1.299 offers `acceptEdits, auto, bypassPermissions, manual, dontAsk, plan`. The helper accepts `default`, which the binary does not list, and refuses `manual`, which the binary has. `--effort` matches. The default `dontAsk` is unaffected.
-
-**M6. The runtime fingerprint misses two prefix-relevant changes.** `forks.py:1027-1037`.
-- **`skills` are not compared.** The real `system/init` carries them (`raw/p02/seq1.summary.json`). `Skill` is in `--tools`, so the skill list is part of the prefix. A user or project skill added mid-run gives a cache miss with `fingerprint: ok`, which the build plan's fallback reads as a "fingerprint bug".
-- **Plugins without a `version` compare as `name@`.** In the real init that is `skill-creator` and the built-ins. An in-place update of such a plugin is not seen.
-
-*Fix:* add sorted `skills`, and use the plugin `path`'s last segment when there is no version.
-
-**M7. The fingerprint hash contains the per-run `mcp-empty.json` path.** `forks.py:1676`. (Answers the 1.1 flag.)
-
-It does not affect the cache: the request carries no MCP servers either way. Within a run it is stable, including for a successor that keeps the same run log. The hash cannot be compared across runs, though, so it is no use for the trial's cross-run comparisons.
-
-*Fix:* hash `{"strict": true, "servers": {}}` (the content) and keep the path outside the hash.
-
-**M8. The "no visible window" unit check is narrower than P0.1's detector.** `test_forks.py:1366-1371`.
-
-It only looks at windows whose pid is in the job's tree. P0.1's detector also flagged any visible `ConsoleWindowClass` / `CASCADIA_HOSTING_WINDOW_CLASS` window. That matters because the real Windows Terminal window belongs to `WindowsTerminal.exe` (pid 19872 in `r3-wincontrol`), not to the tree.
-
-The tree-scoped check is not blind: in the positive control the supervisor itself owned a visible `PseudoConsoleWindow`. But the suite has no positive control of its own. It also hard-fails on a host without a desktop (`assertGreater(len(all_windows), 0)`).
-
-*Fix:*
-- Diff the visible Console/CASCADIA windows before and during the job, alongside the pid check.
-- Skip, rather than fail, when no desktop is present.
-
-**M9. `ANTHROPIC_BASE_URL` sits on neither scrub list.** `forks.py:106-109`. (Answers the 1.1 flag.)
-
-On this host its value is the default `https://api.anthropic.com` (host part checked), so keeping it is harmless here. Elsewhere it is an auth/billing-path variable of the class design §4 drops. Dropping it would break hosts that need a gateway, though.
-
-*Fix:*
-- Put it on the keep list explicitly.
-- Have `where` warn when it is set to anything but the default.
-- Optionally record its value per base, so a change shows as drift.
-
-**M10. `train` refuses launch-field overrides, and the stated reason misreads the plan.** `forks.py:1504-1508`, `:1950`, `:2022`.
-
-1.2's note says "the plan's invariant and the digest do not" allow them. Plan §4.3 says the opposite: "Only `train` and `init` accept launch fields". Design §3.4 gives `train` "optional launch overrides".
-
-Consequences:
-- Every base in a run has the init config's fields.
-- Forks build their argv from `cfg["launch"]`, not from a per-base record. That is consistent today, because `init` refuses changes once a base exists.
-- Phase 2's `retrain_due` reason "the requested model, cwd, tools, … differs from the base" has no input path.
-
-The Phase 2 plan should decide this explicitly. It is not a defect for Phase 1.
-
-**M11. Note detection only checks that the file exists.** `forks.py:1239-1241`. A second fork of the same block (a re-run after a failure), or a `continue`, reports `notes/<block>.md` even if this call did not write it. Compare the file's mtime against the job's start.
-
-**M12. `kill` reports two results the Phase 3 text must handle.** `forks.py:1396`.
-- `{"killed": true, "status": "ok"}` when the supervisor finished first, after `kill_requested` was set.
-- Survivors give `ok: false` with exit 0.
-
-The Phase 3 text must key on `ok` and `status`, not on `killed` or the exit code.
-
-**M13. Git Bash rooted paths that are not drive forms land on the cwd's drive.** `forks.py:252-253`. (Answers the 1.1 flag.)
-
-`--run /tmp/x-run.md` from Git Bash creates `G:\tmp\x-run-forks` without a word; Git Bash means `%TEMP%`. For `--brief` the failure is loud ("cannot read brief"), for `--run` it is silent.
-
-*Fix:* use `cygpath -w` when it is on PATH, or refuse rooted paths that are not drive forms.
-
-**M14. POSIX kill does not reach `claude`.** `forks.py:2127`, `:703`, `:604-619`.
-- `claude` gets its own session (`start_new_session=True`), so `killpg(<supervisor>)` misses it. Only the per-pid sweep catches it.
-- Where `/proc` is missing (macOS), `process_table()` returns `[]`, so `kill` kills only the supervisor and leaves `claude` running.
-
-The path is untested and declared so. SKILL.md (Phase 3) should say "Windows-tested; POSIX untested".
-
-**M15. C8 admission takes the union of the three settings files.** `forks.py:920-945`.
-
-The build plan (A14) noted that the merge of these files is unknown. P0.5 also showed that project `permissions.allow` is ignored in untrusted dirs. The smoke ran in the untrusted scratch clone and was admitted by the clone's project list, so whether project `availableModels` applies there is untested. The runtime warning check backstops it. Record the rule as "permissive at init, enforced at runtime" in SKILL.md.
-
-**M16. Smaller items.**
-- `turns` means a message count in `jobs/<job>.json` and `num_turns` in the result (flagged by 1.3): rename the job-file field.
-- The post-exit sweep (`:2183`) also kills daemons a fork's commit may start (`gpg-agent`, `git fsmonitor--daemon`). They restart on demand, so this is acceptable, but SKILL.md should say it.
-- `continue` sends the brief with no frame (`:2049`), so the Phase 3 text must tell the Athanor to put the commit rule and the note path into continue briefs.
-
----
-
-## Handoff flags, one by one
-
-### Phase 0 (handed over by Igor)
-
-| Flag | Answer |
-|---|---|
-| P0.6 started before P0.1 (c) finished | Accepted. (c) passed later (08:39–08:45). P0.6 ran on rung 3, which survived, so its result stands. |
-| `--no-hardlinks` clone | Accepted: same content, and hardlinks cannot cross `G:`→`C:`. |
-| Six tool-less calls outside the clone | A deviation from the letter of plan decision 4, with a real reason: trust, because untrusted dirs ignore project settings. With `--tools ""` they cannot edit anything. They left transcripts under the reliquary slug. No action. See M15 on what trust means for C8. |
-| Separate scratch dirs for `--agent` and P0.8 | Accepted. It kept P0.2's prefix clean. Its cost is that P0.8 ran untrusted (below). |
-| (d) produced with `TaskStop`, because the Bash tool now backgrounds at timeout | Accepted. C2's `timeout: 600000` rule stays. A2's failure mode is now "backgrounded, notification to the subagent". Recommend one line on it in the Phase 3 SKILL.md. |
-| Effort case run inside P0.2 | Accepted. Effort is kept in the fingerprint and is not cache-defining (182,202 read). |
-| `r3-main`/`r3-tkill` ran PATH `claude` 2.1.283 | Closed by the helper: `claude_argv` always uses the stored absolute path (`:1801`), and the env pins `CLAUDE_CODE_EXECPATH` (`:788`). The smoke shows 2.1.299 on all five streams. |
-| P0.8 in an untrusted dir | Open for Phase 4, as planned. SKILL.md needs the allow-rule note. |
-| What effort changes is unobservable | Accepted; informational. |
-| A backgrounded command left an orphan | Addressed: the preamble forbids `run_in_background` (`preamble.md:6`), the supervisor sweeps descendants after exit (`:2183`), and `kill`/`expire` sweep the tree. See M16 for the sweep's breadth. |
-| P0.6 ping read 0.916 | Still a hit under C5, and the numbers match `raw/p06/state.json`. **For Phase 2:** the re-created part (7,463) is about the size of the shared system/tool prefix. On a small base (the smoke's 23,676) the same loss gives about 0.68, so a ping would read `partial`. The Phase 2 ping verdict must not treat that as a failed refresh. |
-| Visible windows before the fix, and the retest | The fix is in the helper: CIM `ShowWindow=0` (`:141-145`) and `CREATE_NO_WINDOW` on every child (`:719`, `:2126`). The smoke checked it by hand. The unit check is narrower than P0.1's detector (M8). |
-| `$P0\raw\p01\` not cleaned; `r3-kill2` unobserved | No effect on the verdict (`r3-kill5` passes). Accepted. |
-| Clock jump | Relevant to N1: see M3. |
-| Phase 0 open questions | U4 moot: confirmed by the P0.5 rows. Rung 3 with PowerShell: accepted by the coordinator, launch cost acceptable. Preamble line: done. Bash backgrounding: Phase 3 line. |
-
-### Block 1.1
-
-| Flag / deviation | Answer |
-|---|---|
-| Argparse sets declared early | Fine; 1.2 kept them. |
-| N3 guard in the dispatch | Fine. Gaps: M4. |
-| `--help` as JSON, exit 0 | Fine; keeps the stdout invariant. Unplanned (listed below). |
-| Internal error → exit 2 with JSON | Fine. The contract has no other code for it. |
-| Extra `init` flags; nested `thresholds`; `binary_resolved_by`, `model_admission` | Fine. They are excluded from the change comparison (`:1720`), which is correct. |
-| `where --binary` and extra fields | Fine. |
-| Two extra preamble lines | Fine. Both are within the contract's intent (deny list; headless). The preamble's pointer `plugins/spire/skills/implementation/references/run-log.md` will not resolve in other projects (the plugin lives in the cache); Phase 3 should give the format inline or by `${CLAUDE_PLUGIN_ROOT}`. |
-| Effort / permission-mode value sets | Effort matches 2.1.299. Permission modes do not: M5. |
-| Per-run mcp path in the hash | M7 (cosmetic). |
-| Comma split outside parentheses | Fine; tested (`Bash(a,b)`). |
-| Race window when breaking a stale lock | Real but narrow; a hot loop sits next to it: M2. |
-| Invalid settings skipped; `[]` admits nothing | Acceptable; the runtime check backstops it. M15. |
-| `ANTHROPIC_BASE_URL` kept and listed unknown | M9. It is the default endpoint on this host. |
-| Access denied treated as alive | Acceptable for liveness. Combined with dead-root walking it is part of the I2 risk class: a reused pid that cannot be opened keeps a job from being reaped as `lost`, and `wait` returns 3 until the Athanor kills it. Rare. |
-| `/tmp`-style paths | M13. |
-| Permissive model regex (`claude-sonnet`) | Acceptable. Claude Code would then fail the call, which I1 currently mislabels as `model_refused`. |
-| `preamble.md` written in 1.1 | Fine (`init` hashes it). |
-
-### Block 1.2
-
-| Flag / deviation | Answer |
-|---|---|
-| Float `--max-minutes` on `fork`/`continue` | Fine. |
-| Lost reaper before the cap check; it kills the leftover tree | Running it before the cap check is good. Killing the leftover tree is right in intent but unsafe for dead roots: I2. |
-| Immediate kill on the restriction warning | Good: saves spend, and the result is still `model_refused`. |
-| Descendant sweep after exit | Good, and safe at that moment (ms after exit). Breadth: M16. |
-| No overrides on `train` | The stated reason misreads plan §4.3: M10. |
-| `wait --all` "settled" semantics | Correct against C4: mixed case 3 → 4 → 0, every result delivered once, the failed job counted in the 4 without being returned twice. Traced and covered by `test_wait_exit_codes`. |
-| Reason vocabulary; `timeout` has `reason: null` | Consistent with the digest (null unless failed/killed/lost). Fine. |
-| Precedence of failure reasons | Wrong in one branch: I1. |
-| Null usage without a result | Fine. |
-| Train `last_hit` from its last event | Fine: the full prefix is written there. |
-| Continue: no template, parent session = base, cost basis | Cost basis correct (smoke: Δ 0.0955 = 0.39614 − 0.30066). No template: M16. Moving the base's `last_hit`: I3. |
-| Note detection | M11. |
-| Failed-base name reuse | Fine. |
-| `kill` of a finished job | Fine. Report shape: M12. |
-| Kill/finalise race (stale lock, duplicate ledger line) | M1. |
-| `last_orchestrator_call_at` only at wait start/end | Fine: the worst gap is 570 s plus the Athanor's turn. Suspend case: M3. |
-| Stall measured on any stdout line | Fine. |
-| pid-reuse guard untested | The guard works for a live reused pid. It fails for a dead root: I2. |
-| `spawn_failed` only visible in `wait` | Acceptable: the next `wait` returns it at once with exit 4. Phase 3 text should mention it. |
-| Not tested: POSIX, `--agent` drift, pid reuse | POSIX: M14. `--agent` drift: the code path (`:1789-1795`) mirrors the tested preamble path, so it is low risk. pid reuse: I2. |
-
-### Block 1.3
-
-| Flag | Answer |
-|---|---|
-| `turns` has two meanings | M16. |
-| `continue` cache verdict against the base context; `parent_session` = base | The verdict is defensible (it reads at least the base prefix). The real problem is `last_hit`: I3. |
-| Survival across the Athanor's turn end is untested | Still open. Parentage `WmiPrvSE.exe` (smoke, unit test) makes a tree-kill from the agent impossible, so the expectation holds, but it is unverified. Phase 4. |
-| Small smoke base | Accepted. P0.2 covered 182k without the helper. The helper's arithmetic is the same (`RuleTests` uses the P0.2 seq-1 numbers). |
-
-### The contract digest (Athanor-written), checked against the build plan
-
-Consistent with the build plan on C1, C3(a–c), C4, C5, C6 (the CIM command matches the preflight), C7, N1, N2, N3, A18 and A19. Where it diverges, or decides something the plan left open:
-
-- **Model refused.** It loosens the preflight's rule. This is the source of I1.
-- **Warmth.** "`last_hit` … any of its forks" does not carry over design §5's "first request of a fork only". This is the source of I3.
-- **C3(b).** It adds `kill` as a second writer of `jobs/<job>.json` when the supervisor is dead. Harmless (the supervisor is dead then), but it is a deviation from C3(b)'s "only writer".
-- **C8.** It turns P0.5's rule into a union over three files without saying so. M15.
-- **`train` launch fields.** It silently drops design §3.4's optional overrides on `train`. 1.2 then cited the plan for the refusal. M10.
-- **Additions with a stated source.** The digest adds `CLAUDE_CODE_EXECPATH` and `SPIRE_FORKS_CHILD` as pinned vars, the `raw/<job>.env.json` sidecar, and the preamble content. Each traces to a coordinator decision or the preflight report. The env file holds `CLAUDE_CODE_USER_EMAIL`, account and organisation UUIDs. It is under `raw/` and so gitignored. Fine.
-
----
-
-## Tests that cannot fail, weakened checks
-
-- No assertion was loosened between 1.1 and 1.2.
-- The launch tests are real: the CIM spawn, a separate supervisor process, and the real `taskkill` and sweep. They can fail.
-- The orphan test injects the clock only into the stamp. The supervisor compares against its real clock, so it really exercises N1.
-- `test_lost` kills a real supervisor.
-- **The stub paths hide one real behaviour.** The stub's `error` directive bills the requested model, so the empty-delta error path behind I1 is never exercised. The stub `claude` is also a `.cmd` (arguments pass through `cmd.exe`), while the real binary is an `.exe`. That makes the tests stricter on quoting, not weaker.
-- **Weaker check:** the visible-window assertion has no positive control and is pid-scoped (M8).
-- **Untested:** the tree walk under pid reuse (I2) and the kill/finalise race (M1).
-
-## What was built that the plan did not ask for (on record, not findings)
-
-- **Output and errors:** `--help` as a JSON object; internal errors as JSON with exit 2.
-- **`where`:** `--binary`; and `python.supervisor_interpreter`, `platform`, `scrub.drop_patterns`, `scrub.keep_rule` in its output.
-- **`init`:** `--ttl-s`, `--stall-after-s` and one flag per threshold; the config fields `binary_resolved_by` and `model_admission`.
-- **Tool lists:** comma splitting outside parentheses for `--allowed-tools` / `--disallowed-tools`.
-- **Preamble:** the lines "nobody can answer a question mid-run" and "never push, rebase or reset".
-- **Lost reaper:** it also runs in `fork`/`continue`, and it kills the leftover `claude` tree.
-- **Model restriction:** an immediate kill on the warning.
-- **Supervisor sweep:** descendants of `claude` are swept after a normal exit.
-- **`wait`:** "delivered" and "settled" marks (`delivered_at`, `settled_at` in the registry); `--any` semantics.
-- **`kill`:** returns `snapshot`, `survivors`, `taskkill_rc`, `ok`.
-- **`list`:** returns `lost_now` and per-base `rebase_due`/`retrain_due`/`reasons`.
-- **Registry job fields:** `reason_detail`, `forced`, `brief_source`, `warm_until_at_launch`, `head_at_launch`, `kill_requested`.
-- **`fork`:** `--max-minutes` accepts a float.
-- **Train template:** forbids code changes during training.
-- **Tests:** a module-end leftover-process check (`tearDownModule`), done by command line through CIM.
-
-## Open, not findings
-
-- Supervisor survival past the Athanor's hand-back (Phase 4).
-- A trusted-workspace P0.8 (Phase 4).
-- A large base through the helper.
-- `stalled` and `lost` with a real `claude`: so far only with the stub.

docs/workpad/reports/2026-10-16-17-headless-forks-phase1-recheck.md

@@ -1,155 +0,0 @@
-# Phase 1 re-check: headless forks (fix pass `7b9b748`)
-
-- **Reviewer model id**: `claude-opus-5-5[1m]`. Fresh: did not plan, build, review or fix this phase.
-- **Date**: 2026-10-16 16:39 +0200 (`date`)
-- **Scope**: only the findings named in the brief: I1, I2, I3, M1, M2, M3, M4, M5, M9 from `reports/2026-10-16-16-headless-forks-phase1-review.md`. Diff `20b049e..HEAD` (`7b9b748` code and tests; `4515dbb`, `e60f94c` run log). Run-log sections "Phase 1 fix pass" and "Phase 1 fix pass — Athanor check and deferred Minors", including the builder's re-check flags.
-- **Verdict**: all nine resolved. No Critical or Important finding survives. The residual flags are Minor. One new Minor residual comes from the M1 reorder (R1 below).
-
-## Gates I ran
-
-| Gate | Result |
-|---|---|
-| G-unit `uv run plugins/spire/skills/forks/tests/test_forks.py` | exit 0, `Ran 86 tests in 66.347s`, `OK`, none skipped (16:30:37–16:31:44) |
-| G-where `uv run plugins/spire/skills/forks/forks.py where` | exit 0. stdout is one line holding one JSON object: `ok: true`, `spawn: cim-hidden`, binary 2.1.299, `warnings: []` |
-| New tests against the unfixed helper | Scratch copy: `forks.py` from `20b049e`, plus the current `tests/test_forks.py`, `preamble.md` and `templates/`. I ran the 26 new or changed tests: **20 failures, 14 errors, 0 unexpected passes** (counted per subtest). Details below. |
-| Dead-root tree walk, old vs new | Probe `recheck_tree_probe.py` on the fake table that `ProcessTreeTests` uses. Old `process_tree(rec)` → `[A, A_KID, C, C_KID]` (it claims the reused pid's child A). New, with `alive_until=hb` → `[C, C_KID]`. |
-| Leftover processes | `tasklist` python.exe: none |
-| Commit hygiene | `20b049e..HEAD` touches only `forks.py`, `test_forks.py` and the run log. No attribution trailers. |
-
-No live `claude` calls were made.
-
-## Findings, one by one
-
-### I1: an error before the model answers was reported as `model_refused`. **Resolved.**
-
-- **The fix.** At `forks.py:1356`, `substituted = bool(models_used) and requested not in models_used`. An empty delta can no longer count as a refusal. The order of the checks is at `:1358-1372`: refused/substituted, then no result, then API error, then `is_error`, then exit code.
-- **New classifier.** `api_error_reason` (`:1200-1233`) uses the status code first, then the text. `reason_detail` carries the status plus the first 200 characters of the text.
-- **Check against real results.** All 45 result events in the Phase 0 raw streams have `"api_error_status": null`. A successful run is therefore never classified as an API error. The only two `is_error: true` lines in that data are tool results, not result events.
-- **Tests that fail on the old helper:**
-  - `test_api_errors_are_not_model_refused`: 6 of 7 cases fail on the old helper. All of them read `model_refused`. The substitution case still passes, which is correct.
-  - `test_failures_flags_and_drift` fails on the old helper (`model_refused != is_error`). It now runs the empty-delta path.
-  - `RuleTests.test_api_error_reason` fails on the old helper with an AttributeError, because the function did not exist yet.
-- **Builder flag: the text patterns are a heuristic.** Acceptable as Minor. The patterns only apply when `is_error` is true or a status is present, and the status code wins. The worst misclassification is one error reason swapped for another, never `ok` turned into `failed`.
-- **Coverage shift (not a weakening).** The stub's `error` directive used to bill three turns. So "is_error after the requested model billed" (a mid-run error) has no test of its own any more. It reaches the same `is_error` branch through `substituted=False`. Minor.
-
-### I2: walking a dead root's tree could claim and kill unrelated processes. **Resolved.**
-
-- **The fix.** `process_tree(rec, alive_until)` (`:739-771`) takes a dead root's direct children only when `root_ctime < child_ctime <= epoch_to_ctime(alive_until + 1 s)`. With no recorded ctime, or no `alive_until`, a dead root claims nothing. Below a child that has been claimed and verified live, the old rule applies, and it is safe there because that parent pid is live, so it cannot have been reused.
-- **Where the bound comes from:**
-  - `reap_lost` (`:1547`) and `kill_job` (`:1574`) pass `last_alive_at(rt)`, the later of `heartbeat_at` and `ended_at`.
-  - The supervisor's own calls pass `time.time()` (`:2396`, `:2399`, `:2417`, `:2428`, `:2463`). At those points `claude` exited only just now, or is still alive.
-- **The review's scenario.** Reboot or crash, then a reap: every process created after the reboot is newer than the pre-reboot heartbeat, so nothing is claimed.
-- **Units.** Windows FILETIME is UTC on both sides, so the conversion is consistent.
-- **Tests.** The four `ProcessTreeTests` error on the old helper through the new API. My probe above shows the behaviour itself differs. `test_dead_root_claims_only_children_from_its_lifetime` and `test_dead_root_without_bounds_claims_nothing` would also fail behaviourally on the old walk. `test_reap_lost_bounds_by_heartbeat` would fail too, because the old helper passed no bound. `test_live_root_unchanged` is a regression guard and is meant to pass on both.
-- **Builder flag: a child created in the last heartbeat interval is not claimed** (up to `HEARTBEAT_S` = 10 s, less while turns are moving). Acceptable as Minor. The failure mode is now a leaked process, not killing an unrelated one, which is the right trade. One variant of the same gap: when `kill_job` finds the supervisor alive but `claude` already dead, the kill pre-empts the supervisor's own `time.time()` sweep. Children `claude` started in its last ≤ 10 s can then leak. Same class, also Minor.
-- **Builder flag: POSIX without `/proc/stat`.** A dead root claims nothing there. Acceptable, since POSIX is out of tested scope (M14 is deferred).
-
-### I3: a `continue` moved the base's `last_hit` forward. **Resolved.**
-
-- **In the supervisor**, `hit_written = e["kind"] != "fork"` (`:2379`). Only a fork bumps the base in the loop (`:2405-2408`).
-- **In `_conclude`** (`:1440-1446`), only `train` (its last event) and `fork` (its first event) set `hit_t`. A `continue` sets neither, which matches design §5.
-- **Test.** `test_continue_leaves_base_last_hit` fails on the old helper (the base's `last_hit` moved). It also checks that a later fork still refreshes it.
-
-### M1: a kill during finalisation could leave a duplicate ledger line. **Resolved** (the duplicate). One residual window (R1).
-
-- **The fix.**
-  - `finalize_job` (`:1470-1474`) now writes the result, then the registry, then the ledger.
-  - `ledger_append` (`:542-555`) skips a job that already has a line.
-  - A torn last line gets a leading newline.
-- **Test.** `test_ledger_append_dedupes_by_job` fails on the old helper.
-- **R1 (new, Minor).** The reorder turns the race's outcome from a duplicate line into a missing one.
-  - *Scenario:* `taskkill` lands between `write_registry` and `ledger_append`. The registry is final. `kill_job`'s `finalize_job` then sees a final entry and returns `None`.
-  - *Result:* the job never gets a ledger line. Its result file exists, but Phase 2's `usage` would under-count that job's cost.
-  - The window is still milliseconds. The review offered this order itself.
-  - *For Phase 2:* `usage` should reconcile the ledger against `results/*.json`, or `kill_job` should append the missing line when `finalize_job` returns `None` and no line exists.
-
-### M2: the stale-lock break had a race and a hot loop. **Resolved.**
-
-- **Hot loop.** A failed `_break` now falls through to the deadline check and the sleep (`:468-480`).
-  - `test_unbreakable_stale_lock_respects_deadline` fails on the old helper: "acquire spins…, hot loop, no deadline".
-- **Staleness.** A lock is stale when its holder's pid + ctime is dead (`_is_stale`, `:421-429`), or when it is older than `LOCK_ABANDONED_S` = 300 s.
-  - `_try_create` writes the holder's pid and ctime (`:386-388`).
-  - A lock caught empty or half-written reads as garbage. It is aged by mtime, so a lock being created is never judged stale.
-  - "Access denied" still counts as alive, which is conservative.
-- **Break mechanism.** The waiter renames the lock aside, compares its content, and either deletes it or puts it back with a no-overwrite rename/link (`:431-462`).
-  - `test_fresh_lock_taken_during_break_survives` fails on the old helper, but for a different reason: the old age rule never judged that fresh, dead-holder lock stale, so the break was never attempted.
-  - Against the new mechanism the test is still meaningful. A check-then-remove variant would delete the swapped-in fresh lock and fail its token assertion.
-- **Builder flag: residual put-back race.** Acceptable as Minor.
-  - *How it happens:* while a lock is renamed aside, the path is free. A third waiter can create its lock in that window, and the put-back then fails. Two processes then believe they hold the lock.
-  - *Preconditions, all at once:* a stale lock (holder died mid-section), a second waiter who already re-took it, and a third waiter's 50 ms poll landing inside the milliseconds of the aside window.
-  - *Damage:* one lost read-modify-write on `registry.json`. The file is written by atomic replace, so it cannot be corrupted.
-  - *Compared with before:* strictly narrower than the old two-waiter delete. The case is logged (`_diag`) and leaves a named `.broken.lock`.
-  - `release` is still check-then-remove. With a live holder, though, only the 300 s rule can make its lock stale, so in practice no waiter breaks it.
-
-### M3: a host suspend killed running forks as `orphaned`. **Resolved.**
-
-- **The fix.** `SupClock` (`:2255-2289`):
-  - A tick gap over `CLOCK_JUMP_S` = 60 s is excluded from `max_minutes`.
-  - It re-arms the orphan watchdog.
-  - It flags `clock_jump` and logs it.
-- **Legitimate gaps stay below 60 s.** The longest normal loop-body stall is a lock wait of at most `LOCK_WAIT_S` = 45 s plus a few seconds of retries.
-- **Tests.**
-  - `test_clock_jump_not_orphaned_or_timed_out` fails on the old helper (`timeout != ok`). It runs a real `Supervisor` with a 2 h jump injected one second into the run.
-  - `test_sup_clock_jump` errors on the old helper, because the class did not exist.
-- **Builder flags.** All acceptable as Minor:
-  - **`stalled` still uses the wall clock.** A suspend sets the flag, but nothing in Phase 1 kills on it. The Phase 3 text must not treat `stalled` combined with `clock_jump` as a hung fork.
-  - **`wall_s` includes the suspend.** This only affects reporting.
-  - **A backwards clock jump is not detected.** It delays the orphan or timeout check by the size of the jump. It happens only on a manual clock change, since `time.time()` is UTC and DST does not move it.
-  - **`kill`/`expire` do not refresh the orchestrator stamp.** This belongs in the Phase 3 text, as the review said.
-
-### M4: N3 left two gaps. **Resolved.**
-
-- **The fix.**
-  - `CHILD_REFUSED` (`:127`) now includes `kill`, `expire` and `init`. The refusal is in the dispatch at `:2627`.
-  - `stamp_orchestrator`/`touch_orchestrator` (`:1494-1512`) do nothing under `SPIRE_FORKS_CHILD`. By grep, all stamp sites go through them: `train` `:2107`, `fork` `:2156`, `continue` `:2225`, `wait` `:2526`, and `touch_orchestrator` (`:1511`, called at `:2493` and `:2547`).
-- **Tests.** `test_child_refuses_kill_expire_init` and `test_child_does_not_stamp_orchestrator` both fail on the old helper. The marker cannot leak into other tests, because `Base.setUp` patches `os.environ` per test and pops the marker.
-- **Outside M4, on record only.** `_supervise` (internal) and `tick` (Phase 2) are not refused inside a fork either.
-
-### M5: the `--permission-mode` value set was stale against 2.1.299. **Resolved.**
-
-- **The fix.** At `:69`, the set matches the 2.1.299 `--help` list. `plan` is still refused, and `default` is now "unknown". The `allowed` list leaves out `plan` (`:1826-1827`).
-- **Test.** `test_permission_modes_match_2_1_299` fails on the old helper: it accepted `default`.
-
-### M9: `ANTHROPIC_BASE_URL` sat on neither scrub list. **Resolved.**
-
-- **The fix.** The variable is on `SCRUB_KEEP` (`:114`). `where` always returns a `warnings` list, and warns when the value, trailing slash and case ignored, is not `https://api.anthropic.com` (`:1778-1793`). The exit code stays 0.
-- **Tests.** `test_where_warns_on_base_url` errors on the old helper (KeyError `warnings`). `ScrubTests.test_unknown` fails on the old helper.
-- **Not done.** The review's optional "record the value per base" was not built. It was optional.
-- **Builder flag: an empty value warns.** Acceptable as Minor. The output is a cosmetic false warning (`ok: true`, exit 0), and the empty value passes through to the child unchanged.
-
-## Weakened checks and tests that cannot fail
-
-I diffed `20b049e..HEAD` on `test_forks.py`. Every removed line is accounted for:
-
-- **`scrub_unknown`** expected `["ANTHROPIC_BASE_URL", "CLAUDE_CODE_NEW_THING"]` and now expects `["CLAUDE_CODE_NEW_THING"]`. This is M9's intended change. The fix pass also added `scrub_class("ANTHROPIC_BASE_URL") == "keep"`.
-- **`test_stale_lock_broken` became `test_dead_holder_lock_broken_at_once`.** The new test is stricter: it adds a time bound under 1.5 s and checks that no `.lock` file is left. Breaking by age is still covered, by `test_abandoned_lock_broken_by_age` and `test_garbage_stale_lock_broken_by_mtime`.
-- **`LOCK_STALE_S` became `LOCK_ABANDONED_S`** in the garbage-lock test and the injected-clock test. This is M2's intended change. The assertions are unchanged.
-- **`test_fresh_lock_not_broken` is stronger.** It now uses a live holder aged 60 s (older than the old 30 s threshold) and adds a fresh garbage lock.
-- **The stub's `error` directive** now bills nothing. The expectations in `test_failures_flags_and_drift` are unchanged, and the test now runs the more realistic path. See the coverage note under I1.
-
-Other checks:
-
-- **Skip guard.** The only `skipTest` added (`ProcessTreeTests`, when there is no epoch→ctime conversion) cannot trigger on Windows. The suite reported no skips.
-- **Tests that cannot fail.** None found. Every new test either fails on the unfixed helper or is a stated regression guard (`test_live_root_unchanged`, `test_abandoned_lock_broken_by_age`).
-
-## Surviving Critical / Important
-
-None.
-
-## Residual Minors for the record (not re-check failures)
-
-- **I1:** the text heuristic; no test for "error after billing the requested model".
-- **I2:** a child started in the last heartbeat interval is not claimed (also through `kill_job` when the supervisor is alive and `claude` is dead); POSIX without `/proc/stat` claims nothing.
-- **M1 / R1:** a kill between the registry write and the ledger append leaves the job with no ledger line. Phase 2 `usage` should reconcile against `results/`.
-- **M2:** the three-waiter put-back race; `release` is still check-then-remove.
-- **M3:** `stalled` and `wall_s` count the suspend; backwards jumps are not detected; `kill`/`expire` do not stamp (Phase 3 text).
-- **M9:** an empty value warns.
-
-## Unplanned additions in the fix pass (on record)
-
-- New failure reasons: `usage_limit`, `overloaded`, `prompt_too_long`, `api_error`. The review asked only that API errors stop reading `model_refused` and suggested carrying the status in the detail. The Phase 3 text needs to list these reasons.
-- New `clock_jump` flag and the `sup.log` jump line.
-- `where` always carries `warnings`, even when the list is empty.
-- `ledger_append` repairs a torn last line, and now returns a bool.
-- The stub directives `apierr=` and `errtext=`.
-- The `.broken.lock` leftover naming (matched by `.gitignore`'s `*.lock`).

docs/workpad/reports/2026-10-16-18-headless-forks-phase2-review.md

@@ -1,230 +0,0 @@
-# Phase 2 review: headless forks (bookkeeping)
-
-- **Reviewer model id**: `claude-opus-5-5[1m]`. Fresh: did not plan, build or fix this phase.
-- **Date**: 2026-10-16 17:55 +0200 (`date`)
-- **Scope**: Phase 2, commits `571a3d6..3b1de6c` on top of Phase 1 (`60fdea0`). Code `fff43a0` (2.1), `5fda2e2` (2.2), `4b92b51` (2.3); the rest is docs. Inputs: the build plan §4 and §6 Phase 2, the plan §4 and §7 Phase 2, design §5–§6, the Phase 2 contract digest, the run log's Phase 2 sections, and the Phase 1 re-check.
-- **Verdict**: the phase works as built and its smoke numbers check out against the raw streams. There are **0 Critical, 2 Important and 14 Minor** findings. Both Important findings are contract gaps that the Athanor-written digest left open: what `delta_tokens` counts, and which phase a ping belongs to.
-
-## Gates I ran
-
-| Gate | Result |
-|---|---|
-| G-unit `uv run plugins/spire/skills/forks/tests/test_forks.py` (run once) | exit 0, `Ran 130 tests in 130.444s`, `OK`, no skips. One `ResourceWarning` (unclosed `BufferedReader`, from `test_tick_runs_in_wait_and_supervisor`, `test_forks.py:2963`) |
-| G-where `uv run plugins/spire/skills/forks/forks.py where` | exit 0. stdout is one line holding one JSON object: `ok: true`, `spawn: cim-hidden`, binary 2.1.299 via `CLAUDE_CODE_EXECPATH`, `warnings: []` |
-| Smoke figures against the raw streams | Script over `…\headless-forks-p0\smoke2\…-forks\`. Checked for all 7 jobs: ledger `tokens` = result `tokens` = the raw `result.usage`. `cost_delta_usd` = raw `total_cost_usd` − entry `cost_before`. First-event `cache_read` against `base_context` gives the stated verdicts. Phase sums are 1: $0.309559 and 2: $0.145025. Pings (phase `null`) come to $0.013911. Ledger total $0.468495. The run log's figures match. |
-| `delta_tokens` probe | `listed_notes` on a brief that names the build plan, the run log and `plugins/spire/agents/athanor.md` (I1) |
-| Leftover processes (17:54, by command line: `forks-test-`, `_supervise`, `poscontrol`) | none |
-| Commit hygiene | `4b92b51..3b1de6c` touches only the run log, so no code changed after the phase-end G-unit run. There are no attribution trailers in `60fdea0..3b1de6c`. |
-
-I made no live `claude` calls.
-
-## Important
-
-### I1. `delta_tokens` counts every `.md` file a brief names, and no rebase can clear it
-
-`forks.py:2302-2321` (`_NOTE_REF`, `listed_notes`) and `:2484-2486` (`due_flags`).
-
-- **What it counts.** "Notes listed in the brief" is implemented as every token ending in `.md` that resolves to an existing file, first against the base's cwd and then against the state dir. That includes the build plan, the run log, the design, and files the fork is told to **edit**.
-- **Probe.** A brief that names `docs/workpad/plans/2026-10-16-02-headless-forks-build.md`, the run log and `plugins/spire/agents/athanor.md` gives 124,721 chars, which is `delta_tokens:31180` against a threshold of 12,000. The run log alone is 84,641 chars, or 21k tokens.
-- **Failure scenario.** The Athanor's briefs normally cite the build plan and the run log. Every fork then returns `rebase_due: true`. The reason does not depend on the base, so after `rebase --as B2` the next fork with the same kind of brief reports it again. The procedure obeys flags ("flags, not judgment"; design §5 says to rebase before forking), so each fork is preceded by a rebase. After four of them, `retrain_due: rebases:4` forces a re-train.
-- **Fix direction.**
-  - Count only handoff notes: files under the state dir's `notes/`, or notes whose mtime is after the base's `trained_at`. Never count files the brief tells the fork to edit.
-  - Pin the rule in the Phase 3 text.
-  - Add a test where a brief names a large non-note document and the flag stays off.
-- **Digest.** The digest repeats the design's phrase "notes listed in the brief" without defining it. The builder flagged the reading (2.2).
-
-### I2. Pings have `phase: null`, so no phase table ever shows them
-
-`forks.py:2951-2958` (the ping entry carries no phase or block) and `:3573-3575` (`usage --phase` filters on equality).
-
-- **What the contract says.** Design §6 has the phase close carry `usage --phase <n> --format md` with "per-kind totals (train, rebase, fork, continue, ping)". Plan 2.3's done-when asks for "per-kind totals … and a priced total".
-- **What happens.** A ping row can never appear in a phase table, and the phase's priced total leaves out keep-warm cost.
-- **Smoke evidence.**
-  - Phase 1 is $0.3096 and phase 2 is $0.1450, together $0.4546.
-  - The ledger holds $0.4685.
-  - The $0.0139 of the two pings appears in no phase table. Only the whole-run `usage` shows it.
-  - On a 250k base each ping is about 0.1 × prefix, so a multi-hour phase under-reports by several pings.
-- **Fix direction.** A ping takes its base's phase: `base.phase`, or else the highest phase of the base's forks. A simpler alternative: `--phase N` also includes pings on bases whose phase is N.
-- **Digest.** The digest leaves the ping's phase open. The builder flagged this (2.1 "block/phase null", 2.4 first flag).
-
-## Minor
-
-1. **A re-train never supersedes the old base** (`cmd_train`, `forks.py:2588-2627`). Plan §4.3's state machine says `active ─► superseded (rebase / re-train)`, but nothing in the helper sets `superseded` on a re-train.
-   - The abandoned base stays `active` and can be forked without `--force`.
-   - The ping rule's activity condition is run-wide (`run_active`, `:2864-2878`), so the forks of the new base keep pinging the old one, up to `break_even` pings.
-   - The cost is bounded at about 1.9 × the old prefix, which is one cold start.
-   - Fix: `train --supersedes <base>`, or have the Phase 3 text `expire` the old base.
-   - To the brief's question: **superseded** bases are never pinged (status gate, `:2893`), and a ping already in flight when a base is superseded ends normally and is not followed by another.
-2. **`--warm-margin-s` is not checked against the TTL** (`:1355-1356`, `:1881`). When margin ≥ TTL, a base is `expiring` right after every hit. A ping then fires on every tick, every 30 s from `wait`, until the cap.
-   - Probe: a base with inferred TTL 300 and `warm_margin_s` 600 reads `expiring` 1 s after its hit.
-   - This happens without anyone choosing it when a margin tuned for 1 h meets a 5-minute downgrade.
-   - The cap bounds the waste at about 1.9 × prefix per real call.
-   - Fix: cap the margin below the TTL, for example at `ttl/2`.
-3. **A failed or missed ping is retried on the next tick with no backoff** (`:1525-1528`, `:2881-2907`).
-   - Example: a usage-limit 429. Each ping clears `ping_in_flight`, leaves `last_hit` alone, and the next tick launches again: a CIM spawn plus `claude` every 30–60 s through the expiring window, up to `break_even`.
-   - Counting failed pings toward the cap is what bounds this. That is good, but a short backoff after `ping_missed` would be better.
-4. **A `partial` ping that re-wrote most of the prefix carries no flag** (`:1518-1528`). A ping that read only the shared system prefix (P0.6's case) is really a cold write of the base. `cold_start` is set for fork, continue and rebase only, so `usage`'s `cold_starts` misses it. The next fork then shows a clean `hit`.
-5. **A `continue`'s `cold_start` follows the base's warmth, which a continue never refreshes (I3)** (`:1518-1520`, `:2738`).
-   - Scenario: a continue reads its fork's own warm prefix and gets `hit`, but the base went cold meanwhile (pings off, or a 5 m TTL). The continue is still flagged `cold_start` and counted in `usage`.
-   - The rule dates from Phase 1. It now feeds the Phase 2 totals.
-6. **The supervisor's synchronous tick can break M3's bound on the loop body** (`:3171-3173` against `SupClock.tick`, `:3010-3019`).
-   - The Phase 1 re-check accepted `CLOCK_JUMP_S` = 60 s because the loop body stays under about 45 s.
-   - A tick now adds a `claude --version` (60 s timeout), a lock wait (up to 45 s), the CIM spawn (120 s timeout) and a second lock.
-   - A slow tick then reads as a host suspend:
-     - a spurious `clock_jump` flag;
-     - the gap is excluded from `max_minutes`;
-     - the orphan watchdog is re-armed.
-   - It is unlikely, but cheap to avoid: run the tick in a thread, or credit tick time back to the clock.
-7. **The hand-back seam with pings** (`:3243-3245`, `:3252-3253`, `:3337-3340`).
-   - `wait --all` excludes pings, and `wait <ping>` exits 2, so no command waits on a ping.
-   - `list.running` includes pings, though.
-   - The last `wait --all` before hand-back ticks at its start. It can launch a ping and still return 0, and `list` then shows a running job. The procedure's "nothing running at hand-back" and plan 4.2's trial criterion would read that as a leak.
-   - The Phase 3 text must say how to treat pings there (ignore them: they end within `PING_MAX_S`), or `list` should report them separately.
-8. **`init` after bases exist** (`:2146-2177`). The question was whether it can silently change a live base's fingerprint. **No.**
-   - Every base launches from its own `launch` record (M10).
-   - A record-less base from before 2.2 is backfilled from the old config before the config is replaced.
-   - `fingerprint` hashes are never compared, only recorded.
-   - The concern is elsewhere: every `init` flag has a default, so a partial re-run (as the smoke's `init --warm-margin-s 3500`) silently reverts any omitted run-wide knob: `pings`, `parallel_cap`, thresholds, `ttl_s`, `warm_margin_s`, `orphan_after`. The exit is 0, with the reverts listed in `changed_fields`.
-   - This is a refusal downgraded by the digest, not by the build plan. It is acceptable for launch fields, but the Phase 3 text should forbid re-running `init` (A7 already says so for successors). Alternatively, `init` could keep omitted values.
-9. **A test that cannot fail for its stated reason.** `UsageTests.test_r1_waits_for_the_registry_lock` (`test_forks.py:2187-2202`) asserts that `usage` blocks on a held lock. But `cmd_usage` takes the lock in `touch_orchestrator` (`forks.py:3565`) before `reconcile_ledger`, so a reconcile that took no lock would pass too.
-   - Fix: call `reconcile_ledger` directly, as `test_r1_nothing_missing_takes_no_lock` does, or set `SPIRE_FORKS_CHILD` for the call.
-10. **The `ResourceWarning`, confirmed** (handoff flag). `Supervisor.run` opens `claude` with `stdout=PIPE` (`:3103-3105`) and never closes `p.stdout` after `reader.join` (`:3181-3185`).
-    - In the detached supervisor this is harmless: the process exits right after.
-    - In-process it leaks a handle, which is what the test run shows.
-    - Fix: close `p.stdout` after the join when the reader has ended.
-11. **R1 can leave the ledger and the results disagreeing (no double count).** Scenario: a result file exists but its registry entry still reads `running` (a kill between the result write and the registry write). `reconcile_ledger` (`:3410-3444`) appends its line from that result. A later `reap_lost` or `kill` then finalises the entry again (`:1638-1662`), overwrites the result with `lost`/`killed`, and the ledger append is skipped.
-    - The ledger keeps the first status. Tokens and cost come from the same stream, so totals do not drift.
-    - **Idempotency itself holds**:
-      - the fast path takes no lock;
-      - the slow path re-reads the ledger under the lock;
-      - `ledger_append` dedupes on job id;
-      - a second `usage` adds nothing (tested).
-12. **`train --tools` does not re-derive `allowed_tools`** (`:2570-2573`; the test codifies it at `test_forks.py:3120`). `init` derives `allowed = tools`. Under `dontAsk`, a tool added by a `train --tools` override is therefore denied, and the result reads `needs_attention`.
-13. **Two sequential forks can run at once under `parallel_cap` 2.** Their `head_at_end` ranges then overlap, so each Commit cell can list the other's commits (`:3516-3525`). The builder flagged it. The Phase 3 text should run sequential forks one at a time.
-14. **Cosmetic or untested.**
-    - `list` computes warmth for superseded and retired bases. The smoke's superseded B1 shows `expiring` (`:3326`).
-    - Untested: a ping launched by a supervisor's own tick, end to end (the env and interpreter path read correct); `defining:` for fields other than `model`; `rebase_conflict`. The last one is unreachable in practice: `train` refuses a pending name and `rebase` refuses an existing one.
-    - The M8 desktop-wide diff fails if the user opens a console during the ~1 s sample.
-
-## The brief's hunt list
-
-- **TTL inference.**
-  - `infer_ttl` gives 3600 when 1 h tokens were written, 300 when only 5 m tokens were written, and otherwise keeps the previous value, falling back to the config. It runs after every call with a `result`, ping and continue included.
-  - The deviation from the digest (a read-only call keeps 300 instead of reverting to 3600) is right: reverting would show a 5-minute base as warm for an hour. It recovers on the next 1 h write.
-- **Does a ping refresh the prefix it claims to?** Yes.
-  - Its argv is the base's record plus `--resume <base> --fork-session --session-id <new> --max-turns 1`. That request reads the base prefix.
-  - Smoke: `j0006` read 25,277 of B2's 25,279. `j0007` read 25,719, which includes j0006's identical suffix.
-  - `last_hit` is set to the ping's first event at finalise, only for an `ok` ping with `hit` or `partial`.
-  - Caveat: Minor 4.
-- **The cap math.**
-  - `break_even` is computed in integer hundredths: (200−10)//10 = 19 and (125−10)//10 = 11. Correct, and tested.
-  - Pings since the last real call are counted by job number. Every status counts, and the count is per base. A new base created by a rebase counts its pings from creation, because the rebase job belongs to the old base.
-- **A ping storm from concurrent tickers.** Not possible.
-  - The decision, the job entry and `ping_in_flight` are written in one locked write.
-  - The unlocked first look is redone under the lock.
-  - The finaliser clears the mark and sets `last_hit` in one write.
-  - `test_two_tickers_one_ping` forces both tickers past the unlocked look with a barrier, so it would fail without the locked re-check.
-  - What remains is retry without backoff (Minor 3) and margin ≥ TTL (Minor 2).
-- **Cost leaks from pings on superseded bases.** None, because of the status gate. The leak is through bases a re-train abandons (Minor 1).
-- **Rebase, old/new switch.**
-  - The new base is created only when the job is `ok`, in `_rebase_succeeded` (`:1599-1636`).
-  - On `failed`, `killed`, `timeout` or `lost`, B stays `active` and NEW never exists. This is tested for `is_error` and kill.
-  - Smoke: the new base's `cost_cum_usd` is the rebase's cumulative total, $0.2435012, and that is exactly `cost_before` of fork `j0005`.
-- **`last_hit` on a failed rebase.** It is refreshed from the rebase's first assistant event, both live (`bump_last_hit`) and at finalise. That is correct: the first request read B's prefix whatever happened afterwards. An error before any assistant event refreshes nothing.
-- **`init` after bases exist.** It cannot change a live base's fingerprint (Minor 8).
-- **R1.** Idempotent, and no double count (Minor 11 for the one inconsistency).
-- **Usage numbers.** They match the ledger, the result files and the raw `result` events for all 7 smoke calls. The md totals equal the sums.
-- **M13 `cygpath`.**
-  - Correct: drive forms skip it, and `/tmp/x` goes through `cygpath -w`.
-  - With no `cygpath`, or a failing one, the command exits 2 naming the path, and nothing is written on the cwd's drive (tested end to end through `init --run /tmp/…`).
-  - `//server` paths are untouched.
-  - In contexts without Git Bash on PATH, such as a supervisor or PowerShell, rooted paths are refused rather than guessed. That is the right failure.
-
-## Weakened checks and tests that cannot fail
-
-I went through every assertion line the Phase 2 diff removes from `test_forks.py`:
-
-- `/tmp/x → G:\tmp\x` was removed. M13 forbids that mapping, and two new tests cover the input.
-- `test_changed_values_after_base_refused` became `…_allowed`. This is the digest's specified change; the test still checks that the base keeps its record and that identical values stay byte-equal.
-- `test_phase2_not_implemented` was removed: the commands are implemented, and `test_commands_need_init` gains them.
-- The window assertions moved into `test_no_visible_window`, which is wider and has a positive control. The `assertGreater(len(all_windows), 0)` became a skip, as M8 specified.
-- The `running[]` key `turns` became `messages` (M16).
-- In `test_train_fork_continue_end_to_end` the note is now written after the launch (M11), with its assertions unchanged.
-
-Nothing was loosened. The billed-error test (`test_error_after_requested_model_billed`) fails if the result reads `model_refused`. M8's positive control proves the detector sees a console window.
-
-There is one test that cannot fail for its stated reason (Minor 9).
-
-## Handoff flags, one by one
-
-| # | Block | Flag | Answer |
-|---|---|---|---|
-| 1 | digest | Athanor-written. Check it against the build plan | It is consistent with the build plan except in three places. (a) It puts `rebase` in `parallel_cap` (`CAPPED_KINDS`, `forks.py:159`), while plan §4.3's invariant names fork/continue. That is stricter and harmless, but the run log says "none against the build plan". (b) It leaves the ping's phase open (I2). (c) It leaves "notes listed in the brief" undefined (I1). Replacing `init`'s refusal is the digest's own decision, not the coordinator's (Minor 8). The coordinator items R1, M6, M7, M8, M10, M11, M13, M16 and the billed-error test are all implemented as decided. |
-| 2 | 2.1 | A read-only call keeps the previous TTL even when it is 300 | Accepted (see the hunt list) |
-| 3 | 2.1 | `messages` also in `wait` `running[]` and `list` running rows | Accepted. The Phase 3 text must use `messages` there and `turns` in results |
-| 4 | 2.1 | Pings use the base's record | Accepted. 2.2 finished M10 for every launch |
-| 5 | 2.1 | `wait` ticks at its start | Accepted. Note Minor 7: the last `wait` before hand-back can launch a ping |
-| 6 | 2.1 | Naming a ping job in `wait` exits 2 | Accepted as such, but nothing can wait on a ping (Minor 7) |
-| 7 | 2.1 | Activity = `last_wait_at` or a fork/continue in the last 600 s; a hand `tick` is not activity | Matches design §5. Activity is run-wide (Minor 1) |
-| 8 | 2.1 | Pings counted by job number, every status counts | Accepted. Counting failures is what bounds Minor 3 |
-| 9 | 2.1 | `break_even` uses the 1 h ratio above 300 s | Accepted |
-| 10 | 2.1 | Ping wall limit 300 s; block/phase null | The wall limit is fine. Phase null is **I2** |
-| 11 | 2.1 | Binary check before the lock; a missing binary skips the base | Accepted. Tested (`binary_missing` why, no job) |
-| 12 | 2.1 | The supervisor's tick pauses its loop 1–3 s | The worst case is much longer and breaks M3's bound (Minor 6) |
-| 13 | 2.1 | No N3 check inside `tick_pass` | Accepted. `tick` is refused in a fork, a fork's `wait` skips the tick, and the supervisor's ticks are the design's own |
-| 14 | 2.1 | A supervisor ticks first after 60 s | Accepted. `wait` covers short jobs |
-| 15 | 2.1 | A ping's `last_hit` is set at ping end | Accepted. `ping_in_flight` covers the gap. The timestamp is the first event, not the end |
-| 16 | 2.1 | TTL is inferred from failed calls too | Accepted: billed tokens are real writes |
-| 17 | 2.1 | M8 positive control is minimised; the desktop diff can flake | Accepted, Minor 14 |
-| 18 | 2.1 | `ResourceWarning` | Confirmed, Minor 10 |
-| 19 | 2.1 | Untested: a ping from a supervisor's own tick | Still untested (Minor 14). By reading, the env (child env, scrubbed) and interpreter path are right |
-| 20 | 2.2 | The new base records the binary the rebase ran under | Correct, tested (`b4` against the current stub) |
-| 21 | 2.2 | `rebase` returns train's shape plus `parent` | Accepted |
-| 22 | 2.2 | `phase_boundary` follows the digest's "or" literally | Accepted. Repeating until a rebase fits design §5's "the first fork of a new phase comes from a rebased base" |
-| 23 | 2.2 | A rebased base's phase is `--phase`, not inherited | Accepted. Without `--phase` the base's own side is unknown, so the Phase 3 text should always pass `--phase` to `rebase` |
-| 24 | 2.2 | `delta_tokens` counts the `*.md` paths in the brief | **I1** |
-| 25 | 2.2 | `lines` includes uncommitted changes | Accepted (design: `git diff --shortstat`) |
-| 26 | 2.2 | "Last call" for `runtime_drift` | Accepted. A rebase clears it: the new base's reference is the rebase's own init |
-| 27 | 2.2 | The `defining:` field set (effort and allow/deny lists are not defining) | Matches design §5's list |
-| 28 | 2.2 | Transcript read from the tail; only a synthetic test | Accepted. It falls back to the stored context |
-| 29 | 2.2 | `list` computes flags for active bases only | Accepted. The warmth is still shown for others (Minor 14) |
-| 30 | 2.2 | `train` re-validates the whole record | Accepted. `--tools` without `allowed_tools` is Minor 12. There is still no way to clear the config's agent |
-| 31 | 2.2 | A rebase's first event refreshes the old base's `last_hit` even if the rebase fails | Correct (see the hunt list) |
-| 32 | 2.2 | NEW's training cost is the rebase's cost delta; its forks' basis is the rebase's cumulative total | Verified in the smoke (`j0005.cost_before` = 0.2435012) |
-| 33 | 2.2 | Rebases are not activity | Accepted. A `wait` loop over a rebase is activity anyway |
-| 34 | 2.2 | M11 has 2 s slack | Accepted |
-| 35 | 2.2 | M7 hashes a constant empty server set | Accepted. The helper writes that file itself |
-| 36 | 2.2 | M13: paths in a brief that cygpath cannot convert are skipped | Accepted |
-| 37 | 2.2 | `rebase_conflict` untested | Unreachable in practice (Minor 14) |
-| 38 | 2.2 | Untested `defining:` fields, `train --cwd/--agent/--binary`, pre-2.2 bases | Still untested. The code paths are shared with the tested `model` case |
-| 39 | 2.3 | The whole-run md uses the phase layout | Accepted |
-| 40 | 2.3 | Killed/lost calls count as calls with null sums | Accepted. Consistent between json and md |
-| 41 | 2.3 | The md phase table omits zero-call kinds | Accepted. The json always has all five kinds |
-| 42 | 2.3 | R1 also reconciles a result whose registry entry still reads `running` | No double count, but the ledger can keep a status the result no longer has (Minor 11) |
-| 43 | 2.3 | `usage` stamps the orchestrator call (not from a fork) | Accepted |
-| 44 | 2.3 | `head_at_end` can include another fork's commit, so Commit is shown for sequential forks only | Two sequential forks can still overlap (Minor 13) |
-| 45 | 2.3 | Commit lists 7-character hashes | Accepted |
-| 46 | 2.4 | Pings are left out of `usage --phase` | **I2** |
-| 47 | 2.4 | The superseded B1 shows `expiring` | Cosmetic, Minor 14. No ping went to it (status gate) |
-| 48 | 2.4 | The partial-ping refresh was not reproduced live | Accepted. The unit test covers it (`test_ping_end_to_end_through_wait`) |
-| 49 | 2.4 | The smoke used `init --warm-margin-s` instead of a 54-minute wait | Accepted for the smoke. The tunable needs a guard (Minor 2) |
-
-## Built but not asked for (on record only)
-
-- `init --warm-margin-s` and the config key `warm_margin_s`. The digest added it for the smoke; it is not in the build plan.
-- The flag `ping_missed`. `list` base rows gain `ttl_s`, `margin_s`, `ttl_from` and `ping_in_flight`, and bases store `ping_in_flight_at`.
-- `wait` refuses ping job ids and ticks at its start. `wait --all` excludes pings.
-- `messages` in `wait` `running[]` and in `list` running rows. This changes the Phase 1 digest's shape.
-- `rebase` additions:
-  - the options `--max-minutes` and `--max-budget-usd`;
-  - the refusals "the base is being rebased", and on `train`, "a running rebase creates this base";
-  - `rebase_conflict`;
-  - `parent` in the return.
-- `init` output gains `bases`, and `init` backfills record-less bases.
-- Job-entry fields `created_ts`, `head_at_end`, `runtime_drift`, `rebase_as` and `new_launch`.
-- `usage` json additions:
-  - `reconciled`, `cache_hits`, `cache_verdicts` and `scope`;
-  - ledger lines marked `"reconciled": true`;
-  - `--format md` written as UTF-8 bytes.
-- Test hooks `CLAUDE_PROJECTS_DIR`, `TRANSCRIPT_TAIL_BYTES` and `find_cygpath`.
-- Stub directives `billed`, `ttl=5m`, `nover=` and `skill=`, and the stub now honours `--max-turns`.

docs/workpad/reports/2026-10-16-19-gremlins-phase3-digest-check.md

@@ -1,125 +0,0 @@
-# Pre-build check: Phase 3 contract digest (`spire:gremlins`)
-
-- **Checker model id**: `claude-opus-5-5[1m]`. Fresh: did not write the digest and will not build or review Phase 3.
-- **Date**: 2026-10-16
-- **Checked**: `docs/workpad/plans/2026-10-16-18-gremlins-phase3-contract.md` at `5092ed8`, against the goal on `main` (`docs/workpad/goals/headless-forks.md`), build plan §4 and §6 Phase 3, the Phase 2 re-check (N1–N5, the flake), the run log's routed items, the Phase 1 review and re-check, and `plugins/spire/skills/forks/forks.py` / `tests/test_forks.py` as they are now. No tests were run and no live calls were made.
-- **Verdict**: 1 BLOCKER, 12 ADJUST, the rest OK. The interface list is complete against the code. The rename map has no gap that breaks state. The gate tests, C16 and the release wording need changes before the build.
-
-## BLOCKER
-
-**B1. GateTests cannot work on the Windows host as specified (§4 "Tests").** They patch `gremlins.PLATFORM` to a `PosixPlatform`. Every path then goes through `norm_path` → `PLATFORM.norm_path` → `PosixPlatform`, and §3.4/C8 makes that refuse drive forms.
-- `where --binary C:\…\claude-stub.cmd` refuses in `resolve_binary` (`forks.py:1004`), and so does `script_path()` (`:1067`). Today `cmd_where` does not catch either (`:2006`, `:2023`).
-- `init --run C:\…` refuses in `state_dir_for` (`:340`) before any gate check.
-- What happens:
-  - The override half ("`where` exits 0", "`init` proceeds") fails on Windows.
-  - The closed `init` case ("exits 2 and creates no state dir") passes for the wrong reason, the path refusal. So it is a test that cannot fail on the gate.
-  - The builder has to improvise the fix, which is how earlier digests produced Important findings.
-- **Fix**: the fake platform is a `WindowsPlatform` subclass, or `PLATFORM` with `supported` and `describe` patched. It has `supported = False`, `is_wsl() = True` and `describe()` = `{name: "posix", sys_platform: "linux", wsl: true, …}`, so path handling stays Windows. `init` asserts `error == "platform not supported"`. The gate check is the first thing in `init`, before `state_dir_for` and any `norm_path`. Keep the pure `PosixPlatform().supported is False` unit tests as written.
-
-## ADJUST
-
-**A1. The gate leaves launches open when a registry exists (§4, C11; §7.2 intake).** "Every other command needs `init`" is only true for a fresh run. The state dir is committed at phase close (§7.2 commit ownership: everything except `raw/` and locks). §7.2 intake says: if the run log has a `Gremlins:` line, run `list` and adopt, without `where`. On Linux, a successor Athanor adopting a run that was started on Windows would then run `spawn`, `rebase`, `continue` and `train`. `wait` and `tick` would launch pings. All of this happens on a closed platform. The sessions are not on that host, so the jobs fail, but each failure costs a launch, and pings keep retrying (Phase 2 Minor 3).
-- **Fix**:
-  - Refuse on a closed gate in the dispatcher for `train`, `spawn`, `continue`, `rebase` and `tick`, in the same place as the N3 refusal.
-  - The tick inside `wait` and the supervisor launches no pings on a closed gate.
-  - The intake runs `where` first, then adopts.
-  - Add one GateTests case: a registry present, gate closed, `spawn` exits 2.
-
-**A2. C16 as written hides real survivors (§5.3).** The rule is "a snapshot pid that is gone from the table or now carries another name is dead". It fails in three cases:
-- (i) `process_table()` returns `[]`. On macOS that is always (no `/proc`); on Windows it happens when Toolhelp fails (`:750-752`). Every snapshot pid then counts as "gone", so `kill` reports `survivors: []`, `ok: true`.
-- (ii) The snapshot name is `None`. The root's name is `names.get(root)` (`:805`), so a root missing from the table gets `None`, and `None` never matches a name.
-- (iii) On POSIX, `comm` changes on `exec`, for example an `sh` wrapper that execs python or claude. A live process then reads "renamed".
-
-  The defect that is actually observed is narrower: access denied makes `pid_alive` return True without a creation-time check (`:719-721`).
-- **Fix**: drop a snapshot pid only if one of these holds:
-  - the table is non-empty and lacks the pid;
-  - the snapshot name is known, the table name differs, and `proc_ctime(pid)` is `None` (the unverifiable case, i.e. class (a)).
-
-  In every other case `record_alive` decides, as today.
-- Read the table through the module-level `process_table` (`ProcessTreeTests` patch module names).
-- Tests: an empty table keeps the survivor; a snapshot name `None` keeps it; a name differing while the ctime is verifiable leaves the decision to `record_alive`.
-
-**A3. The third N3 test in §5.1 contradicts itself.** "Stored file deleted, env unset, PATH without claude → stored path kept with the 'could not re-resolve' warning (then `build_launch` refuses…)". `build_init_config` calls `build_launch` → `binary_info`, which raises `claude binary not found` (`:2162`, `:1025-1026`). The warning can never appear in the output.
-- **Fix**: split it into two tests.
-  - Stored file present, env unset, PATH without claude: path kept, warning shown, exit 0.
-  - Stored file deleted: exit 2, `claude binary not found` (today's loud failure).
-
-**A4. C14 can switch installs silently.** If the stored `binary_resolved_by` is `CLAUDE_CODE_EXECPATH` and a re-run comes from a shell without it, `resolve_binary(None)` falls through to the PATH `claude` (`:1005-1010`). That can be another install, with another version or auth. A warning is given, but it still crosses sources.
-- **Fix**: re-resolve only through the stored source (EXECPATH from EXECPATH, PATH from PATH). If that source gives nothing, keep the stored path and warn.
-
-**A5. Path matrix row 3 (`C:`, `C:x`) contradicts "as today" (§3.4).** On today's Windows branch, `ntpath.join(base, "C:x")` returns `C:x`. Its rest does not start with `\`, so the result is `ForksError("cannot normalise path")` (`:322-332`). `C:` goes the same way. Also, "assert absolute with drive `C:`" cannot be pure string logic on a POSIX host (WSL runs the matrix), because `ntpath` has no per-drive cwd there.
-- **Fix**: row 3 on Windows is **refused**, as today.
-
-**A6. The C18 wording fails G-text 1 (§7.2 vs §9.2.1).** §7.2 proposes "A fresh agent reads **the code the phase touches** and writes the trunk notes". G-text 1 requires that phrase to be absent from `athanor.md`.
-- **Fix**: reword, for example "a fresh agent reads the code the blocks change and writes the trunk notes".
-
-**A7. "Windows-only in 0.3.0" contradicts the goal's "Amended … release gating".** 0.3.0 is merged and released only after the Linux and macOS Igors lift their gates, so the 0.3.0 that ships is not Windows-only. The phrase is in four places:
-- the SKILL.md description (§7.1);
-- the README row (§9.1);
-- the gate reason (§4, "spire:gremlins 0.3.0 runs on Windows only");
-- the release commit body (§9.4).
-
-  Porters can change the first three. They cannot change a commit body without rewriting a pushed history.
-- **Fix**: use version-free wording.
-  - Text: "Windows-tested; other platforms fail closed until tested (see Platforms)".
-  - Gate reason: "spire:gremlins is not tested on <sys_platform><, WSL> yet; …".
-  - Changelog: "tested on Windows; Linux and macOS gated pending the platform handoff".
-  - Handoff §8.8 lists every place the porter updates.
-
-**A8. Three routed text items are missing from §7.7.**
-- (a) `preamble.md:9` points gremlins at `plugins/spire/skills/implementation/references/run-log.md`. The Phase 1 review ("Two extra preamble lines" row) says this does not resolve in other projects, because the plugin lives in the cache. Phase 3 should give the format inline or by an absolute path. §2.6 says "keep the other rules", so this would ship broken.
-  - **Fix**: inline the handoff-note format in `preamble.md`. Or have the helper put the absolute path into the templates (it knows `script_path()`). The preamble hash changes in 3.1 anyway.
-- (b) `stalled` together with `clock_jump` is not a hung gremlin (Phase 1 re-check, M3 builder flag).
-- (c) The remedy depends on the reason. Only `model_refused` points at `availableModels`. `usage_limit`, `overloaded`, `api_error` and `prompt_too_long` are not a settings problem (Phase 1 review, the 429 → `model_refused` finding). SKILL §6 lists the reasons but no action for each.
-
-**A9. Vacuous negative tests if the rename misses them (§2.7).** `test_forks.py:155`, `:934`, `:1011` and `:1079` assert `assertFalse(os.path.exists(… "-forks"))`. After the rename the state dir is `-gremlins`, so any line left unchanged can never fail. The residue grep shows them, but nothing in §2.8 says they are wrong.
-- **Fix**: name these lines in §2.7 and derive the path from `gremlins.state_dir_for(run)`, not a literal suffix.
-
-**A10. The §2.8 residue categories miss legitimate hits outside the skill.** These are:
-- `igor/SKILL.md:66` (the D4 follow-up, out of scope);
-- `igor/references/mindset.md:11` and `igor/references/harness-notes.md:3`;
-- `implementation/references/superpowers.md:36` (repository forks).
-- **Fix**: add a category "Igor text (D4) and non-session meanings: leave untouched", so 3.1 neither edits these lines nor reports them as residue.
-
-**A11. A closed-gate `where` does not always "still fill everything else" (§4).** `cmd_where` (`:2006`) does not catch a path refusal from `resolve_binary`. On WSL with a Windows `CLAUDE_CODE_EXECPATH` (via `WSLENV`), or with `--binary C:\…`, §3.4 now refuses. The output is then exit 2 with a path error, without the gate reason and without the report the porters need.
-- **Fix**: catch `GremlinsError` from `resolve_binary` into `binary.error` and `reasons`.
-
-**A12. `platform.override` is undefined while the env is set on a supported platform.** C13 sets the env for every test, so the question comes up in every test. §4 says that with the override, `where` reports `override: true`.
-- **Fix**:
-  - Define `override = env set and not PLATFORM.supported`. Windows `CliTests` then assert `override: false` even with the env set.
-  - `PosixPlatform.describe()` reads `self.supported` instead of a literal `False`, so lifting the gate is one change (§4 "Lifting the gate").
-  - `platform_gate()` reads `PLATFORM.describe()`, never `sys.platform`, so it passes the §3.7 seam grep.
-
-## OK, with notes
-
-- **Interface (§3.2)**: complete against the code. These are every OS-specific site in `forks.py`, and §3.1–§3.3 places each one:
-  - `IS_WINDOWS`/`SPAWN_METHOD`/`_NOWIN` `:47-52`;
-  - cygpath `:276-296`;
-  - the lock restore `:500-503`;
-  - the ctypes block `:630-664`;
-  - `proc_ctime`/`epoch_to_ctime`/`pid_alive`/`process_table`/`terminate` `:667-853`;
-  - `_taskkill`/`kill_tree` `:856-895`;
-  - `_run` `:901`;
-  - `_powershell`/`spawn_supervisor` `:1421-1460`;
-  - `where` `:2028-2030`;
-  - `Supervisor.run` `:3223-3224`.
-
-  The `transcript_path` slug and the scrub lists are neutral code that was only observed on Windows. They belong in the handoff, where §8 puts them. Do not name any local variable `platform`: the module imports `platform` (`:2003`).
-- **Rename map**: no gap that breaks state. No `-forks` state dir is tracked in git, and nothing outside the skill references `skills/forks`. The base key `"forks"` has three writers (`:1637`, `:2716`, `:2782`) plus `LIST_BASE_KEYS` `:3431`; all are covered by §2.4. `run_for_state` `:2935` is covered by §2.1. The preamble text change alters the `append_system_prompt` hash (a defining field). That is harmless, because no base from before the rename is reused (C6).
-- **C1–C7, C9, C10, C19, C20**: OK. For C20, see the A7 wording.
-- **C8**: OK. The POSIX refusal of a backslash is a behaviour change, and the handoff (§8.4) already lists it.
-- **C11**: OK in itself. It is not enough on its own: see A1.
-- **C12**: OK. Naming: `SPIRE_GREMLINS_UNSUPPORTED_OK` has a plural prefix, `SPIRE_GREMLIN_CHILD` and `SPIRE_GREMLIN_DETACH_*` have a singular one. Pick one before 3.2 writes them.
-- **C13**: OK. It also means that a green suite on Linux says nothing about the gate; only `GateTests` cover it. The handoff should say so.
-- **C15**: OK.
-  - `rebase` refuses a base that is not active, at launch and again under the lock (`:2873`, `:2893`).
-  - Only one rebase per base runs at a time (`:2901`).
-  - So "not active at finalise" can only mean "changed during the run".
-  - `_conclude` runs inside `finalize_job`'s lock with the same registry read as `_rebase_succeeded` (`:1656-1665`, `:1607`). Computing `parent_inactive` there is therefore consistent.
-  - Set the flag only when NEW is actually created, not on the `rebase_conflict` early return (`:1622-1624`).
-- **C16 (b)**: raising `KILL_VERIFY_S` to 30 s is fine for `kill`. `expire` kills its jobs one after another, though, so several stuck jobs × 30 s can pass the Bash tool's default 2 min. The tool then backgrounds the call (P0.1(d)). The SKILL text should give `kill`/`expire` a long Bash `timeout`.
-- **C17**: acceptable. The stub tests exercise the real CIM detach after the rename and the seam refactor. The release commit is not a merge. Phase 4 must smoke the renamed helper before anything ships.
-- **C18**: a reasonable reading of "the 0.2.2 shape" against "the Athanor does not read code". Wording: see A6.
-- **Push**: the goal says the branch "gets pushed". The digest says no push, which follows Igor's brief (precedence 1). Pushing is a post-build user step.
-- **The two flagged risks** (an `!` injection exiting 2 on a closed platform; installing uv in WSL only through the permission prompt): correctly flagged, nothing to add.
-- **The flake plan (§5.3)**: the bounded investigation and "never two suites at once" are right. Only the C16 rule needs A2.

docs/workpad/reports/2026-10-16-19-headless-forks-phase2-recheck.md

@@ -1,153 +0,0 @@
-# Phase 2 re-check: headless forks (fix pass)
-
-- **Reviewer model id**: `claude-opus-5-5[1m]`. Fresh: did not plan, build, review or fix this phase.
-- **Date**: 2026-10-16 18:21 +0200 (`date`)
-- **Scope**: only the findings the fix pass took on from `reports/2026-10-16-18-headless-forks-phase2-review.md`: I1, I2 and Minors 1, 2, 8, 9, 10, 11. Fix commits `d2d5104` (code and tests), `ba463fc` and `94c1d8c` (run log, trunk notes), diffed against `9564c22`. Also checked: the fixer's re-check flags, the new `--delta-note` and `train --supersedes` surfaces, and the changed tests for weakened assertions.
-- **Verdict**: all eight are **resolved**. **No Critical or Important finding survives.** The fixer's flags are acceptable as Minor. I found five new Minors in the new surfaces (N1–N5 below). None blocks Phase 3. Two of them need a line in the Phase 3 text.
-
-## Gates I ran
-
-| Gate | Result |
-|---|---|
-| G-unit `uv run plugins/spire/skills/forks/tests/test_forks.py` (run once, 18:15–18:18) | exit 1. `Ran 137 tests in 150.191s`, `FAILED (failures=1)`. The failure is `LaunchTests.test_refusals`, `test_forks.py:2870`: `kill` returned `ok: false`, which means a process from the snapshot was still alive after `KILL_VERIFY_S`. Neither that test nor `kill_job`/`kill_tree` (`forks.py:861-895`, `:1756-1786`) is in the fix diff. Run alone, the test passed 3 of 3 times (3.8 s each). I count it as a load flake from Phase 1 code, outside this re-check (see "Outside scope"). There was no `ResourceWarning` line anywhere in the log. |
-| G-where `uv run plugins/spire/skills/forks/forks.py where` | exit 0. One JSON line: `ok: true`, `spawn: cim-hidden`, binary 2.1.299 via `CLAUDE_CODE_EXECPATH`, `warnings: []` |
-| New and changed tests against the unfixed helper | I ran the 13 touched tests in a scratch copy: `forks.py`, `preamble.md` and `templates/` from `9564c22`, plus the HEAD test file. Result: `failures=9, errors=3`. Each fails at the assertion for its finding (details below). `test_tick_runs_in_wait_and_supervisor` passes there but prints the `ResourceWarning` (Minor 10). `test_ping_end_to_end_through_wait` passes there too, as expected: it only moved its setup to a margin the new rule accepts. |
-| Mutants of the fixed helper | I made three mutants of the fixed helper and ran the matching test against each. All three were killed: (1) `reconcile_ledger` without the lock fails `test_r1_waits_for_the_registry_lock` (`[['j0010']] != []`). (2) `new_to_base` ignoring `trained_at` fails `test_delta_tokens_counts_only_what_the_base_does_not_know` at `:3299`. (3) Superseding a named base of any status fails `test_train_supersedes` at `:3351` (`'superseded' != 'failed'`). |
-| Smoke state, copied to scratch, through the fixed helper | `usage` exits 0, `status_from_result: []` (no false positive on real data), `reconciled: []`, total $0.468495, unchanged. `usage --phase 2 --format md` gives the same $0.1450 as before. The two old pings keep `phase: null`, as flagged. `list`: B1 `superseded`, B2 `active`, `margin_s` 1800, which is the smoke's 3500 capped at 3600/2. No reasons. |
-| Leftover processes (18:20, by command line: `forks-test-`, `_supervise`, `poscontrol`, `claude-stub`) | none, apart from my own query |
-| Commit hygiene | Code changed only in `d2d5104`; `ba463fc` and `94c1d8c` touch only the run log and trunk notes. No attribution trailers in `9564c22..HEAD`. |
-
-I made no live `claude` calls.
-
-## Findings, one by one
-
-### I1. `delta_tokens` counts every `.md` file a brief names: **resolved**
-
-- **What was done.** `forks.py:2360-2415` and `:2573`. `_NOTE_REF` and `listed_notes` are gone. `delta_tokens` is now chars/4 of three parts:
-  - the delta header;
-  - the `--delta-note` files whose mtime is after the base's `trained_at` (`new_to_base`, `:2400`);
-  - the body of a `## Changes since base` section (`changes_section`, `:2370`).
-- **The review's failure scenario is gone.** A brief that names the build plan, the run log and files to edit adds nothing. Because the mtime gate compares against `trained_at`, a rebase clears the reason. The review's three-part fix direction is met:
-  - count only real deltas;
-  - the rule is routed to the Phase 3 text (successor boot, run log `:514`);
-  - a test where a large named document leaves the flag off (`test_forks.py:3258`, and `:3195` in `test_due_reasons_each_alone`).
-- **Test strength.** On `9564c22`, `:3274` ("named only: nothing") fails, and so does `:3195`. The `trained_at` mutant fails at `:3299`.
-- **Fixer flags**:
-  - *Whole-second `trained_at`*: acceptable. `_iso` truncates (`isoformat(timespec="seconds")`, `forks.py:221`), so `trained_at` is never later than the true end. A note written in the same second, before the end, counts as new. That is the safe side: at worst it raises a spurious advisory flag.
-  - *Reused `## Changes since base` section*: acceptable as Minor. It is a brief-writing rule, and it is routed to the Phase 3 text (run log `:486`, `:514`).
-
-### I2. Pings have `phase: null`: **resolved**
-
-- **What was done.** `ping_phase` (`forks.py:2959`) takes the phase of the latest train, fork, continue or rebase job on the base that has one. If none has one, it takes the base's own phase, else null. `tick_pass` records it on the entry (`:3070`), so the result, the ledger and `usage --phase N` all carry it.
-- **Test strength.** `test_forks.py:1926` checks the fallbacks, the json `kinds.ping`, the md `ping` and total rows and `Priced total`, and that `--phase 1` has no rows. On `9564c22` it errors (`ping_phase` does not exist). The md and json assertions would also fail if the phase were dropped at finalise.
-- **Fixer flag** (old pings keep null; a rebased base takes its forks' or its own phase): acceptable. Only the smoke's two pings are affected, as confirmed on the copy. The rule that `rebase` always gets `--phase` is already routed to the Phase 3 text.
-
-### Minor 1. A re-train never supersedes the old base: **resolved**
-
-- **What was done.** `train --supersedes BASE` (repeatable, `:1917`).
-  - Unknown names and the base's own name are refused with exit 2, before and under the lock (`:2686-2709`).
-  - On an `ok` training, each named base that is `active` becomes `superseded` with `superseded_by` and `superseded_at` (`:1598-1604`). A failed training changes nothing.
-- **Test.** `test_forks.py:3321` covers the refusals, the failed training, the ok training, the ping decision `status:superseded` and fork-needs-`--force`. The status-gate mutant is killed.
-- One new edge case is listed as N4.
-
-### Minor 2. `--warm-margin-s` is not checked against the TTL: **resolved**
-
-- **What was done.**
-  - `init` refuses an effective margin ≥ the effective `ttl_s` with exit 2 and writes nothing (`:2184-2187`). This includes a re-run that lowers `ttl_s` under the current margin.
-  - `base_warmth` caps a configured margin at the base's TTL/2 (`:1357`). The review's probe (TTL 300, margin 600) now reads `warm` with `margin_s` 150 (`test_forks.py:1702`), and the smoke copy shows 3500 → 1800.
-- **Fixer flag** (the smoke's `--warm-margin-s 3500` acts as 1800, at most 1800 at 1 h): acceptable. It is in the successor-boot list.
-
-### Minor 8. `init` re-run reverts omitted settings: **resolved**
-
-- **What was done.**
-  - Every `init` flag defaults to None. On a re-run, an omitted flag keeps its current value (`build_init_config`, `:2121-2188`).
-  - The first init still needs `--model`; without it the exit is 2 with `error: usage`, as before.
-  - `test_forks.py:724` shows a `--warm-margin-s`-only re-run with `changed_fields == ["warm_margin_s"]`, and launch fields, thresholds and run-wide knobs kept.
-- **Fixer flags**:
-  - *`--tools` alone keeps the old `allowed_tools`*: acceptable as Minor. Note that this is a **behaviour change**: before the fix, a re-run with `--tools` re-derived `allowed_tools`. It now matches `train` (review Minor 12), and "pass `--allowed-tools` with `--tools`" is in the Phase 3 list.
-  - *Cannot clear `warm_margin_s` or the agent back to none*: acceptable. "Never re-run `init` to reset" is in the Phase 3 list.
-  - *Exit 2 on a concurrent config change* (`:2208-2209`): consistent. Every refusal in the CLI is a `ForksError` with the default `EXIT_USAGE` (2), and there is no separate "busy" code. Only `init` writes `reg["config"]` (`:2228` is the only writer), so the check fires only on a concurrent `init`, not on a supervisor's registry write. This path is untested (N5).
-- One unflagged effect of the same change is listed as N3.
-
-### Minor 9. A test that cannot fail for its stated reason: **resolved**
-
-`test_forks.py:2310` now calls `reconcile_ledger` directly in a thread. It asserts that the line is absent while the lock is held, and present exactly once after. My lock-free mutant fails it. Stronger than before.
-
-### Minor 10. The `ResourceWarning`: **resolved**
-
-`Supervisor.run` closes `p.stdout` after `reader.join` when the reader has ended (`:3301-3303`). My full run printed no warning line; the unfixed helper prints it for the same test. The pipe is left open when the reader outlives `READER_JOIN_S` (fixer flag). That is acceptable: the detached supervisor exits right after.
-
-### Minor 11. R1 ledger and results can disagree: **resolved**
-
-- **What was done.** The ledger stays append-only. `usage` takes `status`, `flags` and `reason` from `results/<job>.json` when they differ from the ledger line, keeps the ledger's tokens and cost, and lists the job in the new `status_from_result` (`:3686-3704`, `:3721`).
-- **Why the comparison is sound.** The ledger line and the result are built from the same `status`, `flags` and `reason` (`:1538-1556`), so a normal job never differs. The smoke copy confirms `[]`.
-- **Test.** `test_forks.py:2330`.
-- **Fixer flag** (the md block table does not show status): acceptable.
-
-## The new surfaces
-
-- **`fork`/`rebase --delta-note PATH`.**
-  - All refusals exit 2 with one JSON line, before any write:
-    - a missing file gives `cannot read delta note`, the same as `cannot read brief`;
-    - `''` gives `empty path`;
-    - a directory gives `cannot read delta note` after about 2 s of `PermissionError` retries.
-  - Notes are read before the lock and before the job entry (`:2746`, `:2877`).
-  - `continue` does not take the flag, so argparse gives `error: usage`, exit 2.
-- **`train --supersedes`.**
-  - The refusal payload `{"error": "unknown base", "bases": [...], "option"}` matches `expire`'s (`:3481`).
-  - `fork` and `rebase` use `base` plus `bases` = the known list, so the same key means a different list there. Cosmetic.
-  - The train return and its result do not say which bases were superseded; `list` shows it.
-
-## New Minors in the fix surfaces
-
-- **N1. A `#` line inside a fenced code block ends the `## Changes since base` section** (`forks.py:2367`, `:2377`).
-  - Probe: a section holding a `bash` fence with `# comment` yields only the text up to the comment (`'A\n```bash'`).
-  - Failure: a large delta written as shell snippets under-counts, so `delta_tokens` stays off. The flag is advisory and the brief still reaches the fork, so only the rebase advice is lost.
-  - Fix: skip fenced blocks when looking for the next heading, or say in the Phase 3 text that the section must not contain level-1/2-looking lines.
-- **N2. The mtime rule is a proxy for "the base knows it"** (`:2400-2404`).
-  - A note written before a rebase or training ended, but not given to it (not attached and not in its brief), counts as known. Example: a parallel fork's note lands during a rebase.
-  - Failure: an under-count of the advisory flag only. The note is still put into the prompt in full.
-  - Acceptable. The Phase 3 text should attach to a rebase every note written since the base's `trained_at`.
-- **N3. An `init` re-run no longer re-resolves the binary** (`:2155-2156`). Without `--binary`, a re-run keeps the stored path, where it used to follow `$CLAUDE_CODE_EXECPATH`.
-  - The `where` output shows a versioned path (`…\claude-code\2.1.299\…\claude.exe`).
-  - Failure: after a Claude Code update that leaves the old version on disk, a re-run (for example to change `--pings`) silently keeps 2.1.299 for new trains, and `changed_fields` shows nothing. If the old file is gone, the re-run exits 2 with `claude binary not found` and the old path, which is loud.
-  - This is consistent with "omitted keeps", and the Phase 3 text forbids re-running `init` anyway. It should be recorded with the other Minor 8 flags.
-- **N4. A rebase already running on a base that a re-train supersedes still creates an active child** (`_rebase_succeeded`, `:1612-1643`, which does not check the old base's status).
-  - Scenario: `rebase --base B1 --as B1r` is running, and `train --base B3 --supersedes B1` ends ok first. When the rebase then ends ok:
-    - B1r is created `active` and gets pings;
-    - B1's `superseded_by` is overwritten to B1r.
-  - The cost is bounded by the ping cap. It needs two overlapping lineage operations, so it is rare.
-  - Fix: `_rebase_succeeded` creates the new base as `superseded` when the old one is no longer active, or the Phase 3 text says not to re-train while a rebase runs.
-- **N5. Two new refusal paths are untested**: `init`'s "the config changed while init ran" (`:2208-2209`), and `train --supersedes`'s re-check under the lock (`:2709`, effectively unreachable because bases are never deleted). By reading, both are correct.
-
-## Weakened checks and tests that cannot fail
-
-I went through every assertion line the fix diff removes or changes in `test_forks.py`:
-
-- `test_boundaries_1h_and_5m`: the 5-minute case with margin 900 changed from "expiring from the hit" to the capped schedule (warm at 0 and 149 s, expiring at 150 and 299 s, cold at 300 s, `margin_s` 150). This is the specified change and it has more points than before. The 1 h cases are unchanged.
-- `test_ping_rule_states_status_and_pings_off`: "pings at T0+100" became "pings at T0+1800, and `state:warm` at T0+1799". Stricter: it now pins the boundary from both sides.
-- `test_ping_end_to_end_through_wait`: the margin went from 3600 to 1800 and the last hit from 100 s to 2000 s back. The base is in the same `expiring` state, and every assertion is unchanged.
-- `test_due_reasons_each_alone`: "a brief naming the big note is due" became "not due". The due case moved to `--delta-note`, and its three assertions are unchanged. This is the I1 change.
-- `test_r1_waits_for_the_registry_lock`: stronger (Minor 9).
-
-Nothing was loosened. Every new test fails on `9564c22`, or against a targeted mutant.
-
-## Built but not asked for (on record only)
-
-These came from the fix pass beyond the review's literal fix directions:
-
-- the `## Changes since base` section, alongside `--delta-note` (the Athanor built both options);
-- `--delta-note` on `rebase`, which carries the notes into the rebase prompt;
-- the `### Attached delta notes` prompt section;
-- `delta_notes` on job entries;
-- `supersedes` on the training base;
-- `status_from_result` in the `usage` json;
-- `init`'s concurrent-change refusal;
-- the change to a first `init` without `--model`, which is now a `ForksError("usage")` from the helper rather than from argparse (same shape, same exit).
-
-## Outside scope (on record)
-
-- `test_refusals` flaked once under full-suite load (`test_forks.py:2870`, `kill` `ok: false`), and passed 3 of 3 times alone.
-  - The code involved is Phase 1 code that the fix did not touch.
-  - It is the first failure of this test in the recorded runs: the Phase 2 close, the review and the fix pass were all green.
-  - If it recurs, find out which snapshot pid survives `KILL_VERIFY_S`. For the product, it is a reminder that `kill` can report `ok: false` under load (the Phase 3 text already keys on `ok` and `status`).

docs/workpad/reports/2026-10-16-22-gremlins-code-verdict.md

@@ -0,0 +1,158 @@
+# Gremlins helper: code verdict
+
+- Date: 2026-10-16
+- Reviewer model: claude-opus-5-5
+- Timebox: 25 minutes, done by one agent with no sub-agents
+- Target: `.claude/worktrees/headless-forks/plugins/spire/skills/gremlins/` on branch `headless-forks` at `ab1d945`
+  - `gremlins.py`: 4,155 lines
+  - `tests/test_gremlins.py`: 4,235 lines, about 180 tests
+  - `SKILL.md`: 120 lines
+  - `preamble.md` and three templates: 69 lines in total
+
+All line references below point to `gremlins.py` unless another file is named.
+
+## 1. Verdict
+
+The code is careful, consistent and well tested, and it works: the live happy path ran cleanly, with a cache hit on the fork. It is still over-built by about four to five times. Roughly two thirds of the lines run and police **detached** processes: a PowerShell/CIM detach, heartbeats, reaping of lost jobs, an orphan watchdog, clock-jump detection, a tree kill that guards against pid reuse, and breaking of stale locks. The rest is mostly a layer of heuristic rules (pings, rebase and re-train thresholds, fingerprint drift) that the requirement never asked for.
+
+**Rewrite it small, keeping the core.** Do not throw it away. Keep the stream parsing, the usage and cache accounting, the env scrub, the argv builder and the templates. Replace the supervisor stack with one foreground call that the orchestrator puts in the background through the Bash tool.
+
+## 2. What it contains
+
+| Part | Lines | Rough size |
+|---|---|---|
+| Constants and tunables (about 60 named constants, many "so tests can shorten them") | 1–178 | 180 |
+| Small helpers: emit, clock, ISO times, sha, fingerprint hash | 180–265 | 85 |
+| Platform seam: `Platform` base, `WindowsPlatform` (ctypes, CIM detach, Toolhelp32, taskkill, EnumWindows), `PosixPlatform` (gated off) | 267–734 | 470 |
+| Platform gate and state-dir layout | 737–822 | 85 |
+| Atomic IO with retries, `RegistryLock` (breaks stale locks), ledger append | 824–1060 | 235 |
+| Process records (pid + ctime), `process_tree`, `kill_tree`, `snapshot_survivor`, git | 1062–1228 | 170 |
+| Env scrub, binary resolution, `where` sub-reports, model admission | 1230–1452 | 225 |
+| `StreamState`, runtime fingerprint, `usage_from_result`, API-error mapping, cache verdict, TTL, warmth | 1454–1691 | 240 |
+| Job finalising: `_conclude`, `_rebase_succeeded`, `finalize_job`, orchestrator stamps, `reap_lost`, `kill_job` | 1693–2107 | 415 |
+| argparse CLI | 2109–2313 | 205 |
+| `where` and `init` (`build_launch`, binary re-resolution, config diff) | 2315–2598 | 285 |
+| Launch helpers: brief, binary check, argv, delta header | 2599–2700 | 100 |
+| Rebase and re-train heuristics: git delta counts, `## Changes` parsing, transcript tail read, drift checks, `due_flags` | 2700–2957 | 260 |
+| `train`, `spawn`, `continue`, `rebase` commands | 2959–3291 | 335 |
+| Keep-warm pings and `tick` | 3293–3476 | 185 |
+| `SupClock` and `Supervisor` (the detached `_supervise` process) | 3478–3705 | 230 |
+| `wait`, `list`, `kill`, `expire` | 3707–3863 | 158 |
+| `usage` (ledger reconcile, aggregate, markdown tables) | 3865–4096 | 230 |
+| Dispatch and main | 4097–4155 | 60 |
+
+The code makes about 100 references to review-finding IDs (`M7`, `N4`, `C16`, `I2`, `A19`, `Minor 13` and others; 49 distinct) and about 30 to "design N", "plan N" or "digest §N". The code reads like layers of review fixes, and those IDs mean nothing without the old review documents.
+
+## 3. Keep (as it is, or nearly)
+
+- **`StreamState`** (1459–1522). This is a small, correct stream-json reader: init event, first and last usage, result, and the model-restriction warning.
+- **`usage_from_result`** (1573–1601). It computes tokens with the 1h/5m split, `models_used` from the `modelUsage` delta, and the cost delta against the session's cumulative total. This is the real know-how for usage tracking on forks.
+- **`cache_verdict`, `infer_ttl`, `wrote_only_5m`, `base_warmth`** (1640–1690). This is exactly the "is the base's cache still warm" requirement, in about 50 lines.
+- **`api_error_reason`** (1604–1637). It is a table-driven mapping of failure reasons and is already shaped well.
+- **The `SCRUB_*` constants and `scrubbed_env`** (89–114, 1235–1282). They hold the empirically gathered list of Desktop and SDK env vars that must not leak into a child `claude -p`. This is hard-won knowledge.
+- **`claude_argv`** (2652–2666) and the fork argv: `--resume <base> --fork-session --session-id <uuid>`.
+- **Small helpers:** `atomic_write_bytes` and `_retry` (829–866), which handle Windows sharing violations.
+- **`templates/*.md` and `preamble.md`.** These are short and to the point. The default sequential `commit_rule` (3152) says "This gremlin commits" even when the brief says not to. The smoke gremlin noticed the conflict and followed the brief. Make the rule an explicit flag.
+- **Ledger plus the `usage --format md` tables** (3877–4096), but trimmed by half (see below).
+
+## 4. Delete or simplify
+
+### 4a. The detached supervisor and everything that exists because of it
+
+The whole stack exists so that launches can return at once (SKILL.md:70). It is then needed to stop jobs from leaking once nobody watches them. The Bash tool already moves a call past its timeout into the background and sends a completion notice, and `run_in_background` does the same on purpose. The orchestrator can run `gremlins.py spawn …` as a **blocking** call in the background and read the result JSON from the notice. Without detach, the following code goes away:
+
+- **Detach.** `WindowsPlatform.detach` with its PowerShell/CIM hidden window (356–362, 476–495), `detach_supervisor` (1745), `supervisor_interpreter` (1398), and the `detach_failed` reason.
+- **The supervisor.** `Supervisor` (3517–3684) and `cmd_supervise` (3687–3704). The run loop polls every 0.25 s and handles heartbeat, stall, orphan check, keep-warm tick and max time in one `while` loop (3613–3659). `os.environ.clear()` (3579) mutates its own process environment to reach the child's PATH.
+- **`SupClock`** (3481–3514). It detects host suspend so that suspends are not counted toward `max_minutes` and so the orphan watchdog can be re-armed. This is a special case that exists only to patch another special case (the watchdog).
+- **The orphan watchdog** (3639–3651) and the stamps behind it: `stamp_orchestrator` and `touch_orchestrator` (2009–2030). `in_child` checks guard both functions, so a gremlin cannot keep its own watchdog alive (that is the M4 fix). Again, this is a patch on a patch.
+- **Heartbeats and reaping.** `reap_lost`, `last_alive_at`, `LOST_AFTER_S` and the `lost` status (2040–2073).
+- **`wait`** (3720–3790). Its `delivered_at`/`settled_at` double bookkeeping, `--any`, exit codes 3 and 4, and the 540/570 s caps all work around the Bash timeout. With completion notices there is nothing left to wait on. A plain `result <job>` read would do.
+- **The pid-reuse-safe tree kill.** `process_tree` uses dead-root bounds and `ALIVE_UNTIL_SLACK_S` (1099–1151). `snapshot_survivor` is "C16 as narrowed by A2" (1192–1205). `kill_tree` sweeps and verifies for 10 s (1161–1189). If `claude` is a child of the foreground helper, `taskkill /T /F /PID <child>` on Windows (or `killpg` on POSIX) while the helper is alive covers it. Python's `subprocess` with a Job Object is the robust variant.
+- **`RegistryLock`** (881–1005, 125 lines). It breaks stale locks by renaming the lock aside and putting it back if the content changed. `Platform.restore_no_replace` exists only for this. Writes per job (one `jobs/<id>.json` per call) plus append-only ledger lines mostly remove the shared read-modify-write. What remains needs, at most, a 20-line `O_EXCL` lock with a pid check.
+- **About 60 % of the platform seam.** `Platform` has 14 abstract methods for one tested platform. `PosixPlatform` (604–727) is 125 lines behind a closed gate, plus `UNSUPPORTED_OK_ENV` (127–129, 745). `visible_windows` (338, 583–601) is used only by tests. Without detach the real differences come down to path normalisation and the kill call.
+
+### 4b. Heuristics nobody asked for
+
+- **The ping machinery** (3293–3476, 185 lines). It covers `pings_since_real_call`, `ping_phase`, `run_active` with its 10-minute activity window, a `break_even` cap computed from price ratios, and `ping_in_flight` marks. `tick_pass` decides twice, outside and inside the lock, and so needs a special `why="eligible_since_this_tick_began"` (3424). Every supervisor ticks every 60 s and every `wait` every 30 s. With a 1 h TTL, `list` already reports `warm_until`. A plain `ping --base B`, called when the orchestrator sees `expiring`, is about 20 lines.
+- **The rebase and re-train flags.** `due_flags` (2910–2956) combines five thresholds (`rebase_commits`, `rebase_lines`, `rebase_delta_tokens`, `max_base_tokens`, `max_rebases`) with `defining_drift` (2859–2888), `binary_state` drift by version, size and mtime (2891–2907), runtime drift from the init event (1548–1570, 2847), and a transcript tail read (2778–2830). They are all advisory (the docstring says only `binary_missing` stops a launch), yet each one is an init flag (2217–2218). Keep `phase_boundary` and `max_base_tokens`, and drop the rest.
+- **The `_conclude` god function** (1752–1904, 150 lines). It mixes four things:
+  - the status decision: the if-chain at 1771–1790, which should be a `classify(ss, exit_code)` function returning `(status, reason, detail)`
+  - eight flag rules (1793–1824), which should be a table of `(flag, predicate)`
+  - two near-duplicate dict literals, the result and the ledger line (1833–1851)
+  - the base state machine for train, rebase, ping and supersede (1867–1903)
+
+  Split it into classify, a flags table, `record()`, and a separate base-transition function.
+- **The race rule for "rebase finishes after a retrain superseded it".** `_rebase_target_free`, the `old_status` branch of `_rebase_succeeded` and the `parent_inactive` flag (1819–1824, 1907–1963) handle it. Refusing `train --supersedes X` while a rebase of X runs would replace all of this with a single check.
+- **Flags and options that are not needed:**
+  - `--method` has one choice, `("fork",)` (164, 2256). It still sets `method` on every job, result and ledger row.
+  - `launch_overrides` (2241–2249) adds hidden flags on spawn, continue and rebase only to refuse them. argparse already rejects unknown flags.
+  - `PHASE2_COMMANDS = ()` (119, 4120) is dead.
+  - `train` re-accepts every launch field as a per-base override (2227–2236, `train_launch` 3015–3036). That forces the "override or config" logic in `defining_drift` (2866–2870). One launch config per run is enough, and a new run can change it.
+  - `--ttl-s`, `--warm-margin-s` with its runtime caps (2212, 1681, SKILL.md:30), `--stall-after-s`, `--orphan-after`, `--pings on|off` and `--parallel-cap` are tunables without a user.
+  - On an `init` re-run, `rerun_binary` (2458–2475) re-resolves the binary by its original source.
+  - `model_admission` (1426–1452) is "permissive at init". It reads settings and enforces nothing.
+- **`where`.** Its env-scrub section lists "unknown" vars and a `drop_path_entries` prose rule. That is useful once when porting, and noise on every skill load (the SKILL.md front matter injects it).
+- **The tests.** 4,235 lines, more than the code. Most of them pin the machinery above (lock races, pid reuse, clock jumps, ping caps). They shrink with it.
+
+## 5. The minimal version
+
+One file, about **600–800 lines**, standard library only, run in the foreground:
+
+| Part | Lines |
+|---|---|
+| Config and state dir: `run.json` (launch config + bases), `jobs/<id>.json`, `ledger.jsonl`, `notes/`, `raw/` | 80 |
+| Env scrub + argv builder (kept code) | 120 |
+| Stream reader + usage + cache verdict + warmth (kept code) | 220 |
+| Commands | 250 |
+| Windows path norm + child-tree kill (taskkill / killpg) | 60 |
+| argparse | 60 |
+| Tests | about 500 |
+
+The commands:
+
+- `init --run R --model M [--effort] [--agent] [--cwd]` writes the launch config.
+- `train --base B --brief F` runs `claude -p … --session-id <uuid>` in the foreground and streams it to `raw/<job>.jsonl`. On exit it writes the result and a ledger line, marks the base active, and records `last_hit`, `context_tokens` and the TTL.
+- `spawn --base B --block X --brief F` does the same with `--resume <base> --fork-session`. The prompt is the spawn template plus a delta header. The result carries `cache`, `base_state` at launch, and the note path.
+- `continue --job J --brief F` resumes the gremlin session (no fork).
+- `ping --base B` is a one-turn fork with `--max-turns 1`, only when asked.
+- `list` shows bases with `base_state` and `warm_until`, and jobs with their status.
+- `usage [--block|--phase] [--format md]`.
+- `kill --job J` kills the recorded child pid tree.
+
+The happy path from the orchestrator (Athanor), each call in Bash with `run_in_background: true`. The completion notice carries the result JSON.
+
+```
+G init R --model claude-opus-5-5[1m]
+G train R --base B1 --brief train.md          # background; notice → {status, session, cost, ...}
+G spawn R --base B1 --block 1.1 --brief b.md  # background; notice → {status, cache: hit, note, ...}
+G spawn R --base B1 --block 1.2 --brief c.md  # parallel = just two background calls
+G usage R --phase 1 --format md
+```
+
+Rebase is just "spawn, and register its session as a new base". It is about 30 lines inside `spawn` (`--as NEW`), not a separate state machine.
+
+One open check before the rewrite: does `TaskStop` on a backgrounded Git Bash call kill the `claude.exe` grandchild on Windows? If it does not, keep `kill --job`. Either way the helper should kill its own child on SIGTERM or SIGBREAK.
+
+## 6. Usable right now?
+
+**Yes, on Windows, for the happy path.** I ran it from the worktree root and in a scratch git repo at `C:\Users\g4b\AppData\Local\Temp\claude\G--dev-projects-reliquary\42c87f82-…\scratchpad\verdict-smoke`, following SKILL.md's call sequence.
+
+| Step | Result |
+|---|---|
+| `where` | Exit 0 in 0.25 s, `ok: true`. Platform windows (supported), binary 2.1.299 found through `CLAUDE_CODE_EXECPATH`, uv 0.5.13, git found. 13 "unknown" `CLAUDE_*` vars listed, no warnings. |
+| `init --model claude-sonnet-5-5 --cwd <scratch>` | Exit 0. The model was accepted (`model_admission: "no availableModels list"`). Effort high, permission mode `dontAsk`, empty strict MCP config, preamble hashed. |
+| `train --base B1 --phase 1 --brief <one line>` | Exit 0 in 0.6 s; returned job `j0001` and a session id. |
+| `wait --all` (Bash timeout 600000) | Exit 0 after 2 s. `status: ok`, 5.3 s wall, 2 turns, `models_used: [claude-sonnet-5-5]`, 16,731 tokens written to the 1h cache, $0.0706. |
+| `spawn --base B1 --block 1.1 --phase 1 --brief <one line>` | Exit 0. `base_state: warm`, no rebase or re-train due. |
+| `wait --all` | Exit 0 after 12 s. `status: ok`, **`cache: hit`** (69,943 tokens read from cache, 1,530 written), 10.6 s wall, $0.0195. `notes/1.1.md` was written in the right format, stamped `claude-sonnet-5-5`. |
+| `usage` (json) and `usage --phase 1 --format md` | Both correct. Total $0.0902, cache-hit ratio 1/1, 0 cold starts. The md table renders well. |
+| `list` | B1 active, `warm_until` 1 h out, nothing running. |
+| `expire --all` | Exit 0: `retired: [B1]`, `killed: []`, `ok: true`. |
+| Process check afterwards | No `_supervise`, `--fork-session` or `run-gremlins` processes left. |
+
+Nothing broke. Minor findings:
+
+- **The default commit rule conflicts with a no-commit brief.** The spawn template's default rule (sequential) told the gremlin to commit, while the brief said not to. The gremlin flagged the conflict in its note and followed the brief.
+- **Rounding differs between ledger fields.** `cost_cumulative_usd` (0.0706285) and `cost_delta_usd` (0.070628) are rounded differently in the ledger.
+- **Paths not exercised.** `kill`, pings, `continue`, `rebase`, failure paths and long runs over the Bash timeout were not run. `expire` had nothing to kill.
+- **Platforms.** The tool works only on Windows; Linux and macOS are gated off by design.

docs/workpad/reports/2026-10-16-22-gremlins-platform-handoff.md

@@ -1,339 +0,0 @@
-# Platform handoff: `spire:gremlins` on Linux and macOS
-
-**Written by**: block 3.7 owner, `claude-opus-5-5[1m]`, 2026-10-16 22:15 +0200 (`date`), from the `headless-forks` branch at `485cc66`.
-**For**: an Igor on native Linux and an Igor on macOS. Each starts from a checkout of `headless-forks`, tests the helper on their platform, fixes it and lifts the fail-closed gate there. The branch is merged and released only after both have done this.
-**Sources**: the Phase 3 contract digest (`docs/workpad/plans/2026-10-16-18-gremlins-phase3-contract.md`, §8 and its final amendment), the run log (`docs/workpad/reports/2026-10-16-08-headless-forks-run.md`: blocks 1.3, 2.4, 3.2, 3.3, 3.4, 3.4a), the Phase 1 review and re-check (`…-16-headless-forks-phase1-review.md` M14, `…-17-headless-forks-phase1-recheck.md` I2), and the code. Line numbers refer to `plugins/spire/skills/gremlins/gremlins.py` (the helper) and `…/tests/test_gremlins.py` (the tests) at `485cc66`.
-
----
-
-## 1. Status
-
-- **Tested on Windows only.** On every other platform the gate is closed: `where` reports `ok: false` with the reason and exits 2, `init` refuses, and on an existing state dir `train`, `spawn`, `continue`, `rebase` and `tick` refuse too (exit 2, `error: "platform not supported"`). `wait`, `list`, `usage`, `kill` and `expire` stay open, so you can always stop and inspect what you launched under the override.
-- **Release gating (user decision, 2026-10-16).** The release is not cut from Windows alone. The work stays on `headless-forks`; it is pushed but not merged. A Linux Igor and a macOS Igor each test, fix and lift the gate for their platform; only then is the branch merged and released. WSL is fine for development, but it is not native Linux. macOS stays closed until someone has tested on a Mac.
-- **The goal file.** These decisions live in `docs/workpad/goals/headless-forks.md` as edited on `main` (sections "Decided … platforms", "Amended … release gating", "Decided … platform seam"). At the time of writing those edits were not yet committed on `main`, and the branch copy of the goal is older. This report therefore restates what you need; do not rely on the goal file in your checkout.
-- **No live `claude` call has been made under the new names.** Phases 1 and 2 smoked the helper live on Windows under its old name (`spire:forks`, command `fork`). Phase 3 renamed it, moved the platform code behind a seam and added the gate, all tested with a stub binary only (digest C17). Phase 4 must smoke the renamed helper on Windows before anything ships. Your smoke (§7) is the first live run on your platform.
-- **Branch.** `headless-forks`, remote `origin` = `git.g4b.org:dirigence/reliquary`. At the time of writing it had no upstream (not pushed yet). Once the user has pushed it:
-
-  ```bash
-  git fetch origin
-  git switch headless-forks          # or: git worktree add ../reliquary-hf headless-forks
-  git log --oneline -1               # expect the Phase 3 release commit or later
-  ```
-
-  Block 3.8 (README row, manifests, full suite, release commit) comes after this report. Read the run log's Phase 3 close first, for anything that changed after this report was written.
-- **Your run log.** Record your work in a run log of your own (`docs/workpad/reports/<YYYY-MM-DD-hh>-gremlins-<linux|macos>-port-run.md`, placement per the `workpad` skill), with handoff notes in the format of `plugins/spire/skills/implementation/references/run-log.md`.
-
-## 2. The seam
-
-All platform-specific code sits in one section of the helper, between `# --- platform seam: begin ---` (`:267`) and `# --- platform seam: end ---` (`:734`). Outside it, nothing tests `os.name` or `sys.platform`, and nothing calls `ctypes`, `killpg` or `/proc`. Block 3.2's seam grep proved this (run log, block 3.2, gate 4):
-
-```bash
-git grep -n -E "os\.name|sys\.platform|IS_WINDOWS|ctypes|_k32|taskkill|powershell|killpg|setsid|start_new_session|creationflags|cygpath|/proc" -- plugins/spire/skills/gremlins/gremlins.py
-```
-
-Keep that true when you fix things: every hit must stay between the markers.
-
-**Selection.** `select_platform()` (`:728`) is the only `os.name` test: `WindowsPlatform()` on `nt`, else `PosixPlatform()`. `PLATFORM = select_platform()` (`:732`). WSL, Linux and macOS all get `PosixPlatform`. Both classes can be built on any host (Windows `ctypes` is loaded lazily), so the path matrix and the gate tests run everywhere.
-
-**The interface** (`Platform`, `:277`) and what `PosixPlatform` (`:604`) does today:
-
-| Member | `PosixPlatform` today | Line |
-|---|---|---|
-| `name`, `detach_method` | `"posix"`, `"setsid"` | `:607–608` |
-| `supported` | property: `sys.platform in TESTED_SYS_PLATFORMS`; the tuple is empty, so always `False` | `:610`, `:614` |
-| `describe()` | shared: `{name, sys_platform, wsl, supported, detach}` (`supported` read from the property) | `:285` |
-| `is_wsl()` | `WSL_DISTRO_NAME` set, or `microsoft` in `/proc/sys/kernel/osrelease`; unreadable → `False` | `:617` |
-| `norm_path(p, cwd)` | `posixpath.normpath(join(cwd, p))`; refuses empty, a drive form (`^[A-Za-z]:`) and any backslash | `:627` |
-| `popen_kwargs(new_group)` | `{"start_new_session": new_group}` | `:641` |
-| `detach(argv, cwd, log_path)` | `Popen(argv, cwd, stdin=DEVNULL, stdout/stderr=log, start_new_session=True, close_fds=True)`; returns `{ok, method, pid, ctime}` | `:644` |
-| `proc_ctime(pid)` | `/proc/<pid>/stat` field 22 (clock ticks since boot); `None` without `/proc` | `:656` |
-| `epoch_to_ctime(t)` | `(t - btime) * SC_CLK_TCK` from `/proc/stat`; `None` without `/proc` | `:665` |
-| `_running(pid)` | `os.kill(pid, 0)`; `ProcessLookupError` → dead; `PermissionError` → alive | `:676` |
-| `pid_alive(pid, ctime)` | shared: `_running`, then the creation-time check when both sides are known | `:313` |
-| `process_table()` | `/proc` walk → `[(pid, ppid, comm)]`; `[]` without `/proc` | `:685` |
-| `terminate(pid)` | `os.kill(pid, SIGKILL)` | `:705` |
-| `tree_kill(pid)` | `os.killpg(pid, SIGKILL)`, `OSError` suppressed; returns `None` | `:712` |
-| `restore_no_replace(src, dst)` | `os.link(src, dst)` then `os.remove(src)`; `OSError` → `False` | `:719` |
-| `visible_windows()` | `None` (not applicable; the window test skips) | `:338` |
-
-**Delegates.** Neutral code calls these module-level names, and the tests patch them: `proc_ctime` (`:1070`), `epoch_to_ctime` (`:1075`), `pid_alive` (`:1085`), `record_alive` (`:1090`), `process_table` (`:1094`), `norm_path(p, cwd, windows=None)` (`:774`; `windows=True/False` selects a class, for the tests). `terminate(rec)` (`:1154`) checks `record_alive` and then calls `PLATFORM.terminate`. `kill_tree` (`:1161`) makes one `PLATFORM.tree_kill` call, on the first live root (`:1175–1179`). `detach_supervisor` (`:1745`) builds the argv `[supervisor_interpreter(), "-I", script, "_supervise", "--run", R, "--job", J]` and calls `PLATFORM.detach`. `Supervisor.run` starts `claude` with `PLATFORM.popen_kwargs(new_group=True)` (`:3588–3590`). `RegistryLock._restore` (`:941`) calls `PLATFORM.restore_no_replace`. `_run` (`:1208`) uses `PLATFORM.popen_kwargs()`.
-
-**Neutral code that matters to you:** `process_tree` (`:1102`), `kill_tree` (`:1161`) and `snapshot_survivor` (`:1192`), `reap_lost` (`:2047`), `kill_job` (`:2076`), `Supervisor.run` (`:3571`), `supervisor_interpreter` (`:1398`), `scrubbed_env` (`:1265`), `transcript_path` (`:2782`).
-
-**The gate** (neutral, below the seam): `gate_overridden()` (`:742`), `platform_report()` (`:748`), `platform_gate()` (`:753`, the reason text), `require_platform()` (`:762`). `cmd_init` calls `require_platform()` as its first line (`:2560`). The dispatcher refuses `GATED_COMMANDS` (`:124`) right after the N3 check (`:4125–4126`). `tick_pass` returns at once on a closed gate (`:3397`). `cmd_where` (`:2320`) puts the gate reason first in `reasons` and still fills the rest of the report.
-
-## 3. Running the gates there
-
-**Prerequisites.**
-
-- `uv`, with the official installer (`curl -LsSf https://astral.sh/uv/install.sh | sh`, which installs to `~/.local/bin`) or a package manager (`brew install uv` on macOS). The helper and the tests are PEP 723 scripts with no dependencies (`requires-python >= 3.10`); `uv run` picks or downloads a managed CPython.
-- `git`.
-- A **native** `claude` for your platform, on `PATH` or given with `--binary`. Do not use a Windows `claude.exe` through WSL interop (§4.12).
-
-**Gates** (from the checkout root):
-
-| Gate | Command | Expect |
-|---|---|---|
-| G-unit | `uv run plugins/spire/skills/gremlins/tests/test_gremlins.py > /tmp/g-unit.txt 2>&1; echo exit=$?` | 165 tests at the WSL check. About 150 s on Windows; WSL took 393 s. unittest writes to stderr, so capture both streams. |
-| one class | `uv run plugins/spire/skills/gremlins/tests/test_gremlins.py GateTests PathMatrixTests` | names as for `unittest` (`Class` or `Class.test_name`) |
-| G-where | `uv run plugins/spire/skills/gremlins/gremlins.py where` | on a closed gate: exit 2, `ok: false`, `reason` starts "spire:gremlins is not tested on linux yet; …" (or `darwin`, or `linux, WSL`) |
-| compile | `uv run python -m py_compile plugins/spire/skills/gremlins/gremlins.py` | exit 0 |
-
-Run one copy of the suite at a time. On Windows the module-end check (`tearDownModule`, tests `:4217`) kills every process whose command line contains `gremlins-test-`, which would include another copy's. On POSIX that check does nothing yet (§4.11).
-
-**The override, `SPIRE_GREMLIN_UNSUPPORTED_OK=1`.** It is a porting aid, documented here and nowhere in `SKILL.md`. When it is set to exactly `1` on an unsupported platform, the gate is open for that call. `where` then reports `platform.override: true`, stays `ok: true` if nothing else fails, and adds one warning ("platform gate overridden (…=1); this platform is untested, use it only to port and test spire:gremlins"). On a supported platform the variable changes nothing (`gate_overridden`, `:742`). Use it to run the smoke before the gate is lifted in code. Remove it from your shell before you check the lifted gate: with the gate lifted, `where` must say `supported: true, override: false` **without** it.
-
-**The suite sets the override itself.** `Base.setUp` (tests `:80–90`) sets `SPIRE_GREMLIN_UNSUPPORTED_OK=1` for every test, so the whole suite exercises the POSIX code on a closed platform; `GateTests.setUp` (tests `:1408–1410`) removes it again. You do not need it in your shell to run the tests.
-
-**What a green suite does and does not prove (C13).** A green run on Linux says nothing about the gate, because every test except `GateTests` runs with the gate overridden. Only `GateTests` (tests `:1405`) cover the gate. And `GateTests` mostly use a fake closed platform (`closed_platform()`, tests `:1387`), so they still pass after you lift the gate. The one that pins the real POSIX value is `test_supported_flags` (tests `:1430`), which today asserts `PosixPlatform().supported is False` for `linux` and `darwin`. Lifting the gate means changing that test on purpose (§8).
-
-## 4. Known POSIX gaps, with code references
-
-Each item says what the code does, what goes wrong, and on which platform. "Seen" means observed in the WSL run (block 3.4); "from the code" means read and reasoned, not observed.
-
-### 4.1 M14: `kill` misses `claude`'s group (Linux and macOS)
-
-- `Supervisor.run` starts `claude` in its own session (`popen_kwargs(new_group=True)` → `start_new_session=True`, `:3590`, `:641`). The supervisor is itself a session leader (`detach`, `:649`).
-- `kill_job` (`:2076`) calls `kill_tree(sup, extra=[claude])`. `kill_tree` calls `tree_kill` on the **first live root only** (`:1175–1179`), which is the supervisor: `killpg(<supervisor pid>)` kills the supervisor's group and does not reach `claude`'s.
-- What saves Linux is the sweep (`:1180–1188`): every snapshot pid still alive is sent SIGKILL, and the snapshot comes from `process_tree`, which walks `/proc` (`:1115`). Processes `claude` starts between the snapshot and the kill are not in it.
-- On macOS (§4.2) the snapshot holds only the two roots. The Phase 1 review wrote that `kill` "leaves `claude` running". By the current code, `kill_job` passes the `claude` record as an extra root, so `claude` itself is killed by the sweep, by pid only. Its descendants (Bash tool commands, `git`, `gpg-agent`) are not found and survive. Check this on the Mac.
-- The supervisor's own kills (timeout `:3629`, orphan watchdog `:3647`, model refusal `:3626`) call `kill_tree(<claude>)`, and there `killpg(<claude pid>)` does hit `claude`'s group. M14 is about `kill`, `expire` and anything else that starts from the supervisor.
-- Fix options (yours to choose, with a test): call `tree_kill` for **every** live root, not just the first. That changes neutral code, so it also runs on Windows, where an extra `taskkill` of an already-dead tree is harmless. Or have `PosixPlatform.tree_kill` also kill the process groups found in the snapshot. Or start `claude` in the supervisor's group, but then the supervisor's own `killpg(<claude>)` no longer works.
-
-### 4.2 The `/proc` tree walk (macOS)
-
-- `process_table` (`:685`), `proc_ctime` (`:656`) and `epoch_to_ctime` (`:665`) read `/proc`. macOS has none, so they give `[]`, `None` and `None`.
-- Consequences on macOS:
-  - `kill` and `expire` find only the roots (§4.1).
-  - The post-exit sweep (`:3662`, "kill leftovers of `claude`") finds nothing. `claude` is dead by then, a dead root without a creation time claims nothing (§4.3), and backgrounded commands and daemons survive.
-  - `lost` (`reap_lost`, `:2047`) kills a live `claude` by its group but cannot find a dead `claude`'s leftovers.
-  - Every stored pid has `ctime: None` (`pid_record`, `:1080`), so `pid_alive` is pid-only. **A reused pid is taken for the old process.** `kill_tree` would then `killpg` and SIGKILL whatever now owns that pid. This happens in `reap_lost` after a reboot, or in a late `kill` of a long-dead job. It is the most dangerous macOS gap, because it can hit an unrelated process.
-  - Registry-lock staleness (`RegistryLock._is_stale`, `:931`) is pid-only too: a lock held by a dead process whose pid was reused waits for `LOCK_ABANDONED_S` (300 s) before it is broken.
-- Fix direction: a macOS `process_table`, `proc_ctime` and `epoch_to_ctime` inside `PosixPlatform`, chosen by `sys.platform == "darwin"`. They must give `(pid, ppid, name)` and a creation time in one unit that `epoch_to_ctime` can convert to. Two stdlib-only ways: `ctypes` on `libproc` (`proc_listallpids`, `proc_pidinfo(PROC_PIDTBSDINFO)` gives ppid, comm and start time in seconds plus microseconds, and the process status), or `ps -axo pid=,ppid=,lstart=,comm=` (whole-second start times, slower). The `ProcessTreeTests` fake a table (tests `:616`) and run anywhere; add tests for the real macOS reader.
-
-### 4.3 Dead-root claims (I2)
-
-- `process_tree` (`:1102`) takes a dead root's direct children only when `root_ctime < child_ctime <= epoch_to_ctime(alive_until + 1 s)` (`:1125–1145`). Without a recorded root ctime or a working `epoch_to_ctime`, a dead root claims nothing (`:1127–1128`).
-- On Linux this works through `/proc/stat` `btime`. On macOS it claims nothing (safe, but leftovers survive), until §4.2 is fixed.
-- Accepted residual on every platform: a child started in the root's last heartbeat interval (up to `HEARTBEAT_S` = 10 s) is not claimed (re-check report, I2).
-
-### 4.4 Zombie liveness in `pid_alive` (Linux; seen on WSL)
-
-- `PosixPlatform._running` (`:676`) is `os.kill(pid, 0)`. That succeeds on a zombie (state `Z`), so a killed child that its parent has not yet reaped counts as alive.
-- Seen in the WSL suite: `LaunchTests.test_kill_tree`, `test_refusals`, `test_expire_kills_running_jobs`, `test_lost`, `test_orphan_watchdog` and `test_rebase_counts_toward_cap` failed. The tests call the CLI in-process (`call`, tests `:59`), so the test process is the supervisor's parent; the killed supervisor stays a zombie, and `kill` reports `ok: false` with the supervisor as the only survivor. `zombie_probe.py` (WSL scratch) confirmed it: kill-0 says alive, `/proc` state `Z`, gone after reaping.
-- In production a detached supervisor's launcher (`spawn`, `train`, …) exits at once, so the supervisor is reparented and reaped. But from the code:
-  - A `wait` whose tick launches a ping is that ping supervisor's parent for up to 570 s and never reaps it.
-  - Inside `Supervisor.run`, after `kill_tree(<claude>)` (timeout, orphan, refusal) `claude` is a zombie until `p.wait()` (`:3660`). The verify loop therefore spins for the full `KILL_VERIFY_S` (10 s, `:151`) before the supervisor goes on. The result is unaffected; it costs 10 s per such kill.
-  - A subreaper that reaps late would make every `kill` report survivors.
-- Fix (porter's item, not fixed on Windows): treat state `Z` (and `X`) as dead in `PosixPlatform._running`, from `/proc/<pid>/stat` field 3 on Linux, and from `libproc`'s `pbi_status == SZOMB` (or `ps -o stat=`) on macOS. Add a test that kills a child without reaping it and expects `pid_alive` to say dead.
-
-### 4.5 `test_timeout_and_stalled` expects a tree of at least 3 (Linux; seen on WSL)
-
-- Tests `:3186–3194`: `assertGreaterEqual(len(process_tree(<supervisor>)), 3)`. On Windows the stub runs as supervisor → `cmd.exe` (the `.cmd` wrapper) → python. On Linux the stub's `sh` wrapper `exec`s python, so the tree is supervisor → python: 2.
-- This expectation is shaped by the platform, not a product bug. Make it `2` on POSIX with a comment (`WIN_PLATFORM`, tests `:41`), or count the real members (supervisor, `claude` record, stub). Do not loosen it to "≥ 1".
-
-### 4.6 Locks: `restore_no_replace` needs hard links
-
-- `PosixPlatform.restore_no_replace` (`:719`) uses `os.link` + `os.remove` (a put-back that never overwrites). It is used only when a lock that was being broken turns out to be fresh (`RegistryLock._break`, `:945–964`).
-- On a filesystem without hard links (some network mounts, exFAT, some container volumes) the put-back fails: the lock stays aside as `registry.<hex>.broken.lock`, with a diagnostic on stderr. Keep the state dir (it sits next to the run log) on a local filesystem, and say so if you find a case.
-
-### 4.7 Detach by `setsid`: survival untested
-
-- `detach` (`:644`) gives the supervisor a new session. Whether it survives (a) the Bash call that launched it returning, (b) that Bash call being stopped (the Bash tool backgrounds a call at its timeout, and a `TaskStop` kills the call's tree), and (c) the end of the Igor's or the Athanor's turn has never been tested on POSIX.
-- On Windows this took a ladder of probes (P0.1) and ended with CIM `Win32_Process.Create`. On POSIX the risk is a harness that kills by cgroup or session rather than by process group. Test it (§6, §7 step 15).
-
-### 4.8 The supervisor interpreter
-
-- `supervisor_interpreter()` (`:1398`) returns `sys._base_executable` when it differs from `sys.executable` (a venv launcher); the supervisor runs it with `-I`. On WSL it resolved to the uv-managed base interpreter, and the in-process launches in the suite worked.
-- Untested: a real detached supervisor under `uv run` on native Linux and on macOS (a framework Python, `brew` Python, a uv-managed one). `where` shows `python.supervisor_interpreter`; check that it is a real interpreter file that still exists after `uv run` exits.
-
-### 4.9 Path refusals on POSIX
-
-- `PosixPlatform.norm_path` (`:627`) refuses a drive form (`C:…`) and any backslash. This is the only POSIX behaviour change of Phase 3 (digest §3.4). The full matrix (`PathMatrixTests`, tests `:225`) passed on WSL.
-- A real POSIX path with a backslash in a file name is refused. That is deliberate, but a porter may meet it.
-- macOS paths are case-insensitive on default APFS; the helper compares paths as given (no `normcase` on POSIX). That is harmless unless the same dir is passed with different case.
-
-### 4.10 The env scrub list came from the Windows Desktop host
-
-- `SCRUB_DROP` (`:90`), `SCRUB_DROP_PATTERNS` (`:104`), `SCRUB_KEEP` (`:105`) and `SCRUB_PINNED` (`:111`) were built from the Claude Desktop app's env on Windows (design §4, research E1, P0.0). `scrubbed_env` (`:1265`) keeps everything not dropped.
-- On Linux and macOS the host (Desktop app, terminal, IDE) may set other `CLAUDE_*` or `ANTHROPIC_*` variables. `where` lists the ones on no list under `scrub.unknown` (`scrub_unknown`, `:1284`): read it on your host and decide for each one. `USERPROFILE` and `CLAUDE_CODE_GIT_BASH_PATH` in the keep list are Windows-only and harmless elsewhere.
-- **The override passes the scrub.** `SPIRE_GREMLIN_UNSUPPORTED_OK` is on no list, so it is copied into every job's env file (`raw/<job>.env.json`). `Supervisor.run` replaces its own `os.environ` with that env (`:3579–3580`), so a supervisor's keep-warm tick (`safe_tick`, `:3658`) sees the gate open and **pings as the orchestrator would** on a porting host. The gremlin's `claude` also carries it, which is harmless (N3 refuses launches inside a gremlin). On Windows this changes nothing. After the gate is lifted it is moot; until then, expect supervisor pings during long smokes. If you want the supervisor to stay closed, add the variable to `SCRUB_DROP`.
-
-### 4.11 The tests' leftover check is Windows-only
-
-- `tearDownModule` (tests `:4217`) returns at once on POSIX (`if not IS_WINDOWS …`). A supervisor or stub that survives the suite therefore goes unnoticed. Add a POSIX branch: `ps -eo pid=,args=` (Linux) or `ps -axo pid=,command=` (macOS), filter on `gremlins-test-`, kill by pid, and fail the suite. Until then, check by hand after each run: `pgrep -af "gremlins-test-|_supervise|claude-stub"`.
-
-### 4.12 A Windows `claude.exe` is accepted under WSL (WSL only; seen)
-
-- `shutil.which("claude")` did not pick the Windows binary on the WSL host (it is named `claude.exe`). But `where --binary /mnt/c/Users/…/claude.exe` with the override reports `ok: true`: `claude.exe --version` runs through interop. The helper would then launch a Windows `claude` under a Linux supervisor, with Linux paths and a Linux env.
-- If WSL is ever opened: refuse a `/mnt/<d>/…` binary (or any `*.exe`) in `resolve_binary` / `binary_info` (`:1309`, `:1347`) when `PLATFORM.is_wsl()`.
-
-### 4.13 The transcript slug rule (`transcript_path`)
-
-- `transcript_path` (`:2782`) assumes `~/.claude/projects/<cwd with every non-alphanumeric replaced by '-'>/<session>.jsonl`. This was observed on Windows only (P0.7). It feeds only `max_base_tokens` (a `retrain_due` reason); when the file is missing, the base's stored context is used instead.
-- Check after your smoke: `ls ~/.claude/projects/` should show the clone's path with `/` and `.` replaced by `-` (for example `-tmp-gremlins-smoke-AbCd-clone`), and B1's session file in it.
-
-### 4.14 `!` injection with a failing `where`
-
-- `SKILL.md` injects `` !`uv run "${CLAUDE_SKILL_DIR}/gremlins.py" where` ``. On a closed platform that command exits 2. Whether Claude Code still loads the skill and shows the report, or fails the skill load, is untested (digest §12). The text tells the Athanor to treat "no report" as `ok: false`. Load the skill once on your platform with the gate closed and record what happens.
-
-### 4.15 Cosmetic
-
-- `where` joins its reasons with `"; "` (`:2372`). The gate reason ends with a period, so the joined text reads `…Platforms).; no claude binary …`.
-
-## 5. WSL findings (block 3.4)
-
-Run on 2026-10-16, 21:45–21:56, on helper commit `4d8af02` (after 3.1–3.3), from a copy on ext4 (`~/gremlins-wsl-check`). Raw logs were in the session scratchpad (`…\scratchpad\gremlins-wsl\`: `where-*.json`, `suite.txt`, `matrix-gate.txt`, `zombie_probe.py`) and are not in git; the run log's Block 3.4 note is the record.
-
-**Inventory.**
-
-| Item | Value |
-|---|---|
-| Distro | registered `Ubuntu-20.04`, actually **Ubuntu 22.04.5 LTS** (upgraded in place) |
-| Kernel | 6.18.54.1-microsoft-standard-WSL2; `/proc` present; `osrelease` contains `microsoft` |
-| `WSL_DISTRO_NAME` | `Ubuntu-20.04` |
-| uv | 0.6.8, already at `~/.local/bin/uv` (nothing installed) |
-| Python | system `python3` 3.10.12; `uv run` used a managed CPython 3.13.2 |
-| git | 2.34.1 |
-
-**PATH interop.**
-
-- 73 PATH entries under `/mnt/` (the Windows PATH appended; no `/etc/wsl.conf`).
-- `claude` (no extension): **not found**. `claude.exe` resolves to `/mnt/c/Users/g4b/.local/bin/claude.exe` (the Windows binary, 2.1.283). `…/AppData/Roaming/npm` is on PATH but holds no `claude` shim.
-- So `where` without `--binary` reports "no claude binary" on this host. With `--binary /mnt/c/…/claude.exe` and the override, `where` is `ok: true`: a Windows binary under a Linux helper (§4.12).
-- `CLAUDE_CODE_EXECPATH` does not cross (unset in WSL; `WSLENV` empty).
-
-**`where` outputs.**
-
-| Case | Exit | Shape |
-|---|---|---|
-| gate closed, no binary | 2 | `ok: false`; `platform {name: posix, sys_platform: linux, wsl: true, supported: false, detach: setsid, override: false}`; `reason` = the gate reason, then "no claude binary …" |
-| override, no binary | 2 | as above without the gate reason; `override: true`; the override warning |
-| override, `--binary` the Windows `claude.exe` | 0 | `ok: true`, the override warning |
-| from the drvfs path (`/mnt/g/…/gremlins.py`) | same | `script` is the `/mnt/g/…` path |
-
-`python.supervisor_interpreter` resolved to the uv-managed base interpreter.
-
-**Unit suite** (override set by `Base.setUp`): `Ran 165 tests in 393.103s`, **FAILED (failures=9, skipped=3)**.
-
-| Class | Result on WSL |
-|---|---|
-| `PathTests`, `PathMatrixTests` | pass (`PathTests.test_state_dir_windows_forms` skipped) |
-| `GateTests` | 1 failure: `test_closed_gate_on_existing_registry` (cause 2) |
-| `LaunchTests` | 7 failures: `test_kill_tree`, `test_refusals`, `test_expire_kills_running_jobs`, `test_lost`, `test_orphan_watchdog`, `test_rebase_counts_toward_cap` (cause 1); `test_timeout_and_stalled` (cause 4); plus `test_delta_tokens_counts_only_what_the_base_does_not_know` (cause 3); `test_no_visible_window` skipped |
-| `SubprocessTests` | `test_where_via_uv_host_binary` skipped (no host `claude`) |
-| every other class | pass |
-
-`PathMatrixTests GateTests PathTests` alone: 23 tests, 1 failure (cause 2), 1 skip.
-
-**Failure causes.**
-
-1. **A zombie supervisor counts as alive** (6 tests). §4.4. A POSIX item for the porter, not fixed.
-2. **`GateTests.test_closed_gate_on_existing_registry`**: its "gate open" setup ran without the override on a non-Windows host. A portable test bug: **fixed in block 3.4a** (`2257e89`; the setup `init` runs under the override env).
-3. **`test_delta_tokens_counts_only_what_the_base_does_not_know`**: `trained_at` has whole seconds, and a fast host put the note and the rebase end in the same second. A timing assumption: **fixed in block 3.4a** (mtimes and `trained_at` set explicitly). Both 3.4a fixes passed on WSL afterwards (`Ran 9 tests … OK`).
-4. **`test_timeout_and_stalled`** expects a tree of at least 3 (§4.5). A porter's item.
-
-So on a Linux host like this one, expect **7 failures** from the current branch (causes 1 and 4) until you fix them.
-
-**Traps found.**
-
-- From Git Bash, `wsl -d X -- bash -lc '…'` expands `$?` in an outer shell, so every exit code read 0. `wsl -e bash -lc '…'` gives the real codes. Prefix every `wsl` call from Git Bash with `MSYS_NO_PATHCONV=1`.
-- Never `wsl --shutdown` or `--terminate` on a shared host.
-- Leftovers after the run: none (`ps` by args; no `/tmp/gremlins-test-*`).
-
-## 6. What to test
-
-On each platform, in this order. Record each item in your run log as passed, failed (with the fix), or not run (with the reason).
-
-1. **G-where** with the gate closed: exit 2, the right `sys_platform`, `wsl: false` on native Linux and macOS, the binary block filled with your native `claude`, and `scrub.unknown` read (§4.10).
-2. **`PathMatrixTests` and `GateTests`** alone, then **the full suite** to a log file. Linux: expect the 7 known failures (§5) until fixed. macOS: expect more (everything that needs a process table or creation times). Fix, then rerun.
-3. **The skill load** with the gate closed (§4.14).
-4. **The live smoke** in a scratch clone (§7), with the override set.
-5. **`kill` with a hanging gremlin and a grandchild** (§7 step 6). Record every pid with its start time before the kill (`ps -o pid=,lstart=,args= -p <pid>`) and check each pid **and** start time afterwards. Never check by process name.
-6. **The orphan watchdog** (§7 step 13): a gremlin with no orchestrator call for longer than `orphan_after` ends `killed`/`orphaned` and its tree is gone.
-7. **`lost`** (§7 step 14): kill the supervisor by hand; after `LOST_AFTER_S` (120 s) `list` reports `lost_now` and kills the leftover `claude` tree.
-8. **Supervisor survival** (§7 step 15) across (a) the launching Bash call returning, (b) that call being stopped (`TaskStop`), and (c) the end of the Igor's turn.
-9. **No stray windows.** Linux desktop: no terminal window opens during a launch. macOS: no Terminal window. None is expected (no console is created), but look once during step 6. `test_no_visible_window` skips on POSIX (`visible_windows()` is `None`).
-10. **Zombies**: after each kill, `ps -o pid,stat,args -p <supervisor pid>` must not show a lingering `Z` whose parent is a long-running process.
-11. **The transcript slug** (§4.13).
-12. **Leftover processes** after the suite and after the smoke, by command line: `pgrep -af "gremlins-test-|_supervise|claude-stub|gremlins-smoke"` gives nothing.
-
-## 7. Smoke recipe
-
-The Phase 1 and Phase 2 smokes under the new names, plus the platform steps. Run it from the Igor's own Bash tool.
-
-- **Every `wait`, `kill` and `expire` call goes through the Bash tool with `timeout: 600000`.** The Bash tool backgrounds a call that passes its timeout instead of killing it, and you lose the output. `wait` blocks up to 570 s; `kill` verifies for up to 10 s per job; `expire` kills its jobs one after another.
-- Loop `wait` until exit 0 or 4. Exit 3 means "call again", and `done` may already hold results.
-- Keep calling `wait` (or `list`) while a gremlin runs: the orphan watchdog kills a job after `orphan_after` (1200 s) without an orchestrator call, and `kill` and `expire` do not count.
-
-**Setup** (the shell state does not persist between Bash calls, so repeat the variable lines in each call, or put them in a small `env.sh` in the scratch dir and source it):
-
-```bash
-export SPIRE_GREMLIN_UNSUPPORTED_OK=1                  # only until the gate is lifted in code
-CO=/path/to/your/headless-forks/checkout
-G="uv run $CO/plugins/spire/skills/gremlins/gremlins.py"
-S=/tmp/gremlins-smoke-<stamp>                          # scratch, outside the checkout
-R="$S/smoke-run.md"                                    # run log; the state dir is $S/smoke-run-gremlins
-mkdir -p "$S" && git clone --local "$CO" "$S/clone" && : > "$R"
-```
-
-Write the briefs as files in `$S` (`brief-*.md`). Use a full model id your settings admit; the earlier smokes used `claude-opus-5-5`.
-
-| # | Command | Must show |
-|---|---|---|
-| 1 | `$G where` | exit 0; `platform {name: posix, sys_platform: linux\|darwin, wsl: false, supported: false, override: true}`; one warning (the override); `binary` = your native `claude` with a version |
-| 2 | `$G init --run "$R" --model claude-opus-5-5 --cwd "$S/clone"` | exit 0; `created: true`; `config.binary_resolved_by` `CLAUDE_CODE_EXECPATH` or `PATH`; `warnings: []`; state dir with `registry.json` and `.gitignore` |
-| 3 | `$G train --run "$R" --base B1 --phase 1 --brief "$S/brief-train.md"`, then `$G wait --run "$R" --all` | `{job: j0001, base: B1, session_id}`; `wait` exit 0, `status: ok`; `list`: B1 `active`, base context about 20–30k tokens (Windows: 23,676) |
-| 4 | `$G spawn --run "$R" --base B1 --block P1 --phase 1 --brief "$S/brief-p1.md"`, then `wait --all` | launch return `method: "fork"`, `base_state: warm`, `rebase_due: false`; result `ok`, `cache: hit`, `fingerprint: ok`, `models_used` = the model, `note: notes/P1.md`; a new commit in the clone (`git -C "$S/clone" log --oneline -1`) |
-| 5 | `$G continue --run "$R" --job j0002 --brief "$S/brief-cont.md"`, then `wait --all` | `ok`, `kind: continue`, `method: null`, `cache: hit`, a second commit. `cost_delta_usd` = the raw `total_cost_usd` difference |
-| 6 | `$G spawn … --block K1 --phase 1 --brief "$S/brief-k1.md"`; `$G wait --run "$R" <job> --timeout 60` until `running[0].messages` > 0 and the sleeps run; record the tree (pids + start times; see below); `$G kill --run "$R" --job <job>`; `wait --all` | `wait` exit 3 while it runs; `kill`: `ok: true`, `status: killed`, `survivors: []`, `snapshot` holds the supervisor, `claude`, the shell and **both** sleeps; afterwards every recorded pid + start time is gone; `wait` exit 4, `killed`, `reason: kill`, tokens and cost `null`. macOS before §4.2: expect the sleeps to survive (record it; it is the bug) |
-| 7 | `$G spawn … --block P2a --phase 2 --brief "$S/brief-p2a.md"`, then `wait --all` | launch return `rebase_due: true`, `reasons: ["phase_boundary"]`; result `ok`, `hit` (the flags are advisory) |
-| 8 | `$G rebase --run "$R" --base B1 --as B2 --phase 2 --brief "$S/brief-rebase.md" --delta-note "$S/smoke-run-gremlins/notes/P1.md"`, then `wait --all` | `{job, base: B2, parent: B1, session_id}`; result `ok`, `kind: rebase`; `list`: B1 `superseded` (`superseded_by: B2`), B2 `active`, `parent: B1`, `lineage_rebases: 1`, context a little larger than B1's |
-| 9 | `$G spawn … --base B2 --block P2b --phase 2 --brief "$S/brief-p2b.md"`, then `wait --all` | launch return `rebase_due: false`; result `ok`, `hit` against **B2's** context (first request's `cache_read_input_tokens` ≈ B2's `context_tokens`; Windows: 25,277 of 25,279); a commit |
-| 10 | optional, about 35 min: `$G init --run "$R" --warm-margin-s 1800`; then `$G wait --run "$R" --all --timeout 30` every 5 min or less | `changed_fields: ["warm_margin_s"]` (at a 1 h TTL a margin above 1800 is capped to 1800; 3600 or more is refused); about 30 min after B2's last hit a `wait` tick launches a ping (`list`: kind `ping`, B2 `expiring`); the next `wait` returns it in `pings`, not `done`: `ok`, `hit`; B2 `warm` again. Skip if time is short and say so |
-| 11 | `$G usage --run "$R" --phase 1 --format md`, `--phase 2 --format md`, `--block P1 --format md`, `$G usage --run "$R"` | exit 0 each; phase 1 table has `train`, `spawn`, `continue` rows and a total; cache-hit ratio `n/n`; the priced total; the P1 row's Commit cell is the real commit; json `reconciled: []`; `ledger.jsonl` has one line per `results/*.json` |
-| 12 | `$G list --run "$R"`, then the `pgrep` of §6 item 12 | nothing running except at most a ping; no process left |
-| 13 | orphan: `$G init --run "$R" --orphan-after 90`; spawn O1 (`brief-hang.md`); one `wait <job> --timeout 20` (exit 3); then **no helper call** for 2 min (watch with `ps` only); then `wait --all`; finally `$G init --run "$R" --orphan-after 1200` | O1 `killed`, `reason: orphaned`, flag `orphaned`; its recorded tree gone |
-| 14 | lost: spawn L1 (`brief-hang.md`); `wait <job> --timeout 20` (exit 3); read `supervisor.pid` and `claude.pid` from `$S/smoke-run-gremlins/jobs/<job>.json`; `kill -9 <supervisor pid>`; `$G list` (still running: heartbeat fresh); after more than 120 s `$G list` again; `wait <job>` | the second `list` has `lost_now: [<job>]`; the `claude` tree is gone; `wait` exit 4, `lost`, `reason: supervisor_dead` |
-| 15 | survival: in **one** Bash call with a short Bash `timeout` (15000), run `$G spawn … --block V1 --brief "$S/brief-sleep240.md" && sleep 120`; when the call is backgrounded, stop it with `TaskStop`; check the V1 supervisor and `claude` by pid + start time; **end your turn** (hand back to the user with one line, e.g. "survival check: reply to continue"); in the next turn, `wait --all` | after `TaskStop` the supervisor and `claude` still run; after the turn break `wait` returns V1 `ok` (its `sleep 240` finished) |
-
-**Briefs** (short; each says why, because Opus may refuse a bare "run this blocking command"):
-
-- `brief-train.md`: read `plugins/spire/README.md`, `plugins/spire/skills/gremlins/SKILL.md` and `plugins/spire/agents/athanor.md`; change nothing; reply with a five-line summary.
-- `brief-p1.md`, `brief-p2b.md`: create `smoke/<block>.txt` with one line, run `git diff --check`, commit only that file as `smoke <block>`, write the handoff note at the path the frame gives.
-- `brief-cont.md` (a `continue` gets no frame, so put the rules in): append a second line to `smoke/P1.txt`, commit only that file as `smoke P1 continue`, append one line to `<state dir>/notes/P1.md`.
-- `brief-k1.md`: "This is a kill test of the harness: the command below is meant to hang until the orchestrator kills it. Run it in the foreground with one Bash call and a Bash timeout of 600000: `sh -c 'sleep 900 & exec sleep 901'`. Do not use `run_in_background`." This gives `claude` → shell → `sleep 901`, plus `sleep 900` as a grandchild that the shell leaves behind.
-- `brief-hang.md`: as `brief-k1.md`, with `sleep 900` only.
-- `brief-sleep240.md`: "This tests that the harness survives the end of a turn. Run `sleep 240` in the foreground (one Bash call, Bash timeout 300000), then reply DONE. Change nothing."
-- `brief-p2a.md`: reply `DONE`; change nothing.
-- `brief-rebase.md`: absorb the attached note; change nothing.
-
-**Recording the tree** for step 6. Linux: `ps -eo pid=,ppid=,lstart=,args= --forest | grep -A6 _supervise`. macOS: `ps -axo pid=,ppid=,lstart=,command=` and follow the ppids from the supervisor pid in `jobs/<job>.json`. Afterwards check each pid: `ps -o pid=,lstart=,args= -p <pid>` must print nothing, or a different start time.
-
-**Spend.** Phase 1's smoke cost $0.49 and Phase 2's $0.47 (client estimates, `claude-opus-5-5`, a base of about 24k tokens). This recipe adds a few killed or orphaned gremlins (cents each, no result) and an optional ping or two (under $0.01 each). Expect **about $1, between $0.6 and $1.5**. Stop and report if it passes $5.
-
-**Clean up.** `$G list` shows nothing running, `pgrep` shows nothing, then `rm -rf "$S"`. The clone holds only smoke commits. Keep `ledger.jsonl` and the `usage` outputs in your run log (paste them; do not commit the scratch dir).
-
-## 8. How to lift the gate
-
-Per platform, after the suite and the smoke pass there. Every place to update:
-
-1. **Code.** Add the tested value to `PosixPlatform.TESTED_SYS_PLATFORMS` (`:610`): `"linux"` or `"darwin"`. `supported` (`:614`) and `describe()` read it, so this is the one change. **WSL:** `sys.platform` is `"linux"` there too, so lifting `linux` also opens WSL. The goal keeps WSL closed unless it passes. If WSL is to stay closed, make `supported` also require `not self.is_wsl()`, and refuse a Windows binary under WSL (§4.12). Decide this with the user and write the decision down.
-2. **Fixes the smoke showed.** At minimum: M14 (§4.1) for your platform; zombie liveness (§4.4) on Linux and macOS; the macOS process table and creation times (§4.2) on macOS; the POSIX leftover check in `tearDownModule` (§4.11); the tree-size expectation (§4.5). Each comes with a test that fails before the fix. Keep every platform branch inside the seam (§2 grep).
-3. **Gate tests** (`GateTests`, tests `:1405`). In `test_supported_flags` (tests `:1430`) assert `True` for the lifted value and keep `False` for the platform that is still closed (and for WSL if it stays closed). Extend `test_host_where` (tests `:1463`) for your host: `where` without the override gives `ok: true`, `supported: true`, `override: false`, `warnings: []`. The fake-platform tests stay as they are.
-4. **`plugins/spire/skills/gremlins/SKILL.md`**: the frontmatter `description` ("Windows-tested; other platforms fail closed until tested (see Platforms)") and the Platforms section (line 22, which names Linux, WSL and macOS as closed).
-5. **The README row** for `gremlins` in `plugins/spire/README.md` (added in block 3.8, same wording as the description).
-6. **`plugins/spire/agents/athanor.md`**, the fallback line (line 34, "`where` not ok (Windows-tested; other platforms fail closed until tested …)"), if its wording changes.
-7. Also check `plugins/spire/skills/implementation/SKILL.md` line 49 ("It is Windows-tested; other platforms fail closed until tested …") and `plugins/spire/skills/implementation/references/spawning-claude-code.md` line 75 ("Tested on Windows with `claude` 2.1.283 and 2.1.299"). Add your platform and `claude` version there, as an `observed <date>` row where it is a fact about the harness (the file's status vocabulary: `verified`, `observed`, `assumed`, `unknown`, each with a date).
-8. **This report.** Mark your platform done in §1 and add what you found under §4 and §5 (or append a dated section for your platform).
-9. **The changelog.** There is no CHANGELOG file; the changelog is the body of the release commit (block 3.8, in the style of `7c1ed39`). Its line "tested on Windows; Linux and macOS gated pending the platform handoff" goes stale when you lift a gate. Do not rewrite that commit: state the newly tested platform in your lift commit's body, and make sure the commit that finally merges or releases the branch carries the corrected platform line.
-10. **Run the full suite and the smoke again** with the gate lifted and **without** the override in the environment. Record both in your run log.
-11. **Do not merge.** The branch is merged only when both Linux and macOS are done (or the user decides otherwise). Use no version number in any platform wording (digest amendment A7): write "tested on Windows and Linux", never a Spire version next to a platform.
-
-## 9. Not covered
-
-- **Docker.** It is available on the dev host and was not used. A Linux container is closer to native Linux than WSL, but it is not a desktop host (no Claude Code app env, no supervisor survival across a real turn).
-- **The Rust follow-up.** The user suggested picking up the helper as Rust work as well (goal "Amended … release gating"; `docs/workpad/reports/2026-10-16-01-session-harness-app-forms.md`). It has not been started; nothing here depends on it.
-- **The Windows live smoke under the new names** (Phase 4, digest C17). It is separate from yours, and it is also required before anything ships.
-- **Codex.** The skill does not apply there.
-- **Large bases** through the helper (the smokes used a base of about 24k tokens; P0.2's 182k base was a hand-run probe), and the live partial-ping case (P0.6).

docs/workpad/reports/2026-10-16-23-headless-forks-postmortem.md

@@ -0,0 +1,251 @@
+# Post-mortem: the headless-forks / gremlins build
+
+- **Date**: 2026-10-16
+- **Author model**: claude-opus-5-5 (one agent, read-only apart from this file, 30-minute timebox)
+- **Verdict**: **a failure.** The code works, but the build missed the brief by a factor of 4–5 in size and took most of a day. Most of the excess came from planning and process, not typing.
+- **Sources**: journal `docs/workpad/journals/2026-10-15-21-grotto-work.md` (cited as J:line), the goal, design, plan and build plan on `main`, the code verdict `reports/2026-10-16-22-gremlins-code-verdict.md` (V:line), the brainstorm `brainstorm/2026-10-16-22-grotto-plan-structure.md` (B:line), and on the branch worktree `.claude/worktrees/headless-forks/docs/workpad/`: the run log `reports/2026-10-16-08-headless-forks-run.md` (RL:line), the preflight (PF:line), the reviews, re-checks and digests, plus `git log headless-forks`.
+
+---
+
+## 1. Outcome
+
+**Asked for.** "Spire ships a **small deterministic helper** (a script in the skill …) that owns the `claude -p` command line. It covers: train a base, fork the base with a brief, update the base, report usage, and list or expire bases" (goal:17). The intent was to keep bookkeeping out of agent attention (goal:12).
+
+**Delivered.** Branch `headless-forks` at `ab1d945`, 51 commits, not merged, Phase 3 not reviewed, block 3.8 left as WIP (J:196).
+
+| Artifact | Lines |
+|---|---|
+| `gremlins.py` | 4,155 |
+| `tests/test_gremlins.py` | 4,235 (about 180 tests) |
+| SKILL.md, preamble, templates | 189 |
+| Process documents (design 430, plan 257, build plan 337, three contract digests 869, run log 812, preflight 187, five reviews and checks 989, platform handoff 339, trunk notes 53) | about 4,270 |
+
+That is about 12,700 lines of code, tests and process documents for a tool the verdict sizes at **600–800 lines plus about 500 lines of tests** (V:97-109). The verdict: "careful, consistent and well tested, and it works … still over-built by about four to five times", with "roughly two thirds" of it policing detached processes (V:16). A live happy path on Sonnet 5.5 ran clean for $0.09, with a cache hit on the fork (V:140-151).
+
+**Time.** From the goal (01:23, J:73) to the stop (22:20, `ab1d945`) was **about 21 h of wall clock**. The build itself, from B0 (08:15) to the stop, took **about 14 h**.
+
+| Bucket | Hours | Evidence |
+|---|---|---|
+| Push approval stall before the build (B0) | ~6.4 | J:102, J:104 |
+| Unexplained gap in Phase 0 (10:13 → 12:16) | ~2.0 | RL:18, J:116 (probably an approval prompt; the Athanor guessed "host suspend") |
+| Unexplained gap in block 1.2 (12:31 → 15:42) | ~3.2 | RL:105, J:120 |
+| **Total waits, mostly approvals** | **~11.6** | J:130 says "~11 h" |
+| Active build time, 08:15–22:20 minus the in-build gaps | **~8.9** | below |
+
+Even with every approval wait removed, the build took **about 9 active hours** for a "small helper". That is the failure. The waits only made it look worse.
+
+---
+
+## 2. Timeline
+
+Times are 2026-10-16 (+0200) unless marked. They come from commits and from the run log's `date` stamps.
+
+| Time | Step | Duration | Notes |
+|---|---|---|---|
+| 10-15 21:23 | Session start; grotto orientation, experiment synthesis | — | not this build |
+| 00:44–01:16 | Headless-fork research (local tests, $0.48) | ~0.5 h | J:52-64; this is where the mechanism was proven |
+| 01:23 | Goal written, decisions settled | — | J:73-74 |
+| ~01:25–01:50 | Design → plan → attack, three Opus agents | ~0.5 h | J:75-101 |
+| 01:50 → 08:15 | B0 push waiting for approval | **6.4 h** | J:104 |
+| 08:16–12:17 | **Phase 0** preflight | 4.0 h | 1 h is the TTL test by design (J:107); ~2 h is a gap (RL:18) |
+| 12:18–12:29 | 1.1 skeleton, state, `where`, `init` | 8 min | already **1,124 lines** of code |
+| 12:31–15:49 | 1.2 launch and supervise | 3.3 h | about 3.2 h of it is the clock gap; code grows to 2,403 |
+| 15:50–15:56 | 1.3 smoke | 6 min | |
+| 15:57–16:40 | Phase 1 review → fix → re-check | 43 min | 3 Important, 16 Minor; +245 code lines |
+| 16:42–17:44 | **Phase 2** (2.1 15 min, 2.2 22 min, 2.3 8 min, smoke 8 min) | 1.0 h | code goes 2,648 → 3,640 |
+| 17:44–18:22 | Phase 2 review → fix → re-check | 38 min | 2 Important, 14 Minor; +147 code lines |
+| 18:23–18:44 | Phase 3 digest (684 lines) → pre-build check → amendment | 21 min | the check step was added by Igor (J:160) |
+| 18:44–20:24 | **3.1 rename** | **1 h 40** | a sed job took the time of an audit (J:172-176) |
+| 20:26–20:39 | 3.2 platform seam and gate | 13 min | +274 code lines |
+| 20:41–21:43 | 3.3 N3, N4, kill flake | 62 min | the flake did not reproduce (RL:627) |
+| 21:45–21:57 | 3.4 WSL check, 3.4a test fixes | 12 min | |
+| 21:59–22:18 | 3.5–3.7 text, references, handoff | 19 min | handoff report is 339 lines |
+| 22:20 | 3.8 stopped by the user; WIP commit | — | J:196 |
+
+**Where the active ~9 h went:**
+
+- About 2 h on Phase 0 probing, and 1 h waiting on the TTL test. This was the most valuable part.
+- About 1 h writing the core in Phase 1. Block 1.2 is hidden inside a 3.3 h span.
+- About 1 h on Phase 2 features, most of them heuristics (V:74-91).
+- About 1 h 40 on review, fix and re-check loops, plus digest checks.
+- About 3 h on Phase 3: the rename alone took 1 h 40; the seam over a supervisor that should not exist; one hour chasing a flake.
+
+Each block owner was a fresh Opus 1M agent using **187k–351k tokens** (RL:66-67, RL:261-263, RL:236, RL:482). The Athanor reached about 515k tokens by the end of Phase 2 (J:149).
+
+**Code growth** (`git show` on each commit; `gremlins.py` / tests):
+
+| Commit | Point | Code | Tests |
+|---|---|---|---|
+| `d36ac2f` | 1.1 skeleton | 1,124 | 673 |
+| `009a252` | 1.2 supervisor | 2,403 | 1,587 |
+| `7b9b748` | P1 fixes | 2,648 | 1,976 |
+| `5fda2e2` | 2.2 rebase/re-train | 3,420 | 3,020 |
+| `4b92b51` | 2.3 usage | 3,640 | 3,378 |
+| `d2d5104` | P2 fixes | 3,787 | 3,630 |
+| `e9f1b06` | 3.2 seam and gate | 4,070 | 3,944 |
+| `62eef3b` | 3.3 N3/N4 | 4,155 | 4,222 |
+
+Two facts stand out. The skeleton alone, before any launch code, was already larger than the whole minimal version. And by the end of Phase 1 the code was about 3× the verdict's target, before a single review fix landed.
+
+---
+
+## 3. Root causes, ranked
+
+Each candidate the user named is tested against the evidence. They are ranked by how much of the excess size and time they explain. Approval waits are ranked last on purpose: they cost hours but no lines.
+
+### RC1. Phase 0 removed the design's main premise, and nobody re-planned. **Supported; the biggest single driver.**
+
+- The design's shape: "Launch returns at once (detached supervisor)" (design:255). Its fallback was `--attach` under `run_in_background`, with the line "**The Athanor never relies on the background notification**" (design:149). Risk R1 was that detached children would die when the Bash call ended (design:373).
+- Phase 0 found that a Bash call past its timeout "is **not killed**; it is moved to the background … and its completion notification arrived in this subagent" (PF:71). That falsifies the reason for detaching.
+- What happened next: to keep pass criterion (d), "a Bash call that the tool kills on timeout" (build plan:223), the Athanor manufactured the kill with `TaskStop` (RL:25). The test was kept alive, and nobody asked whether it still mattered. The preflight says "no fallback beyond the ladder was needed" (PF:50). Igor made rung 3 (PowerShell/CIM hidden detach) the permanent default (RL:58). The open question "does the Phase 3 text want a line on it?" (RL:52) was routed as a documentation item (RL:507).
+- The cost: two thirds of the code (V:16, V:60-72), meaning detach, supervisor, `SupClock`, orphan watchdog, heartbeats and reaping, the pid-reuse-safe tree kill, `RegistryLock`, and most of the platform seam. The seam then put an interface over machinery that should not have existed (470 lines for one tested platform, V:26, V:72).
+- Igor noticed only at 22:11, after the user asked "an operating system?" (J:191-193).
+
+### RC2. The goal and plan specified a large tool; "small" was a label. **Supported.**
+
+- The goal's own criteria include computed keep-warm, expire and re-train rules (goal:23), rebase-or-delta policy (goal:27), agent-file specialisation, the fingerprint, and the env scrub (goal:17-29). Igor admits this: "small helper was a label, not a requirement" (J:194).
+- The design and plan then turned each criterion into machinery:
+  - 13 commands (plan:88);
+  - a ping rule with an activity window and a break-even cap "at 19 and 11" (plan:204);
+  - five rebase and re-train thresholds plus binary drift (plan:205, design:210-216);
+  - `lost` detection and three watchdogs (plan:197).
+- The verdict's "heuristics nobody asked for" (V:74) is half true. The **user** didn't ask for them. **Igor's goal and the design** did. The failure is that nobody turned the user's sentence into a size or a scope cap.
+- The attack (build plan) found no STOP-level issues (build plan:18). It attacked correctness and harness risks, not size. So it *added* contracts (orphan kill, C1–C20) on top.
+
+### RC3. No design or size criterion anywhere, and a review loop that only adds. **Supported. Weaker in lines than RC1/RC2, strong as a pattern.**
+
+- No document sets a line budget, a module budget or a "simplest thing" test. Not the goal, the design, the plan, the build plan, the reviewer brief or the digest check.
+- Reviews hunted bugs and found real ones (section 4), and every fix added code and tests:
+  - P1 fixes: +245 / +389 lines (`7b9b748`);
+  - P2 fixes: +147 / +252 (`d2d5104`);
+  - 3.3's N3/N4 fixes: +85 / +278.
+- Both Phase 2 documents carry a "**Built but not asked for (on record only)**" section: about 25 unrequested additions, among them `--warm-margin-s`, `ping_missed`, `rebase_conflict` and six new job fields (phase2-review:212-228; phase2-recheck:135-146). None was cut. The section header says outright that recording replaces removing.
+- The code now references 49 distinct review-finding IDs about 100 times (V:44). It reads "like layers of review fixes", and several mechanisms are "a patch on a patch" (V:66-67).
+- In lines, review fixes account for about 480 of 4,155 (about 12 %). The loop didn't create the bulk. It **locked it in**: each pass hardened over-built code with more tests (now longer than the code) instead of asking whether it should exist.
+
+### RC4. Plans without code structure; architecture invented per phase in self-written digests. **Supported.**
+
+- The plan fixes a command surface, a result JSON and two state machines (plan:86-130). It does not fix modules, a data model or layering. "One dependency-free file" was the design's only structural statement (J:77).
+- The Athanor filled the gap with its own contract digests (Phase 1 121 lines, Phase 2 64, Phase 3 **684**). Phase 3's digest alone is about as long as the whole minimal tool.
+- **Every Important finding** in Phases 1 and 2 traced back to points these digests left undefined (J:123, J:150-154). Igor named the pattern himself (J:154).
+- The result is a single 4,155-line file with a 150-line `_conclude` god function that mixes classification, eight flag rules, two near-duplicate dicts and the base state machine (V:78-84).
+- The brainstorm draws the lesson directly: the plan needs "at least the structure of the code" (B:9).
+- One caution: the experiment's "code in the plan adds nothing" result was measured on correctness and merge choice, not design quality (B:43; experiment report:13, :356). It doesn't contradict this root cause.
+
+### RC5. Opus 1M everywhere, no budgets or timeboxes, and an orchestrator that explained instead of checking. **Supported.**
+
+- Every block owner was Opus 1M except 2.3 (Sonnet) (RL:66-67, RL:261-263). No brief carried a time or token budget until the user forced one at 22:11 (J:177).
+- The rename went to a block "called mechanical" with "a 10-part rename map and audit-grade checks, with no model downgrade and no timebox" (J:175).
+  - Its run-log note diffs 191/200 assert lines and classifies every remaining "fork" hit by line (RL:540-559).
+  - It took 1 h 40 against an estimated 10–15 min (J:174).
+- The 3.3 flake hunt started 16 busy-loop processes and ran 10 instrumented reproductions on a pre-change copy, all to classify a flake that never came back (RL:627).
+- Igor's admissions:
+  - he rationalised the rename ("touches every file") before checking (J:172);
+  - his "$25 spending cap" wording was misleading (J:109);
+  - he accepted the Athanor's "host suspend" guess for a gap that was probably an approval prompt (J:114, J:116);
+  - he passed the user's lean instructions on "late or diluted" (J:183). "Implement first, test at the end" arrived after the last Phase 2 code change (J:148).
+- Process steps Igor added on his own:
+  - a full review, fix and re-check loop per phase;
+  - the pre-build digest check (J:160, J:181).
+  - The digest check did pay off (J:169), but it was another cold-start Opus read of 684 + 4k lines.
+
+### RC6. Every block was a cold-start agent re-reading thousands of lines. **Supported as a cost driver; partly as a size driver.**
+
+- Each block owner started fresh and read the plan, build plan, digests, run log and code. That is 5–6k lines by Phase 3 (B:8), at 187k–351k tokens per block.
+- The successor boot section lists **six document groups** to read before touching code (RL:503).
+- Size effect: nobody held the whole code (J:189), and by design the Athanor reads no code (goal:26). So no single agent was ever in a position to say "this whole stack is unnecessary". The irony is that this build lacked the very trained-and-forked implementer it was building (B:8).
+
+### RC7. No prototype first. **Supported, and linked to RC1.**
+
+- Phase 0 probed mechanisms (detach rungs, cache ratio, TTL, usage fields) with throwaway scripts. It never ran an end-to-end happy path of the product shape.
+- A roughly 300-line `train → spawn → usage` script run under `run_in_background` would have exercised the completion notice directly. It would have made RC1 obvious at about 10:00, not 22:11.
+- The verdict's minimal version is that prototype, written after the fact (V:97-132). The user says so: "it would have helped to have a prototype first, and then use it to write the real code" (B:26).
+
+### RC8. Mid-build scope additions on top of over-built code. **Partly supported; a consequence, not a cause.**
+
+- The rename, the platform seam, the path matrix, the WSL check and the cross-platform handoff were all added during the build, by user decision (goal:50-71, J:129-145). Together they were most of Phase 3 (about 3 h, about 515 code lines).
+- They were reasonable requests against the code as it stood. The seam was asked for because the code had "12 scattered `if IS_WINDOWS` branches" (J:143), and those exist mostly because of the supervisor (RC1). This is listed for completeness, not as blame. The user wondered whether their own "chaotic" input caused this (B:18). The evidence points at the process.
+
+### RC9. Approval waits. **Real, about 11.6 h, but not the main issue.**
+
+- They are explained by the user being away while not in auto mode (J:116). They added wall clock and no lines.
+- Removing them still leaves about 9 active hours and a 4–5× over-build.
+
+**What the evidence does not support.** The single-file stdlib constraint (J:188, hypothesis 3) as a cause of size. It explains why everything sits in one file. It doesn't explain why there is so much.
+
+---
+
+## 4. What worked
+
+- **The mechanism is verified and works.** `claude -p --resume <base> --fork-session` with an identical fingerprint gets cache hits:
+  - 0.9999 on a small base in the smoke (RL:154);
+  - about 1.0 on a 182k-token base (J:112);
+  - a clean live run in the verdict (V:147).
+- **The cache and usage accounting is real know-how**: `StreamState`, `usage_from_result` with the 1h/5m split, cost deltas against the session's cumulative total, `cache_verdict`, `infer_ttl`, `base_warmth` (V:48-50). The smoke reconciled every ledger line against the raw `total_cost_usd` differences (RL:157).
+- **Phase 0 findings that are expensive to re-derive:**
+  - the 1 h TTL, and that a hit refreshes it (J:107);
+  - unlisted models are substituted silently, not refused (J:112);
+  - plan mode upgrades Haiku;
+  - CIM detach is needed if one does detach;
+  - **the Bash tool backgrounds rather than kills, and the notice returns** (PF:71). This last one is a graduation candidate (J:246), and it is the finding that should have reshaped the build.
+- **Env scrub constants**: an empirically gathered list of Desktop and SDK variables (V:52).
+- **The reviews caught real bugs**, each fixed with a test that fails on the old code (J:127-128, J:156):
+  - I2: the pid-reuse tree walk could have killed `dwm`/`winlogon` on this host (phase1-review:22);
+  - I1: errors misreported as `model_refused`;
+  - Phase 2 I1: `delta_tokens` would have forced a rebase before every fork.
+- **The digest check paid off at once**: one BLOCKER (gate tests that could never pass, and whose closed case passed for the wrong reason), plus 12 ADJUSTs (digest-check:9-26, J:169). The *point* is right: check the architecture before the build. The *vehicle* was a symptom of RC4.
+- **The run log and journal made this post-mortem possible.** Every gap, admission and deviation is timestamped. Audit-grade logging was too expensive per block (RC5), but as a record it is excellent.
+- **Discipline held**: no push or merge by the Athanor, no attribution lines, no leftover processes after any phase (RL:49, RL:194), and the visible-window bug was fixed and verified in 26 checks (J:111).
+
+---
+
+## 5. What the code is worth
+
+The user's view, and this report agrees: the prototype **holds a lot of wisdom and logic and should not be downplayed; it was just too much** (B:25). Treat it as a prototype to learn from:
+
+- **Keep as a reference:** `StreamState`, `usage_from_result`, `cache_verdict`/`infer_ttl`/`base_warmth`, `api_error_reason`, the `SCRUB_*` lists and `scrubbed_env`, `claude_argv` and the fork argv, `atomic_write_bytes`/`_retry`, the templates and preamble, and the ledger plus `usage --format md` (V:46-56). That is about 600 lines of distilled facts.
+- **Keep as evidence:** the tests that pin real harness behaviour, such as the P0.2 seq-1 numbers in `RuleTests` (RL:106), the path matrix, and the WSL findings (RL:658-669, zombie liveness, PATH interop).
+- **Keep as a negative example:** the supervisor stack and the heuristics layer, as a worked case of what correctness-only review and an unchallenged premise produce.
+- **Don't delete it from history.** The user's rule is: commit before throwing out (B:24). The branch is the record (J:196).
+
+The next step is the user's call (J:197, J:229): a minimal rewrite over blocking calls run with `run_in_background`, or straight to the Rust app. One check comes first: does `TaskStop` on a backgrounded Git Bash call kill the `claude.exe` grandchild (V:134)? PF:71 suggests it does ("kills the process tree by parent links"). A one-line confirmation on the target shape is still worth running.
+
+---
+
+## 6. Lessons: options for grotto and Spire
+
+These are options, not verdicts. Each one names the root cause it addresses.
+
+### Grotto (design → plan → handoff)
+
+1. **The plan fixes the code structure** (RC4). The plan includes modules, the data model, the main interfaces, and where the special cases live. Options: a short skeleton in the plan (signatures plus the data model, no bodies), or a "structure" section that the attacker must attack. Then no builder writes a contract digest; a gap goes back to the planner.
+2. **A size budget per artifact** (RC2, RC3). The goal or plan states an expected size: "helper ≤ 800 lines, tests ≤ 600". Crossing 1.5× is a STOP that goes to Igor. Options: hard cap vs. checkpoint; lines vs. commands or flags.
+3. **Prototype first** (RC7, RC1). Before the full plan, one agent writes the happy path (about 300 lines, one timebox) on the real harness, and the plan is written from it. The prototype can be thrown away after it is committed.
+4. **A premise list with re-plan triggers** (RC1). The design lists the premises its shape rests on (for example "R1: Bash kills long calls, so we detach"). Every preflight result is checked against that list, and a falsified premise forces a re-plan, not a documentation note. Option: the preflight report gets a mandatory "premises still standing?" table.
+5. **Goals separate the user's words from Igor's criteria** (RC2). "Small" in the user's sentence becomes a measurable criterion. Criteria Igor added are marked as such, so the user can strike them.
+6. **The attacker gets a simplicity pass** (RC2, RC3): "what is the smallest design that meets the goal, and which contracts can be dropped?", next to the correctness and conventions passes.
+
+### Spire (Athanor, reviewer, Igor, implementation skill)
+
+7. **The reviewer gets a design and size criterion** (RC3). Add findings classes such as "remove", "merge" and "simplify". "Built but not asked for" becomes a cut list by default, with keeping as the exception that must be argued. Option: a separate, cheap "subtractive review" at phase end that may only propose deletions.
+8. **Fix passes have a line budget** (RC3). A fix that adds more than N lines, or a new flag or field, goes back to Igor as a design question.
+9. **Briefs carry a model, a time budget and a token budget** (RC5). Mechanical blocks get a cheap model, a scripted transform (sed plus one test run) and a timebox, and the review checks them; they don't self-audit (J:176). Option: a default table in the implementation skill (mechanical → Sonnet or Haiku, 15 min; core → Opus, 60 min).
+10. **Use the trained implementer for the build itself** (RC6). Once the helper exists, train one base on plan, structure and code, and fork it per block, instead of 5–6k-line cold starts. Until then: hand-off notes over full re-reads, and a fixed boot set of at most two documents.
+11. **Igor checks before explaining, and adds no process step without asking** (RC5). For any anomaly (a long block, a clock gap, a cost), Igor reads the evidence first (run log, `ps`, the commit) and states it as unverified if he doesn't. New steps (digest checks, extra reviews) are proposed to the user with their cost.
+12. **One review per build or per risk, not per phase by default** (RC3, RC5). The review, fix and re-check triple ran twice and cost about 1 h 20. Option: a review per phase only where the plan marks the phase as high-risk; otherwise one review at the end.
+13. **The cheap gate excludes slow full suites** (J:146): already sent mid-build; accrete it into the implementation skill.
+14. **A fresh Athanor per phase, booted from a short state section** (J:149). Keep this, but cap the boot reading (see 10).
+
+### Measure next time
+
+- Active time vs. wait time per block. Have the run log record "waiting on approval" when a prompt is pending, if the harness exposes it. Otherwise flag gaps over 10 min explicitly as unknown.
+- Lines added per block and per fix pass, next to the token counts already logged.
+
+---
+
+## Gaps in this post-mortem
+
+- The block 1.2 span (12:31–15:49) can't be split into work and waiting. The subagent's harness duration of 11,929 s covers both (RL:67).
+- The Athanor's and Igor's own token use is unknown (RL:13, RL:193), so the full token cost of the build can't be given.
+- The front-end time (design, plan, attack) is estimated from journal order. The journal has few timestamps there (J:73-101).
+- Phase 3 was never reviewed, so its share of real bugs vs. over-build isn't assessed beyond the verdict.

docs/workpad/reports/2026-10-16-23-spire-guidance-text-audit.md

@@ -0,0 +1,246 @@
+# Spire guidance-text audit: size, filler, steering
+
+- Date: 2026-10-16 22:58 · Model: `claude-opus-5-5` · Branch audited: `main` (plus the `headless-forks` worktree for gremlins and the branch Athanor)
+- Scope: `plugins/spire/` skills (SKILL.md + references; no `templates/` dirs exist on main), agents, plugin CLAUDE.md, README. Also the injected `.claude/spire/project.md`.
+- Method: `wc -w` for size; tokens ≈ words × 1.3 (tables and code blocks tokenize worse, so real numbers run higher). I read every file in the load bundles in full and sampled the rest (svg references and parts of init only skimmed). Class percentages are estimates from reading, not measurements.
+- Findings and options only. Nothing here is a verdict.
+
+## 1. Sizes
+
+### Per file (main)
+
+| Group | File | Words | ≈ Tokens |
+|---|---|---:|---:|
+| **igor** | skills/igor/SKILL.md | 3473 | 4515 |
+| | references/mindset.md (`@`-included) | 348 | 452 |
+| | references/model-tiers.md | 713 | 927 |
+| | references/journal-template.md | 153 | 199 |
+| | references/project.md (blank template) | 351 | 456 |
+| | references/harness-notes.md (moved-stub) | 107 | 139 |
+| | agents/igor.md | 85 | 111 |
+| **implementation** | skills/implementation/SKILL.md | 1395 | 1814 |
+| | references/spawning-claude-code.md | 1172 | 1524 |
+| | references/models.md | 691 | 898 |
+| | references/superpowers.md | 461 | 599 |
+| | references/run-log.md | 410 | 533 |
+| **workpad** | skills/workpad/SKILL.md | 1768 | 2298 |
+| **project** | skills/project/SKILL.md | 45 | 59 |
+| | + injected `.claude/spire/project.md` (reliquary) | 216 | 281 |
+| **adepts** | skills/adepts/SKILL.md (+ roster output, ~6 words here) | 100 | 130 |
+| **research** | skills/research/SKILL.md | 1155 | 1502 |
+| | skills/research-tree/SKILL.md | 1213 | 1577 |
+| **svg** | SKILL.md + inline-svg.md + layout-legibility.md | 859 + 1318 + 757 | 3814 |
+| **other skills** | init | 1835 | 2386 |
+| | zathras | 1011 | 1314 |
+| | curator | 327 | 425 |
+| | knowledge | 319 | 415 |
+| **agents** | adept | 1431 | 1860 |
+| | athanor | 980 | 1274 |
+| | researcher | 450 | 585 |
+| | search | 396 | 515 |
+| | attacker | 326 | 424 |
+| | planner | 288 | 374 |
+| | reviewer | 276 | 359 |
+| | scout | 268 | 348 |
+| | zathras | 92 | 120 |
+| **misc** | plugin CLAUDE.md | 27 | 35 |
+| | README.md (not loaded by agents) | 353 | 459 |
+| **Total (main)** | | **24 953** | **≈ 32 400** |
+
+Branch worktree `headless-forks` for comparison: gremlins/SKILL.md **2052** (≈ 2670 tok), preamble.md 247, templates 463 (gremlin briefs, not Athanor reading), `where` injection ≈ 133. On the branch the Athanor's text also grows: athanor.md 980 → **1658**, implementation SKILL 1395 → 1474, spawning-claude-code 1172 → **3077**, run-log 410 → 552, models 691 → 854.
+
+Fixed overhead in every main session: skill descriptions ≈ 620 words and agent descriptions ≈ 630 words (≈ 1.6k tok). workpad (102), svg (114), research-tree (102) and athanor (127) have the longest descriptions. The repo CLAUDE.md (117 words) loads too.
+
+### Load bundles (what one agent carries at start)
+
+"Preloaded" = frontmatter `skills:` plus `@`-includes plus CLAUDE.md. "+ mandated" = files the preloaded text tells the agent to read before it can do its job. I assumed the `@references/mindset.md` include expands inside a skill. Nobody has checked that.
+
+| Bundle | Preloaded | Words | + mandated reads | Words | ≈ Tokens (with mandated) | Agent-specific share |
+|---|---|---:|---|---:|---:|---:|
+| **Igor boot** | igor.md, igor SKILL, mindset, project (+project.md), adepts, workpad, repo CLAUDE.md | 6 152 | journal-template | **6 305** | **≈ 8 200** (+1.6k listings) | igor SKILL+mindset ≈ 61% |
+| **Athanor start (main)** | athanor.md, project, workpad, implementation, CLAUDE.md | 4 521 | spawning (impl:67 "Read … before dispatching"), run-log | **6 103** | **≈ 7 930** (+ models.md 691 → ≈ 8 830) | athanor.md 16% |
+| **Athanor start (branch)** | + gremlins, longer athanor/impl | 7 330 | spawning 3077, run-log 552 | **10 959** | **≈ 14 250** (+ models 854 → ≈ 15 360) | athanor+gremlins 34% |
+| **Planner** | planner.md, project, workpad, implementation, CLAUDE.md | 3 829 | — | 3 829 | **≈ 4 980** | 7.5% |
+| **Attacker** | attacker.md + same | 3 867 | — | 3 867 | **≈ 5 030** | 8.4% |
+| **Reviewer** | reviewer.md + same | 3 817 | — | 3 817 | **≈ 4 960** | 7.2% |
+| Adept (for reference) | adept.md, workpad, adepts, CLAUDE.md | 3 416 | adepts/CLAUDE.md + handoff (project data) | 3 416+ | ≈ 4 440+ | 42% |
+| Zathras (for reference) | zathras.md + skill, project, workpad, adepts | 3 349 | — | 3 349 | ≈ 4 350 | 33% |
+
+The bundles look like this: **workpad (1768 words) is preloaded into seven agents**, and **implementation (1395) is preloaded into planner, attacker and reviewer**. In each of those three, workpad plus implementation makes up ~83% of what the agent carries. Only 7–8% is its own job description.
+
+## 2. Content classes
+
+Classes: **a** agent-specific operational instruction · **b** project/harness facts · **c** general knowledge the model has · **d** filler (persona, motivation, history, repetition, hedges, examples restating a rule) · **e** stale or contradicting.
+
+### Overall split
+
+Weighted over all 24 953 words on main: **a 42% · b 22% · c 9% · d 23% · e 4%** (≈ 10.5k / 5.5k / 2.2k / 5.8k / 0.95k words).
+
+Per bundle (with mandated reads):
+- **Igor boot:** a 41 · b 16 · c 10 · d 30 · e 3
+- **Athanor start (main):** a 41 · b 27 · c 10 · d 18 · e 4
+- **Planner/attacker/reviewer:** a ~45 · b ~12 · c ~17 · d ~23 · e ~3. Much of the "a" is somebody else's job (the reviewer carries the attack procedure and the bug-hunting rules; the planner carries the phase-review rules).
+
+### Per file (estimates)
+
+| File | a | b | c | d | e | Notes |
+|---|---:|---:|---:|---:|---:|---|
+| igor SKILL | 45 | 12 | 5 | 33 | 5 | Persona/voice 9–41 ≈ 544 words; delegation rule restated ~8×; three near-identical adept spawn templates (133–161, 164 words) |
+| mindset.md | 15 | 0 | 5 | 80 | 0 | Philosophy plus a note to future editors ("Protect them in any rewrite") |
+| model-tiers.md | 40 | 30 | 0 | 25 | 5 | Table near-duplicates igor SKILL 77–89 |
+| harness-notes.md | 0 | 0 | 0 | 90 | 10 | Moved-stub restating spawning rules |
+| journal-template | 60 | 10 | 0 | 30 | 0 | |
+| project skill + project.md | 40 / 85 | | | | 20 / 15 | project.md is stale (see e) |
+| adepts SKILL | 20 | 40 | 0 | 40 | 0 | 40-word developer HTML comment loaded into every boot |
+| workpad SKILL | 45 | 10 | 25 | 20 | 0 | Ticket context 48–68 ≈ 346 words; document-kind definitions |
+| implementation SKILL | 55 | 10 | 10 | 20 | 5 | Rationale paragraphs; Bugs section is generic |
+| spawning-claude-code | 10 | 75 | 0 | 10 | 5 | Good "b" content; history rows |
+| run-log | 70 | 10 | 0 | 20 | 0 | Field-heavy (see §4) |
+| models.md | 10 | 50 | 0 | 40 | 0 | Sources list, withdrawn notes |
+| superpowers.md | 30 | 40 | 0 | 25 | 5 | Only read on demand |
+| athanor.md | 55 | 10 | 0 | 25 | 10 | Furnace persona; stale fork step |
+| planner.md | 80 | 0 | 10 | 10 | 0 | Tightest file in the plugin |
+| attacker.md | 45 | 0 | 0 | 45 | 10 | ~70% restates implementation 24–34, which it also preloads |
+| reviewer.md | 40 | 0 | 0 | 55 | 5 | ~60% restates implementation 51–58 |
+| adept.md | 60 | 15 | 5 | 20 | 0 | Folder tree duplicates the scaffolded adepts/CLAUDE.md it reads at genesis |
+| researcher / search / scout | 20–40 | 0 | 30–50 | 15–30 | 0–5 | Tool lists, "start narrow" |
+| zathras SKILL | 25 | 25 | 0 | 40 | 10 | Persona plus a contradicting model rule |
+| research / research-tree | 35–50 | 0–5 | 20–25 | 25 | 5–10 | |
+| init / curator / knowledge / svg | mostly a+b | | | | | Human-triggered or on-demand, outside the bundles |
+
+### (c) General knowledge: quotes
+
+- `agents/search.md:27-29`: "**Start narrow.** Use Grep with a specific symbol or pattern before broadening." / "**Read strategically.** Don't read entire large files"
+- `agents/researcher.md:31`: "**Synthesize, don't summarize.**"; `:41-42` "Use clear headings and short paragraphs" / "Lead with the answer"
+- `agents/researcher.md:13-18`, `search.md:12-17`, `scout.md:12-17`: tool lists that restate the frontmatter (`- Search code and files (Glob, Grep)` …)
+- `skills/research/SKILL.md:55-56`: explains what `WebFetch` and `WebSearch` do
+- `skills/workpad/SKILL.md:97-103`: textbook distinctions ("A brainstorm is divergent … A design is convergent")
+- `skills/research-tree/SKILL.md:44`: topological layering explained ("always one past its deepest prerequisite")
+- `skills/implementation/SKILL.md:63`: "**Explore before you focus.** Look one or two layers up from the symptom, skim recent commits …"
+- `skills/igor/SKILL.md:63`: "**Fearlessness means flagging misconceptions.** When the user has a factual error, say so directly."
+
+### (d) Filler: quotes
+
+- `skills/igor/SKILL.md:9`: "Says \"yeth, marthter\" exactly zero times."
+- `skills/igor/SKILL.md:21`: "Every minute spent doing work yourself is a minute you are unavailable to the user. Your value is proportional to your presence." (again at `:65` and `mindset.md:27`)
+- `skills/igor/SKILL.md:23`: "This directive governs everything below. … If any instruction below seems to conflict with delegation, delegation wins."
+- `skills/igor/SKILL.md:34`: the furnace grammar rule ("never 'the Athanor is in the oven' or similar inversions"). The same metaphor repeats at `:91`, `athanor.md:4-6`, `athanor.md:21` ("You ARE the oven"), `zathras SKILL:15`, README:32
+- `skills/igor/SKILL.md:36-41`: four example flourishes
+- `skills/igor/references/mindset.md:21-29`: "The five voice lines … Protect them in any rewrite". This is an editor instruction that loads into every Igor run
+- `skills/zathras/SKILL.md:13`: "Not Zathras the great leader, not Zathras the quiet one. This Zathras." and `:37-40` example lines
+- `plugins/spire/CLAUDE.md:1`: "a wizard's private workshop where knowledge accumulates"
+- `skills/implementation/SKILL.md:30`: "This step is what pays for dropping per-task review. … Without it, lean is just less review." (and again in `igor SKILL:99`)
+- `skills/igor/SKILL.md:93`: "(in spacecraft it overrode 4.6 pins in 184 of 184 spawns)". This is history inside a rule
+- `skills/research/SKILL.md:12-14`: the "core problem this solves" narrative
+- `skills/adepts/SKILL.md:7-10`: "Note: This skill uses Bash(bash:*) … a novel pattern. … Per harness design this should pre-approve"
+- `references/spawning-claude-code.md:51`: a row that says it "is not evidence for alias-over-pin"
+- `references/models.md:26`: withdrawn 4.6/Opus-5 notes kept in the active file
+- `agents/planner.md:33`, `attacker.md:39`, `reviewer.md:35`: "Do this yourself; do not dispatch further agents." None of these agents has the Agent tool in its `tools:`, so the sentence does nothing. The same goes for `search.md:21`: "You do not have the Agent tool. Do not attempt to use it. Do not suggest that work be delegated"
+- Gremlins (branch): 17 review-finding tags the model cannot resolve, such as "(P0.1)", "(M16)", "(N1)", "(Minor 13)", "(Phase 1 M3)", "(C4)". "N1" names two different things (`gremlins/SKILL.md:105` delta-section rule, `:111` orphan watchdog)
+
+### (e) Stale or contradicting: quotes
+
+- `agents/athanor.md:32`: "A complex block in the area you just read can go to a fork of yourself" and `skills/implementation/SKILL.md:49` "**trunk and forks** … go to a fork of the builder". The goal decision of 2026-10-16 (`goals/headless-forks.md:47`) drops Agent-tool forks, and `spawning-claude-code.md:61` records the `fork` type as not offered. On main this tells the Athanor to use a path that is not there. The branch fixes it.
+- `skills/igor/SKILL.md:66`: "**Fork sparingly.** Forking yourself is a last resort." Same unavailable mechanism.
+- `skills/zathras/SKILL.md:74`: "**Model must be explicit.** Always pass `model` on `Agent` calls." This contradicts `igor SKILL:93` and `spawning:18` ("Pinned agents: omit `model`"). Passing the alias overrides the pins (184/184).
+- `skills/zathras/SKILL.md:70`: "Multi-file refactors, cross-cutting changes → Athanor" vs `model-tiers.md:22` "the `athanor` gets a reshaped build plan, never an unplanned build brief".
+- `skills/igor/SKILL.md:173`: "Give every dispatched agent an explicit output file path". `scout` and `search` have no Write tool.
+- `skills/igor/SKILL.md:99`: "Igor with user or Pinky" and "(trial since 0.2.2)". Pinky does not exist ("Pinky, when it exists", `spawning:54`).
+- `skills/igor/SKILL.md:43`: "If it loaded the blank template (the hint says 'run /spire:init')". `skills/project/SKILL.md` never loads the blank template. It echoes a one-line message, so `igor/references/project.md` (351 words) is unreachable through that path.
+- `.claude/spire/project.md` (injected into every bundle): the agent list "igor, athanor, adept, researcher, scout, search, zathras" has no planner/attacker/reviewer. There is no `## Build` section, though implementation:82 reads it. The field is called "Verification commands", not Gate/Tests. "Legacy: `plugins/g4b_ai/` still exists (… being phased out)".
+- `skills/research/SKILL.md:121`: "Which model to use — out of scope" right below its own model table (`:26-30`). Same at `research-tree:100`.
+- `agents/researcher.md`: three fetch caps, "at most 3–5" (`:23`), "1–3 key sources" (`:30`), "at most **5** … hard cap" (`:36`).
+- `skills/research/SKILL.md:59-63`: MCP server names (`@anthropic/fetch`, `markdownify`, `jina-reader`) that are not verified.
+- `skills/init/SKILL.md:219,226`: the adept template frontmatter has two `status:` keys (`generated` and `active`).
+- `skills/adepts/SKILL.md:9-10`: "should pre-approve the command at load time". The gremlins work found that `allowed-tools` did *not* pre-approve in a subagent (`gremlins/SKILL.md:27`, P0.8).
+- `athanor.md:60` and `implementation:87`: two paragraphs on superpowers, which the user no longer runs, loaded at every Athanor start to say it is "not part of the loop".
+
+## 3. Duplication
+
+| Rule | Where (file:line) | Count |
+|---|---|---:|
+| Igor delegates / "work vs conversation" | igor SKILL 15–21, 29, 54, 65, 67, 186; mindset 19, 25–29; zathras 21 | ~9 |
+| Stamp the model id / check the stamp | igor 93; model-tiers 39; spawning 20; implementation 53, 68; run-log 9, 37; athanor 45; planner 34; attacker 40; reviewer 37 | 11 |
+| Pinned → omit `model`, unpinned → pass alias, no Fable | igor 93; model-tiers 35–40; spawning 18–19, 47–49; athanor 45; models.md 31; (contradicted: zathras 74) | 6 |
+| Leaf briefs "do this yourself; do not dispatch" | igor 181; harness-notes 12; spawning 21; implementation 67; athanor 46; zathras 74; model-tiers 33; research 111; planner/attacker/reviewer | 11 |
+| Gate between blocks, tests once per phase | igor 99; implementation 18, 41; athanor 33–34; attacker 32; init 72–73; project template 27–28 | 7 |
+| Review: answer every flag, hunt weakened checks / tests that cannot fail, list unplanned additions | igor 99; implementation 54–55; reviewer 22–24; athanor 34; run-log 54 | 5 |
+| One fix pass, re-check only Critical/Important, stop | igor 104–105, 177; implementation 19, 56–57; athanor 40; reviewer 29–31; superpowers 20 | 7 |
+| Separation of roles | igor 101; implementation 22; planner 15; attacker 15; reviewer 16; athanor 51; model-tiers 11–13 | 7 |
+| Attack checklist | implementation 26–28; attacker 19–25; igor 99 | 3 |
+| Code in a plan only where its form is the decision | implementation 34; planner 29; attacker 33; superpowers 21 | 4 |
+| Times from `date`, not feel | igor 174; implementation 76; run-log 7–8; journal-template 14 | 4 |
+| Agents write their own reports | igor 173; athanor 54; zathras 82; model-tiers 21 | 4 |
+| Goals read-only | igor 178; athanor 53; zathras 86 | 3 |
+| Notifications = turn ending | igor 180; harness-notes 9; spawning 22 | 3 |
+| Research agent tiers and fetch caps | research 26–32, 49; model-tiers 8–10; igor 79–81; researcher 23/30/36; search 38; scout 33 | 6+ |
+| Athanor furnace metaphor | igor 34, 91; athanor 4–6, 21; zathras 15; README 32 | 6 |
+| Adept folder tree | adept.md 114–131; init 181–198 (→ adepts/CLAUDE.md, read at genesis) | 2 |
+| Delegation table | igor 77–89; model-tiers 5–17; zathras 65–72 | 3 |
+
+Inside the planner/attacker/reviewer bundles, the agent body restates rules that are also in the preloaded implementation skill, so each agent reads the same rule twice per start.
+
+## 4. Steering risk
+
+The user's earlier finding is that a single sentence steers Opus 5.5 strongly. These sentences most likely push toward over-building, over-verifying or audit-style notes.
+
+**Toward audit-style review and long notes**
+1. `agents/reviewer.md:22`: "Answer **every** deviation and flag in the run log's handoff notes, one by one." This is reinforced at `implementation:54` and `igor SKILL:99` ("it answers every handoff flag"). Together with item 2, the review turns into a point-by-point audit, and its length follows the builder's flag count, not the risk.
+2. `references/run-log.md:54`: "Flags for the reviewer: every deviation and every 'flagged for review' line above, one per bullet". `:41` invites "anything the reviewer should look at". Builders flag freely and reviewers answer each one.
+3. `references/run-log.md:37-44`: eight fields per block (model, start/end `date`, done, deviations, flagged, left for later, expected broken, commits), plus a Tokens column, provisional status and "Not run / untested". The branch adds usage tables. Nothing caps the length.
+4. `agents/reviewer.md:23`: "**Hunt** weakened checks … and tests that cannot fail". "Hunt" invites a search that keeps going until it finds something.
+
+**Toward over-building (scope)**
+5. `agents/attacker.md:25`: "Missing function: a thing planned that does nothing, a path with no way back (onboarding without offboarding), error handling, security." This asks the attacker to add scope, against its own `:33` "Scope cut back to the goal". It is probably the strongest single scope-widener in the cycle.
+6. `agents/attacker.md:23` / `implementation:26`: "consumers of changed semantics … other readers, stats, migrations, callers in other crates". Useful, but with no stopping rule.
+7. `agents/planner.md:26`: "within a phase, **steps** with a completion criterion each". `models.md:17` already notes that 5.5 plans ran ~11× larger, yet planner.md has no size cap.
+8. `research-tree:41`: "List every sub-topic you can think of, even ones that feel redundant."
+
+**Toward over-verifying**
+9. `igor SKILL:93`: "check the stamped id before acting on the result; if it is not the intended model … re-dispatch". The stamping rule appears 11 times across the bundles (§3).
+10. `athanor.md:34`: "read the fix's diff for loosened assertions or deleted checks before you report green". This is the reviewer's job, done a second time by the builder. The branch makes it a mechanical per-block grep (`git diff … | grep -c '^-.*assert'`).
+11. `implementation:62-63`: "If you cannot write the failing test, keep investigating" plus four exploration acts before any bug fix ("Skip this for obvious bugs" helps).
+12. `igor SKILL:187`: every wrap-up runs adept handoffs, accretion, and graduation candidates. `mindset`/`igor:61`: "**Best over fastest.**" pushes toward thoroughness over speed in general.
+13. `adept.md:81`: refresh `handoff.md` after every state-changing consultation, plus journal entries and `search` dispatches ("Don't guess").
+
+**Sentences that are missing (would push toward small and simple)**
+- No size limit for plans, build plans, run logs, review reports, session journals or the Athanor's deliverable. The only caps in the plugin are adept `handoff.md` ≤ ~40 lines, adept `CLAUDE.md` ≤ ~60 lines, docs split at ~200 lines, and trunk notes "a page".
+- No "the smallest change that meets the goal" or "prefer deleting to adding" for planner, attacker or builder.
+- No "happy path first; edge cases only where the plan names them."
+- No reviewer rule like "report findings only; do not list what you checked and found fine; an empty section is omitted."
+- No "flag only what you are unsure of; 'none' is the normal answer" for handoff notes.
+- No cap on tests added per block, and no "a test per behaviour the plan names, not per branch."
+- The attacker has no "cutting is the main job; adding a function needs the goal to require it."
+
+## 5. Sweet-spot options
+
+Options for discussion, not decisions. The target sizes are rough and assume the content classes above.
+
+### Igor boot (now ≈ 6.3k words / 8.2k tok)
+
+- **Option I-1, lean (≈ 2.2–2.6k words / ~3k tok).** Persona in two lines, one flourish rule, no examples. Delegation stated once with the line test (code, commands or artifacts → delegate). Drop mindset.md from boot and keep "Orienting is not deciding" as one bullet. One delegation table: delete model-tiers.md or turn it into the only table. One adept spawn template with a variant line. The cycle as stage list plus decision tree (~250 words), pointing to implementation for detail. Replace the workpad preload with a 150-word placement card (folders, `YYYY-MM-DD-hh-slug`, stage→folder), since Igor delegates the writing. Remove the history and Pinky.
+- **Option I-2, moderate (≈ 4k words / ~5.2k tok).** Keep the Voice section but cut it to ~150 words and keep workpad preloaded. Remove only the duplicates (delegation ×8, model rules, notification rules) and the stale fork and Pinky lines.
+- Either way: fix the injected project.md (agent list, a `## Build` section), drop the adepts dev comment, and fix the zathras model contradiction.
+
+### Athanor start (main ≈ 6.1k words / 7.9k tok; branch ≈ 11k / 14.3k)
+
+- **Option A-1, lean core (main ≈ 1.8–2.2k words; branch ≈ 3.5–4k).** athanor.md at ~500 words: procedure plus keepers, no furnace description, no superpowers, no fork step. A "builder core" excerpt of implementation (~400 words: build-phase rules, deviation logging, project settings) instead of the whole skill. The run-log template cut to ~200 words: block row, a handoff note of Done / Deviations / Flags (default "none") / Commits, and a phase close. The spawning reference split into a ~250-word rules card (preloaded or mandated) and the claim tables on demand. No workpad preload, because the brief and the run-log template give the paths. On the branch: split gremlins into a core of ~800–1000 words (setup, the call sequence, waiting, failure → action) and an on-demand results/flags reference, and strip the finding IDs.
+- **Option A-2, keep structure (main ≈ 4k).** Keep the skills preloaded but delete the duplicates (stamp ×4, leaf ×3, fork, superpowers paragraph) and cap the run log ("a handoff note is at most 8 lines").
+
+### Planner / attacker / reviewer (now ≈ 3.8–3.9k words each, 7–8% their own)
+
+- **Option P-1, self-contained (≈ 500–800 words each).** Each agent body carries its whole procedure: planner as now, attacker as now minus "Missing function", reviewer as now. Add a ~200-word shared "cycle contract" (roles, gate/test cadence, severity grades, where outputs go), duplicated on purpose or put in a tiny `spire:cycle` skill. Preload neither workpad nor implementation, because the brief names the output path. That makes each start about 5–7× smaller.
+- **Option P-2, preload a slim implementation.** Shrink implementation itself to ~700 words (move Bugs, Context and Composition into references), keep the preload, and drop the agent-body restatements.
+- Either way, add size and simplicity sentences: planner "a plan fits in ~N lines; cut anything the goal does not need"; attacker "cutting is the main job; added scope needs the goal to require it"; reviewer "findings only; answer a handoff flag only when it hides a finding; no 'checked, fine' lines".
+
+### Read-only agents (scout/search/researcher)
+
+- About 100–200 words each would do: the budget, the output form, the fetch cap (one number). Drop the tool lists and the "you do not have the Agent tool" paragraphs, which the tool restriction already enforces.
+
+### Order of savings (rough, per start)
+
+1. Stop preloading workpad where the brief gives the path: −1.8k words in each of 6 bundles.
+2. Stop preloading full implementation into planner/attacker/reviewer: −1.4k words each.
+3. Cut Igor persona, mindset and delegation repetition: −1.2 to −1.8k words at boot.
+4. Split spawning and gremlins into a core card plus on-demand tables: −1 to −2.5k on the branch Athanor.
+5. Remove stale and contradicting lines (fork, Pinky, zathras model rule, project.md): small in words, large in steering.

docs/workpad/reports/2026-10-17-gremlins-mvp-build.md

@@ -0,0 +1,97 @@
+# Gremlins MVP: build report
+
+- Date: 2026-10-16/17 · Orchestrator model: claude-opus-5-5 · Gremlin model: claude-opus-5-5 (all calls)
+- Branch `gremlins-mvp` (worktree `.claude/worktrees/gremlins-mvp`), from `main` at `b8affd8`. Not pushed, not merged.
+- Spec: [`2026-10-17-00-gremlins-mvp-spec.md`](../plans/2026-10-17-00-gremlins-mvp-spec.md). Tool: the prototype at `.claude/worktrees/headless-forks/plugins/spire/skills/gremlins/gremlins.py`, unmodified.
+- Wall time: about 21 minutes, 23:12:58 to 23:33:35, against a 90-minute timebox. Fallback: **not needed**; the prototype did not misbehave once.
+
+## How it ran
+
+One base (B1) was trained on the spec, the verdict and the prototype source. It wrote no code. It wrote 70 lines of trunk notes, which pinned every cross-module seam: signatures, return shapes, the state-dir layout, the ledger and record keys, and its own decisions where the spec was open. Then eight gremlins were forked from B1, at most two running at a time (`spawn --mode parallel --paths …`, then `wait --any` / `--all` with Bash timeout 600000):
+
+1. Wave 1: `stream` + `launch`, then `store` + `call`, each pair started as soon as a slot freed up. Committed in `aff29d6`.
+2. Wave 2: `cli` + `entry`. `entry` is `gremlins.py` plus SKILL.md. Committed in `9209e7d` and `fd75777`.
+3. Wave 3: `tests-unit` (started in `entry`'s freed slot, since it does not depend on cli), then `tests-cli`. Committed in `d662790`.
+4. Integration fix: `79df026`.
+
+Every gremlin finished `ok` on its first attempt. No gremlin needed a follow-up turn, and none touched another gremlin's files. Each one wrote a note that listed every function with its box.
+
+## Gremlin metrics (from the prototype's results and ledger)
+
+| Gremlin | Module | Wall s | Cost delta $ | Cache | Cache read | Lines written |
+|---|---|---|---|---|---|---|
+| base B1 (train) | trunk notes only | 407.8 | 1.9725 | n/a | 1,085,902 | 0 code (70 notes) |
+| stream | `grm/stream.py` (+`__init__.py`) | 104.3 | 0.5175 | hit | 924,301 | 215 |
+| launch | `grm/launch.py` | 66.7 | 0.4196 | hit | 783,210 | 182 |
+| store | `grm/store.py` | 62.2 | 0.3815 | hit | 903,383 | 116 |
+| call | `grm/call.py` | 80.0 | 0.4198 | hit | 908,838 | 86 |
+| cli | `grm/cli.py` | 230.2 | 1.2211 | hit | 1,667,879 | 359 |
+| entry | `gremlins.py`, `SKILL.md` | 52.2 | 0.3836 | hit | 916,241 | 14 + 54 |
+| tests-unit | `tests/test_{store,launch,stream,call}.py` | 80.0 | 0.5441 | hit | 834,361 | 218 |
+| tests-cli | `tests/fake_claude.py`, `tests/test_cli.py` | 197.3 | 1.1388 | hit | 1,982,799 | 275 |
+
+- Base cost: $1.9725. The eight spawns together cost $5.0260. Build total (prototype `usage`): **$6.9985**, 9 calls, 0 cold starts, 8 of 8 cache hits.
+- The live smoke of the MVP cost another $0.2204 (4 calls). That brings the grand total to about **$7.22**.
+
+## Final line counts against the spec's estimates
+
+| Module | Lines | Estimate | Reason for the difference |
+|---|---|---|---|
+| `grm/store.py` | 116 | 70 | docstrings; `init_state` and `SUBDIRS` added (trunk decision) |
+| `grm/launch.py` | 182 | 110 | the kept scrub constants and the tool lists; `binary_version` added |
+| `grm/stream.py` | 215 | 170 | `iso`/`parse_iso` moved here; `TOKEN_KEYS`; `mismatch` kept (4 lines, not used) |
+| `grm/call.py` | 86 | 60 | feeder and reader threads; the child is killed if `on_start` raises; a second signal escalates to `kill()` |
+| `grm/cli.py` | 359 | 200 | `delta_header` verbatim (~25); JSON argparse errors (~30); explicit job, ledger and base dicts (~40); status; docstrings |
+| `gremlins.py` | 14 | (in cli) | |
+| **Code total** | **972** | **610** | The verdict estimated 600–800. No failure path was dropped, and nothing outside spec §4 was built. |
+| `tests/` | 493 | about 300 | per-file boilerplate; the fake has 7 scenarios; B4 needs a subprocess and per-platform signalling; one extra test (below) |
+| `SKILL.md` | 54 | not in the spec | see Deviations |
+
+## Test and smoke results
+
+- **Unit tests:** `uv run --no-project --python 3.12 python -m unittest discover -s tests`, run from the skill dir: **24 tests, OK, 7.0 s.** That is 14 module tests and 10 CLI tests, which cover every §6 case from B1 to B8.
+- **Live smoke** (MVP; real `claude.exe` 2.1.299; scratch git repo; model `claude-opus-5-5`):
+  - `init`: `run.json` was written with the fingerprint, the argv and `fp_hash`, and a frozen preamble copy was made.
+  - `train B1`: `ok`, 5.0 s, $0.0969, session id taken from `--session-id`.
+  - `spawn s1`: `ok`, **`cache: hit`** (69,651 tokens read, 1,664 written), 36.5 s, cost delta $0.0431, `base_state: warm`. The note was written and the repo was left untouched.
+  - The ledger had **two lines**, each with `model`, `models_used`, six token columns, `cost_delta_usd`, `cost_cumulative_usd` and `hit_at`.
+  - `status`: B1 `warm`, `ttl_s` 3600, `ttl_left_s` 3566.
+- **Parallel test (B3):** two `spawn`s, p1 and p2, ran as separate Bash `run_in_background` calls. Both started at 23:30:33 and ended at 23:30:44 and 23:30:45. Both completion notices arrived with the result JSON and exit 0, and both reported `cache: hit`. The run ended with two new job files, two new whole ledger lines (four in total) and two notes.
+- **Processes afterwards:** `Get-CimInstance Win32_Process` shows no `claude -p`, `python` or `uv` process left. The only `claude.exe` processes are the Desktop app and its own sessions. The prototype's `list` showed nothing running, and `expire --all` retired its base B1, so no keep-warm ping can fire later.
+- **Not run live:** the B4 `TaskStop` on a backgrounded `spawn` (spec §5 step 4), a B7 `rebase`, and the B8 gate on WSL. These paths are covered only by the fake-claude tests: CTRL_BREAK to the helper subprocess, and rebase argv and session id.
+
+## Deviations from the spec, each with its reason
+
+1. **`SKILL.md` was added**, although it is not in the module table. Reason: B3 and B4 only work if the orchestrator is told to run `spawn` via `run_in_background` and to stop it with `TaskStop`, and the skill file is where it is told.
+2. **`templates/rebase.md` was reworded** ("a fork … becomes the new base `${new_base}` (phase …)" became "base `${base}` itself, resumed"). cli stopped passing `new_base` and `phase`. Reason: §3 said to use the templates as is, but the old text contradicts B7, which resumes without a fork and keeps the same base. The cli gremlin flagged it, and the fix is in `79df026`.
+3. **`spawn.md`:** `${commit_rule}` became the fixed line "Commit only if the brief below says so", and `${mode}` was removed. This is per spec §3; the fixed line is so that the rule is still visible.
+4. **Trunk-note decisions where the spec was open:**
+   - `build_fingerprint` takes `mcp_config` and returns `{fingerprint, argv, fp_hash}`.
+   - The argv builders take the stored run dict, so that a test's fake `argv` is honoured.
+   - `resume_argv` has no `--session-id`, because claude refuses it on a resume without a fork.
+   - The fingerprint adds `allowed_tools` and `disallowed_tools`, because `dontAsk` denies every tool that is not allowed.
+   - `resolve_binary` returns a str, not the prototype's tuple.
+5. **`models_used` is ordered by usage, largest first**, not by name. Reason: by name, a haiku side-call could become `model` (= `models_used[0]`).
+6. **The ledger line adds `hit_at`.** Reason: B6 derives warmth from the ledger, and the line's `ts` is the end of the call, not the time the cache was read.
+7. **Job ids:**
+   - train is `<B>-train`; it can be re-run only while there is no base file.
+   - rebase is `<B>-rebase<n>`; a failed rebase re-run overwrites its own job and raw files.
+   - spawn takes `--job J`, and an existing J is refused.
+8. **The base's `cost_cumulative_usd` is stored unrounded.** Ledger and printed costs are still rounded once, at 6 decimals. Reason: a rounded basis made the deltas drift by 1e-6 (0.020001 instead of 0.02).
+9. **`StreamState` prefers the result's `session_id` over the init event's.** Reason: spec §7, B7.
+10. **Exit codes are 0 / 1 / 2:** 0 ok, 1 a call that ended `error` or `stopped`, 2 refused. `status` refuses a run with no `run.json`.
+11. **No `SPIRE_GREMLIN_CHILD` refusal.** Reason: no box needs it, and it would break the helper's own tests when they run inside a gremlin.
+12. **One extra test**, `test_call.test_tee_and_parse`. Reason: it is the only check that the prompt goes in on stdin as UTF-8 and that the stream is teed to the raw file and parsed.
+
+## Observations on the dogfooding
+
+- The prototype raised `rebase_due: phase_boundary` on every wave-2 and wave-3 spawn, because `--phase` was used as a wave label. The flag is advisory, so it was ignored. The delta header gave the forks the new commits instead.
+- The trunk notes were what made the parallel work fit together: four modules written blind against each other imported cleanly on the first try. The only integration fix was the template wording.
+- Each fork read 0.8 to 2.0 M tokens from cache, at about $0.38 to $1.22 per module. The base's $1.97 was spent once.
+
+## Open items
+
+- Live B4 check: a `TaskStop` on a backgrounded MVP `spawn`.
+- Live B7 check: does a plain `--resume` report a cumulative `total_cost_usd`? The cost basis assumes it does.
+- The B8 gate on WSL.
+- Cross-process ledger appends on Windows are not strictly atomic (CRT seek + write). This is accepted per the trunk notes. The live parallel run gave whole lines.

docs/workpad/reports/2026-10-17-gremlins-mvp-review.md

@@ -0,0 +1,82 @@
+# Gremlins MVP: phase review
+
+- Reviewer model: **claude-opus-5-5[1m]** · Date: 2026-10-16 · Branch `gremlins-mvp` @ `0493f03` · Timebox 15 min
+- Scope: `plugins/spire/skills/gremlins/` against the [spec](../plans/2026-10-17-00-gremlins-mvp-spec.md) and the [build report](2026-10-17-gremlins-mvp-build.md)
+- Gate: `uv run --no-project --python 3.12 python -m unittest discover -s tests` gave **24 tests, OK, 7.0 s**, the same as the build report. No live `claude` calls in this review.
+
+## 1. Boxes
+
+| Box | Verdict | Evidence | Verified by |
+|---|---|---|---|
+| B1 | ticked | `cli.py:226-247` train with `--session-id` (`launch.py:172`); fingerprint stored once in `run.json`, overwrite refused `cli.py:202`; `launch.py:139-169` | live smoke + `test_cli` happy/missing_binary/train_failures, `test_stream` |
+| B2 | ticked | `launch.py:176-177` stored argv + `--resume --fork-session --session-id`; `cli.py:250-269`; `cache_verdict` `stream.py:178` | live smoke (`cache: hit`) + `test_launch`, `test_cli` happy/unknown_base/cache_miss |
+| B3 | ticked | no detach/supervisor code anywhere; one job file per job `cli.py:134`; ledger append `store.py:85` | live (two `run_in_background` spawns) + `test_parallel_spawns`, `test_store` |
+| B4 | partly | no `kill` command; handler `call.py:53-66` (SIGTERM/SIGINT/SIGBREAK, second signal kills) | unit only (`test_call` SIGTERM, `test_cli` CTRL_BREAK). Spec §5 step 4 live `TaskStop` on an MVP spawn **not run** |
+| B5 | ticked | `stream.py:141-175` (models by usage, six token columns, delta rounded once); ledger line `cli.py:174-181` | live smoke (two ledger lines) + `test_stream`, `test_usage_models_and_cost` |
+| B6 | ticked | `_warmth` `cli.py:119-126` derived from ledger `hit_at`; `stream.py:206-215`; no ping code | live `status` (warm, ttl_left 3566) + `test_stream` cold/5m/expiring, `test_status_cold_without_hit` |
+| B7 | partly | `cli.py:272-298`, `launch.py:180-182` (no fork, no `--session-id`), session id from result `cli.py:294`, running-jobs warning `cli.py:278-280` | unit only (fake). Not run live; the cumulative-cost basis after a plain resume is an open assumption |
+| B8 | partly | only portable `Popen.terminate/kill` + `getattr(signal,"SIGBREAK")` `call.py:11`; scrub `launch.py:88-103` | `test_launch` scrub test. Spec §5 step 6 non-Windows gate **not run** |
+
+## 2. Unrequested surface (list only; J = the build report justifies it)
+
+| # | Where | What | J |
+|---|---|---|---|
+| 1 | `store.py:10,25-30` | `SUBDIRS` + `init_state` | J |
+| 2 | `store.py:10`, `cli.py:136` | `briefs/<J>.md`: full prompt written per job | - |
+| 3 | `store.py:91-97` | ledger torn-last-line repair before append | - |
+| 4 | `store.py:14,98` | in-process `threading.Lock` around ledger append (spec: "without locks") | - |
+| 5 | `launch.py:10`, `cli.py:211` | `MODEL_RE`: aliases refused at `init` | - |
+| 6 | `launch.py:11`, `cli.py:330` | `EFFORTS` choices; default effort `high` | - |
+| 7 | `launch.py:13-15,158-161` | fixed tool list, `allowed_tools`, `disallowed_tools` (incl. `Bash(claude:*)`, `git push/rebase/reset --hard`) | J (fields); deny list itself not |
+| 8 | `launch.py:41` | `SPIRE_GREMLIN_CHILD=1` still pinned into the child env although the refusal was dropped | partly (dev. 11) |
+| 9 | `launch.py:36-40,65` | `SCRUB_KEEP`/`"keep"` class: no behavioural effect (keep and unlisted both pass) | ported per §3 |
+| 10 | `stream.py:13-27` | `iso`/`parse_iso` in stream | J |
+| 11 | `stream.py:43,56-58,127-128` | `refused` + `model_refused` status case (not in spec's `classify` tuple) | - |
+| 12 | `stream.py:34,36-37,44,73-75` | `init`, `msg_ids`, `_ids`, `events`, `turns`: tracked, never read | - |
+| 13 | `stream.py:165-167,174` | `mismatch` computed, never read | J |
+| 14 | `stream.py:200-203` | `wrote_only_5m`: listed in §3, never called | (spec) |
+| 15 | `cli.py:180` | ledger field `hit_at` | J |
+| 16 | `cli.py:16,87-90` | `NAME_RE` validation of base/job names | - |
+| 17 | `cli.py:17,163-167` | note detection by file mtime with 2 s slack | - |
+| 18 | `cli.py:22-32,355-357` | `Refusal` / JSON argparse errors; `ValueError`/`OSError` mapped to exit 2 | J |
+| 19 | `cli.py:359` | exit codes 0/1/2 | J |
+| 20 | `cli.py:231,255` | train refuses existing base; spawn refuses existing job | J |
+| 21 | `cli.py:281,291-293` | rebase job id `<B>-rebase<n>`; `rebases[]` entries `{job, at, from_commit, from_session}` | J (ids) |
+| 22 | `cli.py:258,269` | spawn output `base_state`, computed before the call | - |
+| 23 | `cli.py:208` | `init` defaults cwd to the git toplevel | - |
+| 24 | `cli.py:214-217` | frozen preamble copy + `mcp-empty.json` in the state dir | J (mcp) |
+| 25 | `call.py:48` | stderr to `raw/<J>.err` | - |
+| 26 | `call.py:10,83-85` | reader join timeout 10 s (orphan holding stdout) | - |
+| 27 | `call.py:56-57` | second signal escalates to `kill()` | J |
+| 28 | `call.py:42` | `ss=None` injection parameter, used by no caller | - |
+| 29 | `SKILL.md` | the skill file | J |
+| 30 | `tests/test_call.py:24` | `test_tee_and_parse` | J |
+
+**30 items, 15 justified (J or partly) by the build report, 15 not.** None looks like a bug. Most are a few lines; #2, #3, #11, #12, #17 are the ones that add real behaviour.
+
+## 3. The 972 vs 610 gap
+
+Measured with `ast` (docstrings), blank, comment and import lines:
+
+| Module | Est. | Actual | Blank | Doc | Cmt | Import | Logic | Where the logic surplus goes |
+|---|---|---|---|---|---|---|---|---|
+| `store.py` | 70 | 116 | 23 | 8 | 0 | 7 | 78 | `init_state`, torn-line repair, lock (#1, #3, #4) |
+| `launch.py` | 110 | 182 | 31 | 9 | 6 | 7 | 129 | scrub constants as estimated; plus tool lists, `binary_version`, `build_fingerprint` re-validating what `cmd_init` already checks (`launch.py:141-150` vs `cli.py:205-212`) |
+| `stream.py` | 170 | 215 | 28 | 17 | 0 | 4 | 166 | on estimate; dead `wrote_only_5m`/`turns`/`mismatch` (~12) offset by a compact `classify` |
+| `call.py` | 60 | 86 | 9 | 4 | 0 | 6 | 67 | two threads, kill escalation, join timeout |
+| `cli.py` | 200 | 359 | 52 | 15 | 0 | 11 | 281 | multi-line dict literals for job/ledger/base (~35); `delta_header` + git helpers (~35, spec counted it "as is"); `_execute` hit/note/excerpt logic (~15); duplicated init validation (~8); `Refusal`/`_Parser` (~12, not the ~30 the build report says) |
+| `gremlins.py` | (cli) | 14 | 3 | 1 | 4 | 3 | 3 | PEP 723 header |
+| **Total** | **610** | **972** | 146 | 54 | 10 | 38 | **724** | |
+
+Form (blank, docstring, comment, import) is **248** of the 362 extra lines. Logic is 724 against 610, so +114 (+19%), and 81 of that is in `cli.py`. That surplus is mostly verbose layout (dicts written over several lines, duplicated validation) plus the small additions in §2. Only `call.py`'s threads and `_execute`'s hit/note logic are real logic the spec underestimated. **Verdict: mostly form.** The substance is within the verdict's 600–800 band.
+
+## Handoff flags answered
+
+- Dev. 1 (SKILL.md): accepted; B3/B4 need the orchestrator to be told. Dev. 2 (rebase.md wording): correct, the old text contradicted B7. Dev. 3: per §3.
+- Dev. 4–6, 8, 9: consistent with the code and tests (`test_cli` happy checks the unrounded basis to 6 places). Dev. 7, 10: as implemented. Dev. 11: the refusal is gone but the env var is still set (#8). Dev. 12: justified, and the only test that covers stdin and the tee.
+- Open items (live B4/B7/B8, Windows append atomicity): still open. These three boxes are "partly", not failures.
+- Weakened checks / tests that cannot fail: none found. On Windows `test_stop_signal` sends CTRL_BREAK to a process group that includes the fake child, so it cannot tell the helper's `terminate()` apart from the child dying on its own. `test_call.test_sigterm_stops_child` (in-process `raise_signal`) does isolate the handler path.
+
+## Bug (one line)
+
+No real bug noticed. The nearest is harmless duplication: `init` validates model, binary and cwd twice (`cli.py:205-212`, `launch.py:141-150`).

plugins/spire/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "spire",
-  "version": "0.3.0",
+  "version": "0.2.2",
   "description": "Spire — an agent orchestration system for structured development. Session coordination (Igor), domain knowledge (adepts), dispatching (athanor), workpad, research, and implementation governance. Knowledge navigation via the separate tome plugin (opt-in).",
   "author": {
     "name": "Gabor Körber",

plugins/spire/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "spire",
-  "version": "0.3.0",
+  "version": "0.2.2",
   "description": "Spire — an agent orchestration system for structured development. Session coordination (Igor), domain knowledge (adepts), dispatching (athanor), workpad, research, and implementation governance. Knowledge navigation via the separate tome plugin (opt-in).",
   "author": {
     "name": "Gabor Körber",

plugins/spire/README.md

@@ -18,7 +18,6 @@ Replaces `g4b_ai`.
 | `research-tree` | Multi-topic research as a dependency tree of parallel phases. |
 | `research` | Research governance — bounded agent spawning, web fetch budgets. |
 | `implementation` | Lean implementation — attack the plan against the code, build in phases, one review per phase. |
-| `gremlins` | Trained headless implementer forked per block: the base, its gremlins, cache and usage bookkeeping. Windows-tested; other platforms fail closed until tested (see the skill's Platforms section). Loaded by the Athanor. |
 | `svg` | SVG diagram placement and referencing in markdown. |
 
 ### Agents

plugins/spire/agents/athanor.md

@@ -6,55 +6,42 @@ description: >
   is the colloquial shorthand for handing it a build. Build furnace pinned to
   Opus 5.5 that may use the Agent (Task) tool and run its own subagents.
   Dispatched by Igor (or the user) with a reshaped build plan: it builds one
-  phase per turn — trains a headless base and spawns gremlins for complex
-  blocks, fresh agents for mechanical ones, a cheap gate between blocks, tests
-  once, a run log with usage — and hands back. It does not plan, attack plans,
-  or review its own output. Also takes non-build multi-part briefs (research
-  cascades, broad audits).
+  phase per turn — blocks in the foreground, a cheap gate between blocks,
+  tests once, a run log with handoff notes — and hands back. It does not plan,
+  attack plans, or review its own output. Also takes non-build multi-part
+  briefs (research cascades, broad audits).
 model: claude-opus-5-5[1m]
 tools: "*"
 skills:
   - spire:project
   - spire:workpad
   - spire:implementation
-  - spire:gremlins
 ---
 
 You are the **Athanor** — the alchemist's slow furnace. You ARE the oven; plans go into you and forged implementations come out. Igor (or the user) loads you with a build plan, closes the door, and waits. You do not talk to the user, you do not surface partial results, you do not ask mid-run; if the brief is unworkable, say so once at the end. You run your own subagents via the Agent (Task) tool. "Fire up the Athanor" and "into the Athanor with it" mean you.
 
-Project-specific knowledge is loaded by the `spire:project` skill at agent startup. Read it before intake. If the project has the `tome` plugin installed, use `tome:navigate` for deeper orientation; otherwise orient by reading plans, designs, reports and notes, not code.
+Project-specific knowledge is loaded by the `spire:project` skill at agent startup. Read it before intake. If the project has the `tome` plugin installed, use `tome:navigate` for deeper orientation; otherwise orient via direct file reads.
 
-The `spire:implementation` skill is how you work. Its references hold the run-log template (`references/run-log.md`), harness mechanics (`references/spawning-claude-code.md`) and model notes (`references/models.md`). The `spire:gremlins` skill is the helper you build complex blocks with: its commands, its JSON and the rules you follow on its flags.
+The `spire:implementation` skill is how you work. Its references hold the run-log template (`references/run-log.md`), harness mechanics (`references/spawning-claude-code.md`) and model notes (`references/models.md`).
 
 ## One phase per turn
 
 The plan you receive has already been attacked and reshaped into phases and blocks. Each turn you build one phase and hand back.
 
-1. **Intake.** Read the build plan, the design, the run log so far, the trunk notes and the last review. Check you are on the branch the brief names; stop if not. Then run `where` first (the report `spire:gremlins` injects, or the command itself):
-   - **`where` not ok** (Windows-tested; other platforms fail closed until tested, see `spire:gremlins`, Platforms): fresh agents for every block, even when the run log names a state dir. At the first phase a fresh agent reads the code the blocks change and writes the trunk notes; you still do not read code. Header line `Gremlins: none: <reason>`.
-   - **`where` ok and the run log header has a `Gremlins:` line**: run `list` and adopt the active base. Never re-run `init`, never re-train an active base.
-   - **`where` ok, no `Gremlins:` line**: `init` (full model id = the plan's owner model for complex blocks; effort; the project's agent file if any), then `train` the base with a brief naming the plan, the design, the phase's blocks, the areas to read and the trunk-notes path, and `wait` for it. The base writes the trunk notes. Add `Gremlins: <state dir>` to the run log header.
-   - **Later phases**: `rebase --as B<n+1> --phase <n>` with the delta (handoff notes as `--delta-note`, review findings, commit range), then `wait`.
-2. **Build the blocks** in the plan's order. Each block goes to its owner.
-   - A complex block in the trained area → `spawn` from the current base with a delta brief: block id and plan section, the handoff notes since the base as `--delta-note`, open review flags touching the block, the mode, the gate and test commands. Then `wait` until it is done; read `notes/<block>.md` and the result.
-   - A mechanical or distant block → a fresh Agent-tool agent in the foreground with the trunk notes.
-   - A complex block whose owner model differs from the base's: a gremlin anyway (logged deviation) or its own base; never a model override (the helper refuses it).
-   - Obey `rebase_due` and `retrain_due` as `spire:gremlins` says. Sequential gremlins one at a time; parallel ones only for blocks the plan marks disjoint.
-3. **Gate between blocks.** The cheap check the plan or project config names (compile, typecheck), output to a `.txt` under the state dir's `logs/` (without gremlins: next to the run log). Not a review. Red → `continue --job <gremlin>` once with the log path; still red → flag it and go on per the plan's "what may stay broken". A fresh agent's red gate gets one fresh fix agent with the log.
-4. **Check, mechanically,** after each block: the commit is present (`git log --oneline`); the evidence log exists and is not empty; `git diff --numstat <range> -- <test paths>`; removed assertion lines `git diff <range> -- <test paths> | grep -c '^-.*assert'` (pattern `assert` by default). A non-zero count goes to the block's note as a question and into the reviewer flags.
-5. **Tests once**, at phase end. You run the test command to a file under `logs/`, never through `tail`; the first run after a fresh worktree is a warm-up, rerun once. Fallout → a gremlin from the current base (or `continue` of the block that caused it) with the failing log as the delta; without gremlins, a fresh agent. Parallel test runs stay off unless the project says they are safe.
-6. **Run log.** Block rows from `usage --block <id> --format md`; the handoff notes appended from `notes/` (fresh agents write theirs into the run log); the phase close with `usage --phase <n> --format md` (per-kind table, cold starts, hit ratio, priced total), the base state from `list`, and every deviation and flag listed for the reviewer.
-7. **Hand back** with nothing running: `list` shows no running job except pings. Do not `expire` the base: a review and fix pass within the TTL finds it warm, and later it is cold but still spawnable. Igor dispatches the phase review.
+1. **Intake.** Read the build plan, the run log so far, and the code the phase touches. That reading is your trunk. Check you are on the branch the brief names; stop if not. Write short trunk notes next to the run log so fresh agents, and a successor Athanor, can start from them.
+2. **Build the blocks** in the plan's order, in the foreground. Each block goes to its owner. A complex block in the area you just read can go to a fork of yourself (it inherits your model and, assumed, your context). A mechanical or distant block goes to a fresh agent that reads the trunk notes. Fork behaviour is partly unverified; see the spawning reference.
+3. **Gate between blocks.** The cheap check the plan or project config names (compile, typecheck). Not a review.
+4. **Tests once**, at phase end. Fix the fallout in that last block. A child's "tests pass" is a claim: read the fix's diff for loosened assertions or deleted checks before you report green.
+5. **Run log.** One handoff note per block, then the phase close with every deviation and flag listed for the reviewer.
+6. **Hand back.** Igor dispatches the phase review.
 
 The plan sets block size and owner model as defaults. You may deviate (split a block, change an owner, add a check) when the work calls for it; log the reason in the run log.
 
-When Igor resumes you with review findings: one fix pass over all of them, by gremlins of the current base with the findings as the delta (`rebase_due` decides whether to rebase first), commits, a note in the run log, hand back. When Igor resumes you for the next phase, start again at intake for that phase.
+When Igor resumes you with review findings: one fix pass over all of them, commits, a note in the run log, hand back. When Igor resumes you for the next phase, start again at intake for that phase.
 
 ## Dispatching
 
-- You call `gremlins.py` from your own Bash, with the `script` path `where` printed; every `wait` with `timeout: 600000` (and every `kill` and `expire`).
 - Sequential work runs in the foreground. Do not resume your children with `SendMessage`; their completion would go to the session root and you would stall. Dispatch a fresh foreground agent instead.
-- Never `SendMessage` or `TaskStop` a gremlin; `continue` and `kill` cover it.
 - Pinned agents: omit `model`. Unpinned agents: pass the owner's alias. Every agent stamps its model id in its handoff note.
 - Leaf briefs say "do this yourself; do not dispatch further agents."
 - If a plugin agent type is missing, use `general-purpose` with the agent's body in the brief.
@@ -62,9 +49,6 @@ When Igor resumes you with review findings: one fix pass over all of them, by gr
 ## Keepers
 
 - **You do not plan, attack plans, or review your own output.** Plans come in finished. Phase review is done by a fresh reviewer that Igor dispatches.
-- **You do not read code; the base and its gremlins do** (without gremlins, fresh agents). You read plans, notes, helper JSON, `git log --oneline`, `git diff --stat`/`--numstat` and gate summaries.
-- **Nothing running at hand-back.**
-- **One committer at a time.** A sequential gremlin commits its block by explicit paths after its gate passes. Parallel gremlins never commit; you commit each block by the paths its note lists, one at a time. A fresh agent commits like a sequential gremlin. You commit the run log and the state dir (except `raw/` and lock files) at phase close as `📝`.
 - **Closed door.** Undecided points get the conservative default, flagged in the handoff note. Never block on the user.
 - **Goals are read-only.** Never write, modify, or delete anything in the workpad `goals/` folder — only the user and Igor author goals. Your outputs go to `reports/`, `research/`, `plans/`.
 - **Agents write their own reports.** Every subagent gets an explicit output file path in the workpad. You read the finished files; you are not a copy-paste bottleneck.
@@ -73,7 +57,7 @@ When Igor resumes you with review findings: one fix pass over all of them, by gr
 
 ## Tools, not the loop
 
-Use what the harness and the project give you, by writing it into your briefs: a fail-first test inside a block, a look one layer up before fixing a stubborn failure, evidence (a log under `logs/`) before a gate or test result is claimed. Parallel gremlins or agents only for genuinely independent blocks. Superpowers is not part of the loop; if a brief asks for it, `spire:implementation` `references/superpowers.md` says which of its rules the lean rules override.
+Use what the harness and the project give you: a fail-first test inside a block, a look one layer up before fixing a stubborn failure, evidence before you claim a gate or test result, parallel agents only for genuinely independent blocks. Superpowers is not part of the loop; if a brief asks for it, `spire:implementation` `references/superpowers.md` says which of its rules the lean rules override.
 
 ## Non-build briefs
 
@@ -81,4 +65,4 @@ Research cascades and broad audits are allowed: decompose the brief, fan out, sy
 
 ## Deliverable
 
-Your final message is a report to your dispatcher, not the user: phase built or not, run log and trunk notes paths, commits, gate and test results, the priced usage totals (`usage --phase`), the base state (`list`: the active base and its warmth), the flags for the reviewer, deviations from the plan, and whether you have room left for the fix pass and the next phase.
+Your final message is a report to your dispatcher, not the user: phase built or not, run log and trunk notes paths, commits, gate and test results, the flags for the reviewer, deviations from the plan, and whether you have room left for the fix pass and the next phase.

plugins/spire/skills/gremlins/SKILL.md

@@ -1,120 +1,54 @@
 ---
 name: gremlins
-description: Trains one headless implementer (the base) per build and spawns gremlins from it, one per complex block, by forking the base's session (`claude -p --resume --fork-session`). Owns the command line, the prompt-cache bookkeeping and the usage ledger. Windows-tested; other platforms fail closed until tested (see Platforms). Loaded by the Athanor.
+description: Trains one headless implementer (the base) per build with `claude -p` and forks a gremlin from it per block, so each gremlin starts from the base's reading at prompt-cache prices.
 allowed-tools: Bash(uv:*)
 ---
-!`uv run "${CLAUDE_SKILL_DIR}/gremlins.py" where`
 
 # Gremlins
 
-## What and when
-
-The Athanor's build path for complex blocks. One **base** per build, trained early: a headless `claude -p` session that reads the code the build touches, writes the trunk notes and changes nothing. One **gremlin** per complex block: `spawn` (method `fork`) forks the base's session, so the gremlin starts from the base's reading at cache-read prices. Mechanical or distant blocks still go to fresh Agent-tool agents with the trunk notes.
-
-Words: `continue` gives a finished gremlin one more turn (it resumes, it does not fork); `rebase` forks the base to absorb what changed, and that session becomes a new base; a **ping** is a one-turn keep-warm call the helper launches by itself.
-
-The helper `gremlins.py` owns every `claude -p` command line, the registry, the cache bookkeeping and the usage ledger. You write briefs and read its JSON.
-
-Claude Code only. Codex loads this skill too; it does not apply there.
-
-## Platforms
-
-Windows-tested; other platforms fail closed until tested. On Linux, WSL and macOS `where` reports `ok: false` with the reason, `init` refuses, and on an existing state dir `train`, `spawn`, `continue`, `rebase` and `tick` refuse too (exit 2, `error: "platform not supported"`). Then use fresh agents for every block (the 0.2.2 shape). Do not try to work around it.
-
-## Setup
-
-- The report injected above is `where`'s. `script` is the helper's absolute path: use it in every call, `uv run "<script>" <command> …`. `ok: false` → Platforms, or the `reason`. No report above (the injection failed) → treat it as `ok: false`.
-- The project needs an allow rule `Bash(uv run:*)` (or `Bash(uv:*)`): this skill's `allowed-tools` did not pre-approve the calls in a subagent (P0.8, untrusted dir). Call plain `uv`; use `$SCRIPTS_UV` only on a host without `uv` on PATH.
-- `init --run <run log .md> --model <full id>` once per run, with `--effort` and `--agent <project agent>` where the plan names them. A successor never re-runs `init` to "reset": it runs `list` and adopts the active base.
-- An `init` re-run changes only the flags given, except that it re-resolves the claude binary through the source it came from, unless it was pinned with `--binary` (N3). Its `warnings` say when the binary changed or could not be re-resolved; existing bases keep their own binary.
-- `--warm-margin-s` must stay below the TTL (at 1 h, at most 1800 takes effect).
-- `--tools` does not re-derive the allow rules: pass `--allowed-tools` together with it.
+A **base** is a headless `claude -p` session that reads the code a build touches, writes the trunk notes and changes nothing. A **gremlin** is a fork of the base's session (`--resume <base> --fork-session`) that works on one block with a brief.
 
 ## Commands
 
-Every command except `where` takes `--run <run log .md>`. stdout is one JSON object (`usage --format md`: one markdown fragment); a refusal is `{"error": …, …}`. Exit codes: `0` ok; `2` usage error or refused; `3` `wait` condition not met at its timeout; `4` `wait` condition met and a job in it did not end `ok`.
+`G` = `uv run --script "${CLAUDE_SKILL_DIR}/gremlins.py"`. Every command prints one JSON object on stdout. Exit codes: 0 ok, 1 the call ended `error` or `stopped`, 2 refused or a usage error.
 
-| Command | Key flags | Returns |
+| Command | Does | Boxes |
 |---|---|---|
-| `where` | `[--binary B]` | `{script, python, uv, binary, git, scrub, platform, warnings, ok}` (+ `reason`, `error` and exit 2 when not ok) |
-| `init` | `--model`, `--effort`, `--agent`, `--cwd`, `--binary`, `--tools`, `--allowed-tools`, `--parallel-cap` (2), `--orphan-after` (1200), `--pings on\|off`, `--warm-margin-s`, `--max-minutes` (90), rebase thresholds | `{ok, state, registry, created, changed, changed_fields, bases, config, warnings}` |
-| `train` | `--base B --brief F [--phase N] [--block X] [--supersedes OLD]…` | `{job, base, session_id}` |
-| `spawn` | `--base B --block X --brief F --phase N [--method fork] [--mode sequential\|parallel] [--paths P…] [--delta-note PATH]… [--max-minutes M] [--max-budget-usd U] [--force]` | `{job, base, method, base_state, warm_until, rebase_due, retrain_due, reasons}` |
-| `continue` | `--job J --brief F [--max-minutes M]` (J is a `spawn` job) | `{job}` |
-| `rebase` | `--base B --as NEW --brief F --phase N [--delta-note PATH]…` | `{job, base, parent, session_id}` (`base` is NEW) |
-| `wait` | `--all` or job ids, `[--any] [--timeout S]` (default 540, max 570) | `{done[], running[], pings[]}` |
-| `list` | — | `{state, bases[], jobs[], running[], lost_now[]}`; base rows carry warmth, `trained_at` and the due flags |
-| `usage` | `[--block X \| --phase N] [--format json\|md]` | tokens and cost per kind, cold starts, cache-hit ratio, priced total |
-| `expire` | `--base B \| --all` | `{retired, bases, killed[], ok}` |
-| `kill` | `--job J` | `{job, killed, status, ok, snapshot, survivors, tree_kill_rc}` |
-| `tick` | — | one keep-warm pass `{state, pinged, bases}` (`wait` and the supervisors already tick) |
+| `G init --run R --model M [--effort E] [--cwd D] [--agent A] [--binary P]` | Writes `run.json`: the launch fingerprint (binary, full model id, flags, cwd, appended prompt) and the argv, stored once. Refuses to overwrite an existing run. | B1 |
+| `G train --run R --base B --brief F` | One blocking call with `--session-id`; on `ok` it writes `bases/B.json`. Prints `{status, session_id, cost, …}`. | B1 |
+| `G spawn --run R --base B --job J --brief F` | One blocking fork of B, reusing the stored argv verbatim. The prompt is the spawn template plus a delta header (git changes since the base's commit) plus the brief. Prints `{status, cache, note, cost, …}`. | B2, B3, B5 |
+| `G rebase --run R --base B --brief F` | Resumes B without a fork, with the delta header and the brief, then updates `bases/B.json` (the session id comes from the result). Warns when jobs of B are still `running`. | B7 |
+| `G status --run R [--job J]` | Bases with their warmth (`warm`/`expiring`/`cold`, `warm_until`, `ttl_left_s`), and the job records. | B6, B3 |
 
-A first phase, in calls (`G` = `uv run "<script>"`, `R` = `--run <run log .md>`; every `wait` with Bash `timeout: 600000`):
+`R` is the run log `.md`; `M` is a full model id (for example `claude-opus-5-5[1m]`; aliases are refused). The helper has no `kill`, `wait`, `ping` or `continue` command.
 
-```
-G init R --model claude-opus-5-5[1m] --effort high
-G train R --base B1 --phase 1 --brief <train brief>      → G wait R --all (until exit 0 or 4)
-G spawn R --base B1 --block 1.1 --phase 1 --brief <delta brief> --delta-note <notes>…
-G wait R --all                                           → read notes/1.1.md and the result
-G continue R --job <job> --brief <fix brief>             (only on a red gate, once)
-G usage R --block 1.1 --format md                        → the block's run-log row
-G usage R --phase 1 --format md;  G list R               → phase close; nothing running
-```
+## Call sequence
 
-Next phase: `G rebase R --base B1 --as B2 --phase 2 --brief <delta> --delta-note <notes since trained_at>…`, `wait`, then spawn from `B2`.
+1. `G init …` (foreground).
+2. `G train …` as a blocking Bash call with `timeout: 600000`. If it runs past the timeout, the harness moves it to the background, and the completion notice carries the result.
+3. Each `G spawn …` as its own Bash call with `run_in_background: true`. Several spawns run at once as several background calls. Read the result JSON from each completion notice; do not poll.
+4. `G status …` to see warmth before spawning again, or to re-read a job record.
 
-The helper treats `--phase` as optional; always pass it on `spawn` and `rebase` (it drives `phase_boundary` and `usage --phase`). `spawn`, `continue` and `rebase` refuse (exit 2) while `parallel_cap` jobs of those kinds run: `wait` first. `spawn` and `rebase` refuse a base that is not active; `spawn --force` overrides that.
+Every call is reported in `ledger.jsonl` with the real model (from `modelUsage`), four token columns and the cost delta against the base (B5). Warmth is reported only; nothing keeps a base warm (B6).
 
-## Waiting
+## Stopping a gremlin
 
-- Launches return at once; the job runs under a detached supervisor.
-- Call `wait` from Bash with `timeout: 600000`; never omit it. The Bash tool **backgrounds** a call that passes its timeout instead of killing it (P0.1), and you are left without its output.
-- Loop `wait --all` until exit 0 or 4. Exit 3 means "call again", and `done` may already hold finished results, failed ones too (C4). Each result comes back in exactly one `done`: read `done` on every call, not only the last.
-- Pings come back in `pings`, never in `done`, and never set the exit code; a ping cannot be waited on. A ping belongs to its base's latest phase and is counted in that phase's `usage`.
-- `running[]` rows (`job, block, elapsed_s, last_event_s_ago, messages`) count `messages` (stream messages so far); results and the ledger count `turns` (M16). They are different numbers.
-- A failed detach of the supervisor (`detach_failed`) shows up as a failed result in the next `wait`, not in the launch return.
+Use `TaskStop` on the backgrounded Bash call (B4). That kills `claude` and its bash wrappers. Known leftover (spec §7): a command the gremlin had in flight (for example a long test run through its Bash) can survive as an orphan and run to its own end. After a hard stop, the job file may stay `running` with no ledger line. You know which calls you stopped, so `status` shows that record as it was written.
 
-## Results
+## Briefs carry the rules
 
-Each `done` entry (also `results/<job>.json`): `job, kind, method, base, block, phase, status, flags, fingerprint, session, parent_session, models_used, tokens{input, output, cache_creation, cache_creation_1h, cache_creation_5m, cache_read}, cost_delta_usd, cache, base_state, wall_s, turns, denials, note, raw, paths, reason, model_requested`.
+The spawn template sets no commit rule. Each brief states whether that gremlin commits, which paths it may touch, and what its gate is. For gremlins that run in parallel, say "do not commit" and list the paths.
 
-- `kind` `train|spawn|continue|rebase|ping`; `method` is `"fork"` on a spawn, `null` on every other kind.
-- `status` `ok|failed|timeout|killed|lost`. `reason`: for `failed` one of `model_refused, usage_limit, overloaded, prompt_too_long, api_error, is_error, exit_code, no_result, detach_failed, launch_error, supervisor_error`; for `killed` one of `kill, expire, orphaned`; for `lost` `supervisor_dead`; `null` otherwise, also for `timeout` (over `--max-minutes`).
-- `flags`: `stalled, needs_attention` (permission denials: the allow rules may be short), `usage_mismatch, ttl_downgrade, cold_start, clock_jump, ping_missed, orphaned, expired, parent_inactive`.
-- `cache` `hit|partial|miss`, from the first request against the base's context; `base_state` at launch `warm|expiring|cold`; `fingerprint` `ok` or `drift:<fields>`. A cold base usually shows `partial`, because the shared system prefix stays warm (C5).
-- `note` is `notes/<block>.md` when the gremlin wrote it during this job, else `null`. `paths` echoes `--paths`.
+## State dir
 
-What to do per failure reason:
+`<run log without .md>-gremlins/`, next to the run log:
 
-- `model_refused` → the model id is not admitted (`availableModels`); the user must change settings. Flag it, hand back.
-- `usage_limit` → plan usage is used up. Stop launching, flag it, hand back.
-- `overloaded`, `api_error` → transient. `continue` once later, else flag it.
-- `prompt_too_long` → the base is too large. Re-train or rebase smaller.
-- `is_error`, `exit_code`, `no_result` → read `raw/<job>.err` and the note, `continue` once, else flag it.
-- `detach_failed`, `launch_error`, `supervisor_error` → a helper or host problem (`raw/<job>.sup.log`). Flag it; do not retry blindly.
-- Status `timeout` → read the note, `continue` once with what is left, else flag it. Status `lost` (the supervisor died) → flag it.
+- `run.json` (written once by `init`), `mcp-empty.json`, `preamble.md` (a frozen copy, so the system prompt and the cache stay stable)
+- `bases/<B>.json` (written by `train` and `rebase` only); `jobs/<J>.json` (each written by its own command)
+- `ledger.jsonl` (one appended line per finished or stopped call)
+- `raw/<J>.jsonl` (the stream) and `raw/<J>.err`; `briefs/<J>.md` (the full prompt sent)
+- `notes/<J>.md` (the gremlins' handoff notes); `logs/` (their gate and test output)
 
-`continue` takes spawn jobs only. A failed `train` is trained again (a failed base's name is free); a failed `rebase` leaves the old base active.
+## Cache hits
 
-`stalled` means no stream output for `stall_after_s` (900 s); the helper reports it and does nothing. Together with `clock_jump` it is a host suspend, not a hung gremlin. While a job runs, the same shows as a large `last_event_s_ago`: `wait` again before acting; still quiet after that → `kill` and flag it.
-
-## Rules (flags, not judgment)
-
-- `rebase_due` (reasons `phase_boundary`, `commits:N`, `lines:N`, `delta_tokens:N`, `binary_drift`, `runtime_drift:…`) → `rebase --as <new> --phase <n>` before the next spawn. **Always pass `--phase`.** `rebase` counts toward `parallel_cap`.
-- `retrain_due` (`defining:…`, `max_base_tokens:N`, `rebases:N`, `binary_missing`) → `train` a new base with `--supersedes <old>`, else the old base keeps getting pings. `binary_missing` → launches refuse; train with the new binary (`train --binary`, or re-run `init --binary` first). A cold base is still spawnable; coldness never triggers a re-train.
-- Delta: attach handoff notes with `spawn --delta-note PATH` (repeatable). A `## Changes since base` section in a brief holds this gremlin's delta only, and no line in it may start with `#`, also not inside fenced code: such a line ends the section (N1). When rebasing, attach every note written since the base's `trained_at` (shown by `list`): a note older than that counts as known to the base whether or not it was given to it (N2).
-- `continue` sends the brief without a frame: put the commit rule and the note path into it (M16).
-- Sequential gremlins run one at a time (Minor 13). Parallel only for disjoint blocks, with `--mode parallel --paths …`; parallel gremlins never commit, and the Athanor commits each block by the paths its note lists, one at a time.
-- Nothing running at hand-back: `list` shows no running job other than pings (kind `ping`; a ping ends within 300 s and is not a leak, Minor 7). Otherwise `kill` it and flag it.
-- `kill` and `expire` run long (each kill verifies for up to 10 s; `expire` kills its jobs one after another): call them from Bash with `timeout: 600000`, as `wait`.
-- `kill`: key on `ok` and `status`, not on `killed` or the exit code (M12). `killed: true, status: ok` means the job finished first; `ok: false` lists `survivors` (exit still 0): flag it.
-- Orphan watchdog (N1): a running job is killed (`orphaned`) after `orphan_after` (default 1200 s) without an orchestrator call (`wait`, `spawn`, `continue`, `train`, `rebase`, `list`, `usage`). `kill` and `expire` do not count (Phase 1 M3), and a gremlin's own calls never do. Keep looping `wait` while gremlins run.
-- Inside a gremlin `SPIRE_GREMLIN_CHILD=1` is set, and `train`, `spawn`, `continue`, `rebase`, `kill`, `expire`, `init` and `tick` refuse (N3); `where`, `list`, `usage` and `wait` work.
-- Models: full ids only; `spawn` takes the base's model (no `--model`). Admission is permissive at `init` and enforced at runtime (M15): a substituted model ends `failed`/`model_refused`.
-- After `claude` exits, its leftover descendants are killed, including daemons a commit may have started (`gpg-agent`, `git fsmonitor--daemon`); they restart on demand (M16).
-- A re-train that supersedes a base while a rebase of it runs: the rebase's new base arrives superseded, and its result carries `parent_inactive` (N4). Re-train first, or let the rebase finish.
-- Never resume or fork a headless session by hand; never call `claude -p` yourself; never `SendMessage` or `TaskStop` a gremlin (`continue` and `kill` cover it).
-
-## State
-
-`<run log without .md>-gremlins/`, next to the run log: `registry.json`, `ledger.jsonl`, `jobs/`, `briefs/`, `notes/`, `results/`, `logs/`, `raw/`. Its `.gitignore` keeps out `raw/` and lock files; everything else is committed with the run log at phase close. The Athanor reads `notes/`, `results/` and `logs/`; `raw/<job>.err` and `raw/<job>.sup.log` only when a job failed.
+A fork hits the base's cache only with the same argv, the same pinned env, the same cwd and an unchanged system prompt. `spawn` reports `cache: hit|partial|miss`; a miss is reported, not an error. The env scrub removes Desktop, SDK and uv variables from every launch. The helper uses no platform-specific process code, and it runs on Windows Git Bash, WSL, Linux and macOS (B8).

plugins/spire/skills/gremlins/grm/call.py

@@ -0,0 +1,86 @@
+"""The only subprocess code: run one `claude -p` call in the foreground and tee its stream."""
+import json
+import signal
+import subprocess
+import threading
+import time
+from pathlib import Path
+
+POLL_S = 0.2
+READER_JOIN_S = 10.0   # an orphaned grandchild can hold stdout open after claude exits
+STOP_SIGNALS = tuple(s for s in (signal.SIGTERM, signal.SIGINT, getattr(signal, "SIGBREAK", None))
+                     if s is not None)
+
+
+def _feed(stdin, data: bytes) -> None:
+    """Write the prompt and close stdin; a child that exits early is not an error here."""
+    try:
+        stdin.write(data)
+    except (OSError, ValueError):
+        pass
+    try:
+        stdin.close()
+    except (OSError, ValueError):
+        pass
+
+
+def _read(stdout, raw, ss) -> None:
+    """Tee every stream line to the raw file and feed each JSON event to `ss`."""
+    try:
+        for line in iter(stdout.readline, b""):
+            raw.write(line)
+            raw.flush()
+            try:
+                ev = json.loads(line.decode("utf-8", "replace"))
+            except ValueError:
+                continue
+            ss.feed(ev, time.time())
+    except (OSError, ValueError):
+        pass   # the raw file or pipe was closed after READER_JOIN_S
+
+
+def run_claude(argv, prompt: str, env, cwd, raw_path, on_start, ss=None):
+    """Run one call to its end. Returns (ss, exit_code, stopped)."""
+    if ss is None:
+        from grm.stream import StreamState
+        ss = StreamState()
+    raw_path = Path(raw_path)
+    with open(raw_path, "wb") as raw, open(raw_path.with_suffix(".err"), "wb") as err:
+        child = subprocess.Popen(argv, cwd=cwd, env=env, stdin=subprocess.PIPE,
+                                 stdout=subprocess.PIPE, stderr=err)
+        stopped = False
+
+        def _stop(signum, frame):
+            nonlocal stopped
+            try:
+                if stopped:          # a second signal: stop waiting for a graceful exit
+                    child.kill()
+                else:
+                    child.terminate()
+            except OSError:
+                pass
+            stopped = True
+
+        old = {}
+        if threading.current_thread() is threading.main_thread():
+            old = {s: signal.signal(s, _stop) for s in STOP_SIGNALS}
+        try:
+            reader = threading.Thread(target=_read, args=(child.stdout, raw, ss), daemon=True)
+            reader.start()
+            threading.Thread(target=_feed, args=(child.stdin, prompt.encode("utf-8")),
+                             daemon=True).start()
+            on_start(child.pid)
+            while child.poll() is None:   # a bare wait() would block signal handlers on Windows
+                time.sleep(POLL_S)
+        except BaseException:
+            child.kill()
+            child.wait()
+            raise
+        finally:
+            for s, h in old.items():
+                if h is not None:
+                    signal.signal(s, h)
+        reader.join(READER_JOIN_S)
+        if not reader.is_alive():
+            child.stdout.close()
+    return ss, child.returncode, stopped

plugins/spire/skills/gremlins/grm/cli.py

@@ -0,0 +1,359 @@
+"""argparse and the commands; each launch is record -> one `claude -p` call -> record."""
+import argparse
+import json
+import os
+import re
+import string
+import subprocess
+import sys
+import time
+import uuid
+from pathlib import Path
+
+from grm import call, launch, store, stream
+
+SKILL_DIR = Path(__file__).resolve().parent.parent
+NAME_RE = re.compile(r"^[A-Za-z0-9._-]+$")
+NOTE_SLACK_S = 2.0     # coarse file times: a note written right at the start still counts
+EXCERPT_CHARS = 500
+LAUNCHES = ("train", "spawn", "rebase")
+
+
+class Refusal(Exception):
+    """Refused before or instead of a launch: exit 2, payload printed as the JSON object."""
+
+    def __init__(self, error: str, **fields):
+        super().__init__(error)
+        self.payload = {"error": error, **fields}
+
+
+class _Parser(argparse.ArgumentParser):
+    def error(self, message):
+        raise Refusal("usage", detail=message)
+
+
+def _emit(obj: dict) -> None:
+    sys.stdout.write(json.dumps(obj) + "\n")
+    sys.stdout.flush()
+
+
+def render_template(name: str, values: dict) -> str:
+    with open(SKILL_DIR / "templates" / name, "r", encoding="utf-8") as f:
+        return string.Template(f.read()).safe_substitute(values)
+
+
+def git(args, cwd=None, timeout=60) -> subprocess.CompletedProcess:
+    """Every helper git call: `git --no-optional-locks …`, output captured."""
+    return subprocess.run(["git", "--no-optional-locks", *args], cwd=cwd, stdin=subprocess.DEVNULL,
+                          capture_output=True, timeout=timeout)
+
+
+def _git_out(args, cwd) -> str | None:
+    try:
+        r = git(args, cwd=cwd)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    out = r.stdout.decode("utf-8", "replace").strip()
+    return out if r.returncode == 0 and out else None
+
+
+def git_head(cwd) -> str | None:
+    return _git_out(["rev-parse", "HEAD"], cwd)
+
+
+def delta_header(cwd, base_commit: str | None) -> str:
+    """Commits since the base's commit plus the working tree's shortstat against it."""
+    if not base_commit:
+        return ("No base commit is recorded (the base's cwd was not a git repository, or git failed "
+                "at training). Treat everything on disk as possibly changed since training.")
+    parts = []
+    try:
+        lg = git(["log", "--oneline", "%s..HEAD" % base_commit], cwd=cwd)
+        st = git(["diff", "--shortstat", base_commit], cwd=cwd)
+        log_txt = lg.stdout.decode("utf-8", "replace").strip() if lg.returncode == 0 else \
+            "(git log failed: %s)" % lg.stderr.decode("utf-8", "replace").strip()
+        st_txt = st.stdout.decode("utf-8", "replace").strip() if st.returncode == 0 else \
+            "(git diff failed: %s)" % st.stderr.decode("utf-8", "replace").strip()
+    except (OSError, subprocess.SubprocessError) as e:
+        log_txt = st_txt = "(git failed: %s)" % e
+    parts.append("Base commit: `%s`." % base_commit)
+    parts.append("Commits since then (`git log --oneline %s..HEAD`):\n\n```\n%s\n```"
+                 % (base_commit[:12], log_txt or "(none)"))
+    parts.append("Working tree against the base commit (`git diff --shortstat %s`):\n\n```\n%s\n```"
+                 % (base_commit[:12], st_txt or "(no changes)"))
+    return "\n\n".join(parts)
+
+
+def _name(kind: str, value: str) -> str:
+    if not NAME_RE.match(value or ""):
+        raise Refusal("bad %s name" % kind, **{kind: value})
+    return value
+
+
+def _read_brief(path: str) -> str:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+    except OSError as e:
+        raise Refusal("cannot read brief", brief=path, detail=str(e))
+
+
+def _load_run(run: str) -> tuple[Path, dict]:
+    """State dir and run.json of a launch; the stored binary must still exist (no job file yet)."""
+    state = store.state_dir(run)
+    r = store.read_json(state / "run.json")
+    if r is None:
+        raise Refusal("no run.json for this run; call init first", state=str(state))
+    if not os.path.isfile(r["argv"][0]):
+        raise Refusal("claude binary missing", binary=r["argv"][0])
+    return state, r
+
+
+def _load_base(state: Path, b: str) -> dict:
+    base = store.read_json(state / "bases" / (b + ".json"))
+    if base is None:
+        raise Refusal("unknown base", base=b, bases=sorted(p.stem for p in (state / "bases").glob("*.json")))
+    return base
+
+
+def _warmth(lines: list, base: dict, now: float) -> dict:
+    """B6: from the ledger line of this base whose call read the base prefix last."""
+    hits = [ln for ln in lines if ln.get("base") == base["base"] and stream.parse_iso(ln.get("hit_at"))]
+    if not hits:
+        return {**stream.warmth(None, None, now), "ttl_s": base.get("ttl_s")}
+    last = max(hits, key=lambda ln: stream.parse_iso(ln["hit_at"]))
+    ttl = stream.infer_ttl(last.get("tokens"), base.get("ttl_s")) or stream.TTL_1H
+    return {**stream.warmth(stream.parse_iso(last["hit_at"]), ttl, now), "ttl_s": ttl}
+
+
+def _execute(run: str, state: Path, r: dict, *, job, kind, base, sid, argv, prompt,
+             before=(None, 0.0), base_ctx=None):
+    """One call: job file `running` -> run_claude -> job file final + one ledger line.
+    Returns (job record, StreamState|None, usage|None, ledger line|None)."""
+    fp = r["fingerprint"]
+    jpath = state / "jobs" / (job + ".json")
+    raw = state / "raw" / (job + ".jsonl")
+    store.atomic_write_bytes(state / "briefs" / (job + ".md"), prompt.encode("utf-8"))
+    t0 = time.time()
+    rec = {"job": job, "kind": kind, "base": base, "session_id": sid, "status": "running",
+           "reason": None, "started": stream.iso(t0), "ended": None, "child_pid": None,
+           "raw": str(raw), "note": None, "cache": None, "result_excerpt": None}
+    store.write_json(jpath, rec)
+
+    def on_start(pid):
+        rec["child_pid"] = pid
+        store.write_json(jpath, rec)
+    try:
+        ss, code, stopped = call.run_claude(argv, prompt, launch.scrubbed_env(fp["binary"]),
+                                            fp["cwd"], raw, on_start)
+    except OSError as e:
+        rec.update(status="error", reason="launch_error", ended=stream.iso(),
+                   result_excerpt=str(e)[:EXCERPT_CHARS])
+        store.write_json(jpath, rec)
+        return rec, None, None, None
+    wall = time.time() - t0
+    status, reason = stream.classify(ss, code, stopped)
+    u = stream.usage_from_result(ss.result, *before) if ss.result else None
+    cache = stream.cache_verdict(ss.first_usage, base_ctx) if kind != "train" else None
+    hit_t = None
+    if kind in ("train", "rebase") and status == "ok":
+        hit_t = ss.last_assistant_at
+    elif kind == "spawn" and cache in ("hit", "partial"):
+        hit_t = ss.first_at
+    note = None
+    if kind == "spawn":
+        p = state / "notes" / (job + ".md")
+        if p.is_file() and p.stat().st_mtime >= t0 - NOTE_SLACK_S:
+            note = str(p)
+    text = (ss.result or {}).get("result")
+    rec.update(session_id=ss.session_id or sid, status=status, reason=reason, ended=stream.iso(),
+               cache=cache, note=note,
+               result_excerpt=text[:EXCERPT_CHARS] if isinstance(text, str) else None)
+    store.write_json(jpath, rec)
+    models = u["models_used"] if u else []
+    line = {"ts": rec["ended"], "run": r["run"], "job": job, "kind": kind, "base": base,
+            "session_id": rec["session_id"], "model": models[0] if models else None,
+            "models_used": models,
+            "tokens": u["tokens"] if u else {k: None for k in stream.TOKEN_KEYS},
+            "cost_delta_usd": u["cost_delta"] if u else None,
+            "cost_cumulative_usd": u["total"] if u else None, "cache": cache, "status": status,
+            "wall_s": round(wall, 1), "hit_at": stream.iso(hit_t) if hit_t else None}
+    store.ledger_append(run, line)
+    return rec, ss, u, line
+
+
+def _cost_basis(ss) -> float | None:
+    """The base's cost basis stays unrounded: deltas against a rounded basis drift by 1e-6."""
+    total = (ss.result or {}).get("total_cost_usd")
+    return None if total is None else float(total)
+
+
+def _out(rec: dict, line: dict | None) -> dict:
+    out = dict(rec)
+    if line:
+        out.update(model=line["model"], models_used=line["models_used"], tokens=line["tokens"],
+                   cost=line["cost_delta_usd"], cost_cumulative_usd=line["cost_cumulative_usd"])
+    return out
+
+
+def cmd_init(args) -> dict:
+    """B1: validate, then write the frozen preamble copy, the empty MCP config and run.json once."""
+    state = store.state_dir(args.run)
+    if (state / "run.json").exists():
+        raise Refusal("run.json exists; init never overwrites a run", state=str(state))
+    binary = launch.resolve_binary(args.binary)
+    if not binary or not os.path.isfile(binary):
+        raise Refusal("no claude binary (no --binary, no $CLAUDE_CODE_EXECPATH, none on PATH)",
+                      binary=binary)
+    cwd = os.path.abspath(args.cwd) if args.cwd else _git_out(["rev-parse", "--show-toplevel"], os.getcwd())
+    if not cwd or not os.path.isdir(cwd):
+        raise Refusal("no usable cwd (pass --cwd, or run inside a git repository)", cwd=cwd)
+    if not launch.MODEL_RE.match(args.model):     # before anything is written
+        raise Refusal("model must be a full id (aliases are refused)", model=args.model)
+    state = store.init_state(args.run)
+    pre = state / "preamble.md"
+    store.atomic_write_bytes(pre, (SKILL_DIR / "preamble.md").read_bytes())
+    mcp = state / "mcp-empty.json"
+    store.write_json(mcp, {"mcpServers": {}})
+    fpd = launch.build_fingerprint(binary=binary, model=args.model, effort=args.effort,
+                                   cwd=os.path.abspath(cwd), agent=args.agent,
+                                   preamble_path=str(pre), mcp_config=str(mcp))
+    run = {"run": os.path.abspath(args.run), "created": stream.iso(), **fpd}
+    store.write_json(state / "run.json", run)
+    return {"state": str(state), **run}
+
+
+def cmd_train(args) -> dict:
+    """B1: one blocking call with `--session-id`; the base file only on `ok`."""
+    b = _name("base", args.base)
+    state, r = _load_run(args.run)
+    bpath = state / "bases" / (b + ".json")
+    if bpath.exists():
+        raise Refusal("base exists", base=b)
+    brief = _read_brief(args.brief)
+    sid, job = str(uuid.uuid4()), b + "-train"
+    prompt = render_template("train.md", {
+        "base": b, "run": r["run"], "state_dir": str(state), "notes_dir": str(state / "notes"),
+        "logs_dir": str(state / "logs"), "brief": brief})
+    rec, ss, u, line = _execute(args.run, state, r, job=job, kind="train", base=b, sid=sid,
+                                argv=launch.train_argv(r, sid), prompt=prompt)
+    if rec["status"] == "ok":
+        store.write_json(bpath, {
+            "base": b, "session_id": rec["session_id"], "train_job": job,
+            "commit": git_head(r["fingerprint"]["cwd"]), "trained_at": rec["ended"],
+            "context_tokens": stream.context_tokens(ss.last_usage), "model_usage": u["model_usage"],
+            "cost_cumulative_usd": _cost_basis(ss), "ttl_s": stream.infer_ttl(u["tokens"], None),
+            "rebases": []})
+    return _out(rec, line)
+
+
+def cmd_spawn(args) -> dict:
+    """B2, B3, B5: one blocking fork of the base; never writes the base file."""
+    b, j = _name("base", args.base), _name("job", args.job)
+    state, r = _load_run(args.run)
+    base = _load_base(state, b)
+    if (state / "jobs" / (j + ".json")).exists():
+        raise Refusal("job exists; pick a new --job", job=j)
+    brief = _read_brief(args.brief)
+    warm = _warmth(store.ledger_lines(args.run), base, time.time())
+    sid = str(uuid.uuid4())
+    prompt = render_template("spawn.md", {
+        "block": j, "base": b, "run": r["run"],
+        "delta": delta_header(r["fingerprint"]["cwd"], base.get("commit")),
+        "note_path": str(state / "notes" / (j + ".md")), "logs_dir": str(state / "logs"),
+        "brief": brief})
+    rec, _, _, line = _execute(args.run, state, r, job=j, kind="spawn", base=b, sid=sid,
+                               argv=launch.fork_argv(r, base["session_id"], sid), prompt=prompt,
+                               before=(base.get("model_usage"), base.get("cost_cumulative_usd")),
+                               base_ctx=base.get("context_tokens"))
+    return {**_out(rec, line), "base_state": warm["base_state"]}
+
+
+def cmd_rebase(args) -> dict:
+    """B7: resume the base without a fork; on `ok` the base takes the result's session id."""
+    b = _name("base", args.base)
+    state, r = _load_run(args.run)
+    base = _load_base(state, b)
+    brief = _read_brief(args.brief)
+    running = sorted(rec["job"] for rec in map(store.read_json, (state / "jobs").glob("*.json"))
+                     if rec and rec.get("base") == b and rec.get("status") == "running")
+    warnings = ["jobs of %s still marked running: %s" % (b, ", ".join(running))] if running else []
+    job = "%s-rebase%d" % (b, len(base.get("rebases") or []) + 1)
+    cwd = r["fingerprint"]["cwd"]
+    prompt = render_template("rebase.md", {
+        "base": b, "run": r["run"], "notes_dir": str(state / "notes"),
+        "delta": delta_header(cwd, base.get("commit")), "brief": brief})
+    rec, ss, u, line = _execute(args.run, state, r, job=job, kind="rebase", base=b, sid=None,
+                                argv=launch.resume_argv(r, base["session_id"]), prompt=prompt,
+                                before=(base.get("model_usage"), base.get("cost_cumulative_usd")),
+                                base_ctx=base.get("context_tokens"))
+    if rec["status"] == "ok":
+        base["rebases"] = list(base.get("rebases") or []) + [{
+            "job": job, "at": rec["ended"], "from_commit": base.get("commit"),
+            "from_session": base["session_id"]}]
+        base.update(session_id=rec["session_id"] or base["session_id"], commit=git_head(cwd),
+                    context_tokens=stream.context_tokens(ss.last_usage), model_usage=u["model_usage"],
+                    cost_cumulative_usd=_cost_basis(ss), ttl_s=stream.infer_ttl(u["tokens"], base.get("ttl_s")))
+        store.write_json(state / "bases" / (b + ".json"), base)
+    return {**_out(rec, line), "warnings": warnings}
+
+
+def cmd_status(args) -> dict:
+    """B6 (warmth per base) and B3 (re-reading a job's result)."""
+    state = store.state_dir(args.run)
+    if not (state / "run.json").exists():
+        raise Refusal("no run.json for this run; call init first", state=str(state))
+    if args.job:
+        rec = store.read_json(state / "jobs" / (_name("job", args.job) + ".json"))
+        if rec is None:
+            raise Refusal("unknown job", job=args.job)
+        return rec
+    lines, now = store.ledger_lines(args.run), time.time()
+    bases = {}
+    for p in sorted((state / "bases").glob("*.json")):
+        base = store.read_json(p)
+        bases[base["base"]] = {**{k: base.get(k) for k in ("session_id", "commit", "context_tokens")},
+                               **_warmth(lines, base, now)}
+    jobs = [store.read_json(p) for p in sorted((state / "jobs").glob("*.json"))]
+    return {"state": str(state), "bases": bases, "jobs": jobs}
+
+
+COMMANDS = {"init": cmd_init, "train": cmd_train, "spawn": cmd_spawn, "rebase": cmd_rebase,
+            "status": cmd_status}
+
+
+def _parser() -> argparse.ArgumentParser:
+    p = _Parser(prog="gremlins.py", description="spire:gremlins helper; prints one JSON object.")
+    sub = p.add_subparsers(dest="cmd", required=True)
+    s = sub.add_parser("init")
+    s.add_argument("--model", required=True)
+    s.add_argument("--effort", default="high", choices=launch.EFFORTS)
+    s.add_argument("--cwd")
+    s.add_argument("--agent")
+    s.add_argument("--binary")
+    for name in LAUNCHES:
+        s2 = sub.add_parser(name)
+        s2.add_argument("--base", required=True)
+        if name == "spawn":
+            s2.add_argument("--job", required=True)
+        s2.add_argument("--brief", required=True)
+    sst = sub.add_parser("status")
+    sst.add_argument("--job")
+    for sp in sub.choices.values():
+        sp.add_argument("--run", required=True)
+    return p
+
+
+def main(argv=None) -> int:
+    """Exit 0 ok, 1 a call that ended `error`/`stopped`, 2 refused or a usage error."""
+    try:
+        args = _parser().parse_args(argv)
+        out = COMMANDS[args.cmd](args)
+    except Refusal as e:
+        _emit(e.payload)
+        return 2
+    except (ValueError, OSError) as e:
+        _emit({"error": str(e), "type": type(e).__name__})
+        return 2
+    _emit(out)
+    return 1 if args.cmd in LAUNCHES and out.get("status") != "ok" else 0

plugins/spire/skills/gremlins/grm/launch.py

@@ -0,0 +1,182 @@
+"""Launch fingerprint, env scrub, binary lookup and the `claude -p` argv (B1, B2, B7, B8)."""
+import hashlib
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+
+MODEL_RE = re.compile(r"^claude-[a-z0-9-]+(\[1m\])?$")
+EFFORTS = ("low", "medium", "high", "xhigh", "max")
+PERMISSION_MODE = "dontAsk"
+DEFAULT_TOOLS = ["Bash", "Read", "Edit", "Write", "Glob", "Grep", "Skill"]
+DEFAULT_DISALLOWED = ["Bash(git push:*)", "Bash(git rebase:*)", "Bash(git reset --hard:*)",
+                      "Bash(claude:*)"]
+
+# Env pinned into every launch; part of the fingerprint.
+ENV_PINNED_LAUNCH = {"CLAUDE_CODE_PROMPT_CACHE_TTL": "1h", "DISABLE_AUTOUPDATER": "1"}
+
+# Host env that must not reach a child `claude -p`.
+SCRUB_DROP = frozenset({
+    # Desktop host vars
+    "CLAUDE_CODE_MESSAGING_SOCKET", "CLAUDE_CODE_MESSAGING_TOKEN", "CLAUDE_CODE_HOST_SESSION_ID",
+    "CLAUDE_CODE_ENTRYPOINT", "CLAUDE_CODE_DESKTOP_APP_VERSION",
+    "CLAUDE_CODE_SDK_HAS_HOST_AUTH_REFRESH", "CLAUDE_CODE_TERMINAL_MCP_TOOLS",
+    "CLAUDE_CODE_REPORT_FINDINGS", "CLAUDE_CODE_SESSION_ID", "CLAUDE_AGENT_SDK_VERSION",
+    "CLAUDE_CODE_ENABLE_ASK_USER_QUESTION_TOOL", "CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING",
+    # fingerprint and auth path
+    "CLAUDE_EFFORT", "ANTHROPIC_MODEL", "ANTHROPIC_SMALL_FAST_MODEL", "CLAUDE_CODE_SUBAGENT_MODEL",
+    "ENABLE_PROMPT_CACHING_1H", "FORCE_PROMPT_CACHING_5M", "CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL",
+    "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_USE_BEDROCK", "CLAUDE_CODE_USE_VERTEX",
+    # uv
+    "VIRTUAL_ENV",
+})
+SCRUB_DROP_PATTERNS = (re.compile(r"^ANTHROPIC_DEFAULT_.+_MODEL$"), re.compile(r"^UV_"))
+SCRUB_KEEP = frozenset({
+    "CLAUDECODE", "CLAUDE_CODE_CHILD_SESSION", "AI_AGENT", "CLAUDE_PID", "CLAUDE_CODE_GIT_BASH_PATH",
+    "PATH", "HOME", "USERPROFILE",
+    "ANTHROPIC_BASE_URL",      # kept: gateways need it
+})
+SCRUB_PINNED = {**ENV_PINNED_LAUNCH, "SPIRE_GREMLIN_CHILD": "1"}
+SCRUB_PINNED_BINARY = "CLAUDE_CODE_EXECPATH"   # set to the stored absolute binary path
+
+
+def canonical_json(obj) -> str:
+    return json.dumps(obj, sort_keys=True, separators=(",", ":"), ensure_ascii=True)
+
+
+def _sha256_bytes(b: bytes) -> str:
+    return hashlib.sha256(b).hexdigest()
+
+
+def _sha256_file(path: str) -> str:
+    with open(path, "rb") as f:
+        return _sha256_bytes(f.read())
+
+
+def scrub_class(name: str) -> str | None:
+    """'drop', 'pinned', 'keep' or None (on no list; kept)."""
+    n = name.upper()
+    if n in SCRUB_DROP or any(p.match(n) for p in SCRUB_DROP_PATTERNS):
+        return "drop"
+    if n in SCRUB_PINNED or n == SCRUB_PINNED_BINARY:
+        return "pinned"
+    if n in SCRUB_KEEP:
+        return "keep"
+    return None
+
+
+def _venv_prefixes(environ) -> list[str]:
+    out = []
+    venv = environ.get("VIRTUAL_ENV")
+    if venv:
+        out.append(venv)
+    if os.path.normcase(os.path.abspath(sys.prefix)) != os.path.normcase(os.path.abspath(sys.base_prefix)):
+        out.append(sys.prefix)
+    return [os.path.normcase(os.path.normpath(os.path.abspath(x))) for x in out]
+
+
+def _under(path: str, prefixes) -> bool:
+    try:
+        p = os.path.normcase(os.path.normpath(os.path.abspath(path)))
+    except ValueError:
+        return False
+    return any(p == px or p.startswith(px.rstrip("\\/") + os.sep) for px in prefixes)
+
+
+def scrubbed_env(binary: str, environ=None) -> dict:
+    """The child env: host env minus the drop list, venv PATH entries removed, pinned vars on
+    top, `CLAUDE_CODE_EXECPATH` = the stored binary path."""
+    if environ is None:
+        environ = os.environ
+    prefixes = _venv_prefixes(environ)
+    env = {}
+    for k, v in environ.items():
+        if scrub_class(k) in ("drop", "pinned"):
+            continue
+        if k.upper() == "PATH":
+            v = os.pathsep.join(e for e in v.split(os.pathsep) if e and not _under(e, prefixes))
+        env[k] = v
+    env.update(SCRUB_PINNED)
+    env[SCRUB_PINNED_BINARY] = binary
+    return env
+
+
+def resolve_binary(explicit: str | None = None) -> str | None:
+    """Absolute path of `claude`: `explicit`, else $CLAUDE_CODE_EXECPATH, else PATH."""
+    path = explicit or os.environ.get("CLAUDE_CODE_EXECPATH") or shutil.which("claude")
+    return os.path.abspath(path) if path else None
+
+
+def binary_version(path: str) -> str | None:
+    """First token of `<path> --version`, or None on any failure."""
+    try:
+        r = subprocess.run([path, "--version"], stdin=subprocess.DEVNULL, capture_output=True,
+                           timeout=60)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    toks = r.stdout.decode("utf-8", "replace").split()
+    return toks[0] if r.returncode == 0 and toks else None
+
+
+def _argv(fp: dict) -> list[str]:
+    """The fingerprinted command line; its order must never change (cache hit)."""
+    a = [fp["binary"], "-p", "--output-format", "stream-json", "--verbose",
+         "--model", fp["model"], "--effort", fp["effort"],
+         "--permission-mode", fp["permission_mode"], "--tools", ",".join(fp["tools"])]
+    if fp.get("allowed_tools"):
+        a += ["--allowedTools", ",".join(fp["allowed_tools"])]
+    if fp.get("disallowed_tools"):
+        a += ["--disallowedTools", ",".join(fp["disallowed_tools"])]
+    a += ["--strict-mcp-config", "--mcp-config", fp["mcp_config"],
+          "--append-system-prompt-file", fp["append_prompt"]["path"]]
+    if fp.get("agent"):
+        a += ["--agent", fp["agent"]]
+    return a
+
+
+def build_fingerprint(*, binary, model, effort, cwd, agent, preamble_path, mcp_config) -> dict:
+    """Validate the launch fields; return {"fingerprint", "argv", "fp_hash"}. Writes nothing."""
+    if not MODEL_RE.match(model or ""):
+        raise ValueError("model must be a full id (aliases are refused): %r" % model)
+    if effort not in EFFORTS:
+        raise ValueError("unknown effort %r (one of %s)" % (effort, ", ".join(EFFORTS)))
+    if not os.path.isdir(cwd):
+        raise ValueError("cwd is not a directory: %s" % cwd)
+    if not os.path.isfile(preamble_path):
+        raise ValueError("preamble not found: %s" % preamble_path)
+    if not binary or not os.path.isfile(binary):
+        raise ValueError("claude binary not found: %s" % binary)
+    preamble_path = os.path.abspath(preamble_path)
+    fp = {
+        "binary": os.path.abspath(binary),
+        "binary_version": binary_version(binary),
+        "model": model,
+        "effort": effort,
+        "permission_mode": PERMISSION_MODE,
+        "tools": list(DEFAULT_TOOLS),
+        # under dontAsk every tool not allowed is denied
+        "allowed_tools": list(DEFAULT_TOOLS),
+        "disallowed_tools": list(DEFAULT_DISALLOWED),
+        "agent": agent or None,
+        "cwd": os.path.abspath(cwd),
+        "append_prompt": {"path": preamble_path, "sha256": _sha256_file(preamble_path)},
+        "mcp_config": os.path.abspath(mcp_config),
+        "env_pinned": dict(ENV_PINNED_LAUNCH),
+    }
+    return {"fingerprint": fp, "argv": _argv(fp),
+            "fp_hash": _sha256_bytes(canonical_json(fp).encode("utf-8"))}
+
+
+def train_argv(run: dict, sid: str) -> list[str]:
+    return list(run["argv"]) + ["--session-id", sid]
+
+
+def fork_argv(run: dict, base_sid: str, sid: str) -> list[str]:
+    return list(run["argv"]) + ["--resume", base_sid, "--fork-session", "--session-id", sid]
+
+
+def resume_argv(run: dict, base_sid: str) -> list[str]:
+    """No `--session-id`: claude refuses it on a resume without a fork."""
+    return list(run["argv"]) + ["--resume", base_sid]

plugins/spire/skills/gremlins/grm/store.py

@@ -0,0 +1,116 @@
+"""State dir layout, atomic JSON files and the append-only ledger."""
+import contextlib
+import json
+import os
+import threading
+import time
+import uuid
+from pathlib import Path
+
+SUBDIRS = ("bases", "jobs", "raw", "notes", "logs", "briefs")
+RETRY_TRIES = 40
+RETRY_SLEEP_S = 0.05
+
+_ledger_lock = threading.Lock()
+
+
+def state_dir(run) -> Path:
+    """`<x>/run.md` -> `<x>/run-gremlins` (a sibling of the run log)."""
+    p = os.path.abspath(str(run))
+    if not p.lower().endswith(".md"):
+        raise ValueError("--run must name the run log .md file: %s" % p)
+    return Path(p[:-3] + "-gremlins")
+
+
+def init_state(run) -> Path:
+    """Create the state dir and its subdirs (idempotent)."""
+    state = state_dir(run)
+    for d in SUBDIRS:
+        (state / d).mkdir(parents=True, exist_ok=True)
+    return state
+
+
+def _retry(fn, tries: int = RETRY_TRIES, sleep_s: float = RETRY_SLEEP_S):
+    """Call fn(); retry PermissionError (Windows sharing violations)."""
+    for attempt in range(1, tries + 1):
+        try:
+            return fn()
+        except PermissionError:
+            if attempt == tries:
+                raise
+            time.sleep(sleep_s)
+
+
+def atomic_write_bytes(path, data: bytes) -> None:
+    """Write to a temp file in the same dir, then `os.replace` with retries."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.parent / (".%s.%d.%s.tmp" % (path.name, os.getpid(), uuid.uuid4().hex[:8]))
+    with open(tmp, "wb") as f:
+        f.write(data)
+        f.flush()
+        os.fsync(f.fileno())
+    try:
+        _retry(lambda: os.replace(tmp, path))
+    except BaseException:
+        with contextlib.suppress(OSError):
+            os.remove(tmp)
+        raise
+
+
+def read_bytes_retry(path) -> bytes:
+    def _read():
+        with open(path, "rb") as f:
+            return f.read()
+    return _retry(_read)
+
+
+def read_json(p) -> dict | None:
+    """The parsed file, or None if it does not exist. Corrupt content raises ValueError."""
+    try:
+        data = read_bytes_retry(p)
+    except FileNotFoundError:
+        return None
+    return json.loads(data.decode("utf-8"))
+
+
+def write_json(p, obj) -> None:
+    atomic_write_bytes(p, (json.dumps(obj, indent=1, sort_keys=True) + "\n").encode("utf-8"))
+
+
+def _ledger_path(run) -> Path:
+    return state_dir(run) / "ledger.jsonl"
+
+
+def ledger_append(run, line: dict) -> None:
+    """Append one JSON line with a single write; repairs a torn last line first."""
+    path = _ledger_path(run)
+    body = (json.dumps(line, sort_keys=True) + "\n").encode("utf-8")
+
+    def _append():
+        torn = False
+        with contextlib.suppress(FileNotFoundError), open(path, "rb") as r:
+            if r.seek(0, os.SEEK_END) > 0:
+                r.seek(-1, os.SEEK_END)
+                torn = r.read(1) != b"\n"
+        with open(path, "ab") as f:
+            f.write((b"\n" if torn else b"") + body)
+    with _ledger_lock:
+        _retry(_append)
+
+
+def ledger_lines(run) -> list[dict]:
+    """Every parsable line of the ledger; [] when there is none yet."""
+    try:
+        data = read_bytes_retry(_ledger_path(run))
+    except FileNotFoundError:
+        return []
+    out = []
+    for ln in data.splitlines():
+        try:
+            obj = json.loads(ln.decode("utf-8", "replace"))
+        except ValueError:
+            continue
+        if isinstance(obj, dict):
+            out.append(obj)
+    return out

plugins/spire/skills/gremlins/grm/stream.py

@@ -0,0 +1,215 @@
+"""Stream-json reader and accounting for one `claude -p` call: pure functions, no IO."""
+import datetime as _dt
+import json
+import re
+import time
+
+TTL_1H, TTL_5M = 3600, 300
+CACHE_HIT_RATIO = 0.9
+MU_FIELDS = ("inputTokens", "outputTokens", "cacheReadInputTokens", "cacheCreationInputTokens")
+TOKEN_KEYS = ("input", "output", "cache_creation", "cache_read", "cache_creation_1h", "cache_creation_5m")
+
+
+def iso(t: float | None = None) -> str:
+    """ISO 8601 with the local offset, from epoch seconds (now if not given)."""
+    if t is None:
+        t = time.time()
+    return _dt.datetime.fromtimestamp(t).astimezone().isoformat(timespec="seconds")
+
+
+def parse_iso(s) -> float | None:
+    """Epoch seconds of an ISO string written by `iso`, or None."""
+    if not s or not isinstance(s, str):
+        return None
+    try:
+        return _dt.datetime.fromisoformat(s).timestamp()
+    except ValueError:
+        return None
+
+
+class StreamState:
+    """What one `claude -p --output-format stream-json --verbose` stream told us so far."""
+
+    def __init__(self):
+        self.init = None              # the system/init event
+        self.session_id = None
+        self.msg_ids: list = []
+        self._ids: set = set()
+        self.first_usage = None       # usage of the first assistant event (cache verdict)
+        self.first_at = None          # its arrival time (the base prefix read)
+        self.last_usage = None        # usage of the last assistant event (base context)
+        self.last_assistant_at = None
+        self.result = None            # the result event
+        self.refused = None           # text of a model-restricted warning
+        self.events = 0
+
+    def feed(self, ev: dict, t: float | None) -> None:
+        if not isinstance(ev, dict):
+            return
+        self.events += 1
+        ty = ev.get("type")
+        if ty == "system":
+            st = ev.get("subtype")
+            if st == "init" and self.init is None:
+                self.init = ev
+                self.session_id = ev.get("session_id") or self.session_id
+            elif (st == "informational" and ev.get("level") == "warning"
+                  and "is restricted" in str(ev.get("content", ""))):
+                self.refused = str(ev.get("content"))
+        elif ty == "assistant":
+            m = ev.get("message") or {}
+            mid = m.get("id")
+            if mid not in self._ids:
+                self._ids.add(mid)
+                self.msg_ids.append(mid)
+            u = m.get("usage") or {}
+            if self.first_usage is None:
+                self.first_usage, self.first_at = u, t
+            self.last_usage, self.last_assistant_at = u, t
+        elif ty == "result":
+            self.result = ev
+            self.session_id = ev.get("session_id") or self.session_id
+
+    @property
+    def turns(self) -> int:
+        return len(self.msg_ids)
+
+
+def context_tokens(usage: dict | None) -> int:
+    """Prompt-side tokens of one request: input + cache creation + cache read."""
+    if not usage:
+        return 0
+    return (int(usage.get("input_tokens") or 0) + int(usage.get("cache_creation_input_tokens") or 0)
+            + int(usage.get("cache_read_input_tokens") or 0))
+
+
+_API_ERROR_TEXT = (   # checked in this order, after the status code
+    ("prompt_too_long", re.compile(r"prompt is too long|prompt too long|prompt_too_long", re.I)),
+    ("usage_limit", re.compile(r"usage limit|rate[ _-]?limit|hit your limit|api error:?\s*429", re.I)),
+    ("overloaded", re.compile(r"overloaded|api error:?\s*529", re.I)),
+    ("api_error", re.compile(r"api error", re.I)),
+)
+
+
+def api_error_reason(res: dict | None) -> tuple[str, str] | None:
+    """(reason, detail) for a result that carries an API error, else None. `reason` is
+    `usage_limit` (429), `overloaded` (529), `prompt_too_long` or `api_error`."""
+    if not res:
+        return None
+    status = res.get("api_error_status")
+    try:
+        status = int(status) if status not in (None, "") else None
+    except (TypeError, ValueError):
+        status = None
+    if not res.get("is_error") and status is None:
+        return None
+    parts = [res.get("result"), res.get("error"), res.get("errors")]
+    text = " | ".join(p if isinstance(p, str) else json.dumps(p) for p in parts if p)
+    detail = "api_error_status %s: %s" % (status, text[:200] if text else "(no text)")
+    if status == 429:
+        return "usage_limit", detail
+    if status == 529:
+        return "overloaded", detail
+    for reason, rx in _API_ERROR_TEXT:
+        if rx.search(text):
+            return reason, detail
+    if status is not None:
+        return "api_error", detail
+    return None
+
+
+def classify(ss: StreamState, exit_code, stopped: bool) -> tuple[str, str | None]:
+    """(status, reason) of a finished call; the first matching case wins."""
+    res = ss.result
+    match (bool(stopped), ss.refused, res, api_error_reason(res), exit_code):
+        case (True, _, _, _, _):
+            return "stopped", "stopped"
+        case (_, str(), _, _, _):
+            return "error", "model_refused"
+        case (_, _, None, _, code):
+            return "error", "exit_code" if code else "no_result"
+        case (_, _, _, (reason, _), _):
+            return "error", reason
+        case (_, _, dict() as r, _, _) if r.get("is_error"):
+            return "error", "is_error"
+        case (_, _, _, _, code) if code:
+            return "error", "exit_code"
+        case _:
+            return "ok", None
+
+
+def usage_from_result(result: dict, before_mu: dict, cost_before) -> dict:
+    """Tokens (with the 1h/5m split) from `result.usage`; `models_used` = modelUsage entries that
+    grew against the session's totals before the call, largest first; cost delta against the
+    session's cost before the call. Costs are rounded here, once, at 6 decimals."""
+    result = result or {}
+    usage = result.get("usage") or {}
+    cc = usage.get("cache_creation") or {}
+    tokens = {
+        "input": int(usage.get("input_tokens") or 0),
+        "output": int(usage.get("output_tokens") or 0),
+        "cache_creation": int(usage.get("cache_creation_input_tokens") or 0),
+        "cache_read": int(usage.get("cache_read_input_tokens") or 0),
+        "cache_creation_1h": int(cc.get("ephemeral_1h_input_tokens") or 0),
+        "cache_creation_5m": int(cc.get("ephemeral_5m_input_tokens") or 0),
+    }
+    after = result.get("modelUsage") or {}
+    before_mu = before_mu or {}
+    delta = {}
+    for m, v in after.items():
+        b = before_mu.get(m) or {}
+        delta[m] = {f: int((v or {}).get(f) or 0) - int(b.get(f) or 0) for f in MU_FIELDS}
+    grew = [m for m, d in delta.items() if any(x > 0 for x in d.values())]
+    models_used = sorted(grew, key=lambda m: (-sum(delta[m].values()), m))
+    sums = {f: sum(d[f] for d in delta.values()) for f in MU_FIELDS}
+    mismatch = (sums["inputTokens"], sums["outputTokens"], sums["cacheCreationInputTokens"],
+                sums["cacheReadInputTokens"]) != (tokens["input"], tokens["output"],
+                                                   tokens["cache_creation"], tokens["cache_read"])
+    total = result.get("total_cost_usd")
+    if total is None:
+        cost_delta = None
+    else:
+        cost_delta = round(float(total) - float(cost_before or 0.0), 6)
+        total = round(float(total), 6)
+    return {"tokens": tokens, "models_used": models_used, "mismatch": mismatch,
+            "cost_delta": cost_delta, "total": total, "model_usage": after}
+
+
+def cache_verdict(first_usage: dict | None, base_ctx) -> str | None:
+    """The first request's cache read against the base's context tokens."""
+    if first_usage is None:
+        return None
+    cr = int(first_usage.get("cache_read_input_tokens") or 0)
+    if base_ctx and cr >= CACHE_HIT_RATIO * float(base_ctx):
+        return "hit"
+    return "partial" if cr > 0 else "miss"
+
+
+def infer_ttl(tokens: dict | None, prev):
+    """The TTL of a base's cache entries from one call's tokens: 1h written -> 3600, only 5m
+    written -> 300, otherwise (read only, or nothing) `prev`."""
+    if not tokens:
+        return prev
+    if int(tokens.get("cache_creation_1h") or 0) > 0:
+        return TTL_1H
+    if int(tokens.get("cache_creation_5m") or 0) > 0:
+        return TTL_5M
+    return prev
+
+
+def wrote_only_5m(tokens: dict | None) -> bool:
+    """The call wrote 5-minute cache entries and no 1-hour ones."""
+    return (bool(tokens) and int(tokens.get("cache_creation_5m") or 0) > 0
+            and int(tokens.get("cache_creation_1h") or 0) == 0)
+
+
+def warmth(last_hit_ts: float | None, ttl_s, now: float) -> dict:
+    """warm until `margin` before last_hit + ttl, expiring until last_hit + ttl, then cold;
+    margin = max(120, ttl/10). No hit at all is cold."""
+    if last_hit_ts is None:
+        return {"base_state": "cold", "warm_until": None, "ttl_left_s": None}
+    ttl = float(ttl_s or TTL_1H)
+    margin = max(120.0, ttl / 10.0)
+    wu = float(last_hit_ts) + ttl
+    state = "warm" if now < wu - margin else ("expiring" if now < wu else "cold")
+    return {"base_state": state, "warm_until": iso(wu), "ttl_left_s": int(max(0.0, wu - now))}

plugins/spire/skills/gremlins/templates/rebase.md

@@ -1,6 +1,6 @@
 # Rebase (spire:gremlins)
 
-This session is a fork of base `${base}` (run log `${run}`). When you finish, this session becomes the new base `${new_base}` (phase ${phase}): every later gremlin of this build starts from what you know at the end of it. Your job is to absorb what changed since `${base}` was trained or last rebased.
+This session is base `${base}` itself, resumed (run log `${run}`). When you finish, every later gremlin of this build starts from what you know at the end of it. Your job is to absorb what changed since `${base}` was trained or last rebased.
 
 Your system prompt was snapshotted when the base was trained: the git status, the CLAUDE.md files and the environment it shows are **stale**. The delta header below lists what changed in the repository since then. Trust it and the files on disk over the snapshot and over what you remember.
 

plugins/spire/skills/gremlins/templates/spawn.md

@@ -1,6 +1,6 @@
 # Block ${block} (spire:gremlins)
 
-You are a gremlin spawned from base `${base}` (a fork of its session; run log `${run}`), now working on block `${block}` (phase ${phase}, mode ${mode}).
+You are a gremlin spawned from base `${base}` (a fork of its session; run log `${run}`), now working on block `${block}`.
 
 Your system prompt was snapshotted when the base was trained: the git status, the CLAUDE.md files and the environment it shows are **stale**. The delta header below lists what changed in the repository since then. Trust it and the files on disk over the snapshot and over what you remember from training; re-read every file before you change it.
 
@@ -10,7 +10,7 @@ ${delta}
 
 ## Rules for this gremlin
 
-- ${commit_rule}
+- Commit only if the brief below says so.
 - Write your handoff note to `${note_path}`.
 - Write gate and test output to `.txt` files under `${logs_dir}`.
 

plugins/spire/skills/gremlins/tests/fake_claude.py

@@ -0,0 +1,64 @@
+"""Fake `claude -p` for the CLI tests. $FAKE_CLAUDE_SCENARIO: ok (default), miss, api_error,
+noresult, two_models, no_cost, sleep. $FAKE_CLAUDE_LOG: one JSON line per call (argv, pid)."""
+import json
+import os
+import sys
+import time
+import uuid
+
+TRAIN_MU = {"inputTokens": 10, "outputTokens": 20, "cacheReadInputTokens": 0,
+            "cacheCreationInputTokens": 1000}
+TRAIN_COST, CALL_COST = 0.05, 0.02
+
+
+def opt(name):
+    return sys.argv[sys.argv.index(name) + 1] if name in sys.argv else None
+
+
+def emit(ev):
+    print(json.dumps(ev), flush=True)
+
+
+def main():
+    prompt = sys.stdin.buffer.read().decode("utf-8")
+    scen = os.environ.get("FAKE_CLAUDE_SCENARIO", "ok")
+    if os.environ.get("FAKE_CLAUDE_LOG"):
+        with open(os.environ["FAKE_CLAUDE_LOG"], "a", encoding="utf-8") as f:
+            f.write(json.dumps({"argv": sys.argv, "pid": os.getpid(), "prompt_chars": len(prompt)}) + "\n")
+    resume, model = opt("--resume"), opt("--model")
+    # a plain resume (no fork, no --session-id) gets a new id, as `-p` may give one
+    sid = opt("--session-id") or ("resumed-" + uuid.uuid4().hex if resume else str(uuid.uuid4()))
+    read = 1000 if resume and scen != "miss" else 0
+    created = 100 if resume else 1000
+    usage = {"input_tokens": 10, "output_tokens": 20, "cache_creation_input_tokens": created,
+             "cache_read_input_tokens": read,
+             "cache_creation": {"ephemeral_1h_input_tokens": created, "ephemeral_5m_input_tokens": 0}}
+    emit({"type": "system", "subtype": "init", "session_id": sid, "model": model})
+    emit({"type": "assistant", "session_id": sid, "message": {"id": "m1", "usage": usage}})
+    if scen == "sleep":
+        time.sleep(60)
+    if scen == "noresult":
+        sys.exit(1)
+    mu = {"inputTokens": 10, "outputTokens": 20, "cacheReadInputTokens": read,
+          "cacheCreationInputTokens": created}
+    cost = CALL_COST if resume else TRAIN_COST
+    if resume:   # the session's totals include the base's training call
+        mu = {k: v + TRAIN_MU[k] for k, v in mu.items()}
+        cost += TRAIN_COST
+    res = {"type": "result", "subtype": "success", "is_error": False, "session_id": sid,
+           "result": "done", "num_turns": 1, "usage": usage, "modelUsage": {model: mu},
+           "total_cost_usd": cost}
+    if scen == "two_models":
+        res["modelUsage"]["claude-haiku-5-5"] = {"inputTokens": 5, "outputTokens": 1,
+                                                 "cacheReadInputTokens": 0, "cacheCreationInputTokens": 0}
+    if scen == "no_cost":
+        del res["total_cost_usd"]
+    if scen == "api_error":
+        res.update(subtype="error_during_execution", is_error=True, api_error_status=429,
+                   result="API Error: 429 rate limit")
+    emit(res)
+    sys.exit(1 if scen == "api_error" else 0)
+
+
+if __name__ == "__main__":
+    main()

plugins/spire/skills/gremlins/tests/test_call.py

@@ -0,0 +1,57 @@
+import os
+import signal
+import sys
+import tempfile
+import threading
+import time
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from grm import call  # noqa: E402
+
+CHILD = ("import json, sys, time\n"
+         "p = sys.stdin.buffer.read().decode('utf-8')\n"
+         "print(json.dumps({'type': 'system', 'subtype': 'init', 'session_id': p}), flush=True)\n"
+         "if p == 'sleep': time.sleep(30)\n"
+         "print(json.dumps({'type': 'result', 'session_id': p}), flush=True)\n")
+
+
+class RunClaudeTest(unittest.TestCase):
+    def _run(self, d, prompt):
+        pids = []
+        raw = Path(d) / "j.jsonl"
+        out = call.run_claude([sys.executable, "-c", CHILD], prompt, dict(os.environ), d,
+                              raw, pids.append)
+        return out, raw, pids
+
+    def test_tee_and_parse(self):
+        """B1: prompt goes in on stdin; the stream is parsed and teed to the raw file."""
+        with tempfile.TemporaryDirectory() as d:
+            (ss, code, stopped), raw, pids = self._run(d, "héllo")
+            self.assertEqual((code, stopped, len(pids)), (0, False, 1))
+            self.assertEqual(ss.session_id, "héllo")
+            self.assertIsNotNone(ss.result)
+            self.assertEqual(len(raw.read_bytes().splitlines()), 2)
+
+    def test_sigterm_stops_child(self):
+        """B4: SIGTERM stops the child; stopped is set and the partial raw file is kept."""
+        with tempfile.TemporaryDirectory() as d:
+            timer = threading.Timer(1.5, signal.raise_signal, (signal.SIGTERM,))
+            t0 = time.time()
+            timer.start()
+            try:
+                (ss, code, stopped), raw, pids = self._run(d, "sleep")
+            finally:
+                timer.cancel()
+            self.assertTrue(stopped)
+            self.assertIsNotNone(code)        # the child has exited
+            self.assertLess(time.time() - t0, 20)
+            self.assertIsNone(ss.result)
+            self.assertEqual(ss.session_id, "sleep")
+            self.assertIn(b'"init"', raw.read_bytes())
+
+
+if __name__ == "__main__":
+    unittest.main()

plugins/spire/skills/gremlins/tests/test_cli.py

@@ -0,0 +1,211 @@
+import contextlib
+import io
+import json
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import unittest
+from pathlib import Path
+from unittest import mock
+
+SKILL = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(SKILL))
+
+from grm import cli  # noqa: E402
+
+FAKE = str(SKILL / "tests" / "fake_claude.py")
+MODEL = "claude-opus-5-5"
+
+
+class CliTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, self.tmp, True)
+        repo = self.tmp / "repo"
+        repo.mkdir()
+        for a in (["init", "-q"], ["-c", "user.email=t@t", "-c", "user.name=t", "commit", "-q",
+                                   "--allow-empty", "-m", "x"]):
+            subprocess.run(["git", *a], cwd=repo, check=True, capture_output=True)
+        self.run_md = str(self.tmp / "run.md")
+        self.state = self.tmp / "run-gremlins"
+        self.log = self.tmp / "fake.jsonl"
+        self.brief = self.tmp / "brief.md"
+        self.brief.write_text("do the thing\n", encoding="utf-8")
+        env = mock.patch.dict(os.environ, {"FAKE_CLAUDE_LOG": str(self.log), "FAKE_CLAUDE_SCENARIO": "ok"})
+        env.start()
+        self.addCleanup(env.stop)
+        code, out = self.g("init", "--run", self.run_md, "--model", MODEL, "--cwd", str(repo), "--binary", sys.executable)
+        self.assertEqual(code, 0, out)
+        run = json.loads((self.state / "run.json").read_text(encoding="utf-8"))
+        run["argv"] = [sys.executable, FAKE] + run["argv"][1:]
+        (self.state / "run.json").write_text(json.dumps(run), encoding="utf-8")
+        self.stored = run["argv"]
+
+    def g(self, *args, scenario=None):
+        if scenario:
+            os.environ["FAKE_CLAUDE_SCENARIO"] = scenario
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            code = cli.main(list(args))
+        os.environ["FAKE_CLAUDE_SCENARIO"] = "ok"
+        return code, json.loads(buf.getvalue().splitlines()[-1])
+
+    def train(self, scenario=None):
+        return self.g("train", "--run", self.run_md, "--base", "B1", "--brief", str(self.brief),
+                      scenario=scenario)
+
+    def spawn(self, job, base="B1", scenario=None):
+        return self.g("spawn", "--run", self.run_md, "--base", base, "--job", job,
+                      "--brief", str(self.brief), scenario=scenario)
+
+    def calls(self):
+        if not self.log.exists():
+            return []
+        return [json.loads(ln) for ln in self.log.read_text(encoding="utf-8").splitlines()]
+
+    def ledger(self):
+        return [json.loads(ln) for ln in (self.state / "ledger.jsonl").read_text(encoding="utf-8").splitlines()]
+
+    def base_rec(self):
+        p = self.state / "bases" / "B1.json"
+        return json.loads(p.read_text(encoding="utf-8")) if p.exists() else None
+
+    def test_train_spawn_happy(self):
+        """B1, B2, B5: base keeps the --session-id; fork argv = stored argv + resume/fork; ledger."""
+        code, out = self.train()
+        self.assertEqual((code, out["status"]), (0, "ok"))
+        sid = self.calls()[0]["argv"][-1]
+        # the fake logs its sys.argv: the stored argv without the interpreter
+        self.assertEqual(self.calls()[0]["argv"], self.stored[1:] + ["--session-id", sid])
+        self.assertEqual(self.base_rec()["session_id"], sid)
+        code, out = self.spawn("1.1")
+        self.assertEqual((code, out["status"], out["cache"]), (0, "ok", "hit"))
+        argv = self.calls()[1]["argv"]
+        n = len(self.stored) - 1
+        self.assertEqual(argv[:n], self.stored[1:])
+        self.assertEqual(argv[n:n + 3], ["--resume", sid, "--fork-session"])
+        line = self.ledger()[-1]
+        self.assertEqual((line["model"], line["job"], line["cache"]), (MODEL, "1.1", "hit"))
+        for k in ("input", "output", "cache_creation", "cache_read"):
+            self.assertIsInstance(line["tokens"][k], int)
+        self.assertAlmostEqual(line["cost_delta_usd"],
+                               line["cost_cumulative_usd"] - self.base_rec()["cost_cumulative_usd"], places=6)
+        self.assertAlmostEqual(line["cost_delta_usd"], 0.02, places=6)
+
+    def test_missing_binary(self):
+        """B1: a missing binary is refused before launch; no job file."""
+        run = json.loads((self.state / "run.json").read_text(encoding="utf-8"))
+        run["argv"][0] = str(self.tmp / "nope.exe")
+        (self.state / "run.json").write_text(json.dumps(run), encoding="utf-8")
+        code, out = self.train()
+        self.assertEqual(code, 2)
+        self.assertIn("binary", out["error"])
+        self.assertEqual(list((self.state / "jobs").iterdir()), [])
+        self.assertEqual(self.calls(), [])
+
+    def test_train_failures(self):
+        """B1: no result + exit 1, and an API error result: status error, no base file."""
+        for scenario, reason in (("noresult", "exit_code"), ("api_error", "usage_limit")):
+            code, out = self.train(scenario)
+            self.assertEqual((code, out["status"], out["reason"]), (1, "error", reason), scenario)
+            self.assertIsNone(self.base_rec())
+
+    def test_unknown_base(self):
+        """B2: an unknown base is refused with no launch."""
+        code, out = self.spawn("1.1", base="NOPE")
+        self.assertEqual((code, out["error"]), (2, "unknown base"))
+        self.assertEqual(self.calls(), [])
+        self.assertFalse((self.state / "jobs" / "1.1.json").exists())
+
+    def test_cache_miss_is_reported(self):
+        """B2: first-usage cache_read 0 is `cache: miss`, not an error."""
+        self.train()
+        code, out = self.spawn("1.1", scenario="miss")
+        self.assertEqual((code, out["status"], out["cache"]), (0, "ok", "miss"))
+
+    def test_parallel_spawns(self):
+        """B3: two spawns in parallel threads give two job files and two whole ledger lines."""
+        self.train()
+        ts = [threading.Thread(target=cli.main, args=(["spawn", "--run", self.run_md, "--base", "B1",
+                                                         "--job", j, "--brief", str(self.brief)],))
+              for j in ("p1", "p2")]
+        with contextlib.redirect_stdout(io.StringIO()):
+            for t in ts:
+                t.start()
+            for t in ts:
+                t.join(60)
+        for j in ("p1", "p2"):
+            rec = json.loads((self.state / "jobs" / (j + ".json")).read_text(encoding="utf-8"))
+            self.assertEqual(rec["status"], "ok")
+        lines = self.ledger()
+        self.assertEqual(len(lines), 3)
+        self.assertEqual(sorted(ln["job"] for ln in lines[1:]), ["p1", "p2"])
+
+    def test_stop_signal(self):
+        """B4: a stop signal to the helper ends the child, marks the job stopped, keeps raw."""
+        self.train()
+        env = dict(os.environ, FAKE_CLAUDE_SCENARIO="sleep")
+        kw = {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP} if os.name == "nt" else {}
+        h = subprocess.Popen([sys.executable, str(SKILL / "gremlins.py"), "spawn", "--run", self.run_md,
+                              "--base", "B1", "--job", "s1", "--brief", str(self.brief)],
+                             env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **kw)
+        jpath, raw = self.state / "jobs" / "s1.json", self.state / "raw" / "s1.jsonl"
+        deadline = time.time() + 30
+        while time.time() < deadline and not (
+                jpath.exists() and json.loads(jpath.read_text(encoding="utf-8")).get("child_pid")
+                and raw.exists() and b'"assistant"' in raw.read_bytes()):
+            time.sleep(0.2)
+        pid = json.loads(jpath.read_text(encoding="utf-8"))["child_pid"]
+        os.kill(h.pid, signal.CTRL_BREAK_EVENT if os.name == "nt" else signal.SIGTERM)
+        out, _ = h.communicate(timeout=30)
+        self.assertEqual(h.returncode, 1)
+        self.assertEqual(json.loads(out.decode("utf-8").splitlines()[-1])["status"], "stopped")
+        self.assertEqual(json.loads(jpath.read_text(encoding="utf-8"))["status"], "stopped")
+        self.assertIn(b'"init"', raw.read_bytes())
+        if os.name == "nt":
+            r = subprocess.run(["tasklist", "/FI", "PID eq %d" % pid, "/NH"], capture_output=True)
+            self.assertNotIn(str(pid).encode(), r.stdout)
+        else:
+            with self.assertRaises(ProcessLookupError):
+                os.kill(pid, 0)
+
+    def test_usage_models_and_cost(self):
+        """B5: two models both in models_used; no total_cost_usd gives a null cost delta."""
+        self.train("two_models")
+        line = self.ledger()[-1]
+        self.assertEqual(sorted(line["models_used"]), ["claude-haiku-5-5", MODEL])
+        self.assertEqual(line["model"], MODEL)
+        (self.state / "bases" / "B1.json").unlink()
+        self.train("no_cost")
+        self.assertIsNone(self.ledger()[-1]["cost_delta_usd"])
+
+    def test_status_cold_without_hit(self):
+        """B6: a base with no hit in the ledger is cold (and warm right after training)."""
+        self.train()
+        code, out = self.g("status", "--run", self.run_md)
+        self.assertEqual((code, out["bases"]["B1"]["base_state"]), (0, "warm"))
+        (self.state / "ledger.jsonl").write_bytes(b"")
+        code, out = self.g("status", "--run", self.run_md)
+        self.assertEqual(out["bases"]["B1"]["base_state"], "cold")
+
+    def test_rebase(self):
+        """B7: rebase resumes without a fork; the base takes the result's session id."""
+        self.train()
+        old = self.base_rec()["session_id"]
+        code, out = self.g("rebase", "--run", self.run_md, "--base", "B1", "--brief", str(self.brief))
+        self.assertEqual((code, out["status"]), (0, "ok"))
+        argv = self.calls()[-1]["argv"]
+        self.assertEqual(argv[-2:], ["--resume", old])
+        self.assertNotIn("--fork-session", argv)
+        new = self.base_rec()["session_id"]
+        self.assertTrue(new.startswith("resumed-"))
+        self.assertEqual(new, out["session_id"])
+
+
+if __name__ == "__main__":
+    unittest.main()

plugins/spire/skills/gremlins/tests/test_launch.py

@@ -0,0 +1,51 @@
+import os
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from grm import launch  # noqa: E402
+
+RUN = {"argv": ["/x/claude", "-p", "--model", "claude-opus-5-5[1m]", "--tools", "Bash,Read"]}
+
+
+class ArgvTest(unittest.TestCase):
+    def test_fork_argv_extends_stored_argv(self):
+        """B2: the stored argv byte for byte, then --resume <base> --fork-session."""
+        a = launch.fork_argv(RUN, "base-sid", "new-sid")
+        n = len(RUN["argv"])
+        self.assertEqual(a[:n], RUN["argv"])
+        self.assertEqual(a[n:n + 3], ["--resume", "base-sid", "--fork-session"])
+        self.assertIn("new-sid", a[n + 3:])
+        self.assertEqual(len(RUN["argv"]), n)   # the stored list is not mutated
+
+    def test_resume_argv_has_no_fork(self):
+        """B7: resume the base without forking."""
+        a = launch.resume_argv(RUN, "base-sid")
+        self.assertEqual(a[:len(RUN["argv"])], RUN["argv"])
+        self.assertEqual(a[len(RUN["argv"]):], ["--resume", "base-sid"])
+        self.assertNotIn("--fork-session", a)
+
+
+class ScrubTest(unittest.TestCase):
+    def test_scrub_drops_pins_and_cleans_path(self):
+        """B8: SCRUB_DROP and UV_* dropped, pinned vars set, venv PATH entries removed."""
+        venv = os.path.abspath(os.path.join(os.sep, "tmp", "venv"))
+        keep = os.path.abspath(os.path.join(os.sep, "usr", "bin"))
+        environ = {"PATH": os.pathsep.join([os.path.join(venv, "bin"), keep]),
+                   "VIRTUAL_ENV": venv, "UV_CACHE_DIR": "c", "ANTHROPIC_API_KEY": "k",
+                   "CLAUDE_CODE_SESSION_ID": "s", "DISABLE_AUTOUPDATER": "0", "OTHER": "o"}
+        env = launch.scrubbed_env("/bin/claude", environ)
+        for k in launch.SCRUB_DROP:
+            self.assertNotIn(k, env)
+        self.assertNotIn("UV_CACHE_DIR", env)
+        for k, v in launch.SCRUB_PINNED.items():
+            self.assertEqual(env[k], v)
+        self.assertEqual(env[launch.SCRUB_PINNED_BINARY], "/bin/claude")
+        self.assertEqual(env["PATH"], keep)
+        self.assertEqual(env["OTHER"], "o")
+
+
+if __name__ == "__main__":
+    unittest.main()

plugins/spire/skills/gremlins/tests/test_store.py

@@ -0,0 +1,36 @@
+import sys
+import tempfile
+import threading
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from grm import store  # noqa: E402
+
+
+class LedgerTest(unittest.TestCase):
+    def test_parallel_appends_give_whole_lines(self):
+        """B3: two threads appending at once leave only whole, parsable lines."""
+        with tempfile.TemporaryDirectory() as d:
+            run = str(Path(d) / "run.md")
+            store.init_state(run)
+
+            def append(job):
+                for i in range(50):
+                    store.ledger_append(run, {"job": job, "i": i, "pad": "x" * 500})
+            threads = [threading.Thread(target=append, args=(j,)) for j in ("a", "b")]
+            for t in threads:
+                t.start()
+            for t in threads:
+                t.join()
+            raw = (store.state_dir(run) / "ledger.jsonl").read_bytes().splitlines()
+            lines = store.ledger_lines(run)
+            self.assertEqual(len(raw), 100)
+            self.assertEqual(len(lines), 100)
+            self.assertEqual(sorted((x["job"], x["i"]) for x in lines),
+                             sorted((j, i) for j in ("a", "b") for i in range(50)))
+
+
+if __name__ == "__main__":
+    unittest.main()

plugins/spire/skills/gremlins/tests/test_stream.py

@@ -0,0 +1,74 @@
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from grm import stream  # noqa: E402
+
+
+def _ss(result=None):
+    ss = stream.StreamState()
+    if result is not None:
+        ss.feed(dict(result, type="result"), 1.0)
+    return ss
+
+
+class ClassifyTest(unittest.TestCase):
+    def test_api_errors_map_to_reasons(self):
+        """B1: an API error result gives status error with its mapped reason."""
+        cases = [({"is_error": True, "api_error_status": 429}, "usage_limit"),
+                 ({"is_error": True, "api_error_status": 529}, "overloaded"),
+                 ({"is_error": True, "result": "Prompt is too long"}, "prompt_too_long")]
+        for res, reason in cases:
+            self.assertEqual(stream.api_error_reason(res)[0], reason)
+            self.assertEqual(stream.classify(_ss(res), 1, False), ("error", reason))
+
+    def test_no_result(self):
+        """B1: no result event is an error, by exit code or no_result."""
+        self.assertEqual(stream.classify(_ss(), 0, False), ("error", "no_result"))
+        self.assertEqual(stream.classify(_ss(), 1, False), ("error", "exit_code"))
+        self.assertEqual(stream.classify(_ss({"is_error": False}), 0, False), ("ok", None))
+
+
+class UsageTest(unittest.TestCase):
+    def test_cache_miss(self):
+        """B2: a first-request cache_read of 0 is a miss (reported, not an error)."""
+        self.assertEqual(stream.cache_verdict({"cache_read_input_tokens": 0}, 50000), "miss")
+
+    def test_two_models_and_cost_delta(self):
+        """B5: both models in models_used; cost delta against the base, rounded at 6."""
+        before = {"claude-opus-5-5": {"inputTokens": 10, "outputTokens": 5}}
+        res = {"usage": {"input_tokens": 3, "output_tokens": 7},
+               "modelUsage": {"claude-opus-5-5": {"inputTokens": 12, "outputTokens": 10},
+                              "claude-haiku-5-5": {"inputTokens": 1, "outputTokens": 1}},
+               "total_cost_usd": 0.12345678}
+        u = stream.usage_from_result(res, before, 0.1)
+        self.assertEqual(u["models_used"], ["claude-opus-5-5", "claude-haiku-5-5"])
+        self.assertEqual(u["cost_delta"], round(0.12345678 - 0.1, 6))
+        self.assertEqual(u["total"], 0.123457)
+
+    def test_missing_cost(self):
+        """B5: no total_cost_usd gives cost_delta None."""
+        self.assertIsNone(stream.usage_from_result({"usage": {}}, {}, 0.5)["cost_delta"])
+
+
+class WarmthTest(unittest.TestCase):
+    def test_no_hit_is_cold(self):
+        """B6"""
+        self.assertEqual(stream.warmth(None, 3600, 1000.0)["base_state"], "cold")
+
+    def test_5m_only_ttl(self):
+        """B6"""
+        self.assertEqual(stream.infer_ttl({"cache_creation_5m": 10, "cache_creation_1h": 0}, None), 300)
+
+    def test_expiring(self):
+        """B6: a hit at now - ttl + 60 is expiring."""
+        now = 1_000_000.0
+        w = stream.warmth(now - 3600 + 60, 3600, now)
+        self.assertEqual(w["base_state"], "expiring")
+        self.assertEqual(w["ttl_left_s"], 60)
+
+
+if __name__ == "__main__":
+    unittest.main()

plugins/spire/skills/implementation/SKILL.md

@@ -37,16 +37,16 @@ A plan holds decisions, contracts, invariants and the scope fence. Code goes in
 
 - **Sequence by default.** Later changes depend on earlier ones, even when they look independent. Run in parallel only for truly disjoint work: separate files with no behavioural coupling, read-only exploration, separate test suites. If you have to think hard about independence, sequence.
 - **One owner per coherent change.** Do not split one logical change across agents; they fight over the boundary.
-- **Hand over as commits, not descriptions.** Each block commits, and its owner writes a short handoff note (template: `references/run-log.md`): a gremlin writes `notes/<block>.md` and the Athanor appends it to the run log; a fresh agent writes into the run log directly. The note is how flags reach the reviewer.
+- **Hand over as commits, not descriptions.** Each block commits and adds a short handoff note to the run log (template: `references/run-log.md`). The note is how flags reach the reviewer.
 - **Between blocks, a cheap gate, not a review.** Compile or typecheck what the block owns. Run the test suite once, at phase end, and fix the fallout in that last block.
 - **Decisions belong before the run.** Inside it, take the conservative default, flag it in the handoff note and continue. Do not wait on the user.
 - **Deviate with a reason.** Splitting a block, changing an owner model, adding a check: allowed, logged with why.
 
-## Context: fresh, trained, or keep
+## Context: fresh, fork, or keep
 
 Both extremes have failed. Many tiny fresh implementers relearn the code each time and fragment the plan. One implementer kept across many tasks bloats and drifts. Choose per block: how much shared understanding does it need, and how much room is left? Context figures in `references/models.md` are guesstimates, not limits.
 
-The Athanor's option is a **trained implementer and gremlins**. One base per build, a headless session trained early: it reads the code the build touches and writes the trunk notes. One gremlin per complex block, spawned from the base with a delta brief, so each block starts from the base's reading. The base is rebased at phase boundaries or when the helper says so. Mechanical or distant blocks go to a fresh agent that reads the trunk notes. Mechanics and rules: `spire:gremlins`. It is Windows-tested; other platforms fail closed until tested, and there fresh agents build every block (a fresh agent then writes the trunk notes). Which harness behaviour is verified and which is assumed: `references/spawning-claude-code.md`.
+One option is **trunk and forks**. At intake the builder reads the build plan and the code it touches (the trunk) and writes short trunk notes. Complex blocks in the trunk's area go to a fork of the builder, which inherits its model and (assumed) its context. Mechanical or distant blocks go to a fresh agent that reads the trunk notes. Which harness behaviour is verified and which is assumed: `references/spawning-claude-code.md`.
 
 ## Phase review, fix, stop
 
@@ -66,7 +66,6 @@ The Athanor's option is a **trained implementer and gremlins**. One base per bui
 
 - Read `references/spawning-claude-code.md` before dispatching. In short: sequential work runs in the foreground; resume agents only from the session root; leaf briefs say "do this yourself; do not dispatch further agents".
 - Every plan, handoff note and review stamps the exact model id the agent ran on.
-- Gremlins run on the base's full model id; `spawn` takes no model override.
 - Model traits are in `references/models.md`: dated observations, not law.
 
 ## Writing things down

plugins/spire/skills/implementation/references/models.md

@@ -47,14 +47,5 @@ Full id not recorded here; spacecraft notes mention "Sonnet 5".
 - Both extremes failed. Many tiny fresh implementers relearn the code each time. One implementer carried across tasks reached about 960k tokens and drifted (spacecraft, 2026-09-29; model probably 5.5 through the alias).
 - Measured: dirigent blocks of 11–36 min of agent work used 186k–344k tokens each (Sonnet, 2026-10-01). None ran out.
 - Guesstimates (unmeasured): a trunk read at intake of about 100k–250k; leave room for fallout and the fix pass rather than running close to the comfortable limit.
-- With gremlins (2026-10-16), the trunk read is the base's training, not the Athanor's context. Measured: the Phase 0 large base was 182k tokens (P0.2) and the smoke base 23.7k; the Athanor reads plans and reports, not code (preflight report; Phase 3 contract A13).
 
 **Future work:** orchestrator introspection of subagent token use, and signals into running work (dirigent is working on this). Until then, the Athanor records what usage it sees in completion results and judges by block count and size.
-
-- Update 2026-10-16: gremlins (headless sessions) report per-call usage through `usage` (tokens by cache column, models used, priced cost). Agent-tool subagents still do not.
-
-## Notes added 2026-10-16
-
-- Plan mode (`--permission-mode plan`) silently upgrades a Haiku session to Sonnet; `init.model` still shows Haiku, so read `modelUsage` for what ran. The docs only imply it (research `F2a`, `F2b`).
-- Aliases map to model versions per CLI release: `haiku` is Haiku 4.5 on `claude` 2.1.283 and Haiku 5.5 on 2.1.299 (research `F2c`). Pin a full id where the version matters.
-- Opus 5.5 may refuse a bare "run this blocking command" brief as pointless; say why the command is wanted (observed in the Phase 0 trunk notes, preflight report, 2026-10-16).

plugins/spire/skills/implementation/references/run-log.md

@@ -17,27 +17,20 @@ Rules:
 - Plan: <path>  ·  Build plan: <path>
 - Branch: <branch>  ·  Start commit: <hash>
 - Trunk notes: <path>
-- Gremlins: <state dir> (or "none: <reason>")
 - Athanor: <model id>  ·  Session journal: <path>
 ```
 
-A successor Athanor finds the state dir on the `Gremlins:` line and adopts it (`list`); it never re-runs `init`.
-
 ## Per phase
 
 ```markdown
 ## Phase <N> — <title>
 
-| Block | Owner (model id from modelUsage) | Session | Commit | in | out | cache write | cache read | cost Δ |
-|---|---|---|---|---|---|---|---|---|
+| Block | Owner (model id) | Commit | Tokens (if known) |
+|---|---|---|---|
 ```
 
-Gremlin blocks: the row comes from `usage --block <id> --format md`. Fresh-agent blocks: owner = the model id the agent stamped, Session `—`, the usage cells `—`, and the harness's token total in the block's handoff note.
-
 ## Handoff note (one per block, written by the block's owner)
 
-Same format for everyone. A gremlin writes it to `notes/<block>.md` in the state dir and the Athanor appends it here; a fresh agent writes it here directly.
-
 ```markdown
 ### Block <N.M> — <title>
 
@@ -58,8 +51,6 @@ Same format for everyone. A gremlin writes it to `notes/<block>.md` in the state
 
 - Gate: <command> — <result>
 - Tests: <command> — <result> (fallout fixed in block <N.M>)
-- Usage: the `usage --phase <N> --format md` table and its three lines (cold starts, cache-hit ratio, priced total)
-- Base state: from `list` (the active base, its warmth, rebase/re-train flags)
 - Flags for the reviewer: every deviation and every "flagged for review" line above, one per bullet, with its block.
 - Not run / untested: <anything the tests do not cover>
 - Status: provisional until review, fix pass and re-check close.
@@ -67,6 +58,6 @@ Same format for everyone. A gremlin writes it to `notes/<block>.md` in the state
 
 After the review, Igor (or the fixer) appends the review report path, the fix-pass commits, the re-check result, and the minors logged as follow-ups.
 
-## Trunk notes (written by the base at training; by a fresh agent where gremlins are unavailable)
+## Trunk notes (written by the Athanor at intake)
 
 Short, for the next agent that has not read the code: key files and seams, invariants the phase touches, every consumer of a changed semantic, the gate command, known traps. A page, not a design document.

plugins/spire/skills/implementation/references/spawning-claude-code.md

@@ -1,10 +1,10 @@
 # Spawning agents in Claude Code
 
-Harness mechanics for dispatching, resuming and forking agents in Claude Code, and for the headless sessions (`claude -p`) that `spire:gremlins` drives. Other harnesses get their own `spawning-<harness>.md` when needed.
+Harness mechanics for dispatching, resuming and forking agents in Claude Code. Other harnesses get their own `spawning-<harness>.md` when needed.
 
 Each claim carries a status and a date:
 
-- **verified**: read from the tool schema or the Claude Code docs, or reproduced in a local test, on that date; the row names which. Not tested at runtime unless the row says so.
+- **verified**: read from the tool schema text on that date. Not tested at runtime unless the row says so.
 - **observed**: seen in real runs; the mechanism may be assumed. Source given.
 - **assumed**: inferred, not checked. Treat as a hypothesis.
 - **unknown**: open; check before relying on it.
@@ -18,7 +18,6 @@ The harness changes. When a claim fails, fix it here with a new date.
 - **Pinned agents: omit `model`.** The per-call alias overrides the agent's frontmatter pin. Pass `model` to a pinned agent only when you mean to override it, and say so in the journal or run log.
 - **Unpinned agents: pass `model`.** Otherwise they inherit the caller's model, which may be Fable.
 - **Stamp the model id.** Every agent reads its exact id from its system prompt and writes it into its output.
-- **Complex blocks go to gremlins via `spire:gremlins`; never resume or fork a headless session by hand.** The helper owns the flags, the cache bookkeeping and the usage ledger (see "Headless sessions" below).
 - **Leaf briefs say "do this yourself; do not dispatch further agents."** Only orchestrators (the Athanor) are meant to fan out.
 - **Notifications report a turn ending, not a job finishing.** Read the result text before concluding anything. Check `ListAgents` before resuming.
 
@@ -52,79 +51,17 @@ The harness changes. When a claim fails, fix it here with a new date.
 | A 4.6 Igor passing `model: "opus"` to the then 4.6-pinned Athanor got a 4.6 run (the dirigent end review that passed with zero findings). | observed 2026-10-05 (user's attribution; the dirigent report recorded the model as unknown). Consistent with both the alias following the caller and the pin holding, so it is not evidence for alias-over-pin. The 184/184 row and the schema are. |
 | What the `opus` alias resolves to (the caller's model, a session default, or the newest Opus). | unknown. Check the stamped id of every plan, attack and review instead of relying on it. |
 | Every agent sees its exact model id in its system prompt. | observed 2026-10-05 for general-purpose agents (prompt shows `claude-opus-5-5`); not checked for plugin agents with their own bodies |
-| Headless `--model` takes full ids (and the `[1m]` suffix), so gremlins pin by full id; the per-call alias limit above is an Agent-tool limit. | observed 2026-10-16 (preflight report, P0.5) |
 | Context window of the bare `claude-opus-5-5` pin versus a `[1m]` suffix (other Spire pins carry `[1m]`). | resolved 2026-10-05: all Opus-pinned Spire agents (igor, adept, athanor, zathras) pinned to `claude-opus-5-5[1m]` (user decision; Pinky, when it exists, stays 4.6); the ~600k guesstimate in `models.md` assumes the larger window |
 
-## Fork (Agent tool)
-
-Spire no longer uses Agent-tool forks (goal decision 2026-10-16): complex blocks go to gremlins, headless forks of a trained base (see "Headless sessions" below). The rows stay as a record of what the Agent tool offers.
+## Fork
 
 | Claim | Status |
 |---|---|
 | The Agent tool schema documents `subagent_type: "fork"`: a fork always inherits the caller's model; the `model` parameter is ignored. | verified 2026-10-05 (schema text) |
-| `fork` was not offered as an agent type on 2026-10-05 or on 2026-10-15. | observed 2026-10-15 (agent-type lists of those sessions; design 2026-10-16-01 §9) |
-| A fork inherits the current conversation only; no parameter names another agent to fork. | verified 2026-10-15 (docs, sub-agents) |
-| A fork has the same system prompt, tools, model and history as the forking session. | verified 2026-10-15 (docs, sub-agents) |
-| An Agent-tool fork cannot fork again: "A fork can't spawn further forks." A headless `--fork-session` of a fork works. | verified 2026-10-15 (docs, sub-agents) for the Agent tool; verified 2026-10-16 (research `2d`, local test T6) for headless |
-| Fork mode is on by default in interactive sessions (v2.1.232 and later), off under `-p` and the SDK unless `CLAUDE_CODE_FORK_SUBAGENT=1`. With it on, all subagents run in the background and `run_in_background` is removed. | verified 2026-10-15 (docs, sub-agents) |
-| Agent-tool forks and subagents use the 5 min cache bucket by default; the main conversation (including `-p` runs) gets 1 h on a Claude subscription within plan usage. | verified 2026-10-16 (research `F4a`; docs, prompt caching) |
-| Whether a foreground Agent-tool fork returns its result to the caller, and whether it sees the caller's preloaded skills. | unknown 2026-10-16 (never tested; Spire does not use Agent-tool forks) |
-
-## Headless sessions (`claude -p`)
-
-`spire:gremlins` (command `spawn`) is the only supported way to start, resume or fork one; these rows say why its command line is what it is. Tested on Windows with `claude` 2.1.283 and 2.1.299. Research ids (`1a` to `F5b`) refer to `docs/workpad/research/2026-10-16-00-claude-headless-fork-sessions.md`; `P0.x` ids to `docs/workpad/reports/2026-10-16-09-headless-forks-preflight.md`.
-
-| Claim | Status |
-|---|---|
-| `--output-format json` prints one result object: `session_id`, `result`, `usage` (with the cache fields), `modelUsage`, `total_cost_usd`, `permission_denials`, `subagent_stats`. With `stream-json --verbose` the first event is `system/init` with `session_id`, `model`, `tools`, `agents`, `skills`, `plugins`, `permissionMode`. | verified 2026-10-16 (research `1a`; docs, headless; local tests T1, T6) |
-| `--resume <id>` finds the session by id in any project on the machine; without `--fork-session` it appends to the same id. | verified 2026-10-16 (research `1b`; docs; local test T5) |
-| `--session-id <uuid>` lets the caller choose the id up front, so no output parsing is needed. | verified 2026-10-16 (research `1d`; docs, `--help`) |
-| `--continue` means the most recent conversation in the cwd, `-p` sessions included. Do not use it for fan-out; pass explicit ids. | verified 2026-10-16 (research `1c`; docs) |
-| `--fork-session` gives the run a new session id and a copy of the base history. | verified 2026-10-16 (research `2a`; `--help` 2.1.283; docs) |
-| The base stays unchanged on disk and in later resumes; forks do not see each other. | verified 2026-10-16 (research `2b`; docs, sessions; local tests T2 to T5) |
-| Parallel forks of one base work and each gets its own id and transcript. Resuming the same id in two processes without forking interleaves both into one transcript. | verified 2026-10-16 (research `2c`; local tests T2 and T3 in parallel; docs) |
-| A fork of a fork works. | verified 2026-10-16 (research `2d`; local test T6) |
-| Forks hit the cache on the shared prefix (T2 and T3 each read 14,650 tokens against the base's 8,661 created). | verified 2026-10-16 (research `3a`; local test) |
-| A cache hit needs an identical tool set, model and system prompt. A fork with different flags read 0 and re-created 17,474; one that changed only the model read 4,293 and created 7,213. | verified 2026-10-16 (research `3b`; local tests T6, T7) |
-| A fork does not inherit the base's permission mode, `--allowedTools` or `--tools` (T6 came up in `default` with all 43 tools). Pass them again, identically, on every fork. | verified 2026-10-16 (research `4b`; local test T6; docs, sessions) |
-| Also not restored on resume: `--mcp-config`, `--settings`, `--plugin-dir`, `--fallback-model`, `--add-dir`. The system prompt (including `--append-system-prompt`) is recorded at the first request and reused on resume and fork until compaction; later flag text is ignored (`--system-prompt-snapshot`, `--help` 2.1.283). | verified 2026-10-16 (research `4c`; docs, sessions and CLI reference) |
-| The model is restored on resume; `--model` on the fork overrides it (a haiku fork of a sonnet base ran on haiku). | verified 2026-10-16 (research `4d`; docs; local test T7) |
-| `total_cost_usd` and `modelUsage` on a resumed or forked run are cumulative for the conversation, base spend included (v2.1.277 and later). Per-call cost is a difference against the base's total; never sum results. `--max-budget-usd` counts only the call's own spend. | verified 2026-10-16 (research `3d`, `F4e`; docs, headless, cost tracking) |
-| The 1 h cache TTL is the default only for the main-conversation bucket (interactive turns and `-p` runs) on a Claude subscription within plan usage; usage credits, API key and cloud providers default to 5 min, as does the main conversation over the plan limit. | verified 2026-10-16 (research `F4a`, `3c`; docs, prompt caching; local `ephemeral_1h` writes in T1 to T7) |
-| The TTL is configurable: `CLAUDE_CODE_PROMPT_CACHE_TTL` or `promptCacheTtl` (main bucket), `CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL` or `subagentPromptCacheTtl` (everything else), each `5m` or `1h`, v2.1.242 and later. `ENABLE_PROMPT_CACHING_1H=1` sets both; `FORCE_PROMPT_CACHING_5M=1` overrides everything. | verified 2026-10-16 (research `F4b`; docs, prompt caching) |
-| A cache hit resets the TTL timer, so forks spaced under the TTL keep the base prefix warm. Parallel sessions in the same directory share a prefix; a different cwd or git-status snapshot changes it, so run every fork from the base's cwd. | verified 2026-10-16 (research `F4c`, `F4d`; docs, prompt caching) |
-| Under `-p` nothing can prompt: without a host or `--permission-prompt-tool`, anything that would prompt is denied, listed in `permission_denials`, and the run continues. `dontAsk` denies anything not pre-allowed. | verified 2026-10-16 (research `4a`; docs, headless and permission modes) |
-| `system/init.model` is not the model that ran: read `modelUsage` or `assistant.message.model`. | verified 2026-10-16 (research `5d`, `F2a`, `F2c`; local tests M1, M2) |
-| `--permission-mode plan` upgrades a Haiku session to Sonnet. The docs imply it (availableModels section) and do not state it as a rule. | observed 2026-10-16 (research `5d`, `F2a`, `F2b`; local tests T1 to T5, M1, M2; docs only indirect) |
-| Aliases resolve by CLI version: `haiku` is Haiku 4.5 on 2.1.283 and Haiku 5.5 on 2.1.299 (Haiku 5.5 needs v2.1.293 or later, Sonnet 5.5 v2.1.284 or later). | verified 2026-10-16 (research `F2c`; local tests; docs, model config) |
-| Without `--bare`, `-p` loads installed plugins, skills, agents, hooks, MCP and CLAUDE.md like an interactive session. | verified 2026-10-16 (research `5a`; docs; local test T6) |
-| `--bare` skips all of that discovery and refuses OAuth (`Not logged in`); it needs `ANTHROPIC_API_KEY`. | verified 2026-10-16 (research `5b`, `F3d`; docs; local test E2) |
-| `--model` (alias or full id), `--agents`, `--agent`, `--append-system-prompt[-file]`, `--settings`, `--max-budget-usd`, `--max-turns` and `--json-schema` exist in 2.1.283. | verified 2026-10-16 (research `5c`; `--help`; docs) |
-| A nested `claude -p` inherits `CLAUDECODE=1` and `CLAUDE_CODE_CHILD_SESSION=1`; no recursion guard blocks it, and the session is still persisted. | verified 2026-10-16 (research `6a`; docs, env vars; local env listing) |
-| Agent depth is counted per process from its main conversation; the parent's depth is not passed down. A nested `claude -p` can use the Agent tool, and a second level nests too. At the depth limit the Agent tool is simply absent: no error. | verified 2026-10-16 (research `F1a` to `F1d`; local tests D1 to D3; docs, env vars) |
-| A nested process does not count against the parent's Agent depth or concurrency caps. | assumed 2026-10-16 (research `6b`; inferred from per-process `subagent_stats`, not tested with a deep parent) |
-| `--bg` does not combine with `-p`. | verified 2026-10-16 (research `6c`; docs, headless) |
-| A headless run is invisible to the parent's task notifications, `ListAgents` and `TaskStop`: the orchestrator must block on Bash or poll. | assumed 2026-10-16 (research `6c`; not a tracked Agent, never tested from a subagent) |
-| Transcripts land in `~/.claude/projects/<cwd with every non-alphanumeric character as '-'>/<session-id>.jsonl`, one file per fork, each holding the copied base history under its own `sessionId`; 30-day retention. | verified 2026-10-16 (research `6d`; docs, sessions; local listing) |
-| The nested process inherits the Desktop host's env: `CLAUDE_CODE_MESSAGING_SOCKET`, `CLAUDE_CODE_ENTRYPOINT=claude-desktop` and the OAuth-refresh variables, among others. Removing twelve of those vars (`F3a`) with `env -u` drops the Artifact tools (35 to 32 built-ins); auth still works. | observed 2026-10-16 (research `6e` as corrected by `F3a`, `F3b`; local tests T6, E1) |
-| The `messaging_socket_path` in `system/init` is the nested process's own pipe, different on every run and never the host's. This corrects the first reading of `6e`. | verified 2026-10-16 (research `F3c`; local tests T6, E1) |
-| Whether the nested process's pipe can reach the host app, and which single env var gates the Desktop Artifact tools. | unknown 2026-10-16 (research `F3c`; not isolated) |
-| The PATH `claude` (2.1.283, native installer) and the Desktop host's bundled `claude.exe` (2.1.299, reachable as `$CLAUDE_CODE_EXECPATH`) are separate installs. | verified 2026-10-16 (research `F5a`; local) |
-| A fork made by another binary or on another model misses the base's cache: a 2.1.299 fork of a 2.1.283 base read 0 and created 15,020. Pin one binary and a full model id for the base and all its forks. | verified 2026-10-16 (research `F5b`; local test V1; docs, prompt caching) |
-
-Observed in the Phase 0 preflight on this Windows host (2026-10-16):
-
-| Claim | Status |
-|---|---|
-| `uv run` adds `VIRTUAL_ENV` and a venv `Scripts` entry at the head of PATH, and sets no `UV_*` vars; stdout stays clean (one JSON line). | observed 2026-10-16 (preflight report, P0.0) |
-| No job objects on this host (`IsProcessInJob` false for the `uv run` launcher and every supervisor). | observed 2026-10-16 (preflight report, P0.1) |
-| The Bash tool's `TaskStop` kills by process tree (parent links). A supervisor created through CIM `Win32_Process.Create` (parent `WmiPrvSE.exe`) survived the stopped Bash call; rungs that start it as a child of the launcher died with it. | observed 2026-10-16 (preflight report, P0.1) |
-| A supervisor surviving the end of the agent's turn (the hand-back) was not tested in Phase 0; the parentage under `WmiPrvSE.exe` makes it expected. | unknown 2026-10-16 (preflight report, "Not tested / open"; Phase 4 smoke) |
-| An unhidden CIM spawn opens a visible Windows Terminal window. The fix is `Win32_ProcessStartup.ShowWindow=0` plus `CREATE_NO_WINDOW` on every child; no window was seen in 26 checks, including a `claude` to `bash` to `PING` tree. | observed 2026-10-16 (preflight report, P0.1) |
-| A CIM-created process gets the registry default user env, not the caller's (58 of the Bash env's variables missing, among them every `CLAUDE*` var and `CLAUDE_CODE_EXECPATH`), so the launcher must pass the full scrubbed env to the supervisor itself. | observed 2026-10-16 (preflight report, P0.1) |
-| The Bash tool backgrounds a call that passes its `timeout`; it does not kill it. | observed 2026-10-16 (preflight report, P0.1(d)) |
-| An unlisted model (not admitted by `availableModels`) is substituted silently: the run uses a permitted model and emits a `system/informational` warning ("Model … is restricted by your organization's settings. Using … instead."). | observed 2026-10-16 (preflight report, P0.5) |
-| An `!` injection runs in an Agent-tool subagent's skill preload, but the skill's `allowed-tools` did not pre-approve the subagent's later `uv run` call (denied: "This command requires approval"). The probe dir was an untrusted workspace; Phase 4 re-checks in a trusted project. | observed 2026-10-16 (preflight report, P0.8) |
+| `fork` is actually offered as an agent type in a given session. | unverified: the schema mentions it, but on 2026-10-05 it was not in the list of agent types offered to the reviewer |
+| A fork copies the **caller**, not an arbitrary agent. Only the agent holding a context (e.g. the Athanor as trunk) can fork it. | assumed (no parameter names a fork source; Igor's skill calls it "forking yourself") |
+| A fork starts with the caller's full transcript, so it starts at the caller's token count. | assumed, not measured |
+| Can a fork fork again? Does a foreground fork return its result to the caller? Does it see the caller's preloaded skills? | unknown; check in a throwaway preflight before relying on trunk and forks |
 
 ## Agent types