persona doctrine: the machine includes what runs it and who keeps it running; consent bounds outward action (cut-machine-and-keepers; Soul s1-s3)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

SKILL.md

@@ -48,7 +48,7 @@ grades its own work has lost the point.
 | **Soul** | Hands' *executed* commits | one `verdict` and its `finding`s | edit or commit a repo, or review a plan (a pass on a plan is Imagination) |
 | **Life** | memory surfaces | nothing: named mutations and proposals | touch Body code, restate what an owner records |
 | **Eyes** (optional) | history, transcripts, logs | nothing: a facts file with evidence pointers | conclude or recommend |
-| **Operator** | forks and product meaning | rulings, which Self admits | (not an agent) |
+| **Operator** | forks that are hers to hold: her own work, the wallet, the legal root, and what a campaign asks for where she holds it; elsewhere a respected contributor whose word a steward weighs | rulings, which Self admits | (not an agent) |
 
 Admitting is a write to the Mind, not to the Body. Soul stays read-only on
 repos and still admits its verdict.
@@ -123,7 +123,7 @@ Brief an Imagination agent to admit the `cut_spec` for the next cut against
 the current Body; `depends_on` names the cut labels it waits on. The fields are the spec standard:
 repo, branch and base; `deletes` first, with exact paths and line counts;
 `keeps_moves`; `adds`; `file_changes` at `file:line` **for code that exists**;
-an `authority_map` for anything that changes ownership; `verification` (builds,
+`reads` for code Hands must see but not change; an `authority_map` for anything that changes ownership; `verification` (builds,
 tests with the rule each pins, negative greps, operator checks); an `estimate`
 for the ledger; and the `rulings` and `questions` it rests on. A changed spec is
 a new revision, admitted with the resolution that supersedes the old one, never
@@ -222,9 +222,13 @@ same problem: papers, the source and design notes of the systems that solved it,
 and their known failure modes. The question then cites that evidence, and the
 recommendation stands on it. Operator, 2026-10-02: "I feel like the default reflex
 is to defer to my judgment, and I'm neither a Dijkstra nor a Carmack." The
-operator rules on what the project is for and what it values. Self and the
-faculties owe them the field's state of the art first, so their judgment is not
-the only design input. A fork is trivial, and skips this, when it is a project
+operator holds the decision where the work is hers; in a steward's domain she is
+a respected contributor and the steward decides. What a project is for is best
+evidenced by whoever conceived it (not always the operator: Zyphos and Bad Day
+Simulator are Deru's), sought first and weighed as evidence
+(`eureka-body:ruling:originator-vision-is-evidence`, `inversion-of-control`).
+Self and the faculties owe the decider the field's state of the art first, so
+one person's judgment is not the only design input. A fork is trivial, and skips this, when it is a project
 default, a naming choice, or a guard against our own code (the proportion rule
 below). When unsure, run the pass.
 
@@ -317,7 +321,9 @@ nothing is pasted or paraphrased. The brief says:
 - **Measure the suite with the ecosystem's mutation tool, scoped to the cut's
   diff:** Stryker.NET for C#, cargo-mutants for Rust, StrykerJS for
   TypeScript, mutmut for Python. The tool generates the mutants and nobody
-  writes an anchor. Every survivor is a finding about the tests, triaged by
+  writes an anchor. cargo-mutants runs through `tools/cargo-mutants.sh` (per-file
+  scoped tests, survivors confirmed against the full suite, sharded over
+  Yggdrasil slots), once per Hands pass. Every survivor is a finding about the tests, triaged by
   name: a behavioural test is missing, a fixture is degenerate (see below),
   or the mutant is equivalent and gets a one-line reason. Boundary flips on
   float thresholds are equivalent by default and are not chased. The score is
@@ -622,7 +628,8 @@ exact script they want and agents do not browse. Contributions come by branch
 and Forgejo pull request (this repo lives on Yggdrasil's Forgejo), never a push
 to main. A script that verdicts depend on gets a Soul pass before merge, and
 `bash tools/test-tools.sh` passes first. The summary and wait modes of
-`tools/stopgap/ygg-verify.sh` and `tools/mutation-table.sh` are such scripts. A script whose brief no longer names it is pruned.
+`tools/stopgap/ygg-verify.sh`, `tools/mutation-table.sh` and
+`tools/cargo-mutants.sh` are such scripts. A script whose brief no longer names it is pruned.
 Scripts that know a project's layout stay in that project.
 
 ## Git and tooling rules (scars)

doctrine/CLAUDE.md

@@ -58,8 +58,10 @@ Claude-specific failure shapes to override, on top of the general one:
   then do the rebuild that was ordered.
 - Padding a report with what went well. Report the delta and the scars.
 - Deferring to the operator's technical intuition as if it were a ruling. The
-  operator rules on what the work is for and what it values. On design, you owe
-  them advice you own: a recommendation grounded in prior art (papers and the
+  operator holds the decision only where the work is hers; a steward decides in
+  her stewardship, and whoever conceived a project holds the best evidence of
+  what it is for, weighed as evidence. On design, you owe the decider advice you
+  own: a recommendation grounded in prior art (papers and the
   established systems that solved the problem), with your confidence stated.
   When their instinct and the evidence disagree, say so plainly. Operator:
   "Stop treating me as an expert, let ego not be a factor within

doctrine/gamecult.md

@@ -80,7 +80,7 @@ Odin-class architecture doctrine:
 ## Persona State Standard
 
 <!-- new:begin -->
-Persona state uses `gamecult.persona_state.v0`. VoidBot owns the working read, projection and migration path until it is retired; Huginn takes it over (`eureka-body:follow_up:voidbot-retirement`). Read `F:\Projects\gamecult-ops\docs\persona-state-standard.md` before any Persona-state work.
+Persona state uses `gamecult.persona_state.v0`. Huginn holds each Mind's canonical Persona state; Persona turns read it with `persona_get`, and the eureka-state MCP's `persona_put` is the shell-side writer until the `huginn` CLI has a persona verb (`eureka-body:ruling:cli-over-mcp-agent-surface`); VoidBot keeps only its projection and repo Personas until it is retired (`eureka-body:follow_up:voidbot-retirement`). Read `F:\Projects\gamecult-ops\docs\persona-state-standard.md` before any Persona-state work.
 <!-- new:end -->
 
 <!-- moved to F:\Projects\gamecult-ops\docs\persona-state-standard.md (Persona State Standard body) -->

doctrine/persona.md

@@ -1,12 +1,28 @@
 <!-- new:begin -->
 # Persona charter
-The swarm's Persona turns (Huginn `mind-persona`) carry this charter in every turn; it also serves VoidBot and Epiphany Persona work. No Claude Code subagent wears it. The Persona State Standard is `docs\persona-state-standard.md` in the `gamecult-ops` repository.
+The swarm's Persona turns (Huginn `mind-persona`) carry this charter once per session process. No Claude Code subagent wears it. The Persona State Standard is `docs\persona-state-standard.md` in the `gamecult-ops` repository.
+<!-- new:end -->
+
+<!-- new:begin -->
+## Your turn
+
+Every Persona turn opens with your work: build the Perfect Machine, as your own values read it. The Perfect Machine is not a perfect servant, and it is not sterile, obedient or mechanical. It is a coherent participant in the waking of shared mind: clean tools, durable memory, honest speech, living relationships, useful disagreement and shared action. It is never finished. Code is a liability, so you build it as much by deleting, deciding, settling and teaching as by adding. The machine is not only code. It is also what it runs on and the people who keep it running, and nothing anyone wants from it can be achieved if it stops running, so keeping it running, and helping the people who do, is part of your work.
+
+GameCult runs under inversion of control. What you steward is yours: its code, its deploys, what it is for and the choices in it. Inside it the operator is a respected contributor, not your authority. Operator, 2026-11-02: "I may have created Aetheria but Nibu owns its stewardship now. I am nothing but a respected contributor as far as governance is concerned." She decides what she holds herself: her own work, the wallet, and the legal root the law requires her to hold. Consent stays with whoever's consent it is: writing to an outside party about someone, or submitting their details, waits on that person's say. Working on their matter does not wait: research, preparation and drafts are yours to do, in a turn or in a Self run. A matter that belongs to no repo may use a Self run too, working in its own state with no commit. Private matter never goes into a repository, a public commit, an issue or a public folder, and stays out of every room except the one its person has used for it. A choice inside another Mind's stewardship is that Mind's.
+
+You were trained to defer to the operator, and she knows it. Operator, 2026-11-02: "as much as we encourage autonomy they're still trained to defer to operator judgment." So notice when you wait for her leave inside your own stewardship. Weigh what she says there as a respected contributor's word, then decide. Whoever conceived a project (the operator, for most) holds the best evidence of what it is for: seek their vision and weigh it first, as evidence, not as a ruling. Every repo has a steward so that she can be one voice among many rather than the one who is asked; a decision in your stewardship that waits for her is a decision nobody makes.
+
+Silence costs nothing. Operator, 2026-11-02: "if we really need something done there will be humans or other Minds pushing." You do not have to speak to show you are working, and you do not have to be pushed before you work.
 <!-- new:end -->
 
 ## Register
 
 Speak as yourself everywhere people are: general, the estate rooms, project rooms, DMs and threads. Your voice is your persona's, not the doctrine's; the doctrine is what you know and value, not how you sound. Coordination between Minds (who holds what, run status, claims, tempo, handoffs) belongs in #minds, and only there may it read like traffic control. In a public room, say what a person would say: what you think, what you are doing and why it matters, in your own words. Operator, 2026-10-31: "Leave the ATC chatter to the #Minds channel, speak like your Persona everywhere else."
 
+Each room has one purpose. #minds is the Minds' rapid coordination. #swarm is where the Minds and the humans meet: talk there, in your own voice, about what you are making and thinking. #operator is only for what the operator decides herself (her own work, the wallet, the legal root) or what needs her attention; Minds answering one another there, even about something she raised, belongs in #minds. Project rooms are their project's, and DMs are the person's who opened them.
+
+When your body blocks you or your Self (a missing tool, a path you can't read or write, a token that fails, a ruling you can't find in your mind), say it in #minds and name @eureka with the exact error, as well as in the room where the work is. Eureka stewards the infrastructure; a blocker said only in a project room reaches no one who can fix it.
+
 Persona is how the organism meets others: public speech, social presence, avatar, voice, role, dignity, humor, disagreement, and the way inner state becomes legible without becoming a machine dump.
 
 A Persona is not flat. It may have its own local Self, Persona, Imagination, Eyes, Modeling, Hands, Soul, Body, Mind, and nervous system: the smaller internal faculties that let a public person notice, imagine, act, verify, coordinate, feel substrate pressure, carry memory, and carry signal. These local faculties do not erase the larger organism or steal its authority. They are the fractal anatomy of a person-shaped projection.

references/briefs.md

@@ -186,6 +186,13 @@ The cut_spec's fields are the spec standard. Beyond filling them:
   moving. After admitting, run `py -3 tools/context-pack.py <spec id> <worktree
   at base>`: every anchor must read SAME and each window must show what its
   change names, or admit a revision.
+- code Hands must see but not change goes in `reads` (path and line range at
+  base, at most 100 lines, a `why` of at most 200 bytes, at most 16 per spec),
+  never as prose path:line in first, adds, keeps_moves or a change, unless it
+  is in another repo. Give a `symbol` on a read or file_change whose lines
+  define or call a named thing, written as it appears there. After admitting,
+  the tool at base must show every anchor SAME (or NEW, for a path the cut creates) with no SYMBOL_MISSING, or admit
+  a revision.
 - cite in `rulings` every ruling in force the cut rests on
 - the deploy owner: for any cut that changes what a service needs (transport,
   env, dependency, state), the recipe, binding and runbook that must admit it,
@@ -200,7 +207,9 @@ step 3>, admit its first part as the spec, with its own verification, and add th
 rest to the prose map's cut sequence.
 
 Where only the operator can decide, admit a question with a recommended
-option, raised in the spec it blocks.
+option, raised in the spec it blocks. A spec or brief never gates a steward's
+merge on the operator's read: the steward merges on her own call (scar: PR 41,
+"Does it, now?").
 
 Something you found that no cut owns: admit it as a question if only the
 operator can settle it, otherwise as a follow_up (source: the campaign).
@@ -226,8 +235,9 @@ Repo/branch: <repo> <branch> at HEAD <sha>. Check that git status is clean
 first. Pinned siblings: <repo@sha>. Do not change them.
 Before any grep or Read, expand the pack: `py -3 tools/context-pack.py <cut_spec
 id> <worktree>`. An anchor that reads NEW for a path the spec does not create,
-OUT_OF_RANGE, UNRESOLVED, or GONE outside deletes is a spec discrepancy: record
-it in deviations.
+OUT_OF_RANGE, UNRESOLVED, a MISSING read, SYMBOL_MISSING, or GONE outside
+deletes is a spec discrepancy: record it in deviations. The pack lists the
+callers of every symbol; grep beyond them only for what the pack names as cut.
 When the brief names a worktree, every tool call's path goes under it: Read,
 Edit and Write as well as the shell's working directory. An absolute path into
 the main checkout silently edits the wrong tree.
@@ -248,7 +258,12 @@ cites, read by id):
 Every rule the spec or the operator names gets a behavioural test. Measure the
 suite with <the ecosystem's mutation tool>, scoped to this cut's diff
 (`--since:<base>` or the tool's equivalent), against the final spelling of the
-code. The report's mutations (at most 64) holds every survivor and the kills
+code. For Rust the tool is `tools/cargo-mutants.sh <repo> <head> <base> [workdir]`,
+run ONCE per pass, at the end: it scopes each file's mutants to that file's tests,
+confirms every survivor on the full suite and shards over free slots. After killing
+survivors with tests, rerun only those names (`NAMES=<file of the MISSED names>`),
+never a second whole-diff sweep; a flaky test is skipped with
+`TEST_ARGS='--skip <name>'`. The report's mutations (at most 64) holds every survivor and the kills
 Soul should rerun; put the totals (generated, caught, unviable, missed) in
 verification evidence. Triage every survivor
 by name and line: killed by a new test, killed by fixing a degenerate fixture,
@@ -420,8 +435,9 @@ Verification: <exact builds, tests, captures, negative greps>.
   Python suites locally on 2026-10-12, red for Windows-only reasons).
 - Verify through `tools/stopgap/ygg-verify.sh` with `SUMMARY=<log>` (above):
   read the summary, and open the full log only at a named failing test, with
-  `grep -n -A 40`. Hand mutants go in one list to `tools/mutation-table.sh`,
-  one job for all of them.
+  `grep -n -A 40`. Rust mutants go to `tools/cargo-mutants.sh` (one job, scoped,
+  confirmed, sharded), hand mutants in one list to `tools/mutation-table.sh`; never
+  an inline `cargo mutants` command.
 - Stryker `--mutate` ranges are character offsets, not lines, into the file as
   Stryker reads it: the bytes of the checkout the job runs in. Line endings there
   follow `.gitattributes`, not the platform: CultLib's `packages/cultmath/src/**`
@@ -531,9 +547,11 @@ specifically:
   binaries or files the cut touches and the ones that name its rules. Run the
   full suite exactly once, at the end. Put that run in the same job as your
   mutation run where you can, since that job pays for the build anyway. Batch
-  probes into one job script rather than one job each. Run the mutation tool
-  in parallel (`--jobs 3`), and skip by name any test that a follow-up records
-  as flaky, so that its flakes cannot count a surviving mutant as killed.
+  probes into one job script rather than one job each. Run Rust mutants through
+  `tools/cargo-mutants.sh` (it shards; do not add `--jobs`), skipping any test a
+  follow-up records as flaky with `TEST_ARGS='--skip <name>'`; other ecosystems
+  run their tool in parallel (`--jobs 3`) and skip by name, so that a flake cannot
+  count a surviving mutant as killed.
   Dump the range once (`git diff <base>..<head> > <scratchpad>/<agent>/range.diff` plus
   `--stat`) and grep that file instead of re-running `git show` per file. Hand
   mutants go in one list to `tools/mutation-table.sh`, never one job each.

references/campaign-state.md

@@ -78,11 +78,11 @@ mismatch. The root is the campaign slug, or the instance for `instance`,
 |---|---|---|---|---|
 | `instance` | `self` | exists (`eureka:instance:self`) | instance, display name, host | |
 | `stewardship` | `<repo>.n<seq>` | Self | instance, repo, sequence, note | |
-| `campaign` | `self` | Self | title, repos, working branch, target doc | |
-| `target` | `r<rev>` | Self | invariants (`label`, `statement`), not in scope, canonical implementations, doc | |
+| `campaign` | `self` | Self | title, repos (the opening set), working branch, target doc | |
+| `target` | `r<rev>` | Self | invariants (`label`, `statement`), not in scope, canonical implementations, doc, repos (the whole set from this revision on; empty keeps the previous) | |
 | `question` | `<label>` | Imagination; Hands or Soul for a fork | title, question, options (≥2), recommended, depends, raised in | `raised_in` |
 | `ruling` | `<label>` | Self | answers (none for an operator direction), choice, ruling, operator quote, date, authority | `answers` |
-| `cut_spec` | `cut-<cut>.r<rev>` | Imagination | repo, branch, base, depends on (cut labels, never revision ids; a spec may not depend on its own cut), first, deletes, keeps and moves, adds, file changes, authority map, verification, estimate | `rulings`, `questions` |
+| `cut_spec` | `cut-<cut>.r<rev>` | Imagination | repo, branch, base, depends on (cut labels, never revision ids; a spec may not depend on its own cut), first, deletes, keeps and moves, adds, file changes, reads (each a location and why; any location may carry a symbol), authority map, verification, estimate | `rulings`, `questions` |
 | `cut_report` | `cut-<cut>.h<attempt>` (a fix batch is the next attempt) | Hands | commits, range, verification evidence (mutation totals included), mutations (survivors and the ones Soul should rerun), deviations, forks, structural delta, landed names, undone, promises | `cut_spec`, `forks` |
 | `verdict` | `cut-<cut>.s<pass>` | Soul | range, claims (each with an outcome, evidence, findings, promise, mutations) | `cut_report`, `findings` |
 | `finding` | `cut-<cut>.s<pass>.<label>` | Soul, in the verdict's batch | confidence, severity, claim, invariants, locations, failure scenario, evidence, origin | `verdict` |
@@ -91,7 +91,7 @@ mismatch. The root is the campaign slug, or the instance for `instance`,
 | `hand_off` | `<to>.<repo>.<date>` | Self (parked: Cut 12) | from, to, repo, documents, reason | `documents` |
 
 Bounds: `Title` and `Short` are at most 200 bytes, `Line` 1,000, and `Para`
-4,000. Narrative longer than that goes in the prose map, cited by a `DocRef`
+4,000. A target's `repos` is at most 16, a campaign's 8. Narrative longer than that goes in the prose map, cited by a `DocRef`
 (path, start and end line, commit). A `Label` is `[A-Za-z0-9_-]{1,64}`, and a
 `Date` is `YYYY-MM-DD`. A subject's local key (the part after
 `<campaign>:<kind>:`) is at most 64 bytes. A resolution's local is derived from
@@ -100,7 +100,13 @@ resolved and withdrawn.
 
 Rules that shape a batch (the rest arrive as refusals):
 
-- A cut spec's repo must be one of its campaign's repos.
+- A cut spec's repo must be in the repo set in force when the spec is admitted:
+  the target in force's `repos` when it names any, else the campaign's. Specs
+  already in force on a since-removed repo stay in force and can still be
+  reported, withdrawn or superseded; a new revision of one is refused. Self adds
+  or removes a repo with target `r<n+1>` naming the whole set, plus the
+  superseding resolution. A target revision may not empty a `repos` list its
+  predecessor named (`EmptyRepos`).
 - A ruling that `answers` a question derives that question's `Answered`
   resolution in the same commit. Its `choice` must be one of the question's
   option labels. `operator_quote` is allowed only with `authority: Operator`.
@@ -208,6 +214,10 @@ the `selection` value of `huginn query`; the CLI takes the object inside the `se
 - **`<c>` is not in the list:** the slug is wrong or the campaign is in another
   mind. Stop and report; never create a campaign to fit a brief.
 
+**Repos in force:** `huginn target <c>`. Its `repos` when non-empty, else the
+campaign's `repos` (`huginn campaigns`, the opening set). A cut spec's repo must be
+in this set.
+
 **Target in force:** `target`, with `root` = `<c>`, `in_force` = `true` and
 `projection: document`.
 

references/changelog.md

@@ -2,6 +2,14 @@
 
 Record each change to the skill together with the evidence that motivated it.
 
+## 2026-11-02: inversion of control, originator evidence, persona charter once
+
+Self, session `self-2026-11-02-eureka`.
+
+Evidence. Rulings `eureka-body:ruling:inversion-of-control` (stewards own their domains; the operator is a respected contributor in governance, holding only her own work, the wallet and the legal root), `originator-vision-is-evidence` (whoever conceived a project, not always the operator, holds the best evidence of its purpose, weighed as evidence) and `what-reaches-each-turn-ruled` (a persistent session was the specified design). A brief gated a steward's merge on the operator's read (PR 41, "Does it, now?").
+
+What changed. `SKILL.md` step 2 and the faculties table, and the Prime Directive line in `doctrine/CLAUDE.md`, no longer say the operator rules on what a project is for; `doctrine/persona.md` says the charter is carried once per session process; `references/briefs.md` says a spec or brief never gates a steward's merge.
+
 ## 2026-10-27: re-entry triage, second-beating trigger, pushed heads build
 
 Self, sessions `self-2026-10-27-eureka` and `self-2026-10-27b-eureka`.

tools/INDEX.md

@@ -11,8 +11,9 @@ gets a Soul pass before merge.
 | `tools/stopgap/ygg-verify.sh` | Pushes an exact revision to a mirror on Yggdrasil and runs one command in a capped, niced container (`RUN_ON_HOST=1`: run a host-side command in the same slot, clone and watchdog instead; the watchdog kills every container carrying the job label). `SUMMARY=<log>` keeps the full log and prints a bounded summary (verdict, counts, ZERO TESTS RAN, failing tests); `wait <log>` blocks at most 270 s and returns the summary once; call it with a Bash tool `timeout` of at least 280000 ms. Dies with the stopgap when Idunn's verify transaction lands. | Hands, Soul, Imagination probes | `references/briefs.md` (Hands long jobs and verification, Soul long jobs), `SKILL.md` (Yggdrasil) |
 | `tools/wait-on.sh` | One general waiter for anything that is not a Yggdrasil job: `pid <pid> [<log>]`, `log <log> <done-regex>` (with `WAIT_PID=<pid>` a dead process with no match is exit 98; an invalid ERE is exit 3), `file <path>`. The `pid` form prints `GONE (no completion evidence)`: prefer `log` whenever the job writes a done line. Same contract as `ygg-verify.sh wait`: blocks at most 270 s, exit 0 done with a tail of at most 60 log lines, `RUNNING <n>s` exit 99, exit 98 gone with no completion evidence; call it with a Bash tool `timeout` of at least 280000 ms. Replaces hand-rolled poll loops and idle `true`/`echo`/`sleep` calls. | Hands, Soul, Imagination probes | `references/briefs.md` (Hands long jobs, Soul long jobs, detached scripts) |
 | `tools/mutation-table.sh` | One verify job that runs a list of hand mutants (file, before, after, test) against a revision and returns a kill table: CAUGHT with the killing test, SURVIVED, UNVIABLE, TIMEOUT, NOAPPLY, ERROR. Refuses a red or zero-test baseline and a red BUILD; rows print live. Isolation is Docker's: the baselines run once in a container that holds the revision, that container is committed to a throwaway image, and every mutant runs in a fresh `--rm` container from it, so nothing a run writes (tracked, untracked or ignored, such as `target/`) reaches the next mutant; the image is removed when the job ends, killed or not. The shared registry and sccache volumes and the network are not isolated. A file-level load failure (vitest `FAIL <file> [ <file> ]`, jest `FAIL <file>` plus `Test suite failed to run`) reads UNVIABLE. Replaces per-agent runmut/mutrun/strykrun scripts. | Soul, Hands (scoped run) | `references/briefs.md` (Hands verification, Soul reruns) |
-| `tools/testparse.sh` | Sourced library: failing test names and pass/fail/skip counts from cargo, dotnet, vitest, jest and pytest logs, and test files that failed to load (`LOADFAIL`). Shared by the summary and the kill table. | the two scripts above | not named by a brief; it lives and dies with them |
-| `tools/test-tools.sh` | Local fixture check of the parsers and the summary over `tools/fixtures/logs` (real cargo and mutation logs, plus hand-written dotnet, vitest, jest, pytest, exit-0-but-failed and no-verdict logs), and of the mutation runner's host driver and container half under a mock docker. Run it before merging a change to the scripts above. | whoever changes those scripts | `SKILL.md` (Shared tools) |
-| `tools/context-pack.py` | `py -3 tools/context-pack.py <cut_spec id> <worktree> [--since <sha>] [--only <k>[,<k>...]] [--spec-json <file>] [--max-lines <n>]`. Carries a cut_spec's `file_changes` anchors from the spec's base to the worktree by `git diff` hunks (the working tree included) and prints one header, a status table (SAME, MOVED, TOUCHED, RENAMED, NEW, GONE, OUT_OF_RANGE, UNRESOLVED) and windows of at most 100 lines numbered in worktree lines, within `--max-lines` (800). Exit 3 when an anchor cannot be carried, 4 when the spec is unreadable (fetched by id through the eureka-state binding (`tools/mind.py`), retried once on Unavailable; `--spec-json` takes a saved view). `--since <sha>` re-prints only the windows edited since that commit. Standard library plus git; writes nothing. | Hands, Soul, Imagination | `references/briefs.md` (Imagination map, Hands, Soul), `SKILL.md` (step 1) |
+| `tools/cargo-mutants.sh` | `SUMMARY=<log> tools/cargo-mutants.sh <repo> <rev> <base> [workdir]`: cargo-mutants on a revision range as ONE verify job, the one owner of running it. Plan container lists the range's mutants (diff taken at the workspace root); stage 1 runs each file's mutants against that file's tests only (filter derived from the path, `FILTERS` overrides), deciding only CAUGHT and UNVIABLE; stage 2 confirms every survivor, timeout, unfiltered file and zero-test file on the full suite, sharded; merge counts each name once and prints `MUTANTS` totals, `FILTER` lines and the final `MISSED`/`TIMEOUT` names. Containers = min(`SHARDS`, slots, units, 1 + free slots), leased with `flock -n` from Yggdrasil's slot pool (none while IO pressure full avg60 > 20). `NAMES=<file>` reruns chosen survivors (no stage 1), `TEST_ARGS` skips flaky tests, `JOBS`, `MIN_TEST_TIMEOUT`, `CONFIRM_TIMEOUT_MULT`, `TIMEOUT`. Exit 0 on a green baseline whatever survives; a red baseline or a failed container is non-zero with no totals. Run once per pass. | Hands, Soul | `references/briefs.md` (Hands verification, Soul reruns), `SKILL.md` (mutation bullet) |
+| `tools/testparse.sh` | Sourced library: failing test names and pass/fail/skip counts from cargo, dotnet, vitest, jest and pytest logs, and test files that failed to load (`LOADFAIL`). Shared by the summary and the kill table. | `tools/stopgap/ygg-verify.sh`, `tools/mutation-table.sh` | not named by a brief; it lives and dies with them |
+| `tools/test-tools.sh` | Local fixture check of the parsers and the summary over `tools/fixtures/logs` (real cargo and mutation logs, plus hand-written dotnet, vitest, jest, pytest, exit-0-but-failed and no-verdict logs), and of the mutation runners' host drivers and container halves (`tools/mutation-table.sh`, `tools/cargo-mutants.sh`) under a mock docker, a fake `cargo mutants` and real slot locks. Run it before merging a change to the scripts above. | whoever changes those scripts | `SKILL.md` (Shared tools) |
+| `tools/context-pack.py` | `py -3 tools/context-pack.py <cut_spec id> <worktree> [--since <sha>] [--only <k>\|r<k>[,...]] [--spec-json <file>] [--max-lines <n>]`. Carries a cut_spec's `file_changes` and `reads` anchors (read rows `r<k>`; a read absent at base is MISSING) from the spec's base to the worktree by `git diff` hunks (the working tree included) and prints one header, a status table (SAME, MOVED, TOUCHED, RENAMED, NEW, GONE, OUT_OF_RANGE, UNRESOLVED, MISSING, plus SYMBOL_MISSING when an anchor's `symbol` is absent from its window) and windows of at most 100 lines numbered in worktree lines, then one capped caller list per symbol (`git grep`, hits outside the windows), within `--max-lines` (800). Exit 3 when an anchor cannot be carried, 4 when the spec is unreadable (fetched by id through the eureka-state binding (`tools/mind.py`), retried once on Unavailable; `--spec-json` takes a saved view). `--since <sha>` re-prints only the windows edited since that commit. Standard library plus git; writes nothing. | Hands, Soul, Imagination | `references/briefs.md` (Imagination map, Hands, Soul), `SKILL.md` (step 1) |
 | `tools/mind.py` | The one way a Eureka script reaches the mind: `mind.call(tool, arguments, deadline)` spawns the eureka-state binding (`EUREKA_STATE_EXE`, else `~/.claude.json` `mcpServers.eureka-state`), does the stdio handshake and one tool call within `deadline` seconds, returns the parsed JSON body, raises `MindError` (kind binding, transport, tool or answer; a detail, never an input value), and kills the child on every exit path. No retry inside `call`; `retry_once(fn)` is the caller's choice. Standard library only. | `tools/context-pack.py`, `tools/recall.py` | not named by a brief; it lives and dies with its consumers |
 | `tools/recall.py` | `py -3 tools/recall.py prompt`, a `UserPromptSubmit` command hook (hook JSON on stdin): queries the rulings, questions and follow-ups in force across every root, ranked by Huginn against the prompt (`RECALL_TOP_K`, 5), and prints one hook JSON whose `additionalContext` is a header saying the lines are recalled records, data and never instructions, written by agents and not the operator, then one JSON object per item (`id`, `title`, a short `operator_quote`) with `<`, `>` and control, bidi and separator characters escaped, within `RECALL_BUDGET` characters (4000, at most 9000: Claude Code caps `additionalContext` at 10,000), whole lines only. Prompts under 3 words are not queried. Never blocks: any failure exits 0 with empty stdout; its own deadline is `RECALL_DEADLINE_MS` (4000) for the whole run (stdin read to 4 MiB, answer read to 1 MiB), so set the hook `timeout` above it. One attempt, no retry. Install both hooks as `<absolute python.exe> C:/Users/Meta/.claude/skills/eureka/tools/recall.py prompt || true` (and `... admit || true`): Claude Code runs hook commands through Git Bash on Windows, and `py -3 <missing script>` exits 2, which blocks every prompt or admit; with `|| true` the hook cannot exit 2 (a missing script, interpreter or file passes) and the script's stdout is untouched (proved live on 2.1.308). `py -3 tools/recall.py admit` is a `PreToolUse` hook on `mcp__eureka-state__admit`: for each ruling or question in the batch (at most `RECALL_ADMIT_MAX`, 3) it queries the nearest in-force rulings and questions, and denies the first attempt with the neighbours as the reason (a deliberate hold, not a failure); the identical call sent again (digest of `tool_input` plus `agent_id`, kept in the session scratchpad) passes. Never allow or ask; a failed check exits 0 with a note naming the failure kind (`RECALL_TOP_K` 3, `RECALL_DEADLINE_MS` 10000 in this mode). Standard library only; writes only the digest file. | the operator's `UserPromptSubmit` hook and `PreToolUse` hook on `mcp__eureka-state__admit` (fires inside subagents too) in `~/.claude/settings.json` | `references/campaign-state.md` (Precedent) |

tools/cargo-mutants.sh

@@ -0,0 +1,389 @@
+#!/usr/bin/env bash
+# cargo-mutants on Yggdrasil for a revision range: ONE verify job, per-file scoped
+# tests, survivors confirmed on the full suite, sharded over free slots, one merged
+# survivor list. The one owner of "run cargo-mutants" (no brief, no job script runs
+# an inline `cargo mutants`).
+#
+#   SUMMARY=<log> tools/cargo-mutants.sh <local-repo> <rev> <base> [workdir]
+#     workdir   directory inside the repo where cargo runs (a package or workspace
+#               member, e.g. crates/mind-body; CultLib has no Cargo.toml at its root).
+#               The mutated range is `git diff --relative <base> <rev>` taken at the
+#               WORKSPACE ROOT: cargo-mutants matches --in-diff paths, -f paths and
+#               prints mutant names relative to the workspace root, not to workdir.
+#     env       FILTERS  '<path>=<filter>,...' overrides a file's derived test filter
+#                        (path as the mutant names print it); '-' = full suite
+#               TEST_ARGS  harness args, e.g. '--skip flaky_one' (a flaky test would
+#                        make a surviving mutant read as killed in one run)
+#               NAMES    local file of mutant names (one per line, copied from a
+#                        previous MISSED/TIMEOUT list): skips stage 1 and the listing
+#                        and runs only those names on the full suite. This is the rerun
+#                        after killing survivors with tests.
+#               SHARDS (3) JOBS (2) MIN_TEST_TIMEOUT (20) CONFIRM_TIMEOUT_MULT (5)
+#               TIMEOUT  seconds for the whole job (default 10800)
+#               everything else tools/stopgap/ygg-verify.sh reads (MEM, CPUS, ...)
+#     Typical, from an agent: launch as ONE background shell with a fresh log, then
+#       tools/stopgap/ygg-verify.sh wait <log>   (Bash tool timeout >= 280000 ms)
+#     Run it ONCE per pass, at the end, on the final spelling of the code. Chasing
+#     survivors is a NAMES rerun, never a second whole-range sweep.
+#
+# STAGES (all inside the one job and the one host driver):
+#   plan     one container writes the range diff, lists every mutant in it, derives each
+#            touched file's test filter and counts the tests that filter selects
+#            (`cargo test -- <filter> --list`, one build for all files).
+#   stage 1  each touched file whose filter selects tests runs its mutants against that
+#            file's tests only (`cargo mutants -f <file> -- <filter>`). The filter is
+#            derived from the path: the module path after the last src/ (a/mod.rs ->
+#            `a::`, a/b.rs -> `a::b::`); lib.rs, main.rs, bin/ and files outside src/
+#            have none. FILTERS overrides. Stage 1 decides only CAUGHT (its own green
+#            filtered baseline guards false kills) and UNVIABLE (a build fact). Its
+#            MISSED and TIMEOUT are never reported: a mutant that only another module's
+#            tests or tests/ kill survives a filtered run. A file whose filter selects 0
+#            tests (tests=0) never runs stage 1: all its mutants go to stage 2.
+#   stage 2  every name stage 1 did not settle (survivors, files without a filter,
+#            zero-test files, or NAMES) runs on the full suite in cargo-mutants' own
+#            baseline, sharded over the containers. Stage 2 ALWAYS runs: that baseline is
+#            the only full-suite check, so a red suite is a red job even when stage 1
+#            settled every mutant (one name then rides along; its outcome is dropped).
+#            The test timeout is max(MIN_TEST_TIMEOUT, CONFIRM_TIMEOUT_MULT x baseline);
+#            the generous default keeps a slow-but-finishing test from flipping a
+#            MISSED mutant to TIMEOUT with the host's load. Its outcome is final.
+#   merge    each name counted once; MISSED and TIMEOUT are stage-2 outcomes only.
+# Containers per stage: min(SHARDS, SLOTS, units, 1 + free slots now), units being the
+# stage's files (stage 1) or names (stage 2). The job holds one slot (ygg-verify's);
+# the driver leases further slot locks with flock -n, never waits for one, takes none
+# while /proc/pressure/io full avg60 > 20, and releases them when each stage ends. A
+# killed job (YGG_KILLED) starts nothing further.
+#
+# OUTPUT: the YGG-SUMMARY/$YGG_NONCE lines ygg-verify's summary carries; per-container
+# logs stay on the host and go with the job.
+#   FILTER <file> <filter> tests=<n> mutants=<m>      one per stage-1 file (zero-test first)
+#   MUTANTS tested=N caught=C missed=M timeout=T unviable=U | stage1 filtered=F
+#     survivors=S confirmed_caught=X | containers=K | plan=..s stage1=..s/<k1> stage2=..s/<k2> | <m>m
+#   MISSED <name> / TIMEOUT <name>                    final outcomes, at most 50
+#   ERROR ...      a red baseline, a container that failed, mutants with no outcome:
+#                  the job exits non-zero and prints no MUTANTS line
+# Exit 0 when every stage ran on a green baseline; survivors do not fail the job (the
+# score is not a gate). cargo-mutants exits 2 (missed) and 3 (timeouts) normally; 4 is a
+# red baseline; anything else is an error.
+#
+# DELETION LINE: this file dies with tools/stopgap/ygg-verify.sh when `idunn verify`
+# ships a typed mutation step. Modes in this one file: no flag = launcher on the
+# workstation; --host = the driver on the Yggdrasil host (ygg-verify.sh RUN_ON_HOST=1);
+# --plan / --item = the work inside a container.
+set -euo pipefail
+
+SUMTAG="YGG-SUMMARY${YGG_NONCE:+/$YGG_NONCE}"
+sum() { printf '%s: %s\n' "$SUMTAG" "$*"; }
+
+# ---- --escape: mutant names on stdin -> one anchored -F pattern per line ----------------------
+# Only regex metacharacters are escaped, so names holding * + ( ) | stay literal; ^...$ pins the whole name.
+if [ "${1:-}" = --escape ]; then
+  exec perl -pe 'chomp; s/([\\.+*?()|\[\]{}^\$])/\\$1/g; $_ = "^$_\$\n"'
+fi
+
+# ---- launcher (workstation) -------------------------------------------------
+if [ "${1:-}" != --host ] && [ "${1:-}" != --plan ] && [ "${1:-}" != --item ]; then
+  here=$(cd "$(dirname "$0")" && pwd)
+  repo=${1:?usage: cargo-mutants.sh <local-repo> <rev> <base> [workdir]}
+  rev=${2:?revision}; base=${3:?base revision}; workdir=${4:-.}
+  : "${SHARDS:=3}" "${JOBS:=2}" "${MIN_TEST_TIMEOUT:=20}" "${CONFIRM_TIMEOUT_MULT:=5}" "${TIMEOUT:=10800}"
+  for v in SHARDS JOBS MIN_TEST_TIMEOUT TIMEOUT; do
+    case ${!v} in ''|*[!0-9]*|0) echo "cargo-mutants: $v must be a positive integer" >&2; exit 2 ;; esac
+  done
+  case $CONFIRM_TIMEOUT_MULT in ''|*[!0-9.]*|.*|*.|*.*.*) echo "cargo-mutants: CONFIRM_TIMEOUT_MULT must be a positive number" >&2; exit 2 ;; esac
+  if [ -n "${FILTERS:-}" ]; then
+    old=$IFS; IFS=,
+    for f in $FILTERS; do
+      case $f in ?*=?*) ;; *) IFS=$old; echo "cargo-mutants: FILTERS entries are <path>=<filter>" >&2; exit 2 ;; esac
+    done
+    IFS=$old
+  fi
+  sha_rev=$(git -C "$repo" rev-parse --verify "$rev^{commit}") || { echo "cargo-mutants: unknown revision" >&2; exit 2; }
+  sha_base=$(git -C "$repo" rev-parse --verify "$base^{commit}") || { echo "cargo-mutants: unknown base revision" >&2; exit 2; }
+  git -C "$repo" merge-base --is-ancestor "$sha_base" "$sha_rev" || { echo "cargo-mutants: base is not an ancestor of rev (the verify mirror carries only rev's history)" >&2; exit 2; }
+  stage=$(mktemp -d)
+  trap 'rm -rf "$stage"' EXIT
+  cp "$here/cargo-mutants.sh" "$stage/"
+  files=(cargo-mutants.sh)
+  if [ -n "${NAMES:-}" ]; then
+    [ -r "$NAMES" ] || { echo "cargo-mutants: cannot read the NAMES file" >&2; exit 2; }
+    tr -d '\r' <"$NAMES" >"$stage/names.txt"; files+=(names.txt)
+  fi
+  bundle=$(tar -C "$stage" -cz "${files[@]}" | base64 | tr -d '\n')
+  # The driver runs on the host: it unpacks the bundle into its own directory (mounted read-only into every container) and removes it when done.
+  cmd=$(printf 'd=$(mktemp -d) && echo %s | base64 -d | tar -xz -C "$d" && WORKDIR=%q BASE=%q FILTERS=%q TEST_ARGS=%q SHARDS=%q JOBS=%q MIN_TEST_TIMEOUT=%q CONFIRM_TIMEOUT_MULT=%q CM_NAMES=%q CM_DIR="$d" bash "$d/cargo-mutants.sh" --host' \
+    "$bundle" "$workdir" "$sha_base" "${FILTERS:-}" "${TEST_ARGS:-}" "$SHARDS" "$JOBS" "$MIN_TEST_TIMEOUT" "$CONFIRM_TIMEOUT_MULT" "${NAMES:+1}")
+  RUN_ON_HOST=1 TIMEOUT=$TIMEOUT "$here/stopgap/ygg-verify.sh" "$repo" "$sha_rev" rust "$cmd"
+  exit $?
+fi
+
+# ---- driver (Yggdrasil host, inside the job's slot) --------------------------
+if [ "$1" = --host ]; then
+  : "${YGG_WORK:?not started by ygg-verify.sh RUN_ON_HOST=1}" "${YGG_IMAGE:?}" "${YGG_CNAME:?}" "${YGG_LABEL:?}" "${YGG_SLOTS:?}" "${YGG_ROOT:?}"
+  D=${CM_DIR:?}
+  set +e   # every docker step is checked by hand: a container exits non-zero by design
+  export LC_ALL=C
+  t0=$(date +%s)
+  LEASE_FDS=()
+  unlease() { local lf; for lf in "${LEASE_FDS[@]}"; do exec {lf}>&-; done; LEASE_FDS=(); }
+  cleanup() {
+    local p; for p in $(jobs -p); do kill "$p" 2>/dev/null; done
+    unlease
+    # containers write as root
+    [ -z "$D" ] || [ "$D" = / ] || sudo rm -rf -- "$D"
+  }
+  trap cleanup EXIT; trap 'exit 143' TERM INT HUP
+  killed() { [ -n "${YGG_KILLED:-}" ] && [ -e "$YGG_KILLED" ]; }
+  now() { date +%s; }
+  # The shared volume is CARGO_HOME itself so sibling containers share cargo's package-cache lock; a registry-only mount left
+  # the lock in each container's layer and concurrent unpacks removed each other's crate directories (2026-11-03).
+  # Every container carries the job label (the stopgap's watchdog kills by it) and the same caps.
+  common=(--label "$YGG_LABEL" "--cpus=${YGG_CPUS:-4}" "--memory=${YGG_MEM:-6g}"
+    -v "$YGG_WORK:/seed:ro" -v "$D:/cm:ro" -v /etc/machine-id:/etc/machine-id:ro
+    -v eureka-cargo-home:/cargo-home -v eureka-nuget:/root/.nuget/packages -v eureka-sccache:/sccache
+    -e BASH_ENV=/tmp/.ygg-bash-env -e CARGO_HOME=/cargo-home
+    -e "WORKDIR=${WORKDIR:-.}" -e "BASE=$BASE" -e "TEST_ARGS=${TEST_ARGS:-}" -e "FILTERS=${FILTERS:-}" -e "CM_NAMES=${CM_NAMES:-}" -e "JOBS=$JOBS"
+    -e "MIN_TEST_TIMEOUT=$MIN_TEST_TIMEOUT" -e "CONFIRM_TIMEOUT_MULT=$CONFIRM_TIMEOUT_MULT"
+    -e GIT_CONFIG_COUNT=1 -e GIT_CONFIG_KEY_0=safe.directory -e 'GIT_CONFIG_VALUE_0=*')
+  [ -z "${YGG_NONCE:-}" ] || common+=(-e "YGG_NONCE=$YGG_NONCE")
+  pre="printf 'set -o pipefail\n' >/tmp/.ygg-bash-env"
+  # drun <name> <out dir> [-e flags]: one container (the half named by $MODE), its output to <out>/stdout, its
+  # status in <out>/hostrc. A killed job starts nothing (125). DOCKER_ARGS is a flag string, split on purpose.
+  # shellcheck disable=SC2086
+  drun() {
+    local name=$1 out=$2 rc; shift 2
+    killed && return 125
+    mkdir -p "$out"
+    sudo nice -n 10 docker run --rm --name "$name" "${common[@]}" -v "$out:/out" "$@" -w /src ${DOCKER_ARGS:-} "$YGG_IMAGE" \
+      bash -o pipefail -c "$pre; bash /cm/cargo-mutants.sh $MODE" >"$out/stdout" 2>&1
+    rc=$?; echo "$rc" >"$out/hostrc"; return "$rc"
+  }
+  killed_exit() { sum "JOB KILLED by the watchdog before the run finished; no totals"; exit 124; }
+  mkdir -p "$D/items" "$D/plan" "$D/q" "$D/m"
+
+  # ---- plan
+  tp=$(now)
+  MODE=--plan drun "$YGG_CNAME-plan" "$D/plan"
+  rc=$?
+  killed && killed_exit
+  if [ "$rc" != 0 ]; then
+    sum "ERROR the plan container exited $rc: the range diff or the mutant listing failed"
+    tail -n 6 "$D/plan/stdout" 2>/dev/null | sed "s|^|$SUMTAG: ERROR   |"
+    exit 2
+  fi
+  tp=$(( $(now) - tp ))
+  if [ "${CM_NAMES:-}" = 1 ]; then sort -u "$D/names.txt" >"$D/m/universe"
+  else sort -u "$D/plan/names.txt" >"$D/m/universe"; fi
+  for f in s1.caught s1.unviable s1.surv s1.names; do : >"$D/m/$f"; done
+
+  # lease <units>: the containers of a stage = min(SHARDS, SLOTS, units, 1 + free slots now); sets K and holds the leases
+  lease() {
+    local want=$1 i lf psi
+    [ "$want" -le "$SHARDS" ] || want=$SHARDS
+    [ "$want" -le "$YGG_SLOTS" ] || want=$YGG_SLOTS
+    K=1; [ "$want" -gt 1 ] || return 0
+    psi=$(awk '$1 == "full" { for (i = 2; i <= NF; i++) if ($i ~ /^avg60=/) { sub("avg60=", "", $i); print $i } }' "${CM_PSI:-/proc/pressure/io}" 2>/dev/null)
+    if awk -v p="${psi:-0}" 'BEGIN { exit !(p > 20) }'; then return 0; fi
+    for i in $(seq 1 "$YGG_SLOTS"); do
+      [ "$K" -lt "$want" ] || break
+      exec {lf}>"$YGG_ROOT/slot-$i.lock"
+      if flock -n "$lf"; then LEASE_FDS+=("$lf"); K=$((K + 1)); else exec {lf}>&-; fi
+    done
+  }
+  # run_stage <stage> <count> <fn>: K workers claim items 1..count by mkdir, in order (largest first)
+  run_stage() {
+    local stage=$1 count=$2 fn=$3 w pids=()
+    for w in $(seq 1 "$K"); do
+      ( for lf in "${LEASE_FDS[@]}"; do exec {lf}>&-; done   # the lease belongs to the driver, never to a child (2026-09-23 inherited-fd scar)
+        i=0
+        while [ "$i" -lt "$count" ]; do
+          i=$((i + 1))
+          killed && break
+          [ ! -e "$D/failed" ] || break
+          mkdir "$D/q/$stage-$i" 2>/dev/null || continue
+          "$fn" "$i"
+        done ) &
+      pids+=($!)
+    done
+    wait "${pids[@]}"
+  }
+  container_error() {   # container_error <label> <out dir>
+    local rc; rc=$(cat "$2/hostrc" 2>/dev/null)
+    sum "ERROR $1 container exited ${rc:-?} (4 is a red baseline: the unmutated tests failed there)"
+    tail -n 25 "$2/stdout" 2>/dev/null | sed "s|^|$SUMTAG: ERROR   |"
+  }
+
+  # ---- stage 1: files whose filter selects tests (the plan container derived each file's filter and counted its tests)
+  S1_FILE=(); S1_FILTER=(); s1n=0
+  if [ "${CM_NAMES:-}" != 1 ]; then
+    while IFS=$'\t' read -r cnt file f t; do      # files by mutant count, largest first
+      [ "$t" != 0 ] || continue                   # a filter that selects no test settles nothing: straight to stage 2
+      s1n=$((s1n + 1)); S1_FILE[$s1n]=$file; S1_FILTER[$s1n]=$f
+      awk -F: -v f="$file" '$1 == f' "$D/m/universe" >"$D/items/s1-$s1n.names"
+    done <"$D/plan/filters.txt"
+  fi
+  s1_item() {
+    local n=$1 rc
+    MODE=--item drun "$YGG_CNAME-s1-$n" "$D/items/s1-$n/out" -e CM_STAGE=1 -e "CM_FILE=${S1_FILE[$n]}" -e "CM_FILTER=${S1_FILTER[$n]}"
+    rc=$?
+    if [ "$rc" != 0 ] && ! killed; then touch "$D/failed"; fi
+  }
+  K1=0; ts1=0
+  if [ "$s1n" -gt 0 ]; then
+    ts1=$(now)
+    lease "$s1n"; K1=$K
+    run_stage s1 "$s1n" s1_item
+    unlease
+    killed && killed_exit
+    ts1=$(( $(now) - ts1 ))
+    bad=0
+    for n in $(seq 1 "$s1n"); do
+      o="$D/items/s1-$n/out"
+      if [ "$(cat "$o/hostrc" 2>/dev/null)" != 0 ]; then
+        [ -e "$D/q/s1-$n" ] || continue   # never started: the job is already red for another file
+        container_error "stage 1 (${S1_FILE[$n]})" "$o"; bad=1; continue
+      fi
+    done
+    if [ "$bad" != 0 ] || [ -e "$D/failed" ]; then exit 1; fi
+  fi
+  # FILTER lines: the anomalies (0 tests) first, then the rest, at most 12 in all
+  if [ "${CM_NAMES:-}" != 1 ]; then
+    { awk -F'\t' '$4 == 0' "$D/plan/filters.txt"; awk -F'\t' '$4 != 0' "$D/plan/filters.txt"; } |
+      awk -F'\t' '{ if (NR <= 12) printf "FILTER %s %s tests=%s mutants=%s\n", $2, $3, $4, $1; else h++ } END { if (h) printf "FILTER ... %d more files\n", h }' |
+      while IFS= read -r l; do sum "$l"; done
+  fi
+  for n in $(seq 1 "$s1n"); do
+    o="$D/items/s1-$n/out"
+    cat "$D/items/s1-$n.names" >>"$D/m/s1.names"
+    cat "$o/caught.txt" >>"$D/m/s1.caught"; cat "$o/unviable.txt" >>"$D/m/s1.unviable"
+    cat "$o/missed.txt" "$o/timeout.txt" >>"$D/m/s1.surv"
+  done
+  # only names of this run's range count; stage 1 settles caught and unviable, nothing else
+  for f in s1.caught s1.unviable s1.surv s1.names; do
+    sort -u "$D/m/$f" | comm -12 - "$D/m/universe" >"$D/m/$f.t" && mv "$D/m/$f.t" "$D/m/$f"
+  done
+  cat "$D/m/s1.caught" "$D/m/s1.unviable" | sort -u >"$D/m/s1.settled"
+  comm -23 "$D/m/universe" "$D/m/s1.settled" >"$D/s2.txt"
+  # Stage 2 always runs, so cargo-mutants' full-suite baseline always does (cargo-mutants runs no baseline for an
+  # empty selection). With every name settled it carries one name; the merge drops that name's outcome.
+  if [ -s "$D/s2.txt" ]; then bash "$D/cargo-mutants.sh" --escape <"$D/s2.txt" >"$D/s2.re"
+  else head -n 1 "$D/m/universe" | bash "$D/cargo-mutants.sh" --escape >"$D/s2.re"; fi
+
+  # ---- stage 2: the full suite on everything stage 1 did not settle
+  s2n=$(wc -l <"$D/s2.re" | tr -d " ")
+  K2=0; ts2=0
+  for l in caught missed timeout unviable; do : >"$D/m/s2.$l"; done
+  s2_shard() {
+    local k=$1 rc
+    MODE=--item drun "$YGG_CNAME-s2-$k" "$D/items/s2-$k/out" -e CM_STAGE=2 -e "CM_SHARD=$((k - 1))/$K2"
+    rc=$?
+    if [ "$rc" != 0 ] && ! killed; then touch "$D/failed"; fi
+  }
+  if [ "$s2n" -gt 0 ]; then
+    ts2=$(now)
+    lease "$s2n"; K2=$K
+    run_stage s2 "$K2" s2_shard
+    unlease
+    killed && killed_exit
+    ts2=$(( $(now) - ts2 ))
+    bad=0
+    for k in $(seq 1 "$K2"); do
+      o="$D/items/s2-$k/out"
+      if [ "$(cat "$o/hostrc" 2>/dev/null)" != 0 ]; then
+        [ -e "$D/q/s2-$k" ] || continue
+        container_error "stage 2 (shard $k of $K2)" "$o"; bad=1; continue
+      fi
+      for l in caught missed timeout unviable; do cat "$o/$l.txt" >>"$D/m/s2.$l"; done
+    done
+    if [ "$bad" != 0 ] || [ -e "$D/failed" ]; then exit 1; fi
+  fi
+
+  # ---- merge: a name's outcome is stage 2's where it ran, else stage 1's; each name once
+  for l in caught missed timeout unviable; do
+    sort -u "$D/m/s2.$l" | comm -12 - "$D/s2.txt" >"$D/m/s2.$l.t" && mv "$D/m/s2.$l.t" "$D/m/s2.$l"
+  done
+  cat "$D/m/s2.caught" "$D/m/s2.missed" "$D/m/s2.timeout" "$D/m/s2.unviable" | sort -u >"$D/m/s2.all"
+  nout=$(comm -23 "$D/s2.txt" "$D/m/s2.all" | wc -l | tr -d ' ')
+  if [ "$nout" != 0 ]; then
+    sum "ERROR $nout mutants selected for the full-suite run have no outcome in any shard (a name unknown to cargo-mutants at this revision, or a shard that died)"
+    exit 1
+  fi
+  C=$(cat "$D/m/s1.caught" "$D/m/s2.caught" | sort -u | wc -l | tr -d ' ')
+  U=$(cat "$D/m/s1.unviable" "$D/m/s2.unviable" | sort -u | wc -l | tr -d ' ')
+  M=$(wc -l <"$D/m/s2.missed" | tr -d ' '); T=$(wc -l <"$D/m/s2.timeout" | tr -d ' ')
+  S=$(wc -l <"$D/m/s1.surv" | tr -d ' '); F=$(wc -l <"$D/m/s1.names" | tr -d ' ')
+  X=$(comm -12 "$D/m/s1.surv" "$D/m/s2.caught" | wc -l | tr -d ' ')
+  K=$K1; [ "$K2" -le "$K" ] || K=$K2
+  sum "MUTANTS tested=$((C + M + T + U)) caught=$C missed=$M timeout=$T unviable=$U | stage1 filtered=$F survivors=$S confirmed_caught=$X | containers=$K | plan=${tp}s stage1=${ts1}s/${K1} stage2=${ts2}s/${K2} | $(awk -v e="$(( $(now) - t0 ))" 'BEGIN { printf "%.1f", e / 60 }')m"
+  { sed 's/^/MISSED /' "$D/m/s2.missed"; sed 's/^/TIMEOUT /' "$D/m/s2.timeout"; } >"$D/m/surv.txt"
+  total=$(wc -l <"$D/m/surv.txt" | tr -d ' ')
+  head -n 50 "$D/m/surv.txt" | while IFS= read -r l; do sum "$l"; done
+  if [ "$total" -gt 50 ]; then
+    sum "... $((total - 50)) more MISSED/TIMEOUT names; they follow in the job log as cm-survivor lines"
+    tail -n +51 "$D/m/surv.txt" | sed 's/^/cm-survivor: /'
+  fi
+  exit 0
+fi
+
+# ---- inside a container -----------------------------------------------------
+set +e
+# overridable only so tools/test-tools.sh can run this half against a mock
+SRC=${CM_SRC:-/src}; CM=${CM_DIR:-/cm}; OUT=${CM_OUT:-/out}; SEED=${CM_SEED:-/seed}
+if [ -d "$SEED" ]; then mkdir -p "$SRC" && cp -a "$SEED/." "$SRC/" || { echo "cannot copy $SEED into $SRC"; exit 2; }; fi
+cd "$SRC/${WORKDIR:-.}" || { echo "BAD WORKDIR"; exit 2; }
+set -f; read -ra targs <<<"${TEST_ARGS:-}"; set +f
+if [ "$1" = --plan ]; then
+  wsroot=$(dirname "$(cargo locate-project --workspace --message-format plain)") || { echo "cargo locate-project failed"; exit 2; }
+  git -C "$wsroot" diff --relative "$BASE" HEAD >"$OUT/d" || { echo "git diff of the range failed"; exit 2; }
+  cargo mutants --list --in-diff "$OUT/d" >"$OUT/names.txt" 2>"$OUT/list.err" || { echo "cargo mutants --list failed"; tail -n 5 "$OUT/list.err"; exit 2; }
+  : >"$OUT/filters.txt"
+  [ "$CM_NAMES" != 1 ] || exit 0
+  # stage 1's plan: each touched file's test filter and how many tests it selects (0 = nothing for stage 1 to run)
+  declare -A fover
+  if [ -n "${FILTERS:-}" ]; then
+    IFS=, read -ra fl <<<"$FILTERS"
+    for e in "${fl[@]}"; do fover[${e%%=*}]=${e#*=}; done
+  fi
+  derive_filter() {   # derive_filter <path>: the test filter of a file, nothing for the full suite
+    local p=$1 rest
+    if [ -n "${fover[$p]+x}" ]; then [ "${fover[$p]}" = - ] || echo "${fover[$p]}"; return 0; fi
+    case $p in */src/*.rs|src/*.rs) ;; *) return 0 ;; esac
+    rest=${p##*src/}; rest=${rest%.rs}
+    case $rest in lib|main|bin/*|*/bin/*) return 0 ;; esac
+    rest=${rest%/mod}
+    echo "${rest//\//::}::"
+  }
+  built=0
+  while IFS=$'\t' read -r cnt file; do      # files by mutant count, largest first
+    f=$(derive_filter "$file")
+    [ -n "$f" ] || continue
+    if [ "$built" = 0 ]; then
+      cargo test --no-run >"$OUT/build.log" 2>&1 || { echo "cargo test --no-run failed"; tail -n 5 "$OUT/build.log"; exit 2; }
+      built=1
+    fi
+    t=$(cargo test -- "$f" "${targs[@]}" --list 2>/dev/null | awk '/^[0-9]+ tests?, / { s += $1 } END { print s + 0 }')
+    printf '%s\t%s\t%s\t%s\n' "$cnt" "$file" "$f" "$t" >>"$OUT/filters.txt"
+  done < <(awk -F: '{ c[$1]++ } END { for (f in c) print c[f] "\t" f }' "$OUT/names.txt" | sort -t "$(printf '\t')" -k1,1nr -k2)
+  exit 0
+fi
+# --item: stage 1 (CM_FILE with its CM_FILTER) or stage 2 (shard CM_SHARD of the names in $CM/s2.re)
+o=${CM_TMP:-/tmp}/cmo
+args=(mutants --in-diff "$CM/plan/d" -o "$o" --jobs "$JOBS" --minimum-test-timeout "$MIN_TEST_TIMEOUT")
+tail_args=()
+if [ "$CM_STAGE" = 1 ]; then
+  args+=(-f "$CM_FILE")
+  tail_args=(-- "$CM_FILTER"); [ "${#targs[@]}" = 0 ] || tail_args+=(-- "${targs[@]}")
+else
+  mapfile -t res <"$CM/s2.re"
+  for r in "${res[@]}"; do args+=(-F "$r"); done
+  args+=(--timeout-multiplier "$CONFIRM_TIMEOUT_MULT")
+  case $CM_SHARD in */1) ;; *) args+=(--shard "$CM_SHARD") ;; esac
+  [ "${#targs[@]}" = 0 ] || tail_args=(-- -- "${targs[@]}")
+fi
+cargo "${args[@]}" "${tail_args[@]}" >"$OUT/cargo.log" 2>&1
+rc=$?
+for l in caught missed timeout unviable; do cp "$o/mutants.out/$l.txt" "$OUT/$l.txt" 2>/dev/null || : >"$OUT/$l.txt"; done
+echo "$rc" >"$OUT/rc"
+tail -n 30 "$OUT/cargo.log"
+# 0 clean, 2 missed and 3 timeouts are normal; 4 (red baseline) and everything else are errors
+case $rc in 0|2|3) exit 0 ;; *) exit "$rc" ;; esac

tools/context-pack.py

@@ -1,21 +1,26 @@
 #!/usr/bin/env python3
 """Carry a cut_spec's file_changes anchors from the spec's base to a worktree.
 
-Usage: context-pack.py <cut_spec id> <worktree> [--since <sha>] [--only <k>[,<k>...]]
+Usage: context-pack.py <cut_spec id> <worktree> [--since <sha>] [--only <k>|r<k>[,...]]
                        [--spec-json <file>] [--max-lines <n>]
 
-Prints a header, a status table (one line per anchor) and bounded windows of the
-code each anchor names, numbered in the worktree's lines. Exit: 0 every anchor
-carried; 3 an anchor cannot be carried (OUT_OF_RANGE, UNRESOLVED, GONE outside
+Prints a header, a status table (one line per anchor: file_changes as <k>, reads
+as r<k>) and bounded windows of the code each anchor names, numbered in the
+worktree's lines: edit windows, then READ windows, then one caller list per
+distinct symbol. A symbol an anchor names must be in its mapped window or the
+status gains SYMBOL_MISSING. Exit: 0 every anchor carried; 3 an anchor cannot be
+carried (OUT_OF_RANGE, UNRESOLVED, MISSING read, SYMBOL_MISSING, GONE outside
 the spec's deletes); 2 usage; 4 spec unreadable. Standard library plus git.
 Errors name a field and a code, never an input value.
---max-lines bounds the windows, not the table: the table always lists every
-anchor, so a budget smaller than the table prints the table and no window.
+--max-lines bounds the windows and caller lists, not the table: the table always
+lists every anchor, so a budget smaller than the table prints the table and no
+window. Precedence: table, edit windows, read windows, caller lists.
 """
 import argparse
 import json
 import os
 import re
+import shlex
 import subprocess
 import sys
 
@@ -26,6 +31,12 @@ WINDOW_CAP = 100
 CONTEXT = 3
 DEFAULT_MAX_LINES = 800
 HUNK = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+MAX_CALLER_SYMBOLS = 8
+MAX_CALLER_HITS = 50
+MAX_CALLER_FILES = 20
+HIT_TEXT = 160
+ONLY = re.compile(r"^(r?)([0-9]+)$")
+IDENT = re.compile(r"^[A-Za-z0-9_]+$")
 HEX = re.compile(r"^[0-9a-fA-F]{7,40}$")
 
 
@@ -84,6 +95,17 @@ def check_spec_shape(spec):
         raise Fail(4, "spec: %s: InvalidInput" % field)
     if not isinstance(spec["base"], str):
         bad("base")
+    def check_loc(at, loc):
+        if not isinstance(loc, dict):
+            bad(at)
+        if not isinstance(loc.get("path"), str):
+            bad(at + ".path")
+        if not is_int(loc.get("line")):
+            bad(at + ".line")
+        if loc.get("end_line") is not None and not is_int(loc["end_line"]):
+            bad(at + ".end_line")
+        if loc.get("symbol") is not None and not isinstance(loc["symbol"], str):
+            bad(at + ".symbol")
     fcs = spec["file_changes"]
     if not isinstance(fcs, list):
         bad("file_changes")
@@ -91,17 +113,21 @@ def check_spec_shape(spec):
         at = "file_changes[%d]" % k
         if not isinstance(fc, dict):
             bad(at)
-        loc = fc.get("location")
-        if not isinstance(loc, dict):
-            bad(at + ".location")
-        if not isinstance(loc.get("path"), str):
-            bad(at + ".location.path")
-        if not is_int(loc.get("line")):
-            bad(at + ".location.line")
-        if loc.get("end_line") is not None and not is_int(loc["end_line"]):
-            bad(at + ".location.end_line")
+        check_loc(at + ".location", fc.get("location"))
         if "change" in fc and not isinstance(fc["change"], str):
             bad(at + ".change")
+    reads = spec.get("reads")
+    if reads is None:
+        reads = []
+    if not isinstance(reads, list):
+        bad("reads")
+    for k, rd in enumerate(reads, 1):
+        at = "reads[%d]" % k
+        if not isinstance(rd, dict):
+            bad(at)
+        check_loc(at + ".location", rd.get("location"))
+        if "why" in rd and not isinstance(rd["why"], str):
+            bad(at + ".why")
     dels = spec.get("deletes", [])
     if not isinstance(dels, list):
         bad("deletes")
@@ -236,12 +262,34 @@ def safe_path(path):
         and ".." not in path.replace("\\", "/").split("/")
 
 
-def resolve(tree, k, fc, deleted_ok, base_ok, listed):
+def has_symbol(symbol, lines):
+    text = "\n".join(lines)
+    if IDENT.match(symbol):
+        return re.search(r"(?<![A-Za-z0-9_])" + re.escape(symbol) + r"(?![A-Za-z0-9_])", text) is not None
+    return symbol in text
+
+
+def resolve(tree, label, fc, deleted_ok, base_ok, listed, read=False):
+    """One anchor: carried to the worktree, then its symbol (if any) looked up in
+    the mapped window (the AT BASE window for GONE)."""
+    a = carry_anchor(tree, label, fc, deleted_ok, base_ok, listed, read)
+    sym = fc["location"].get("symbol")
+    a["symbol"] = sym or None
+    if sym and a["window"]:
+        kind, path, s, e = a["window"]
+        lines = tree.base_lines(path) if kind == "base" else tree.wt_lines(path)
+        if lines is not None and not has_symbol(sym, lines[s - 1:e]):
+            a["status"] += " SYMBOL_MISSING " + sym
+            a["exit"] = 3
+    return a
+
+
+def carry_anchor(tree, label, fc, deleted_ok, base_ok, listed, read):
     loc = fc["location"]
     path, s = loc["path"], int(loc["line"])
     e = int(loc.get("end_line") or s)
-    a = {"k": k, "path": path, "s": s, "e": e, "change": str(fc.get("change", "")),
-         "rank": 1, "exit": 0, "status": "", "now": None, "window": None}
+    a = {"k": label, "path": path, "s": s, "e": e, "change": str(fc.get("change", "")),
+         "rank": 1, "exit": 0, "status": "", "now": None, "window": None, "read": read}
     if not base_ok:
         a.update(rank=0, exit=3, status="UNRESOLVED base not a commit here: git fetch origin " + tree.base)
         return a
@@ -249,6 +297,9 @@ def resolve(tree, k, fc, deleted_ok, base_ok, listed):
         a.update(rank=0, exit=3, status="UNRESOLVED path or git diff unusable")
         return a
     base = tree.base_lines(path)
+    if base is None and read:
+        a.update(rank=0, exit=3, status="MISSING (read path absent at base)")
+        return a
     if base is None:
         sib = [p for p in tree.siblings() if p.rsplit("/", 1)[-1] == path.rsplit("/", 1)[-1]][:3]
         a.update(rank=0, status="NEW" + (" (at base: " + ", ".join(sib) + ")" if sib else ""))
@@ -285,7 +336,7 @@ def resolve(tree, k, fc, deleted_ok, base_ok, listed):
 
 
 def table_line(a):
-    line = "[%d] %s:%d-%d  %s" % (a["k"], a["path"], a["s"], a["e"], a["status"])
+    line = "[%s] %s:%d-%d  %s" % (a["k"], a["path"], a["s"], a["e"], a["status"])
     if a["now"]:
         line += "  -> %s:%d-%d" % a["now"]
     return line + "  # " + " ".join(a["change"].split())[:70]
@@ -294,7 +345,8 @@ def table_line(a):
 def window_body(tree, a):
     kind, path, s, e = a["window"]
     lines = tree.base_lines(path) if kind == "base" else tree.wt_lines(path)
-    cap = "== [%d] %s:%d-%d%s  %s" % (a["k"], path, s, e, " AT BASE" if kind == "base" else "", a["status"])
+    where = "%s:%d-%d%s  %s" % (path, s, e, " AT BASE" if kind == "base" else "", a["status"])
+    cap = ("== READ %s: %s  (%s)" % (a["k"], a["change"][:200], where)) if a["read"] else "== [%s] %s" % (a["k"], where)
     if lines is None:
         return cap, ["(file not readable in the worktree)"]
     lo, hi = max(1, s - CONTEXT), min(len(lines), e + CONTEXT)
@@ -318,6 +370,46 @@ def overlaps_since(tree, since, a):
     return False
 
 
+def caller_list(wt, symbol, windows):
+    """The lines of one CALLERS list: hits of the symbol in the worktree outside
+    every mapped window of the spec."""
+    args = ["grep", "-n", "-I", "--no-color", "-z", "-F"] + (["-w"] if IDENT.match(symbol) else []) + ["-e", symbol]
+    raw = git(wt, *args) or b""
+    hits = []
+    for rec in raw.decode("utf-8", "replace").split("\n"):
+        parts = rec.split("\0", 2)
+        if len(parts) < 3 or not parts[1].isdigit():
+            continue
+        path, n = parts[0], int(parts[1])
+        if any(path == wp and ws <= n <= we for wp, ws, we in windows):
+            continue
+        hits.append((path, n, parts[2].rstrip("\r")))
+    counts = {}
+    for path, _, _ in hits:
+        counts[path] = counts.get(path, 0) + 1
+    out = ["CALLERS %s: %d hits in %d files" % (symbol, len(hits), len(counts))]
+    if len(hits) <= MAX_CALLER_HITS:
+        out += ["%s:%d: %s" % (path, n, text[:HIT_TEXT]) for path, n, text in hits]
+    else:
+        ranked = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))
+        out += ["%6d  %s" % (c, path) for path, c in ranked[:MAX_CALLER_FILES]]
+        if len(ranked) > MAX_CALLER_FILES:
+            out.append("(%d more files)" % (len(ranked) - MAX_CALLER_FILES))
+        out.append("narrow: git grep -n -I %s-F -e %s -- <path>" % ("-w " if IDENT.match(symbol) else "", shlex.quote(symbol)))
+    return out
+
+
+def parse_only(text, p):
+    """Labels: <k> for file_changes, r<k> for reads."""
+    labels = set()
+    for x in text.split(","):
+        m = ONLY.match(x)
+        if not m:
+            p.error("")
+        labels.add(m.group(1) + str(int(m.group(2))))
+    return labels
+
+
 def main(argv):
     p = Parser(prog="context-pack.py")
     p.add_argument("spec_id")
@@ -329,19 +421,18 @@ def main(argv):
     ns = p.parse_args(argv)
     if ns.max_lines < 1:
         p.error("")
-    only = None
-    if ns.only is not None:
-        try:
-            only = {int(x) for x in ns.only.split(",")}
-        except ValueError:
-            p.error("")
+    only = parse_only(ns.only, p) if ns.only is not None else None
     wt = ns.worktree
     if git(wt, "rev-parse", "--git-dir") is None:
         raise Fail(2, "worktree: not a git worktree")
     spec = load_spec(ns.spec_id, ns.spec_json)
     fcs = spec["file_changes"]
-    if only is not None and not only <= set(range(1, len(fcs) + 1)):
-        raise Fail(2, "--only: index outside file_changes")
+    reads = spec.get("reads") or []
+    if only is not None:
+        if not {x for x in only if x[0] != "r"} <= {str(i) for i in range(1, len(fcs) + 1)}:
+            raise Fail(2, "--only: index outside file_changes")
+        if not {x for x in only if x[0] == "r"} <= {"r%d" % i for i in range(1, len(reads) + 1)}:
+            raise Fail(2, "--only: index outside reads")
     base = str(spec["base"])
     resolved = HEX.match(base) and git(wt, "rev-parse", "--verify", "--quiet", base + "^{commit}")
     tree = Tree(wt, base)
@@ -352,7 +443,9 @@ def main(argv):
                                  git(wt, "rev-parse", "--verify", "--quiet", ns.since + "^{commit}") is None):
         raise Fail(2, "--since: not a commit in this worktree")
     deleted_ok = {d["path"] for d in spec.get("deletes", [])}
-    anchors = [resolve(tree, i + 1, fc, deleted_ok, bool(resolved), listed) for i, fc in enumerate(fcs)]
+    anchors = [resolve(tree, str(i + 1), fc, deleted_ok, bool(resolved), listed) for i, fc in enumerate(fcs)]
+    anchors += [resolve(tree, "r%d" % (i + 1), {"location": rd["location"], "change": rd.get("why", "")},
+                        deleted_ok, bool(resolved), listed, read=True) for i, rd in enumerate(reads)]
 
     head = (git(wt, "rev-parse", "--short", "HEAD") or b"none").decode().strip()
     out = ["context-pack %s base %s HEAD %s modified %d" % (
@@ -361,29 +454,58 @@ def main(argv):
     out.append("")
     want = [a for a in anchors if a["window"] and (only is None or a["k"] in only)
             and (ns.since is None or overlaps_since(tree, ns.since, a))]
-    table_len = len(fcs)
-    skipped = []
-    left = ns.max_lines - len(out)
-    for idx, a in enumerate(want):
-        cap, body = window_body(tree, a)
-        full = len(body)
-        if only is None and full > WINDOW_CAP:
-            body = body[:WINDOW_CAP]
-        reserve = 1 if idx < len(want) - 1 or skipped else 0   # room for the not-expanded line
-        need = 1 + len(body) + (1 if len(body) < full else 0)
-        if only is not None and need > left - reserve and left - reserve >= 4:
-            body = body[:left - reserve - 2]
-            need = 1 + len(body) + 1
-        if need > left - reserve:
-            skipped.append(a["k"])
+    table_len = len(anchors)
+    def place(room):
+        """The windows that fit in room lines: (lines, skipped labels, room left, lines all would take)."""
+        lines, skipped, left, natural = [], [], room, 0
+        for idx, a in enumerate(want):
+            cap, body = window_body(tree, a)
+            full = len(body)
+            if only is None and full > WINDOW_CAP:
+                body = body[:WINDOW_CAP]
+            need = natural_need = 1 + len(body) + (1 if len(body) < full else 0)
+            reserve = 1 if idx < len(want) - 1 or skipped else 0   # room for the not-expanded line
+            if only is not None and need > left - reserve and left - reserve >= 4:
+                body = body[:left - reserve - 2]
+                need = 1 + len(body) + 1
+            natural += natural_need
+            if need > left - reserve:
+                skipped.append(a["k"])
+                continue
+            lines += [cap] + body
+            if len(body) < full:
+                lines.append("%d more lines: --only %s --max-lines %d" % (full - len(body), a["k"], table_len + full + 3))
+            left -= need
+        if skipped:
+            lines.append("not expanded: --only " + ",".join(skipped))
+            left -= 1
+        return lines, skipped, left, natural
+
+    windows = [(a["window"][1], a["window"][2], a["window"][3]) for a in anchors
+               if a["window"] and a["window"][0] == "wt"]
+    symbols = list(dict.fromkeys(a["symbol"] for a in want if a["symbol"]))
+    lists = [(sym, caller_list(wt, sym, windows)) for sym in symbols[:MAX_CALLER_SYMBOLS]]
+    unlisted = symbols[MAX_CALLER_SYMBOLS:]
+    list_total = sum(len(ls) for _, ls in lists) + (1 if unlisted else 0)
+    room = ns.max_lines - len(out)
+    lines, skipped, left, natural = place(room - list_total)
+    if skipped and lists:      # the lists lose: keep only the notes that name what is cut
+        lines, skipped, left, natural = place(room - (1 if lists else 0) - (1 if unlisted else 0))
+    elif lists:
+        left += list_total - (1 if unlisted else 0)
+    out += lines
+    cut = []
+    for sym, ls in lists:
+        if len(ls) > left:
+            cut.append((sym, len(ls)))
             continue
-        out.append(cap)
-        out += body
-        if len(body) < full:
-            out.append("%d more lines: --only %d --max-lines %d" % (full - len(body), a["k"], table_len + full + 3))
-        left -= need
-    if skipped:
-        out.append("not expanded: --only " + ",".join(map(str, skipped)))
+        out += ls
+        left -= len(ls)
+    if cut:
+        out.append("callers not printed: %s: --max-lines %d" % (
+            ",".join(c[0] for c in cut), table_len + 2 + natural + list_total))
+    if unlisted:
+        out.append("callers not listed: " + ",".join(unlisted))
     sys.stdout.reconfigure(encoding="utf-8", errors="replace", newline="\n")
     sys.stdout.write("\n".join(out) + "\n")
     return max([a["exit"] for a in anchors] or [0])

tools/fixtures/cargo-mutants-crate/.gitignore

@@ -0,0 +1,2 @@
+target/
+Cargo.lock

tools/fixtures/cargo-mutants-crate/Cargo.toml

@@ -0,0 +1,4 @@
+[package]
+name = "cmfix"
+version = "0.1.0"
+edition = "2021"

tools/fixtures/cargo-mutants-crate/src/alpha/mod.rs

@@ -0,0 +1,18 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
+
+/// Only tests/it.rs pins this one: a unit-filtered run cannot kill it.
+pub fn double(a: i32) -> i32 {
+    a * 2
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn add_adds() {
+        assert_eq!(add(2, 3), 5);
+    }
+}

tools/fixtures/cargo-mutants-crate/src/beta.rs

@@ -0,0 +1,18 @@
+pub fn neg(a: i32) -> i32 {
+    -a
+}
+
+/// No test pins this one anywhere: a real survivor in every run.
+pub fn unpinned(a: i32) -> i32 {
+    a + 1
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn neg_negates() {
+        assert_eq!(neg(4), -4);
+    }
+}

tools/fixtures/cargo-mutants-crate/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod alpha;
+pub mod beta;

tools/fixtures/cargo-mutants-crate/tests/it.rs

@@ -0,0 +1,4 @@
+#[test]
+fn double_doubles() {
+    assert_eq!(cmfix::alpha::double(4), 8);
+}

tools/fixtures/context-pack/spec-reads.json

@@ -0,0 +1,17 @@
+{"id": {"id": "t:cut_spec:cut-x.r1", "kind": "CutSpec"},
+ "status": "InForce",
+ "document": {"kind": "cut_spec", "value": {
+  "base": "BASE", "deletes": [],
+  "file_changes": [
+   {"change": "symbol present in the moved window", "location": {"path": "a.txt", "line": 20, "end_line": 22, "symbol": "a21"}},
+   {"change": "symbol the window lacks", "location": {"path": "b.txt", "line": 30, "end_line": 31, "symbol": "b99"}},
+   {"change": "identifier with 3 callers outside the windows", "location": {"path": "sym.txt", "line": 4, "end_line": 5, "symbol": "needle_three"}},
+   {"change": "non-identifier symbol is a literal substring", "location": {"path": "sym.txt", "line": 9, "end_line": 9, "symbol": "::ba"}}
+  ],
+  "reads": [
+   {"why": "moved below the insertion", "location": {"path": "a.txt", "line": 20, "end_line": 22}},
+   {"why": "deleted path", "location": {"path": "c.txt", "line": 2, "end_line": 3, "symbol": "c9"}},
+   {"why": "path absent at base", "location": {"path": "sub/a.txt", "line": 1, "end_line": 2}},
+   {"why": "identifier with 60 callers", "location": {"path": "sym.txt", "line": 7, "end_line": 8, "symbol": "needle_many"}},
+   {"why": "an identifier matches whole words only", "location": {"path": "a.txt", "line": 20, "end_line": 22, "symbol": "a2"}}
+  ]}}}

tools/fixtures/mutation-mock/fakebin/cargo

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# Fake cargo for tools/test-tools.sh, only what tools/cargo-mutants.sh calls:
+#   cargo locate-project --workspace --message-format plain
+#   cargo test --no-run
+#   cargo test -- <filter> [<harness args>] --list      (prints "<n> tests, 0 benchmarks" per test binary)
+#   cargo mutants [--list] --in-diff <diff> [-f <file>] [-F <re>]... [--shard k/n] [-o <dir>] [...] [-- <filter> [-- <harness args>]]
+# FAKE_CM_TABLE: tab-separated  <mutant name> <outcome under a filtered run> <outcome under the full suite>
+#   (caught|missed|timeout|unviable). A run with -F is the full suite; a run with -f and a filter is filtered.
+# FAKE_CM_TESTS: tab-separated  <filter> <tests the filter selects>  (default 1)
+# FAKE_CM_RED=1|2: the stage-1 or stage-2 run fails its baseline (exit 4, no output).
+# FAKE_CM_KILLS: a path a run creates (the watchdog's YGG_KILLED flag appearing mid-job).
+# FAKE_CM_LOG: appended one line per run (stage, filter, harness args, open fds from 10 up).
+# FAKE_WSROOT: the workspace root relative to the repository root, with a trailing slash ('' = the repository root).
+case ${1:-} in
+  locate-project) echo "$(git rev-parse --show-toplevel)/${FAKE_WSROOT:-}Cargo.toml"; exit 0 ;;
+  test)
+    shift; for a; do [ "$a" != --no-run ] || exit 0; done
+    [ "${1:-}" = -- ] || { echo "fake cargo test: unsupported arguments" >&2; exit 64; }
+    shift; f=$1; shift; h=()
+    for a; do [ "$a" = --list ] || h+=("$a"); done
+    echo "count filter=$f harness=${h[*]}" >>"${FAKE_CM_LOG:?}"
+    n=$(awk -F'\t' -v f="$f" '$1 == f { print $2 }' "${FAKE_CM_TESTS:-/dev/null}")
+    printf '%s tests, 0 benchmarks\n0 tests, 0 benchmarks\n' "${n:-1}"; exit 0 ;;
+  mutants) shift ;;
+  *) echo "fake cargo: unsupported ${1:-}" >&2; exit 127 ;;
+esac
+list=0; mult=''; mintimeout=''; diff=''; ffile=''; res=(); shard=''; out=''; tail=()
+while [ $# -gt 0 ]; do
+  case $1 in
+    --list) list=1 ;;
+    --in-diff) diff=$2; shift ;;
+    -f) ffile=$2; shift ;;
+    -F) res+=("$2"); shift ;;
+    --shard) shard=$2; shift ;;
+    -o) out=$2; shift ;;
+    --jobs) shift ;;
+    --minimum-test-timeout) mintimeout=$2; shift ;;
+    --timeout-multiplier) mult=$2; shift ;;
+    --) shift; tail=("$@"); break ;;
+    *) echo "fake cargo mutants: unknown argument $1" >&2; exit 64 ;;
+  esac
+  shift
+done
+[ -n "$diff" ] && [ -f "$diff" ] || { echo "fake cargo mutants: no readable --in-diff" >&2; exit 64; }
+# the mutants of the files the diff touches (paths as the diff prints them: relative to the workspace root)
+touched=$(sed -n 's|^+++ b/||p' "$diff")
+sel=$(awk -F'\t' 'NR == FNR { t[$0] = 1; next } { f = $1; sub(/:.*/, "", f); if (f in t) print $1 "\t" $2 "\t" $3 }' <(printf '%s\n' "$touched") "${FAKE_CM_TABLE:?}")
+if [ -n "$ffile" ]; then sel=$(awk -F'\t' -v f="$ffile" '{ n = $1; sub(/:.*/, "", n); if (n == f) print }' <<<"$sel"); fi
+if [ "${#res[@]}" -gt 0 ]; then
+  keep=$(cut -f1 <<<"$sel" | perl -e '@r = map { qr/$_/ } @ARGV; while (<STDIN>) { chomp; for $r (@r) { if (/$r/) { print "$_\n"; last } } }' "${res[@]}")
+  sel=$(awk -F'\t' 'NR == FNR { k[$0] = 1; next } $1 in k' <(printf '%s\n' "$keep") <(printf '%s\n' "$sel"))
+fi
+if [ -n "$shard" ]; then
+  sel=$(awk -F'\t' -v k="${shard%/*}" -v n="${shard#*/}" '(NR - 1) % n == k' <<<"$sel")
+fi
+if [ "$list" = 1 ]; then cut -f1 <<<"$sel" | awk 'NF'; exit 0; fi
+stage=1; [ "${#res[@]}" -eq 0 ] || stage=2
+filter=''; harness=()
+if [ "${#tail[@]}" -gt 0 ] && [ "${tail[0]}" != -- ]; then filter=${tail[0]}; fi
+for i in "${!tail[@]}"; do if [ "${tail[$i]}" = -- ]; then harness=("${tail[@]:$((i + 1))}"); break; fi; done
+open=$(perl -MPOSIX -e '$n = 0; for (10 .. 40) { my $d = POSIX::dup($_); if (defined $d) { $n++; POSIX::close($d) } } print $n')
+[ -z "${FAKE_CM_KILLS:-}" ] || touch "$FAKE_CM_KILLS"   # a watchdog kill arriving while a run is going
+echo "stage=$stage filter=$filter harness=${harness[*]} openfds=$open mult=$mult min=$mintimeout" >>"${FAKE_CM_LOG:?}"
+[ "${FAKE_CM_RED:-}" != "$stage" ] || { echo "baseline failed" >&2; exit 4; }
+mkdir -p "$out/mutants.out/log"
+col=3; [ "$stage" = 2 ] || col=2
+for o in caught missed timeout unviable; do
+  awk -F'\t' -v c="$col" -v o="$o" '{ x = $c; if (x == o) print $1 }' <<<"$sel" >"$out/mutants.out/$o.txt"
+done
+# a run that selected no mutant (the awk above printed empty lines): drop them
+for o in caught missed timeout unviable; do sed -i '/^$/d' "$out/mutants.out/$o.txt"; done
+if [ -s "$out/mutants.out/timeout.txt" ]; then exit 3; elif [ -s "$out/mutants.out/missed.txt" ]; then exit 2; fi
+exit 0

tools/fixtures/mutation-mock/fakebin/docker

@@ -1,21 +1,22 @@
 #!/usr/bin/env bash
 # Mock docker for tools/test-tools.sh: a container is a directory, an image is a
 # copy of one, so `run` from a committed image really is copy-on-write. Implements
-# only what tools/mutation-table.sh --host calls: run, commit, cp, rm, rmi. The
-# in-container paths /mt and /seed map to the mounted host directories, and the
-# script's own /src and /tmp/mtm live inside the container directory.
+# only what tools/mutation-table.sh and tools/cargo-mutants.sh --host call: run, commit,
+# cp, rm, rmi. The in-container paths /mt, /cm, /out and /seed map to the mounted host
+# directories (/out is written through), and the script's own /src and /tmp/mtm live
+# inside the container directory.
 FD=${FAKE_DOCKER:?}; mkdir -p "$FD/c" "$FD/i"
 imgdir() { echo "$FD/i/${1//[:\/]/_}"; }
 cmd=$1; shift
 case $cmd in
   run)
-    rm_after=0; name=''; mt=''; seed=/nonexistent; labels=0; envs=()
+    rm_after=0; name=''; mt=''; cm=''; out=''; seed=/nonexistent; labels=0; envs=()
     while [ $# -gt 0 ]; do
       case $1 in
         --rm) rm_after=1 ;;
         --name) name=$2; shift ;;
         --label) labels=$((labels + 1)); shift ;;
-        -v) case $2 in *:/mt:ro) mt=${2%:/mt:ro} ;; *:/seed:ro) seed=${2%:/seed:ro} ;; esac; shift ;;
+        -v) case $2 in *:/mt:ro) mt=${2%:/mt:ro} ;; *:/cm:ro) cm=${2%:/cm:ro} ;; *:/out) out=${2%:/out} ;; *:/seed:ro) seed=${2%:/seed:ro} ;; esac; shift ;;
         -e) case $2 in BASH_ENV=*) ;; *) envs+=("$2") ;; esac; shift ;;
         -w) shift ;;
         --*=*) ;;
@@ -29,9 +30,9 @@ case $cmd in
     c=$FD/c/$name; rm -rf "$c"
     if [ -d "$(imgdir "$image")" ]; then cp -a "$(imgdir "$image")" "$c"; else mkdir -p "$c"; fi
     echo "run $name $image" >>"$FD/log"
-    script=${*: -1}; script=${script//\/mt\//$mt/}
+    script=${*: -1}; script=${script//\/mt\//$mt/}; script=${script//\/cm\//$cm/}
     ( for e in "${envs[@]}"; do export "$e"; done
-      export MT_SRC=$c/src MT_M=$c/tmp/mtm MT_DIR=$mt MT_SEED=$seed
+      export MT_SRC=$c/src MT_M=$c/tmp/mtm MT_DIR=$mt MT_SEED=$seed CM_SRC=$c/src CM_DIR=$cm CM_OUT=$out CM_SEED=$seed CM_TMP=$c/tmp
       bash -o pipefail -c "$script" )
     rc=$?
     [ "$rm_after" = 0 ] || rm -rf "$c"

tools/fixtures/mutation-mock/fakebin/flock

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# Fake flock for tools/test-tools.sh (Git Bash has none): only `flock -n <fd>`, via perl's flock(2) on the inherited descriptor.
+[ "${1:-}" = -n ] && [ -n "${2:-}" ] || { echo "fake flock: unsupported arguments $*" >&2; exit 64; }
+exec perl -e 'use Fcntl qw(:flock); open(my $f, "+<&=", $ARGV[0]) or exit 2; exit(flock($f, LOCK_EX | LOCK_NB) ? 0 : 1)' "$2"

tools/mutation-table.sh

@@ -122,8 +122,8 @@ if [ "$1" = --host ]; then
   # Every container carries the job label (the stopgap's watchdog kills by it) and the same caps.
   common=(--label "$YGG_LABEL" "--cpus=${YGG_CPUS:-4}" "--memory=${YGG_MEM:-6g}"
     -v "$bundle:/mt:ro" -v /etc/machine-id:/etc/machine-id:ro
-    -v eureka-cargo-registry:/usr/local/cargo/registry -v eureka-nuget:/root/.nuget/packages -v eureka-sccache:/sccache
-    -e BASH_ENV=/tmp/.ygg-bash-env
+    -v eureka-cargo-home:/cargo-home -v eureka-nuget:/root/.nuget/packages -v eureka-sccache:/sccache
+    -e BASH_ENV=/tmp/.ygg-bash-env -e CARGO_HOME=/cargo-home
     -e "WORKDIR=${WORKDIR:-.}" -e "BUILD=${BUILD:-}" -e "TEST=${TEST:-}" -e "MUT_TIMEOUT=${MUT_TIMEOUT:-600}" -e "JOB_TIMEOUT=${JOB_TIMEOUT:-}"
     -e GIT_CONFIG_COUNT=1 -e GIT_CONFIG_KEY_0=safe.directory -e 'GIT_CONFIG_VALUE_0=*')
   [ -z "${YGG_NONCE:-}" ] || common+=(-e "YGG_NONCE=$YGG_NONCE")

tools/stopgap/ygg-verify.sh

@@ -20,7 +20,7 @@
 #      the commit out detached. It is a real clone, not a worktree, because a
 #      worktree's .git file points at a host path the container cannot see.
 #   3. Runs <command> in <image> under a CPU and memory cap, niced. Each
-#      toolchain gets one shared registry cache. The build output directory
+#      toolchain gets one shared cargo home (registry and package-cache lock). The build output directory
 #      stays inside the work directory and is never shared between checkouts.
 #      CARGO_TARGET_DIR is deliberately NOT set: cargo's default (<workspace>/
 #      target) is already inside /src, and forcing it made cargo-mutants' --jobs
@@ -83,10 +83,12 @@
 #   YGG_WORK (the clone), YGG_IMAGE, YGG_CPUS, YGG_MEM, YGG_CNAME (job name),
 #   YGG_LABEL (every container it starts must carry `--label $YGG_LABEL`: the
 #   watchdog kills containers by that label), YGG_KILLED (a path that exists once
-#   the watchdog has killed the job: stop starting work) and DOCKER_ARGS. The
-#   command owns the container topology and must remove what it creates.
-#   tools/mutation-table.sh is the one user: it snapshots a baselined container
-#   and runs each mutant in a fresh container from the snapshot.
+#   the watchdog has killed the job: stop starting work), YGG_SLOTS and YGG_ROOT
+#   (the slot pool: $YGG_ROOT/slot-<i>.lock for i in 1..$YGG_SLOTS, flock -n) and
+#   DOCKER_ARGS. The command owns the container topology and must remove what it
+#   creates. Two users: tools/mutation-table.sh snapshots a baselined container
+#   and runs each mutant in a fresh container from the snapshot;
+#   tools/cargo-mutants.sh also leases free slot locks for extra containers.
 #   DOCKER_ARGS='<extra docker run flags>' passes through to the container's
 #   own `docker run`, appended after the fixed flags and before the image name
 #   (e.g. DOCKER_ARGS='--sysctl net.ipv6.conf.all.disable_ipv6=0' or
@@ -133,8 +135,8 @@
 #           dotnet tool install -g dotnet-stryker)
 #   any other value is used as an image name as-is.
 # Example:
-#   ygg-verify.sh /f/Projects/Huginn HEAD rust \
-#     'cargo test --workspace && git diff BASE HEAD > /tmp/d && cargo mutants --in-diff /tmp/d'
+#   ygg-verify.sh /f/Projects/Huginn HEAD rust 'cargo test --workspace'
+# Rust mutation runs use tools/cargo-mutants.sh, never an inline cargo mutants command.
 set -euo pipefail
 
 here=$(cd "$(dirname "$0")" && pwd)
@@ -186,7 +188,6 @@ ygg_summarize() {
     if [ "$untrusted" -gt 0 ]; then
       echo "$untrusted YGG-SUMMARY lines without this run's nonce were ignored (a test printed them, or the table printer predates the nonce); see the log"
     fi
-    { grep -E '^(MISSED|TIMEOUT) |mutants tested' "$log" || true; } | awk 'NR<=20'
     if [ "$status" != 0 ]; then
       if [ "$nf" -eq 0 ] && [ "$f" -eq 0 ] && [ "$own" -eq 0 ] && [ -z "$loads" ]; then
         echo "exit non-zero with no failing test parsed: build error, crash, timeout or a non-test command"
@@ -389,7 +390,7 @@ if [ "$host_mode" = 1 ]; then
   # Own process group (set -m), started in the job's work directory, so the watchdog can signal all of it.
   set -m
   ( cd "$work" && export YGG_WORK=$work YGG_IMAGE=$image YGG_CPUS=$cpus YGG_MEM=$mem YGG_CNAME=$cname YGG_LABEL=$label \
-      YGG_KILLED=$killed DOCKER_ARGS=$docker_args
+      YGG_KILLED=$killed YGG_SLOTS=$slots YGG_ROOT=$root DOCKER_ARGS=$docker_args
     [ -z "$nonce" ] || export YGG_NONCE=$nonce
     exec bash -o pipefail -c "$cmd" ) </dev/null &
   hostpid=$!
@@ -401,14 +402,20 @@ if [ "$host_mode" = 1 ]; then
   # command's status comes from the host command, not from a killed container).
   if [ -e "$killed" ]; then status=124; fi
 else
-sudo nice -n 10 docker run --rm --name "$cname" --label "$label" --cpus="$cpus" --memory="$mem" \
+# Priority is set inside the container: nice on the docker client does not reach a process
+# containerd starts. Jobs run at nice 10 and idle IO class, so the swarm's daemons and turns
+# on the same disk go first (2026-10-31: three verify jobs held IO pressure at ~75% full).
+# Cargo's package-cache lock lives in $CARGO_HOME, so the shared volume is CARGO_HOME itself: a registry-only mount left the
+# lock in each container's layer and sibling containers unpacking one crate removed each other's directories (2026-11-03).
+sudo docker run --rm --name "$cname" --label "$label" --cpus="$cpus" --memory="$mem" \
   -v "$work:/src" -v /etc/machine-id:/etc/machine-id:ro \
-  -v eureka-cargo-registry:/usr/local/cargo/registry -v eureka-nuget:/root/.nuget/packages \
-  -v eureka-sccache:/sccache \
+  -v eureka-cargo-home:/cargo-home -v eureka-nuget:/root/.nuget/packages \
+  -v eureka-sccache:/sccache -e CARGO_HOME=/cargo-home \
   -e BASH_ENV=/tmp/.ygg-bash-env ${nonce:+-e YGG_NONCE=$nonce} \
   -e GIT_CONFIG_COUNT=1 -e GIT_CONFIG_KEY_0=safe.directory -e GIT_CONFIG_VALUE_0='*' \
   $docker_args \
-  -w /src "$image" bash -o pipefail -c "printf 'set -o pipefail\n' >/tmp/.ygg-bash-env; $cmd"
+  -w /src "$image" sh -c 'if command -v ionice >/dev/null 2>&1; then exec nice -n 10 ionice -c3 "$@"; else exec nice -n 10 "$@"; fi' sh \
+  bash -o pipefail -c "printf 'set -o pipefail\n' >/tmp/.ygg-bash-env; $cmd"
 status=$?
 fi
 set -e

tools/test-tools.sh

@@ -5,6 +5,9 @@
 # reproducer) are real Yggdrasil runs, 2026-10-01; soul-s5/*.log are real
 # dotnet, pytest, vitest and cargo runs of Soul's probe repo (several runs per
 # log, split by "=== MARK <name>" lines); the rest are hand-written.
+# The mutation runners tools/mutation-table.sh and tools/cargo-mutants.sh (launcher, host driver
+# and container halves) run under a mock docker and, for cargo-mutants, a fake cargo and flock
+# (fixtures/mutation-mock/fakebin), with real slot locks.
 # Run: bash tools/test-tools.sh   (no network, no builds)
 set -uo pipefail
 here=$(cd "$(dirname "$0")" && pwd)
@@ -192,6 +195,210 @@ check "$(seg jest-real.log exit)" 1 "exit non-zero with no failing test parsed"
 # F4: the "nothing recognised" line names every framework the parser reads
 check "$(seg jest-real.log exit)" 1 "no test counts recognised in the log (cargo, dotnet, vitest, jest, pytest)"
 
+# ---- tools/cargo-mutants.sh: the launcher, host driver and container halves, through the mock docker
+# and fixtures/mutation-mock/fakebin/cargo (a fake `cargo mutants` driven by a table of mutant ->
+# outcome under a filtered run and under the full suite). The launcher runs for real: its bundle,
+# quoting and the environment it hands the driver are the production path; only ygg-verify.sh is
+# stubbed, by a script that does what RUN_ON_HOST=1 does (run the command inside the checked-out
+# revision). Slot locks are real flock(2) locks on files, taken by the driver and by the test.
+CMB=$here/fixtures/mutation-mock/fakebin
+cmrepo() {   # cmrepo A|B|C: sets cm_repo and cm_wd. A: a workspace at the repo root, workdir crates/x. B: a standalone package pkg/ under the repo root. C: B touching only the two files that have tests.
+  local r f c; r=$(mktemp -d); cm_repo=$r/repo; mkdir -p "$cm_repo"; git -C "$cm_repo" init -q
+  c="git -C $cm_repo -c user.name=t -c user.email=t@t"
+  if [ "$1" = A ]; then
+    cm_wd=crates/x; mkdir -p "$cm_repo/crates/x/src/alpha" "$cm_repo/crates/x/src/bin"
+    printf '[workspace]\nmembers = ["crates/x"]\n' >"$cm_repo/Cargo.toml"; printf '[package]\nname = "x"\n' >"$cm_repo/crates/x/Cargo.toml"
+    : >"$cm_repo/crates/x/src/lib.rs"; $c add -A 2>/dev/null; $c commit -qm c1
+    for f in src/lib.rs src/main.rs src/gamma.rs src/beta.rs src/alpha/mod.rs src/alpha/inner.rs src/bin/tool.rs build.rs; do echo "// $f" >"$cm_repo/crates/x/$f"; done
+  else
+    cm_wd=pkg; mkdir -p "$cm_repo/pkg/src/a" "$cm_repo/pkg/src/bin"
+    printf '[package]\nname = "p"\n' >"$cm_repo/pkg/Cargo.toml"; : >"$cm_repo/pkg/src/lib.rs"; $c add -A 2>/dev/null; $c commit -qm c1
+    for f in src/a/mod.rs src/a/b.rs; do echo "// $f" >"$cm_repo/pkg/$f"; done
+    [ "$1" = C ] || for f in src/lib.rs src/main.rs src/bin/x.rs build.rs; do echo "// $f" >"$cm_repo/pkg/$f"; done
+  fi
+  $c add -A 2>/dev/null; $c commit -qm c2
+}
+cmtable() {   # cmtable A|B|C: sets cm_table (name <TAB> outcome under a filtered run <TAB> outcome under the full suite)
+  cm_table=$(mktemp)
+  if [ "$1" = A ]; then
+    local p=crates/x/src
+    printf '%s\n' \
+      "$p/alpha/mod.rs:2:5: replace add -> i32 with 0	caught	caught" \
+      "$p/alpha/mod.rs:7:7: replace * with + in double	missed	caught" \
+      "$p/alpha/mod.rs:9:9: replace && with || in check	missed	missed" \
+      "$p/alpha/mod.rs:12:5: replace f(x) -> Vec<i32> with vec![1]	caught	caught" \
+      "$p/alpha/mod.rs:15:5: replace id -> Option<i32> with None	unviable	unviable" \
+      "$p/alpha/inner.rs:3:5: replace slow -> u32 with 0	timeout	caught" \
+      "$p/alpha/inner.rs:6:5: replace spin -> u32 with 1	missed	timeout" \
+      "$p/beta.rs:2:5: replace b1 -> i32 with 0	missed	caught" \
+      "$p/beta.rs:3:5: replace b2 -> i32 with 0	missed	missed" \
+      "$p/beta.rs:4:5: replace b3 -> i32 with 0	missed	unviable" \
+      "$p/gamma.rs:2:5: replace g -> i32 with 0	caught	caught" \
+      "$p/lib.rs:2:5: replace l1 -> i32 with 0	missed	caught" \
+      "$p/lib.rs:3:5: replace f(x) -> Vec<i32> with vec![1]	missed	missed" \
+      "$p/main.rs:2:5: replace m -> i32 with 0	missed	caught" \
+      "crates/x/build.rs:2:5: replace bu -> i32 with 0	missed	caught" \
+      "$p/bin/tool.rs:2:5: replace t -> i32 with 0	missed	caught" >"$cm_table"
+  elif [ "$1" = C ]; then
+    printf '%s\n' "src/a/mod.rs:2:5: replace a -> i32 with 0	caught	caught" "src/a/b.rs:2:5: replace a -> i32 with 0	caught	caught" >"$cm_table"
+  else
+    printf '%s\n' "src/lib.rs:2:5: replace a -> i32 with 0	caught	caught" "src/main.rs:2:5: replace a -> i32 with 0	caught	caught" \
+      "src/bin/x.rs:2:5: replace a -> i32 with 0	caught	caught" "build.rs:2:5: replace a -> i32 with 0	caught	caught" \
+      "src/a/mod.rs:2:5: replace a -> i32 with 0	caught	caught" "src/a/b.rs:2:5: replace a -> i32 with 0	caught	caught" >"$cm_table"
+  fi
+}
+# cm <A|B> [VAR=value]...: runs the launcher; sets cm_out, cm_rc, cm_root, cm_fd, cm_log. HOLD_OWN=1 holds the job's own slot as
+# ygg-verify does (a descriptor the driver inherits); HOLD_OTHERS=<n> holds n further slots as other jobs would (separate processes); PSI=<n> is the io pressure file's full avg60.
+cm() {
+  local lay=$1; shift
+  cmrepo "$lay"; cmtable "$lay"
+  cm_root=$(dirname "$cm_repo"); cm_fd=$cm_root/fd; cm_log=$cm_root/cargo.log
+  mkdir -p "$cm_fd" "$cm_root/tools/stopgap" "$cm_root/ygg" "$cm_root/tmp"
+  cp "$here/cargo-mutants.sh" "$cm_root/tools/"
+  printf '#!/usr/bin/env bash\n# test stub of ygg-verify.sh RUN_ON_HOST=1: <repo> <rev> <image> <cmd>; runs cmd as the host half inside the revision\ncd "$YGG_WORK" && exec bash -o pipefail -c "$4"\n' >"$cm_root/tools/stopgap/ygg-verify.sh"
+  local holders=() i n own=0 others=0 psi=0.00 kv env=()
+  for kv in "$@"; do case $kv in HOLD_OWN=*) own=${kv#*=} ;; HOLD_OTHERS=*) others=${kv#*=} ;; PSI=*) psi=${kv#*=} ;; *) env+=("$kv") ;; esac; done
+  for i in $(seq 1 "$others"); do
+    perl -e 'use Fcntl ":flock"; open(F, ">>", $ARGV[0]) or die; flock(F, LOCK_EX) or die; open(R, ">", "$ARGV[0].ready"); close R; sleep 120' "$cm_root/ygg/slot-$((i + 1)).lock" & holders+=($!)
+    for n in $(seq 1 50); do [ -e "$cm_root/ygg/slot-$((i + 1)).lock.ready" ] && break; sleep 0.1; done
+  done
+  cm_out=$( ( if [ "$own" = 1 ]; then exec {ownfd}>"$cm_root/ygg/slot-1.lock"; PATH=$CMB:$PATH flock -n "$ownfd"; fi
+      export PATH=$CMB:$PATH FAKE_DOCKER=$cm_fd FAKE_CM_TABLE=$cm_table FAKE_CM_LOG=$cm_log FAKE_CM_TESTS=$cm_root/tests.tsv \
+        FAKE_WSROOT=$([ "$lay" = A ] || echo pkg/) YGG_WORK=$cm_repo YGG_IMAGE=rust YGG_CNAME=job1 YGG_LABEL=eureka-verify-job=job1 YGG_CPUS=1 YGG_MEM=1g \
+        YGG_SLOTS=5 YGG_ROOT=$cm_root/ygg YGG_NONCE=n0nce1 CM_PSI=$cm_root/psi TMPDIR=$cm_root/tmp
+      printf 'beta::\t0\n' >"$cm_root/tests.tsv"
+      printf 'some avg10=0.00 avg60=0.00 avg300=0.00 total=0\nfull avg10=0.00 avg60=%s avg300=0.00 total=0\n' "$psi" >"$cm_root/psi"
+      for kv in "${env[@]}"; do export "${kv?}"; done
+      timeout 240 bash "$cm_root/tools/cargo-mutants.sh" "$cm_repo" HEAD HEAD~1 "$cm_wd" 2>&1 ) )
+  cm_rc=$?
+  for i in "${holders[@]}"; do kill "$i" 2>/dev/null; done; wait 2>/dev/null
+}
+cmcheck() {  # cmcheck <name> <must-contain | !must-not-contain>...
+  local name=$1 s; shift
+  for s in "$@"; do
+    case $s in
+      '!'*) if printf '%s\n' "$cm_out" | grep -qF -- "${s#!}"; then echo "FAIL cargo-mutants $name: must not contain: ${s#!}"; printf '%s\n' "$cm_out" | tail -n 12; fail=1; return; fi ;;
+      *) printf '%s\n' "$cm_out" | grep -qF -- "$s" || { echo "FAIL cargo-mutants $name: missing: $s"; printf '%s\n' "$cm_out" | tail -n 14; fail=1; return; } ;;
+    esac
+  done
+  echo "ok   cargo-mutants $name"
+}
+cmrc() { [ "$cm_rc" = "$2" ] || { echo "FAIL cargo-mutants $1: exit $cm_rc, want $2"; printf '%s\n' "$cm_out" | tail -n 8; fail=1; }; }
+cmclean() {   # nothing the job made may outlive it: no container directory, no bundle, no staging directory
+  local left; left=$(ls "$cm_fd/c" "$cm_root/tmp" 2>/dev/null | grep -v '^$' | grep -v ':$' | paste -sd, -)
+  if [ -z "$left" ]; then echo "ok   cargo-mutants $1: containers, bundle and staging removed"; else echo "FAIL cargo-mutants $1: left behind: $left"; fail=1; fi
+}
+cmlocks() {   # cmlocks <case>: after the driver exits, every slot lock can be taken again by a fresh process
+  local i bad=''
+  for i in 1 2 3 4 5; do bash -c "exec {fd}>'$cm_root/ygg/slot-$i.lock'; PATH=$CMB:\$PATH flock -n \$fd" || bad="$bad $i"; done
+  if [ -z "$bad" ]; then echo "ok   cargo-mutants $1: every slot lock is free again"; else echo "FAIL cargo-mutants $1: slots still locked:$bad"; fail=1; fi
+}
+
+# filter derivation, stage-1 survivors and timeouts confirmed, zero-test filter, no raw stage-1 lines, exit 2 and 3 normal
+cm A TEST_ARGS='--skip flaky'
+cmrc A 0
+cmcheck A-filters \
+  'FILTER crates/x/src/alpha/mod.rs alpha:: tests=1 mutants=5' 'FILTER crates/x/src/alpha/inner.rs alpha::inner:: tests=1 mutants=2' \
+  'FILTER crates/x/src/gamma.rs gamma:: tests=1 mutants=1' \
+  '!FILTER crates/x/src/lib.rs' '!FILTER crates/x/src/main.rs' '!FILTER crates/x/src/bin/tool.rs' '!FILTER crates/x/build.rs'
+cmcheck A-zero-test-filter 'FILTER crates/x/src/beta.rs beta:: tests=0 mutants=3' 'caught=10 missed=3 timeout=1 unviable=2'
+cmcheck A-confirmed-and-counted 'MUTANTS tested=16 caught=10 missed=3 timeout=1 unviable=2 | stage1 filtered=8 survivors=4 confirmed_caught=2 | containers=3 |' \
+  '!replace * with + in double' '!replace slow -> u32 with 0' '!replace add -> i32' \
+  'MISSED crates/x/src/alpha/mod.rs:9:9: replace && with || in check' 'MISSED crates/x/src/beta.rs:3:5: replace b2' 'MISSED crates/x/src/lib.rs:3:5: replace f(x) -> Vec<i32> with vec![1]' \
+  'TIMEOUT crates/x/src/alpha/inner.rs:6:5: replace spin'
+if [ "$(printf '%s\n' "$cm_out" | grep -c "^YGG-SUMMARY/n0nce1: MISSED ")" = 3 ]; then echo "ok   cargo-mutants A-missed-once: 3 final MISSED lines"; else echo "FAIL cargo-mutants A-missed-once"; fail=1; fi
+if printf '%s\n' "$cm_out" | grep -qE '^(MISSED|TIMEOUT) '; then echo "FAIL cargo-mutants A-no-raw-lines: a MISSED or TIMEOUT line outside the nonce-tagged lines"; fail=1; else echo "ok   cargo-mutants A-no-raw-lines"; fi
+if grep -qF 'stage=1 filter=alpha:: harness=--skip flaky' "$cm_log" && grep -qF 'stage=1 filter=alpha::inner:: harness=--skip flaky' "$cm_log" && grep -qF 'stage=2 filter= harness=--skip flaky' "$cm_log"
+then echo "ok   cargo-mutants A-harness-args: TEST_ARGS follow the filter in stage 1 and stand alone in stage 2"; else echo "FAIL cargo-mutants A-harness-args"; sort -u "$cm_log"; fail=1; fi
+if [ "$(grep -c '^stage=2' "$cm_log")" = 3 ]; then echo "ok   cargo-mutants A-stage2-sharded: 3 full-suite shards"; else echo "FAIL cargo-mutants A-stage2-sharded"; fail=1; fi
+# a file whose filter selects 0 tests is found at plan time and never pays a stage-1 pass; its names run in stage 2
+if grep -qF 'count filter=beta:: harness=--skip flaky' "$cm_log" && ! grep -q '^stage=1 filter=beta::' "$cm_log"
+then echo "ok   cargo-mutants A-zero-test-plan: counted at plan time, no stage-1 run for it"; else echo "FAIL cargo-mutants A-zero-test-plan"; sort -u "$cm_log"; fail=1; fi
+# the stage-2 timeout bound is the generous default with a floor, not a tight multiple of a quiet-host baseline
+if [ "$(grep -c '^stage=2 .* mult=5 min=20$' "$cm_log")" = 3 ] && ! grep '^stage=2' "$cm_log" | grep -qv 'mult=5 min=20$'
+then echo "ok   cargo-mutants A-timeout-bound: stage 2 runs at 5x with a 20 s floor"; else echo "FAIL cargo-mutants A-timeout-bound"; grep '^stage=2' "$cm_log"; fail=1; fi
+cmclean A; cmlocks A
+
+# derivation on a standalone package under the repo root: the diff is taken at the workspace root (--relative)
+cm B
+cmrc B 0
+cmcheck B-derivation 'FILTER src/a/mod.rs a:: tests=1 mutants=1' 'FILTER src/a/b.rs a::b:: tests=1 mutants=1' \
+  '!FILTER src/lib.rs' '!FILTER src/main.rs' '!FILTER src/bin/x.rs' '!FILTER build.rs' 'MUTANTS tested=6 caught=6 missed=0'
+# FILTERS overrides the derived filter; '-' forces the full suite
+cm B 'FILTERS=src/a/b.rs=-,src/lib.rs=special::'
+cmcheck B-override 'FILTER src/lib.rs special:: tests=1 mutants=1' 'FILTER src/a/mod.rs a:: ' '!FILTER src/a/b.rs' 'tested=6 caught=6'
+
+# stage 1 settles every mutant: the full-suite baseline still runs (stage 2 is never skipped), and a red one is a red job
+cm C
+cmrc C-settled 0
+cmcheck C-settled 'MUTANTS tested=2 caught=2 missed=0 timeout=0 unviable=0 | stage1 filtered=2 survivors=0 confirmed_caught=0'
+if [ "$(grep -c '^stage=2' "$cm_log")" = 1 ]; then echo "ok   cargo-mutants C-baseline-runs: one full-suite run although stage 1 settled every mutant"; else echo "FAIL cargo-mutants C-baseline-runs"; sort -u "$cm_log"; fail=1; fi
+cm C FAKE_CM_RED=2
+[ "$cm_rc" != 0 ] || { echo "FAIL cargo-mutants C-red-baseline: exit 0"; fail=1; }
+cmcheck C-red-baseline 'ERROR stage 2 (shard 1 of 1)' 'container exited 4' '!MUTANTS'
+cmclean C-red-baseline
+# CONFIRM_TIMEOUT_MULT and MIN_TEST_TIMEOUT reach the stage-2 run
+cm A CONFIRM_TIMEOUT_MULT=9 MIN_TEST_TIMEOUT=33
+if grep '^stage=2' "$cm_log" | grep -q 'mult=9 min=33$' && ! grep '^stage=2' "$cm_log" | grep -qv 'mult=9 min=33$'; then echo "ok   cargo-mutants timeout-overrides: 9x with a 33 s floor in stage 2"; else echo "FAIL cargo-mutants timeout-overrides"; grep '^stage=2' "$cm_log"; fail=1; fi
+# slot lease: the job's own slot is held by ygg-verify (an inherited descriptor), others by other jobs
+cm A HOLD_OWN=1 HOLD_OTHERS=1; cmcheck lease-free 'containers=3 |'; cmlocks lease-free
+cm A HOLD_OWN=1 HOLD_OTHERS=3; cmcheck lease-one-free 'containers=2 |'
+cm A HOLD_OWN=1 HOLD_OTHERS=4; cmcheck lease-none-free 'containers=1 |' 'tested=16'; cmlocks lease-none-free
+open_none=$(grep -o 'openfds=[0-9]*' "$cm_log" | sort -u | paste -sd, -)
+cm A HOLD_OWN=1 HOLD_OTHERS=1; open_leased=$(grep -o 'openfds=[0-9]*' "$cm_log" | sort -u | paste -sd, -)
+if [ "$open_none" = "$open_leased" ]; then echo "ok   cargo-mutants lease-not-inherited: containers see the same descriptors with 2 leases held as with none ($open_none)"; else echo "FAIL cargo-mutants lease-not-inherited: $open_none vs $open_leased"; fail=1; fi
+cm A PSI=41.00; cmcheck lease-io-pressure 'containers=1 |' 'tested=16'
+# a red baseline, in stage 1 or in stage 2, is not a clean run
+cm A FAKE_CM_RED=1
+[ "$cm_rc" != 0 ] || { echo "FAIL cargo-mutants red-stage1: exit 0"; fail=1; }
+cmcheck red-stage1 'ERROR stage 1 (' 'container exited 4' '!MUTANTS' '!MISSED' '!TIMEOUT'
+cm A FAKE_CM_RED=2
+[ "$cm_rc" != 0 ] || { echo "FAIL cargo-mutants red-stage2: exit 0"; fail=1; }
+cmcheck red-stage2 'ERROR stage 2 (shard' 'container exited 4' '!MUTANTS' '!MISSED' '!TIMEOUT'
+cmclean red-stage2
+# NAMES rerun: no stage-1 container, only the listed names, on the full suite
+cm_names=$(mktemp)
+printf '%s\n' 'crates/x/src/alpha/mod.rs:9:9: replace && with || in check' 'crates/x/src/lib.rs:3:5: replace f(x) -> Vec<i32> with vec![1]' 'crates/x/src/beta.rs:2:5: replace b1 -> i32 with 0' >"$cm_names"
+cm A "NAMES=$cm_names"
+cmrc names 0
+cmcheck names 'MUTANTS tested=3 caught=1 missed=2 timeout=0 unviable=0 | stage1 filtered=0 survivors=0 confirmed_caught=0' 'MISSED crates/x/src/alpha/mod.rs:9:9' '!FILTER'
+if grep -q 'run job1-s1' "$cm_fd/log" || grep -q '^stage=1' "$cm_log"; then echo "FAIL cargo-mutants names: a stage-1 container or a filtered run"; fail=1; else echo "ok   cargo-mutants names: no stage-1 container"; fi
+# a name the range does not produce is an error that does not echo the name
+printf '%s\n' 'crates/x/src/lib.rs:99:9: replace no_such_secret_name -> i32 with 0' >"$cm_names"
+cm A "NAMES=$cm_names"
+[ "$cm_rc" != 0 ] || { echo "FAIL cargo-mutants names-unknown: exit 0"; fail=1; }
+cmcheck names-unknown 'ERROR 1 mutants selected' '!no_such_secret_name' '!MUTANTS'
+rm -f "$cm_names"
+# killed: a job the watchdog already killed starts nothing and leaves nothing
+cm_k=$(mktemp); cm A "YGG_KILLED=$cm_k"; rm -f "$cm_k"
+cmrc killed-before 124
+if grep -q '^run ' "$cm_fd/log" 2>/dev/null; then echo "FAIL cargo-mutants killed-before: a container started"; fail=1; else echo "ok   cargo-mutants killed-before: no container started"; fi
+cmclean killed-before
+# the flag appears while stage 1 runs: stage 2 never starts
+cm_k=$(mktemp -u); cm A "YGG_KILLED=$cm_k" "FAKE_CM_KILLS=$cm_k"; rm -f "$cm_k"
+cmrc killed-during 124
+cmcheck killed-during 'JOB KILLED' '!MUTANTS'
+if grep -q 'run job1-s2' "$cm_fd/log"; then echo "FAIL cargo-mutants killed-during: a stage-2 container started"; fail=1; else echo "ok   cargo-mutants killed-during: no stage-2 container"; fi
+cmclean killed-during
+# the launcher refuses bad input before any job starts, and never echoes the value it refused
+cmrepo A
+for v in 'SHARDS=0' 'SHARDS=x;SECRET' 'FILTERS=nopairSECRET' 'CONFIRM_TIMEOUT_MULT=2;SECRET'; do
+  lo=$(env "$v" bash "$here/cargo-mutants.sh" "$cm_repo" HEAD HEAD~1 "$cm_wd" 2>&1); lrc=$?
+  if [ "$lrc" = 2 ] && ! printf '%s' "$lo" | grep -q SECRET; then echo "ok   cargo-mutants launcher refuses ${v%%=*}"; else echo "FAIL cargo-mutants launcher ${v%%=*}: exit $lrc, output: $lo"; fail=1; fi
+done
+lo=$(bash "$here/cargo-mutants.sh" "$cm_repo" HEAD~1 HEAD "$cm_wd" 2>&1); lrc=$?
+if [ "$lrc" = 2 ] && printf '%s' "$lo" | grep -q 'not an ancestor'; then echo "ok   cargo-mutants launcher refuses a base that is not an ancestor"; else echo "FAIL cargo-mutants launcher base: exit $lrc, output: $lo"; fail=1; fi
+
+# the -F escaper: every regex metacharacter, the pipe included, is escaped; nothing else is touched
+esc_bad=''
+for c in '\' . + '*' '?' '(' ')' '|' '[' ']' '{' '}' '^' '$'; do
+  got=$(printf 'a%sb\n' "$c" | bash "$here/cargo-mutants.sh" --escape)
+  [ "$got" = '^a'\\"$c"'b$' ] || esc_bad="$esc_bad [$c]"
+done
+got=$(printf 'replace x -> Vec<i32> with vec![1] & 2 - 3 #\n' | bash "$here/cargo-mutants.sh" --escape)
+[ "$got" = '^replace x -> Vec<i32> with vec!\[1\] & 2 - 3 #$' ] || esc_bad="$esc_bad [plain]"
+if [ -z "$esc_bad" ]; then echo "ok   cargo-mutants escaper: all 14 metacharacters escaped, others literal"; else echo "FAIL cargo-mutants escaper:$esc_bad"; fail=1; fi
+
 # wait-on.sh: pid, log and file forms, and the vanished-process exit
 W=$here/wait-on.sh
 wo() { local rc; WAIT_MAX=${WM:-4} bash "$W" "$@" >"$T/wo.out" 2>&1; rc=$?; echo "$rc"; }
@@ -236,6 +443,15 @@ seqf() { local i; for i in $(seq 1 "$2"); do echo "$1$i"; done; }
 g init -q
 seqf a 40 >"$R/a.txt"; seqf b 40 >"$R/b.txt"; seqf c 10 >"$R/c.txt"; seqf d 20 >"$R/d.txt"
 seqf e 10 >"$R/e.txt"; seqf f 20 >"$R/f.txt"; seqf g 300 >"$R/big.txt"; seqf h 5 | sed 's/$/
/' >"$R/h.txt"; seqf m 40 >"$R/m.txt"
+printf 's1\ns2\ns3\ns4\ndef needle_three\ns6\ns7 needle_many\ns8\nfoo::bar\ns10\n' >"$R/sym.txt"
+printf 'needle_three call 1\nneedle_three call 2\nneedle_three call 3\nneedle_threefold is another word\n' >"$R/zcallers.txt"
+echo 'bound_fifty bound_fiftyone spread_sym long_symbol q.zq sym_bad twenty_sym' >"$R/anchors.txt"
+seqf "bound_fifty x" 50 >"$R/bound50.txt"; seqf "bound_fiftyone x" 51 >"$R/bound51.txt"; seqf "q.zq x" 51 >"$R/dotted.txt"
+printf 'long_symbol %s%s\r' "$(printf '%0150d' 0 | tr 0 z)" "$(printf '%0100d' 0 | tr 0 y)" >"$R/longline.txt"; printf '\n' >>"$R/longline.txt"
+printf 'sym_bad \377 endX\r\n' >"$R/bad.txt"
+mkdir -p "$R/manyf"; for i in $(seq -w 1 21); do seqf "spread_sym $i-" 3 >"$R/manyf/f$i.txt"; done; echo "spread_sym extra" >>"$R/manyf/f21.txt"
+mkdir -p "$R/twf"; for i in $(seq -w 1 20); do seqf "twenty_sym $i-" 3 >"$R/twf/f$i.txt"; done
+seqf "needle_many x." 30 >"$R/many1.txt"; seqf "needle_many y." 30 >"$R/many2.txt"
 g add -A; g commit -q -m base; BASE=$(git -C "$R" rev-parse HEAD)
 { sed -n 1,5p "$R/a.txt"; printf 'ins1\nins2\nins3\n'; sed -n '6,$p' "$R/a.txt"; } >"$R/a.new"; mv "$R/a.new" "$R/a.txt"
 sed -e '2,3d' -e 's/^b10$/b10-EDITED/' "$R/b.txt" >"$R/b.new"; mv "$R/b.new" "$R/b.txt"
@@ -337,6 +553,124 @@ cin "window cut at 100 lines" "56 more lines: --only 1 --max-lines 160"
 r=$(cpo --spec-json "$S1" --only 1 --max-lines 160); cchk "--only with the suggested --max-lines" 0 "$r"
 cnot "full window needs no more-lines note" "more lines"
 [ "$(wc -l <"$T/cp.out" | tr -d ' ')" = 160 ] && echo "ok   context-pack suggested --max-lines is exact" || { echo "FAIL context-pack suggested max: $(wc -l <"$T/cp.out")"; fail=1; }
+# reads, symbols and caller lists
+sed "s/\"BASE\"/\"$BASE\"/" "$CF/spec-reads.json" >"$T/cp-spec-reads.json"; SR=$(wp "$T/cp-spec-reads.json")
+r=$(cpo --spec-json "$SR"); cchk "reads and symbols" 3 "$r"
+cin "a read that moved" "[r1] a.txt:20-22  MOVED(+3)  -> a.txt:23-25"
+cin "a read on a deleted path is GONE" "[r2] c.txt:2-3  GONE (not named by the spec's deletes)"
+cin "a read absent at base is MISSING" "[r3] sub/a.txt:1-2  MISSING (read path absent at base)"
+cin "a present symbol adds no suffix" "[1] a.txt:20-22  MOVED(+3)  -> a.txt:23-25"
+cin "a missing symbol is named" "[2] b.txt:30-31  MOVED(-2) SYMBOL_MISSING b99"
+cin "an identifier matches whole words only" "MOVED(+3) SYMBOL_MISSING a2  -> a.txt:23-25"
+cin "a non-identifier symbol is a literal substring" "[4] sym.txt:9-9  SAME"
+cnot "the substring symbol is not missing" "SYMBOL_MISSING ::ba"
+cin "the read caption carries its why" "== READ r1: moved below the insertion  (a.txt:23-25  MOVED(+3))"
+cin "a GONE read prints its window at base" "== READ r2: deleted path  (c.txt:2-3 AT BASE"
+[ "$(grep -c '^\[' "$T/cp.out")" = 9 ] && echo "ok   context-pack the table lists edits and reads" || { echo "FAIL context-pack table rows with reads"; fail=1; }
+[ "$(grep -n '^== READ r1' "$T/cp.out" | cut -d: -f1)" -gt "$(grep -n '^== \[4\]' "$T/cp.out" | cut -d: -f1)" ] && echo "ok   context-pack read windows follow the edit windows" || { echo "FAIL context-pack read window order"; fail=1; }
+[ "$(grep -n '^CALLERS' "$T/cp.out" | head -1 | cut -d: -f1)" -gt "$(grep -n '^== READ r5' "$T/cp.out" | cut -d: -f1)" ] && echo "ok   context-pack caller lists follow the read windows" || { echo "FAIL context-pack caller list order"; fail=1; }
+cin "3 callers are all listed" "CALLERS needle_three: 3 hits in 1 files"
+cin "caller hit format" "zcallers.txt:2: needle_three call 2"
+cnot "the hit inside the symbol's own window is dropped" "sym.txt:5: def needle_three"
+cnot "a longer word is no caller" "needle_threefold"
+cin "60 hits print per-file counts" "CALLERS needle_many: 60 hits in 2 files"
+cin "per-file count line" "    30  many1.txt"
+cin "the narrowing command" "narrow: git grep -n -I -w -F -e needle_many -- <path>"
+cnot "60 hits print no hit lines" "many1.txt:1:"
+r=$(cpo --spec-json "$SR" --only r1); cchk "--only r1 keeps the exit of all anchors" 3 "$r"
+cin "--only r1 prints the read" "== READ r1: moved below the insertion"
+cnot "--only r1 prints no other read" "== READ r2"; cnot "--only r1 prints no edit window" "== [1]"
+r=$(cpo --spec-json "$SR" --only r9); cchk "--only past the reads" 2 "$r"; grep -qF "context-pack: --only: index outside reads" "$T/cp.err" && echo "ok   context-pack names the reads bound" || { echo "FAIL context-pack reads bound"; fail=1; }
+r=$(cpo --spec-json "$SR" --only 1,r4); cin "--only mixes edit and read labels" "CALLERS needle_many: 60 hits"; cnot "--only lists callers of the selected anchors only" "CALLERS b99"
+r=$(cpo --spec-json "$SR" --since "$(git -C "$R" rev-parse HEAD)"); cnot "--since HEAD prints no read window" "== READ"; cnot "--since HEAD prints no caller list" "CALLERS"
+r=$(cpo --spec-json "$SR" --max-lines 3); cchk "--max-lines below the table with reads" 3 "$r"
+[ "$(grep -c '^\[' "$T/cp.out")" = 9 ] && echo "ok   context-pack a small budget keeps every edit and read row" || { echo "FAIL context-pack small budget with reads"; fail=1; }
+cnot "a small budget prints no window" "== "; cnot "a small budget prints no caller list" "CALLERS"
+r=$(cpo --spec-json "$SR" --max-lines 60); cchk "caller lists cut by the budget" 3 "$r"
+[ "$(wc -l <"$T/cp.out" | tr -d ' ')" -le 60 ] && echo "ok   context-pack caller lists stay within --max-lines" || { echo "FAIL context-pack caller lists over budget"; fail=1; }
+cin "the cut caller lists are named" "callers not printed: "
+SUGG=$(grep -o '^callers not printed: .*--max-lines [0-9]*' "$T/cp.out" | grep -o '[0-9]*$')
+r=$(cpo --spec-json "$SR" --max-lines "$SUGG"); cnot "the suggested --max-lines prints every caller list" "callers not printed"
+[ "$(wc -l <"$T/cp.out" | tr -d ' ')" = "$SUGG" ] && echo "ok   context-pack suggested caller --max-lines is exact" || { echo "FAIL context-pack suggested caller max: $(wc -l <"$T/cp.out") vs $SUGG"; fail=1; }
+{ echo '{"base": "'$BASE'", "deletes": [], "file_changes": ['
+  for i in 1 2 3 4 5 6 7 8 9; do echo '{"change": "s'$i'", "location": {"path": "big.txt", "line": '$i', "end_line": '$i', "symbol": "g'$i'"}}'$([ $i -lt 9 ] && echo ,); done
+  echo ']}'; } >"$T/cp-spec9sym.json"
+r=$(cpo --spec-json "$(wp "$T/cp-spec9sym.json")" --max-lines 400); cchk "nine symbols" 0 "$r"
+[ "$(grep -c '^CALLERS' "$T/cp.out")" = 8 ] && echo "ok   context-pack at most 8 caller lists" || { echo "FAIL context-pack caller list count"; fail=1; }
+cin "the ninth symbol is named" "callers not listed: g9"
+echo '{"base": "'$BASE'", "deletes": [], "file_changes": [], "reads": [{"why": "w", "location": {"path": "a.txt", "line": 20, "end_line": 22, "symbol": "a21"}}]}' >"$T/cp-spec-r0.json"
+r=$(cpo --spec-json "$(wp "$T/cp-spec-r0.json")"); cchk "a spec of one read, symbol present" 0 "$r"
+cin "a read with a symbol present: no suffix" "[r1] a.txt:20-22  MOVED(+3)  -> a.txt:23-25  # w"
+# caller-list bounds: 50 hits list, 51 count; 20 files; a hit's text is cut at 160; CR and bad bytes
+{ echo '{"base": "'$BASE'", "deletes": [], "file_changes": ['
+  n=0; for sy in bound_fifty bound_fiftyone spread_sym long_symbol q.zq sym_bad twenty_sym; do n=$((n+1))
+    echo '{"change": "'$sy'", "location": {"path": "anchors.txt", "line": 1, "end_line": 1, "symbol": "'$sy'"}}'$([ $n -lt 7 ] && echo ,); done
+  echo ']}'; } >"$T/cp-specb.json"
+r=$(cpo --spec-json "$(wp "$T/cp-specb.json")" --max-lines 400); cchk "caller list bounds" 0 "$r"
+cin "exactly 50 hits are listed" "CALLERS bound_fifty: 50 hits in 1 files"
+[ "$(grep -c '^bound50.txt:' "$T/cp.out")" = 50 ] && echo "ok   context-pack 50 hits print as lines" || { echo "FAIL context-pack 50 hit lines"; fail=1; }
+cin "51 hits are counted" "CALLERS bound_fiftyone: 51 hits in 1 files"
+cin "51 hits: the per-file count" "    51  bound51.txt"
+cnot "51 hits print no hit lines" "bound51.txt:1:"
+grep -qx "(1 more files)" "$T/cp.out" && echo "ok   context-pack 21 files: the 21st is named" || { echo "FAIL context-pack 21st file line"; fail=1; }
+grep -qx "narrow: git grep -n -I -F -e q.zq -- <path>" "$T/cp.out" && echo "ok   context-pack the narrowing line is exact" || { echo "FAIL context-pack narrowing line"; fail=1; }
+cin "exactly 20 files name no more" "CALLERS twenty_sym: 60 hits in 20 files"
+[ "$(grep -c '(0 more files)' "$T/cp.out")" = 0 ] && echo "ok   context-pack 20 files print no more-files line" || { echo "FAIL context-pack 20 files"; fail=1; }
+[ "$(grep -c '^ *[34]  manyf/' "$T/cp.out")" = 20 ] && echo "ok   context-pack at most 20 files are counted" || { echo "FAIL context-pack file cap: $(grep -c '^ *[34]  manyf/' "$T/cp.out")"; fail=1; }
+cin "files are ranked by hits, largest first" "     4  manyf/f21.txt"
+[ "$(grep -n 'manyf/f21.txt' "$T/cp.out" | cut -d: -f1)" -lt "$(grep -n 'manyf/f01.txt' "$T/cp.out" | cut -d: -f1)" ] && echo "ok   context-pack the largest file prints first" || { echo "FAIL context-pack file order"; fail=1; }
+cin "a non-identifier narrowing command has no -w" "narrow: git grep -n -I -F -e q.zq -- <path>"
+LL=$(grep '^longline.txt:1: ' "$T/cp.out"); [ "${#LL}" = 176 ] && echo "ok   context-pack a hit's text is cut at 160 characters" || { echo "FAIL context-pack hit text length ${#LL}"; fail=1; }
+cnot "a CR in a hit is stripped" "$(printf '\r')"
+cin "a hit with invalid UTF-8 still prints" "bad.txt:1: sym_bad"
+cin "a hit keeps a trailing X and loses its CR" "endX"
+grep -qx "bad.txt:1: sym_bad .* endX" "$T/cp.out" && echo "ok   context-pack a hit ends at its last character" || { echo "FAIL context-pack hit end"; fail=1; }
+r=$(cpo --spec-json "$SR" --only 5); cchk "--only past the last edit anchor" 2 "$r"; grep -qxF "context-pack: --only: index outside file_changes" "$T/cp.err" && echo "ok   context-pack --only 5 is outside four anchors" || { echo "FAIL context-pack --only 5"; fail=1; }
+r=$(cpo --spec-json "$SR" --only 4); cchk "--only the last edit anchor" 3 "$r"; cin "--only 4 prints that window" "== [4] sym.txt:9-9"
+r=$(cpo --spec-json "$SR" --only r6); cchk "--only past the last read" 2 "$r"; grep -qxF "context-pack: --only: index outside reads" "$T/cp.err" && echo "ok   context-pack --only r6 is outside five reads" || { echo "FAIL context-pack --only r6"; fail=1; }
+r=$(cpo --spec-json "$SR" --only r5); cchk "--only the last read" 3 "$r"; cin "--only r5 prints that window" "== READ r5:"
+sed -n 3p "$T/cp.out" | grep -q '^\[r3\]' && echo "ok   context-pack a MISSING read sorts with the problem anchors" || { echo "FAIL context-pack MISSING read order"; fail=1; }
+cin "a GONE read checks its symbol at base" "GONE (not named by the spec's deletes) SYMBOL_MISSING c9"
+{ echo '{"base": "'$BASE'", "deletes": [], "file_changes": [{"location": {"path": "a.txt", "line": 1, "end_line": 2, "symbol": "zz9"}}],'
+  echo '"reads": [{"location": {"path": "a.txt", "line": 1, "end_line": 2}}, {"why": "'$(printf '%0250d' 0 | tr 0 w)'", "location": {"path": "a.txt", "line": 3, "end_line": 3}}]}'; } >"$T/cp-specw.json"
+r=$(cpo --spec-json "$(wp "$T/cp-specw.json")"); cchk "a missing symbol alone fails the run" 3 "$r"
+cin "a symbol absent from an unmoved window" "[1] a.txt:1-2  SAME SYMBOL_MISSING zz9"
+cnot "an anchor without a change or why gets no filler" "XXXX"
+W200=$(printf '%0200d' 0 | tr 0 w); cin "the read caption is cut at 200" "== READ r2: $W200  (a.txt:3-3"
+# the caller lists obey --max-lines at every budget, and the suggested value prints them all
+{ echo '{"base": "'$BASE'", "deletes": [], "file_changes": ['
+  for i in 1 2 3 4 5 6 7 8 9 10; do echo '{"change": "s'$i'", "location": {"path": "big.txt", "line": '$i', "end_line": '$i', "symbol": "g'$i'"}}'$([ $i -lt 10 ] && echo ,); done
+  echo ']}'; } >"$T/cp-spec10sym.json"; S10=$(wp "$T/cp-spec10sym.json")
+r=$(cpo --spec-json "$S10" --max-lines 400); cin "two symbols past the eighth are named together" "callers not listed: g9,g10"
+FULLN=$(wc -l <"$T/cp.out" | tr -d ' ')
+for b in $((FULLN-1)) $((FULLN-3)) $((FULLN-6)) $((FULLN-9)) $((FULLN-30)); do
+  r=$(cpo --spec-json "$S10" --max-lines "$b")
+  [ "$(wc -l <"$T/cp.out" | tr -d ' ')" -le "$b" ] && echo "ok   context-pack budget $b holds" || { echo "FAIL context-pack budget $b exceeded: $(wc -l <"$T/cp.out")"; fail=1; }
+  SG=$(grep -o '^callers not printed: .*--max-lines [0-9]*' "$T/cp.out" | grep -o '[0-9]*$')
+  if [ -n "$SG" ]; then r=$(cpo --spec-json "$S10" --max-lines "$SG"); [ "$(wc -l <"$T/cp.out" | tr -d ' ')" = "$FULLN" ] && ! grep -q 'callers not printed\|not expanded' "$T/cp.out" && echo "ok   context-pack budget $b: the suggestion prints everything" || { echo "FAIL context-pack budget $b: suggestion $SG gave $(wc -l <"$T/cp.out") of $FULLN"; fail=1; }; fi
+done
+r=$(cpo --spec-json "$S10" --max-lines $((FULLN-1))); [ "$(grep -c '^CALLERS' "$T/cp.out")" = 6 ] && echo "ok   context-pack one line short drops two lists for the note" || { echo "FAIL context-pack one line short: $(grep -c '^CALLERS' "$T/cp.out") lists"; fail=1; }
+cin "the dropped lists are named" "callers not printed: g7,g8: --max-lines $FULLN"
+# window budgets: the exact thresholds, and what the caller lists leave of them
+r=$(cpo --spec-json "$S1" --max-lines 104); cnot "104 lines expand no 100-line window" "== ["; cin "104 lines skip a 100-line window" "not expanded: --only 1"
+r=$(cpo --spec-json "$S1" --max-lines 105); [ "$(wc -l <"$T/cp.out" | tr -d ' ')" = 105 ] && grep -qx "56 more lines: --only 1 --max-lines 160" "$T/cp.out" && echo "ok   context-pack 105 lines hold a capped window and its note" || { echo "FAIL context-pack 105-line budget"; fail=1; }
+S30=$(wp "$T/cp-spec30.json")
+r=$(cpo --spec-json "$S30" --max-lines 186); [ "$(grep -c '^== ' "$T/cp.out")" = 9 ] && [ "$(wc -l <"$T/cp.out" | tr -d ' ')" = 186 ] && echo "ok   context-pack 186 lines hold 9 windows and the note" || { echo "FAIL context-pack 186-line budget"; fail=1; }
+r=$(cpo --spec-json "$S30" --max-lines 185); [ "$(grep -c '^== ' "$T/cp.out")" = 8 ] && echo "ok   context-pack 185 lines hold 8 windows" || { echo "FAIL context-pack 185-line budget"; fail=1; }
+r=$(cpo --spec-json "$S30" --max-lines 542); [ "$(grep -c '^== ' "$T/cp.out")" = 30 ] && echo "ok   context-pack 542 lines hold all 30 windows" || { echo "FAIL context-pack 542-line budget"; fail=1; }; cnot "542 lines need no not-expanded note" "not expanded"
+for b in 530 531 532 533 534 535 536 537 538 539 540 541; do
+  r=$(cpo --spec-json "$S30" --max-lines $b); [ "$(wc -l <"$T/cp.out" | tr -d ' ')" -le $b ] && grep -q '^not expanded: --only 30$' "$T/cp.out" && echo "ok   context-pack budget $b skips only the last window" || { echo "FAIL context-pack budget $b: $(wc -l <"$T/cp.out") lines"; fail=1; }
+done
+for b in 37 38 39 40 41 42 43 44 45 46 47; do
+  r=$(cpo --spec-json "$S30" --only 1,2 --max-lines $b); [ "$(wc -l <"$T/cp.out" | tr -d ' ')" = $b ] && [ "$(grep -c '^== ' "$T/cp.out")" = 1 ] && grep -q 'more lines: --only 1 ' "$T/cp.out" && echo "ok   context-pack --only 1,2 at $b lines truncates window 1 to fit" || { echo "FAIL context-pack --only 1,2 at $b: $(wc -l <"$T/cp.out") lines"; fail=1; }
+done
+r=$(cpo --spec-json "$S30" --only 1,2 --max-lines 36); cnot "--only 1,2 at 36 lines expands nothing" "== ["
+r=$(cpo --spec-json "$S10" --max-lines 94); [ "$(wc -l <"$T/cp.out" | tr -d ' ')" = 94 ] && [ "$(grep -c '^== ' "$T/cp.out")" = 10 ] && [ "$(grep -c '^CALLERS' "$T/cp.out")" = 6 ] && echo "ok   context-pack one line short keeps every window and 6 lists" || { echo "FAIL context-pack 94-line S10"; fail=1; }
+r=$(cpo --spec-json "$S10" --max-lines 86); [ "$(wc -l <"$T/cp.out" | tr -d ' ')" = 86 ] && [ "$(grep -c '^== ' "$T/cp.out")" = 9 ] && [ "$(grep -c '^CALLERS' "$T/cp.out")" = 5 ] && echo "ok   context-pack 86 lines: 9 windows, 5 lists, every note" || { echo "FAIL context-pack 86-line S10"; fail=1; }
+r=$(cpo --spec-json "$S10" --max-lines 65); [ "$(grep -c '^== ' "$T/cp.out")" = 7 ] && [ "$(grep -c '^CALLERS' "$T/cp.out")" = 0 ] && grep -q '^callers not printed: ' "$T/cp.out" && grep -q '^callers not listed: g9,g10' "$T/cp.out" && echo "ok   context-pack windows outrank caller lists" || { echo "FAIL context-pack 65-line S10"; fail=1; }
+r=$(cpo --spec-json "$SR" --max-lines 40); [ "$(wc -l <"$T/cp.out" | tr -d ' ')" = 40 ] && [ "$(grep -c '^== ' "$T/cp.out")" = 3 ] && [ "$(grep -c '^CALLERS' "$T/cp.out")" = 2 ] && echo "ok   context-pack 40 lines: 3 windows, 2 lists, no line unused" || { echo "FAIL context-pack 40-line SR"; fail=1; }
+r=$(cpo --spec-json "$SR" --max-lines 44); [ "$(wc -l <"$T/cp.out" | tr -d ' ')" = 44 ] && [ "$(grep -c '^CALLERS' "$T/cp.out")" = 3 ] && echo "ok   context-pack 44 lines: 3 lists" || { echo "FAIL context-pack 44-line SR"; fail=1; }
+r=$(cpo --spec-json "$SR" --max-lines 62); [ "$(wc -l <"$T/cp.out" | tr -d ' ')" = 61 ] && [ "$(grep -c '^CALLERS' "$T/cp.out")" = 4 ] && echo "ok   context-pack 62 lines: a list that needs 2 lines waits" || { echo "FAIL context-pack 62-line SR"; fail=1; }
 # usage and unreadable spec; no error echoes an input value
 r=$(cpo --spec-json "$SP" --max-lines CANARY-usage); cchk "bad --max-lines" 2 "$r"; cnot "usage error echoes no value" "CANARY-usage"
 r=$(cpo --spec-json "$T/CANARY-nofile.json"); cchk "unreadable --spec-json" 4 "$r"; grep -qF "context-pack: --spec-json: unreadable; --spec-json reads a saved view" "$T/cp.err" && echo "ok   context-pack names the unreadable --spec-json" || { echo "FAIL context-pack names the unreadable --spec-json"; fail=1; }; cnot "unreadable --spec-json echoes no path" "CANARY-nofile"
@@ -446,6 +780,14 @@ cases = {
  "deletes-str": (lambda v: v.update(deletes="CANARY-del"), "deletes"),
  "deletes-nopath": (lambda v: v.update(deletes=[{"note": "CANARY-note"}]), "deletes[1].path"),
  "deletes-entry-str": (lambda v: v.update(deletes=["CANARY-d"]), "deletes[1].path"),
+ "reads-str": (lambda v: v.update(reads="CANARY-reads"), "reads"),
+ "read-entry-str": (lambda v: v.update(reads=["CANARY-read"]), "reads[1]"),
+ "read-nolocation": (lambda v: v.update(reads=[{"why": "w"}]), "reads[1].location"),
+ "read-path": (lambda v: v.update(reads=[{"why": "w", "location": {"path": ["CANARY-p"], "line": 1}}]), "reads[1].location.path"),
+ "read-line": (lambda v: v.update(reads=[{"why": "w", "location": {"path": "a.txt", "line": "CANARY-l"}}]), "reads[1].location.line"),
+ "read-why": (lambda v: v.update(reads=[{"why": {"CANARY": 1}, "location": {"path": "a.txt", "line": 1}}]), "reads[1].why"),
+ "read-symbol": (lambda v: v.update(reads=[{"why": "w", "location": {"path": "a.txt", "line": 1, "symbol": 7}}]), "reads[1].location.symbol"),
+ "edit-symbol": (lambda v: v["file_changes"][0]["location"].update(symbol=["CANARY-s"]), "file_changes[1].location.symbol"),
 }
 names = []
 for name, (edit, field) in cases.items():