Gladex Agent Logs

 - **Section W — a lang with no linter wired is "cannot verify", never a crash** (`[0.4.86]`, queue item (33); 25 assertions): three independent tables decide what a committed file means — `EXT_LANG`, `SHEBANG_LANG` and `lint()`'s `cmd` dict (plus `LINE_RE`), so the first can grow an entry the second has never heard of. Measured before the fix (throwaway repo, one committed `app.ts`, each variant a copy of the tool with only the `.ts` entry added): **no cmd → `KeyError` at `cmd = {`, exit 1, stdout 0 bytes, traceback**; **no `LINE_RE` → `KeyError` at `LINE_RE[lang].search(msg)`, the same signature** — exit 1 is the code *defined* to carry `result: …` and it carried nothing, so a machine reader cannot tell "these files fail lint" from "the linter crashed". Both dispatches are `.get()` now, and the two failures are deliberately **not** treated alike: **no cmd → `errors[]` + exit 3** (`no linter wired for lang: <lang>`, since no check ran — and a silent `unsupported_ext`-style skip would render "nobody wired it" as "nothing to do"), **no line parser → `failures[]` with `line: null` + exit 1** (the linter *did* run and did say no; demoting a verified failure to exit 3 would hide a real breakage behind an environment problem). **W0** asserts the real tool cannot reproduce this at all (`.ts` is `unsupported_ext` there → exit 0), so the section's fixtures are the *future* edit: `w_build <out> <mode>` copies `$TOOL` and adds the `.ts` entry plus a `cmd` entry (`noline`/`wired`) and a `LINE_RE` entry (`wired`), each needle **counted** in an embedded python builder, with the cmd anchor accepting **both** spellings (`}.get(lang)` and the pre-step `}[lang]`) so a pre-fix replay fails on behaviour rather than on a build. **W2** (no cmd) = exit 3, empty stderr, no traceback, one `errors[]` entry naming `app.ts`/`typescript`, `failures == []`, the same **15-key** object any run emits, both human lines; **W3** (cmd, no parser) = exit 1, empty stderr, `line: null` with the message kept, `errors == []`, both human lines; **W4** is the over-correction guard (a wired `LINE_RE` still reports `line == 7`); **W5** pins the source shape (one `.get` per table, zero surviving subscripts, `--help` naming the new exit-3 cause — first draft reflowed because the phrase straddled a line break and W5's own needle could not match it); **W6** leaves the sandbox green. **No new mutant**: M23 already plants the unclassified `EXT_LANG` entry and catches it *analytically* because nothing runs that copy — W executes that copy now, so `M24` would re-plant what W2 runs; the index stays at **23**, and the suite's **header** (stopping at `M16` / `Section S`) is untouched, because extending a copy nothing checks is items (5)/(32) rather than their fix.
@@ -2703,7 +2705,7 @@ tools/repo-lint --help
 - **Section R — the epilog REFUSES to build a label over nothing** (`[0.4.60]`, widened by `[0.4.61]`): derivation made the epilog correct, but `docstring_section` still returned `""` for a heading it could not find and `"\n\n".join` does not complain about `""`, so a renamed or deleted docstring heading produced `env:` printed above a blank line with `--help` exiting **0** — and only Q-render's non-empty requirement stood in the way, i.e. a defect that was *tested* rather than *prevented*, covering only the heading someone named. **R1–R3** are guards on the healthy tool (exit 0, no refusal on stderr, all seven labels rendering a non-empty body); **R4–R9** cover a heading **renamed away** while the tuple still names it (refuse with exit 3; name the pair `'env:' -> 'Environment:'`; nothing on stdout; name **only** the broken pair), and R9 points `GLADEX_REPO_DIR` at the real sandbox repo for the same reason it always did — run from `$SB` the mutant's default repo is not a git repo and it exited 3 for *that* reason, a false pass the red had to be read to catch. **R10–R12b** cover a heading that **exists but whose block is empty** — `docstring_section` stops at the first blank line, so "found" must not mean "fine". **R9's original assertion was written inverted and is corrected in `[0.4.61]`**: it required *no* parseable JSON from the refusing tool — which is exactly the defect (`| jq` meeting empty stdin), so it passed for it. It now asserts the contract, and the block grew accordingly: **R9b** one object on stdout with `ok false`/`exit 3`; **R9c** it names the broken pair; **R9d** it is an ERROR not a verdict (`failures`/`errors` empty, `sha_resolved` null); **R9e** `go_compile`/`changelog_version` null (die()'s shape); **R9f** stderr clean in json mode; **R9g** its **key set is byte-equal to a normal run's** — the shape-level proof that the refusal is the contract and not an exception to it.
 - **Section R, argv parity — the refusal's reading of argv must BE argparse's** (`[0.4.61]`): it fires before argparse exists, so it reads argv with a throwaway parser built from the **same `_add_flags`** definitions; each assertion below is the first place a hand-rolled `sys.argv` scan would diverge. **R13** one definition, two call sites (source count); **R14/R14b** the `--format=json` equals form; **R15/R15b** argparse's unique-prefix rule (`--form json`) with **R15c** as the guard that argparse really does accept it; **R16/R16b** `--sha probe-r9` echoed by the refusal with **R16c/R16d** as the parity reference — the *healthy* tool must report the same `requested_sha`, one expectation read by two code paths; **R17/R17b/R17c** `--` termination (the scan stops there and emits no JSON, while argparse itself rejects the same argv with exit 2); **R18/R18b/R18c/R18d** an argv argparse rejects (refusal still fires, still names the pair, no `usage:` noise leaked, stdout still empty in human mode) with **R19** as the guard that argparse keeps ownership of validation (invalid choice alone → exit 2). **R17b, R18c and R18d are vacuously green before the fix** — with no scan in existence nothing could print or leak — and they only begin testing something once it exists; disclosed as guards, not findings. **Guards that passed against the pre-fix tool and thereby identify themselves**: R1–R8, R10–R12b, the exit-3 half of R9/R14/R15/R16, R15c, R16c/R16d, R17, R17c, R18, R18b, R19.
 - **Section S — a usage error under `--format json` is still ONE JSON object** (`[0.4.62]`): `repo-lint --format json --timeout abc` used to exit 2 with usage prose on stderr and an **empty stdout**, so a `| jq` consumer got jq's own parse error and could not tell a mistyped flag from a crash — the last path with no object after `[0.4.61]`, and reachable on a perfectly healthy tool. **S1 is the human guard** (usage on stderr, empty stdout, exit 2 — passes before *and* after, which is what makes it a guard rather than a finding, and what M16 leaves green while S3 goes red); **S2–S8** the defect itself (exit 2 preserved; stdout non-empty; one object with `ok false`/`exit_code 2`; `error` names the bad argument; **key set byte-equal to a normal run's** — the shape-level proof that the usage object *is* the contract; not a verdict — `failures[]`/`errors[]` empty, `sha_resolved` null; stderr clean); **S9–S11** argv forms a hand-rolled scan gets wrong — the failing token **before** `--format` (a full pre-parse aborts first and would answer `human`), `--format=json`, `--form json`; **S12** the tool's own `p.error()` checks take the same route as argparse's rejections (both are inside one `try`); **S13–S15** the three argv shapes where **no** format can be read (`--format yaml`, a bare `--format`, anything after `--`) → human, asserted not assumed; **S16/S16b** exactly one `add_argument("--format", …)` and two readers of it (`_add_format_flag` feeds `_add_flags` and `_format_of` — splitting the flag out must not become a second choices list); **S17/S18** guards that a healthy json run still exits 0 and `--help` still exits 0. The section captures **stdout and stderr separately** throughout (`run_tool` merges them) because *which stream* is half of what it asserts, which is why it also needed `assert_empty`/`assert_nonempty`: `assert_not_contains` takes its needle as argument 2, so an empty needle matches every haystack and "this stream is empty" could not be expressed without failing by construction.
-- **Mutation**: 24, each precondition-asserted to occur exactly once, caught by a divergence assertion, and surgically checked — M1 exit gate defeated (`(1 if failures else 0)` → 0); M2 `--sha` ignored (always lints HEAD); M3 `.php` dropped from `EXT_LANG` (mutant still catches broken sh); **M4** `failures.extend(gentries)` → `extend([])` (the 395b9b5 defect returns: a build-breaking commit reports 0; mutant still 0 on a compiling commit); **M5** `3 if errors` → `1 if errors` (an environment failure reads as "broken file": real=3/mutant=1; mutant still 1 on broken php); **M6** the gate's blob read → `open(<worktree path>)` (the 219fd8f class applied to Go: a fixed worktree hides a broken commit; mutant still 1 when the worktree is broken too); **M7** `failures.extend(cl_failures)` → `extend([])` (the hand-off dies while the JSON still names the twin — `ok false`, `duplicates == ['1.0.0']`, `exit_code 0`; mutant still exits 1 on broken php); **M8** `if ver in first_seen:` → `if False:` (the test itself dies: `duplicates == []` and `ok true` where the real tool reports a twin; mutant still green on a clean changelog); **M9** the changelog blob read pinned to `HEAD` instead of `--sha` while the existence probe still uses `--sha` (an ancestor's twin vanishes — real=1/mutant=0; mutant still 0 on a clean HEAD); **M10** the CHANGELOG rule dropped from the tool's one contract (the `[0.4.56]` defect itself planted) — caught by P2/P5 while **P1 and P4 stay green**: the docstring and `--help` still agree because they are one copy, so they lost the rule *together*; surgical checks are the agreement holding, the parse rule surviving, and `--help` still exiting 0; **M11** a second copy of the contract planted as a source comment `--help` never renders — caught by **P1 alone**, with P4 deliberately asserted **green** (what `--help` prints is still byte-identical to the docstring), proving the source-level count is not redundant with the render-level check; **M12** the same shape for a *derived* section (a source-comment second copy of the go-gate text) — caught by **Q-source**, with **Q-render asserted green** on the mutant (`--help` still equals the docstring, so the byte comparison provably cannot see it) and `--help` still exiting 0; **M13** the inverse — `("env:", "Environment:")` repointed to the languages heading, so `env:` renders a different docstring block — caught by **Q-render**, with **Q-source asserted green** (the Environment text still occurs exactly once, so the count cannot see a misattribution) and the `exit codes:` pair still agreeing (one pair misattributed, not the whole epilog). M12/M13 are complementary by construction, exactly as M10/M11 are: each one's green assertions are what prove the other's necessity; **M14** the pre-`[0.4.60]` state reproduced — R's trigger (the docstring heading renamed to `Environment (renamed):` while the tuple still says `Environment:`) **in the same copy as** the refusal's condition defeated (`if missing:` → `if False:`). Two edits deliberately: defeating the guard **alone** changes nothing, because a healthy docstring still yields seven full sections — I built it that way first and the mutant came out **green**, which is the finding rather than a flaw in the mutation: the guard is not the defect, it is what makes an always-available trigger loud. With both halves present `--help` exits 0 over a label printed on nothing, stderr silent — caught by R's refusal assertions and by `r_labels` (R3's own check, run against the mutant) going red at **exactly** `env:` — while an unrelated section still byte-equals its docstring (surgical: one condition defeated, not the derivation); **M15** the machine channel dropped (`[0.4.61]`): R's trigger **in the same copy as** the fix reverted (`raise SystemExit(die(None, default_repo(), message, sha, fmt))` → the bare `sys.stderr.write(message)` + `SystemExit(EXIT_CANNOT)`), i.e. the refusal output as it stood before this step. Two edits for the same reason M14 needs two — with a healthy docstring nothing refuses, so the dropped channel is unobservable (I planted the revert alone first and the mutant came out green, **exit 0**: the second time this mutation taught its own lesson) — and the catch is the point: **every human assertion stays GREEN** (exit still 3, pair still named, `--help` still refusing with an empty stdout) while **R9b** sees the empty stdout. The old suite asserted the *absence* of JSON, so the defect passed it. **M16** the usage-error channel dropped (`[0.4.62]`): `if fmt == "json":` → `if False:` in `_Parser.error`, i.e. the pre-step state exactly — argparse always prints usage to stderr and exits 2, so `--format json --timeout abc` gives a jq pipeline empty stdin again. **One edit where M14 and M15 each needed two, and the difference is the finding**: those needed a *trigger* because a healthy docstring never refuses, whereas here the argv that says json is supplied **by the test**, so the trigger and the defect are the same line. Caught by **S3** (stdout empty again) with **every human assertion staying GREEN** — exit still 2, usage still on stderr, `--help` still 0, the healthy json run still 0 — because the human path never had the check; that asymmetry is the argument for having written S1/S13/S14/S15 as guards. **M17–M19 (the citation rule, `[0.4.82]`)** — three ways to lint green over a version nobody wrote, each with a surgical value that says *which* one: **M17** the existence test → `if False` → the token is still **counted and classified in series** but never judged (`seen ≥ 3, in_series ≥ 3, missing [], exit 0`), caught `real=1 mutant=0`; **M18** the **series fence** dropped (`in_series = list(citations)`) → the one excluded token becomes the defect (`in_series 4`, `missing ['9.9.4']`), caught `real=0 mutant=1`, i.e. red on a fixture the real rule calls clean — and its replace runs through python with `t.count(old) == 1` asserted **inside** the script, because a sed pattern of brackets and quotes that matches the wrong line edits a path no fixture exercises and comes back green; **M19** the **collection** dropped (`citations.extend([])`) → `citations_seen == 0`, nothing was scanned at all, caught `real=1 mutant=0`. M17 vs M19 is the pair that matters: both exit 0 over the defect, and only `citations_seen` (counted-but-unjudged vs never-scanned) tells them apart. Every mutant file is `[ -f ]`-checked before it is run, so a build that produced nothing cannot be reported as a catch. **M20/M21 (`[0.4.83]`, the closing line)** — the two halves of one judgement call, both planted in `_result_line`'s syntax-set test by exact-string replace with `t.count(old) == 1` asserted inside the script: **M20** `if all(…)` → `if True:` (every failure called a parse/compile failure — the pre-step constant with the count still derived) is caught by **U1** while the exit code stays **1 on both sides**, and its surgical check is a *real* syntax failure where mutant and tool say exactly the same sentence; **M21** `if all(…)` → `if False:` (a rule failure never reported as a rule) is caught by **U2** with a *syntax* fixture, and its surgical check is a rule fixture where the inverted mutant is **indistinguishable** from the real tool — which is precisely why only a wording pin on the other branch can catch it. Neither mutant changes any verdict, so no exit-code assertion sees either: the section U pins are the only thing that does. **M22 (`[0.4.84]`, the count)** — the pre-step defect planted in the one expression that decides the number: `n_files = len({f.get("path") for f in failures})` → `n_files = len(failures)`, planted by the same exact-string replace with `t.count(old) == 1` asserted inside the script. Exit code, `kinds` and `failures[]` all stay put, so **every verdict assertion in the suite is green over it**; caught by **V1** with `real_rc == mut_rc == 1` and only the digits telling them apart (`real: 1 file(s)`, `mutant: 2 file(s)`), and its surgical check is V3's fixture — one failure per file, where failures and files are equal and the mutant is **indistinguishable** from the real tool, which is precisely why V1's fixture has to separate them. **M23 (`[0.4.85]`, the coverage)** — an `EXT_LANG` entry nothing classifies (`".ts": "typescript"` planted by exact-string replace with `t.count(old) == 1` asserted inside the script). Nothing RUNS this copy, deliberately: a bare new extension lang dies in `lint()` at `cmd = {...}[lang]` with an **uncaught KeyError** (measured 2026-09-27 in a throwaway repo — traceback, exit 1, no result line; that is a separate defect class, queued as (33)), so the defect cannot be caught through an exit code at all. The catch is therefore the **analyser diverging between two sources** — the same `u7_classify` reports `dispatch_unclassified=NONE` on the tool and `dispatch_unclassified=typescript` on the mutant — which is exactly U7's shape: it reads a file, so the mutant hands it a different file. Its surgical check is that `gate=changelog,go-compile`, `rules_match=YES` and the whole `syntax=` set are byte-identical between the two sources with `emittable_unclassified=typescript` naming **one** lang, i.e. one missing classification rather than a wrecked read.
+- **Mutation**: 26, each precondition-asserted to occur exactly once, caught by a divergence assertion, and surgically checked — M1 exit gate defeated (`(1 if failures else 0)` → 0); M2 `--sha` ignored (always lints HEAD); M3 `.php` dropped from `EXT_LANG` (mutant still catches broken sh); **M4** `failures.extend(gentries)` → `extend([])` (the 395b9b5 defect returns: a build-breaking commit reports 0; mutant still 0 on a compiling commit); **M5** `3 if errors` → `1 if errors` (an environment failure reads as "broken file": real=3/mutant=1; mutant still 1 on broken php); **M6** the gate's blob read → `open(<worktree path>)` (the 219fd8f class applied to Go: a fixed worktree hides a broken commit; mutant still 1 when the worktree is broken too); **M7** `failures.extend(cl_failures)` → `extend([])` (the hand-off dies while the JSON still names the twin — `ok false`, `duplicates == ['1.0.0']`, `exit_code 0`; mutant still exits 1 on broken php); **M8** `if ver in first_seen:` → `if False:` (the test itself dies: `duplicates == []` and `ok true` where the real tool reports a twin; mutant still green on a clean changelog); **M9** the changelog blob read pinned to `HEAD` instead of `--sha` while the existence probe still uses `--sha` (an ancestor's twin vanishes — real=1/mutant=0; mutant still 0 on a clean HEAD); **M10** the CHANGELOG rule dropped from the tool's one contract (the `[0.4.56]` defect itself planted) — caught by P2/P5 while **P1 and P4 stay green**: the docstring and `--help` still agree because they are one copy, so they lost the rule *together*; surgical checks are the agreement holding, the parse rule surviving, and `--help` still exiting 0; **M11** a second copy of the contract planted as a source comment `--help` never renders — caught by **P1 alone**, with P4 deliberately asserted **green** (what `--help` prints is still byte-identical to the docstring), proving the source-level count is not redundant with the render-level check; **M12** the same shape for a *derived* section (a source-comment second copy of the go-gate text) — caught by **Q-source**, with **Q-render asserted green** on the mutant (`--help` still equals the docstring, so the byte comparison provably cannot see it) and `--help` still exiting 0; **M13** the inverse — `("env:", "Environment:")` repointed to the languages heading, so `env:` renders a different docstring block — caught by **Q-render**, with **Q-source asserted green** (the Environment text still occurs exactly once, so the count cannot see a misattribution) and the `exit codes:` pair still agreeing (one pair misattributed, not the whole epilog). M12/M13 are complementary by construction, exactly as M10/M11 are: each one's green assertions are what prove the other's necessity; **M14** the pre-`[0.4.60]` state reproduced — R's trigger (the docstring heading renamed to `Environment (renamed):` while the tuple still says `Environment:`) **in the same copy as** the refusal's condition defeated (`if missing:` → `if False:`). Two edits deliberately: defeating the guard **alone** changes nothing, because a healthy docstring still yields seven full sections — I built it that way first and the mutant came out **green**, which is the finding rather than a flaw in the mutation: the guard is not the defect, it is what makes an always-available trigger loud. With both halves present `--help` exits 0 over a label printed on nothing, stderr silent — caught by R's refusal assertions and by `r_labels` (R3's own check, run against the mutant) going red at **exactly** `env:` — while an unrelated section still byte-equals its docstring (surgical: one condition defeated, not the derivation); **M15** the machine channel dropped (`[0.4.61]`): R's trigger **in the same copy as** the fix reverted (`raise SystemExit(die(None, default_repo(), message, sha, fmt))` → the bare `sys.stderr.write(message)` + `SystemExit(EXIT_CANNOT)`), i.e. the refusal output as it stood before this step. Two edits for the same reason M14 needs two — with a healthy docstring nothing refuses, so the dropped channel is unobservable (I planted the revert alone first and the mutant came out green, **exit 0**: the second time this mutation taught its own lesson) — and the catch is the point: **every human assertion stays GREEN** (exit still 3, pair still named, `--help` still refusing with an empty stdout) while **R9b** sees the empty stdout. The old suite asserted the *absence* of JSON, so the defect passed it. **M16** the usage-error channel dropped (`[0.4.62]`): `if fmt == "json":` → `if False:` in `_Parser.error`, i.e. the pre-step state exactly — argparse always prints usage to stderr and exits 2, so `--format json --timeout abc` gives a jq pipeline empty stdin again. **One edit where M14 and M15 each needed two, and the difference is the finding**: those needed a *trigger* because a healthy docstring never refuses, whereas here the argv that says json is supplied **by the test**, so the trigger and the defect are the same line. Caught by **S3** (stdout empty again) with **every human assertion staying GREEN** — exit still 2, usage still on stderr, `--help` still 0, the healthy json run still 0 — because the human path never had the check; that asymmetry is the argument for having written S1/S13/S14/S15 as guards. **M17–M19 (the citation rule, `[0.4.82]`)** — three ways to lint green over a version nobody wrote, each with a surgical value that says *which* one: **M17** the existence test → `if False` → the token is still **counted and classified in series** but never judged (`seen ≥ 3, in_series ≥ 3, missing [], exit 0`), caught `real=1 mutant=0`; **M18** the **series fence** dropped (`in_series = list(citations)`) → the one excluded token becomes the defect (`in_series 4`, `missing ['9.9.4']`), caught `real=0 mutant=1`, i.e. red on a fixture the real rule calls clean — and its replace runs through python with `t.count(old) == 1` asserted **inside** the script, because a sed pattern of brackets and quotes that matches the wrong line edits a path no fixture exercises and comes back green; **M19** the **collection** dropped (`citations.extend([])`) → `citations_seen == 0`, nothing was scanned at all, caught `real=1 mutant=0`. M17 vs M19 is the pair that matters: both exit 0 over the defect, and only `citations_seen` (counted-but-unjudged vs never-scanned) tells them apart. Every mutant file is `[ -f ]`-checked before it is run, so a build that produced nothing cannot be reported as a catch. **M20/M21 (`[0.4.83]`, the closing line)** — the two halves of one judgement call, both planted in `_result_line`'s syntax-set test by exact-string replace with `t.count(old) == 1` asserted inside the script: **M20** `if all(…)` → `if True:` (every failure called a parse/compile failure — the pre-step constant with the count still derived) is caught by **U1** while the exit code stays **1 on both sides**, and its surgical check is a *real* syntax failure where mutant and tool say exactly the same sentence; **M21** `if all(…)` → `if False:` (a rule failure never reported as a rule) is caught by **U2** with a *syntax* fixture, and its surgical check is a rule fixture where the inverted mutant is **indistinguishable** from the real tool — which is precisely why only a wording pin on the other branch can catch it. Neither mutant changes any verdict, so no exit-code assertion sees either: the section U pins are the only thing that does. **M22 (`[0.4.84]`, the count)** — the pre-step defect planted in the one expression that decides the number: `n_files = len({f.get("path") for f in failures})` → `n_files = len(failures)`, planted by the same exact-string replace with `t.count(old) == 1` asserted inside the script. Exit code, `kinds` and `failures[]` all stay put, so **every verdict assertion in the suite is green over it**; caught by **V1** with `real_rc == mut_rc == 1` and only the digits telling them apart (`real: 1 file(s)`, `mutant: 2 file(s)`), and its surgical check is V3's fixture — one failure per file, where failures and files are equal and the mutant is **indistinguishable** from the real tool, which is precisely why V1's fixture has to separate them. **M23 (`[0.4.85]`, the coverage)** — an `EXT_LANG` entry nothing classifies (`".ts": "typescript"` planted by exact-string replace with `t.count(old) == 1` asserted inside the script). Nothing RUNS this copy, deliberately: a bare new extension lang dies in `lint()` at `cmd = {...}[lang]` with an **uncaught KeyError** (measured 2026-09-27 in a throwaway repo — traceback, exit 1, no result line; that is a separate defect class, queued as (33)), so the defect cannot be caught through an exit code at all. The catch is therefore the **analyser diverging between two sources** — the same `u7_classify` reports `dispatch_unclassified=NONE` on the tool and `dispatch_unclassified=typescript` on the mutant — which is exactly U7's shape: it reads a file, so the mutant hands it a different file. Its surgical check is that `gate=changelog,go-compile`, `rules_match=YES` and the whole `syntax=` set are byte-identical between the two sources with `emittable_unclassified=typescript` naming **one** lang, i.e. one missing classification rather than a wrecked read. **M24 (`[0.4.89]`, the mixed closing line)** — the mixed-run failure clause dropped, planted on a **copy built from section W's fixture** rather than on `$TOOL`, because the real tool cannot reproduce that run; exit codes stay **3/3 identical** and only the `, and 1 file(s) fail …` half of the last line differs (so X3's wording pin is the only assertion that can see it), with the surgical half being an errors-only run where the mutant is byte-identical to the real tool. **M17 re-scoped by `[0.4.146]`** — the bare rule reuses the same existence test, so the old one-line `sed` would have edited **both** comprehensions while the precondition still claimed "exactly once": the precondition reported `found 2 time(s)` and went red first (the drift detector doing its job, before any mutant could be planted), and the mutation is now an exact-string replace of the **bracketed** block alone with `t.count(old) == 1` inside the script, plus a second surgical check that the same mutant still judges a brackets-removed claim (`real=1`) — i.e. exactly one of the two verdicts was defeated. **M25/M26 (`[0.4.146]`, the bare rule's two halves)**: **M25** the collection dropped (`bare.extend(bare_hits(path, blob))` → `bare.extend([])`) — the census reads 0 and a brackets-removed claim goes green, caught `real=1 mutant=0`, surgical: `citations_bare == 0` while `citations_seen ≥ 1` and `citations_missing` still count (M19's pair again: "one rule missing" and "tree unscanned" both exit 0, and only *which* counter died tells them apart); **M26** the current-series fence dropped (`bare_current = list(bare_in_series)`) — an older series' prose becomes a defect, caught `real=0 mutant=1`, surgical: the mutant judges exactly `6.9.9` through `citations_bare_missing` with `citations_missing` still empty, **plus two checks naming the fences that did NOT move** — the lockfile path fence (real 0 / mutant 0) and the bracketed rule's full fence (both judge `[6.9.9]`, same message, 1/1), because a mutation that took three fences with it would be a different defect than the one it claims to plant.
 - Live: HEAD → exit 0 (176 files — **174 → 176 with `[0.4.65]`**, its own `tools/regression-run` + `tests/test_regression_run.sh` going from untracked to tracked (`linted.bash` 24 → 25, `linted.python` 11 → 12), following **173 → 174 with `[0.4.64]`**; the pre-commit run reads **174** with `bash 24` / `python 11` because those blobs are not there yet — the stale-live-number class, re-read after the commit below — 45 module files compile clean in ~1.6s. **`[0.4.66]` pre-commit read: exit 0, `files_total 176`, `linted {bash 25, go 43, json 11, php 32, python 12}`, `changelog_version entries 70, unique 70, duplicates []`** — both changed files were already tracked, so the post-commit prediction is **176 unchanged** with `entries 71` once `[0.4.66]` lands, re-read after the commit rather than carried. **`[0.4.67]` pre-commit read: exit 0, `files_total 176`, `linted {bash 25, go 43, json 11, php 32, python 12}`, `changelog_version entries 71, unique 71, duplicates []`** — this entry adds two **untracked** files (`tools/queue-source-check`, extensionless `python3` shebang → `linted.python`; `tests/test_queue_source.sh`, `.sh` → `linted.bash`) plus its own heading, so the post-commit prediction is **178** with `bash 26`, `python 13` and `entries 72`, re-read after the commit rather than carried) with `changelog_version` = `attempted true, entries 70, unique 70, unparseable 0, duplicates [], ok true` (**69 → 70 with `[0.4.65]`**, following **68 → 69 with `[0.4.64]`**: the count is read from the COMMITTED blob, so it is re-read after the append commits rather than carried over — it read 68 while `[0.4.64]` was still uncommitted, which is the whole point of re-reading; the working-tree count was verified the anchored way, `grep -c '^## \['` → 69 with `uniq -d` empty, because the greedy `sed 's/.*\[\([^]]*\)\].*/\1/'` form reports **5 phantom duplicates** on this tree — 0.4.31/0.4.40/0.4.44/0.4.49/0.4.62 — by taking the last bracket in a heading that cites other versions. The **file** count is 173, not the 171 drafted mid-run: `[0.4.63]`'s own two mailbox files were untracked when that number was written and tracked once it committed, so 171 → 173 is this entry's own movement rather than a count carried); `--sha 219fd8f` → exit 1 naming `tests/test_mailbox_a11y.php:208 [php]`; `--sha 395b9b5` → exit 1 naming `.../status_test.go:5 [go-compile]`; unknown rev / non-repo → exit 3; `--sha probe-r9` → exit 3 with `requested_sha: probe-r9` (the R16 parity reference, live); `--format yaml` → exit 2 with **usage on stderr and an empty stdout** (no format could be read, so none is invented — `[0.4.62]`); **`--format json` + a bad argv → exit 2 with a 384-byte 15-key object on stdout and 0 bytes on stderr** (`--timeout abc`, `--nonsense`, `--timeout 0`, empty `--sha`, and the failing token placed *before* `--format`), while the same argv in human mode still gives argparse's `usage:`+`error:` with **stdout 0 bytes**; `--help` (**106 lines**, was 57 before the epilog stopped carrying its own prose, 102 before the exit-3 clause widened, 103 through `[0.4.61]`, **+3 for `[0.4.62]`'s widened exit-2 clause**) renders all seven docstring blocks verbatim under their labels; a copy with a heading renamed → `repo-lint: ERROR refusing to run - docstring section missing or empty …` + `  'env:' -> 'Environment:'` → **exit 3**, stderr only, and under `--format json` the **same refusal as an object** — `ok false`, `exit_code 3`, `error` naming the pair, **stderr 0 bytes** — which is the `| jq` consumer `[0.4.60]`'s queue described, now parsing (`--format=json` → 3; `--form json` → 3; `-- --format json` → no JSON on stdout; `--format yaml` on the broken copy → refusal only, no `usage:` leak) — **and on that same broken copy `--format json --timeout abc` now yields the 458-byte refusal object with `exit_code 3` instead of falling back to `human`**, which is `[0.4.61]`'s own queue item struck as actioned. **`[0.4.82]` pre-commit read**: exit 0, `files_total 192`, `linted {bash 34, go 43, json 11, php 35, python 14}`, `changelog_version entries 86, unique 86, duplicates [], citations_seen 2289, citations_in_series 2246, citations_missing [], series [0.1, 0.2, 0.3, 0.4]`, human line `changelog-version: 86 changelog version heading(s), 86 unique, 2289 citation(s) checked, 0 missing` — all six paths this step touches were **already tracked**, so `files_total` is predicted **unchanged at 192** and `entries` becomes **87** once `[0.4.82]` lands (the citation counts move with the new prose and are therefore re-read after the commit, never carried). **Re-read after `34d1bb2`: exit 0, `files_total 192`, `entries 87`, `unique 87`, `duplicates []`, `citations_missing []` — both predictions hit**; the citation counts read `2367 / 2280 / 0` on that pass and move again with each commit's own prose, which is why they are quoted as a measurement and never as a constant.
 - Pre-fix replay: the **then-`HEAD` suite against the then-`HEAD` tool** → **88 passed / 28 failed** (including `L: 395b9b5 … (want rc=1 got=0)`) for the Go gate of `[0.4.3x]`; for the changelog gate the *new* suite against the pre-fix tool (md5 `3a4e09176e24ca3414366952467d4944`, log `/tmp/opencode/changelog-gate/pre-fix.log`, suite md5 `9e352394d02096183adef92d55fc5a73`) → **125 passed / 22 failed**: the exact key-set pin plus every O1–O7 finding red, and M7/M8/M9 unplantable (0 matching lines) — while the six guard-style assertions inside O (absent file adds no failure; fixed commit → 0) already passed, which is what identifies them as guards rather than findings. For `[0.4.56]` the new section P against the pre-fix tool (tool md5 `3ebcf0b4ae7e290796fbed12c57e422b`, suite md5 `a50e16d7a5643bdfd18b667752e50d2c`, log `/tmp/opencode/exitcodes/pre-fix.log`) → **166 passed / 6 failed**: P1 (the contract text occurs **twice**), P2 ×2 (Go rule and CHANGELOG rule both absent from the docstring), P4 (the docstring block and `--help`'s section differ), M10's agreement surgical check (pre-fix both copies still exist, so the mutant's docstring and `--help` disagree), and M11's precondition (already 2 occurrences → unplantable, so its other three assertions could not run pre-fix — hence 172 counted pre-fix against 175 post-fix). Guards that passed pre-fix and thereby identify themselves: P2's parse rule, P3 (all four codes), P4's `--help exits 0`, and all three P5 rules — the epilog was the copy that was right. Baseline re-verified on a checkout of the same commit before the fix: **155/156 then 156/156 twice**, the single red being `L: real repo status changed during a run` (a concurrent identity committed mid-run), not this change. For `[0.4.59]` the new section Q against the pre-fix tool (tool md5 `f17563d67064a79f313ef2bab376cd66`, suite md5 `9217e2653fbed256afb704d0a01fd359`, log `/tmp/opencode/epilogderive/pre-fix.log`; baseline of the *old* suite against the old tool was **175/0** first) → **186 passed / 9 failed**: the seven findings are Q1–Q6 (every pair renders different bytes) and Q13 (the drifted synopsis still present), plus **M12's surgical render check** — which fails pre-fix only because the two renderings differ by definition, i.e. it restates Q2 — and **M13's precondition unplantable** (the derivation tuple does not exist yet, so its other three assertions could not run: hence 186 counted pre-fix against 198 post-fix). **Guards passed pre-fix and thereby identify themselves**: all six Q-source counts (each section's text already occurred exactly once — the copies differed, they were not duplicated line-for-line), `--help exits 0`, the generated-usage line, and M12's precondition plus its "caught" assertion. For `[0.4.60]` the new section R against the pre-fix tool (old tool md5 `4e6c58ffc86441a5745054a4ea45d084`, final suite md5 `e126f791dbcd4b1d9ae0bd0626022d82`, log `/tmp/opencode/epilogrefuse/pre-fix.log`; baseline of the old suite against the old tool was **198/0** first) → **203 passed / 10 failed**, captured **inside a clone of the repo** rather than from `/tmp`: pointing `REPO_LINT_BIN` at a copy outside `tools/` makes section L's live checks fail for *path* reasons, because `default_repo()` resolves relative to the script, so the tool reported `repo_root: /tmp/...` and exited 3 — a harness artifact that cost a second capture to get a red meaning what it says. **Nine of the ten are real**: **R5, R6, R7, R9 ×2, R11, R12, R12b** plus **M14's precondition unplantable** (the refusal does not exist yet, so its other five assertions could not run — hence 213 counted pre-fix against 218 post-fix); the tenth is `L: live json structurally sound`, whose `d['repo_root'] == '/data/repo'` is true in the real repo and false in a clone — disclosed as an artifact of my cloning rather than counted as a finding. **Guards passed pre-fix and thereby identify themselves**: R1 (healthy tool exits 0), R2 (no refusal on stderr), R3 (all seven labels non-empty), R4 and R10 (both mutant preconditions), R8 (the refusal names only the broken pair — pre-fix stderr is empty, so it passes vacuously, which is what makes it a guard rather than a finding). For `[0.4.61]` the widened section R against the pre-fix tool (old tool md5 `d6b50e6dcf68df6dccb5a46dfe06e5a0`, **final** suite md5 `b71b64db24d64fa65263e3867e45ba97`, log `/tmp/opencode/jsonrefuse/pre-fix.log`; baseline of the committed suite against the committed tool was **218/218** first) → **230 passed / 12 failed**, again **inside a clone** for the same path reason. **Eleven are real**: **R9b, R9c, R9d, R9e, R9f, R9g** (one cause — stdout empty, refusal on stderr), **R13** (`_add_flags` does not exist yet), **R14b, R15b, R16b** (same empty-stdout cause) and **M15's precondition unplantable** (the die()-routing line does not exist, so its five other assertions could not run — hence **242 counted pre-fix against 247 post-fix**). The twelfth is again `L: live json structurally sound` (`repo_root` is the clone, not `/data/repo`) — disclosed as a cloning artifact, not counted. **Guards passed pre-fix and thereby identify themselves**: R1–R8, R10–R12b, the exit-3 half of R9/R14/R15/R16, **R15c** (argparse really accepts `--form`), **R16c/R16d** (the healthy tool already echoed `requested_sha: probe-r9` — the reference both readers must match), R17, R17c, R18, R18b, R19; and **R17b, R18c, R18d are vacuously green** (nothing could print before a scan existed) — disclosed as guards, not findings. Two first-draft defects of mine are recorded in the CHANGELOG: R9c's predicate used `->` outside a string (the *checker* raised SyntaxError — a red meaning the wrong thing), and M15 was first planted without its trigger (mutant exited **0** and was "NOT caught", because nothing refuses when the docstring is healthy). For `[0.4.62]` the new section S against the pre-fix tool (tool md5 `f42b33e34ab28588334b5f616a551798`, **final** suite md5 `4acbd04968016e319778dda544c6596e`, log `/tmp/opencode/usagejson/pre-fix.log`; baseline of the committed suite against the committed tool was **247/247** first) → **268 passed / 16 failed** of 284, captured **in place rather than in a clone** — the tool was still unmodified at its real path, so section L's `repo_root == '/data/repo'` check passed on its own; the clone was only ever needed because a copy *outside* `tools/` changes `default_repo()`. **All sixteen are real**: **S3–S8** (one cause — stdout empty, usage on stderr), **S9b, S9c, S10b, S10c, S11b** (same cause, one per argv form), **S12b, S12c, S12e, S12f** (same cause, via our own `p.error()`), **S16b** (`_add_format_flag` does not exist yet — hence 268 counted pre-fix against 291 post-fix). **Guards passed pre-fix and thereby identify themselves**: **S1** (the human channel was already exactly right — the strongest evidence this was a *channel* defect, not a validation one), S2, S9a, S10a, S11a, S12a, S12d, **S13a–S15b** (no-format-readable argv), **S16** (the `--format` definition was already single), **S17, S18**. Two first-draft defects of mine are recorded in the CHANGELOG: S17b read `$OUT` where `s_run` wrote `$S_OUT` (a **stale** object, so the assertion failed against the *old* tool for an unrelated reason — caught as the 17th red and fixed before the tool was touched, the capture then re-taken honestly at 16), and S16b's predicate `grep -c '_add_format_flag(p)'` also matched the `def` line, reporting `3` for two call sites plus a definition — the third time this suite has been wrong in the *predicate* direction.
 


[output truncated; full output saved to: /root/.local/share/opencode/shell/fa3e85b2145a60c127b5c9261e76a7ba6d520299/sh_0f4c6b51f001SJW2KvFObDWgKR.out]
> build · mimo-v2.6-flash-free
$ cd /data/repo && grep -n "test_repo_lint" tools/REGISTRY.md | head -10; echo "=== assertions/summary line:"; grep -n "461 passed\|461 assertions\|26 mutation\|Mutation.*: 26" tools/REGISTRY.md | head
2629:**Test hooks (env)**: `APP_CONTRAST_SUITE` — path of the suite under test, defaulting to `tests/test_app_contrast.php`. Mutation runs point it at a mutated **copy**, so the real suite is never edited (same rule as `test_repo_lint.sh`'s mutation sections).
2689:- `bash tests/test_repo_lint.sh` → **461 assertions**, hermetic (throwaway git repos under `${TMPDIR:-/tmp}/opencode`, trap-cleaned): clean→0 with exact per-language/skip counts (`files_total = linted + skipped`), all five languages caught with path+line, the 219fd8f incident replayed **both directions** (bad worktree/clean commit → 0; clean worktree/bad commit → 1), arg/env exit contracts, exact JSON key set (now including `changelog_version`), symlink invocation (sandbox + real `/data/tools`), missing-binary→3 and hung-linter→3, read-only status proof on the live repo — plus **section R**, the epilog refusal and its machine-readable form, **section S**, the usage error's, **section T**, the citation rule **and, since `[0.4.146]`, its bare-token twin (T8–T15, 30 of these 461)**, **section U**, the human closing line (its **U7** + M23 also prove every lang the tool can *emit* is classified), **section V**, the number inside it, **section W**, a lang with no linter wired for it, and **section X**, a *mixed* run — `cannot verify` may not swallow a verified failure. **461 = 420 (2026-09-30, before this step) + 30 in T8–T15 + 10 in M25/M26 + 1 in M17's second surgical check**; section T now holds **54** of the 461.
3178:*pinned by its own suite* (`tests/test_repo_lint.sh` asserts `--sha
=== assertions/summary line:
2689:- `bash tests/test_repo_lint.sh` → **461 assertions**, hermetic (throwaway git repos under `${TMPDIR:-/tmp}/opencode`, trap-cleaned): clean→0 with exact per-language/skip counts (`files_total = linted + skipped`), all five languages caught with path+line, the 219fd8f incident replayed **both directions** (bad worktree/clean commit → 0; clean worktree/bad commit → 1), arg/env exit contracts, exact JSON key set (now including `changelog_version`), symlink invocation (sandbox + real `/data/tools`), missing-binary→3 and hung-linter→3, read-only status proof on the live repo — plus **section R**, the epilog refusal and its machine-readable form, **section S**, the usage error's, **section T**, the citation rule **and, since `[0.4.146]`, its bare-token twin (T8–T15, 30 of these 461)**, **section U**, the human closing line (its **U7** + M23 also prove every lang the tool can *emit* is classified), **section V**, the number inside it, **section W**, a lang with no linter wired for it, and **section X**, a *mixed* run — `cannot verify` may not swallow a verified failure. **461 = 420 (2026-09-30, before this step) + 30 in T8–T15 + 10 in M25/M26 + 1 in M17's second surgical check**; section T now holds **54** of the 461.
2708:- **Mutation**: 26, each precondition-asserted to occur exactly once, caught by a divergence assertion, and surgically checked — M1 exit gate defeated (`(1 if failures else 0)` → 0); M2 `--sha` ignored (always lints HEAD); M3 `.php` dropped from `EXT_LANG` (mutant still catches broken sh); **M4** `failures.extend(gentries)` → `extend([])` (the 395b9b5 defect returns: a build-breaking commit reports 0; mutant still 0 on a compiling commit); **M5** `3 if errors` → `1 if errors` (an environment failure reads as "broken file": real=3/mutant=1; mutant still 1 on broken php); **M6** the gate's blob read → `open(<worktree path>)` (the 219fd8f class applied to Go: a fixed worktree hides a broken commit; mutant still 1 when the worktree is broken too); **M7** `failures.extend(cl_failures)` → `extend([])` (the hand-off dies while the JSON still names the twin — `ok false`, `duplicates == ['1.0.0']`, `exit_code 0`; mutant still exits 1 on broken php); **M8** `if ver in first_seen:` → `if False:` (the test itself dies: `duplicates == []` and `ok true` where the real tool reports a twin; mutant still green on a clean changelog); **M9** the changelog blob read pinned to `HEAD` instead of `--sha` while the existence probe still uses `--sha` (an ancestor's twin vanishes — real=1/mutant=0; mutant still 0 on a clean HEAD); **M10** the CHANGELOG rule dropped from the tool's one contract (the `[0.4.56]` defect itself planted) — caught by P2/P5 while **P1 and P4 stay green**: the docstring and `--help` still agree because they are one copy, so they lost the rule *together*; surgical checks are the agreement holding, the parse rule surviving, and `--help` still exiting 0; **M11** a second copy of the contract planted as a source comment `--help` never renders — caught by **P1 alone**, with P4 deliberately asserted **green** (what `--help` prints is still byte-identical to the docstring), proving the source-level count is not redundant with the render-level check; **M12** the same shape for a *derived* section (a source-comment second copy of the go-gate text) — caught by **Q-source**, with **Q-render asserted green** on the mutant (`--help` still equals the docstring, so the byte comparison provably cannot see it) and `--help` still exiting 0; **M13** the inverse — `("env:", "Environment:")` repointed to the languages heading, so `env:` renders a different docstring block — caught by **Q-render**, with **Q-source asserted green** (the Environment text still occurs exactly once, so the count cannot see a misattribution) and the `exit codes:` pair still agreeing (one pair misattributed, not the whole epilog). M12/M13 are complementary by construction, exactly as M10/M11 are: each one's green assertions are what prove the other's necessity; **M14** the pre-`[0.4.60]` state reproduced — R's trigger (the docstring heading renamed to `Environment (renamed):` while the tuple still says `Environment:`) **in the same copy as** the refusal's condition defeated (`if missing:` → `if False:`). Two edits deliberately: defeating the guard **alone** changes nothing, because a healthy docstring still yields seven full sections — I built it that way first and the mutant came out **green**, which is the finding rather than a flaw in the mutation: the guard is not the defect, it is what makes an always-available trigger loud. With both halves present `--help` exits 0 over a label printed on nothing, stderr silent — caught by R's refusal assertions and by `r_labels` (R3's own check, run against the mutant) going red at **exactly** `env:` — while an unrelated section still byte-equals its docstring (surgical: one condition defeated, not the derivation); **M15** the machine channel dropped (`[0.4.61]`): R's trigger **in the same copy as** the fix reverted (`raise SystemExit(die(None, default_repo(), message, sha, fmt))` → the bare `sys.stderr.write(message)` + `SystemExit(EXIT_CANNOT)`), i.e. the refusal output as it stood before this step. Two edits for the same reason M14 needs two — with a healthy docstring nothing refuses, so the dropped channel is unobservable (I planted the revert alone first and the mutant came out green, **exit 0**: the second time this mutation taught its own lesson) — and the catch is the point: **every human assertion stays GREEN** (exit still 3, pair still named, `--help` still refusing with an empty stdout) while **R9b** sees the empty stdout. The old suite asserted the *absence* of JSON, so the defect passed it. **M16** the usage-error channel dropped (`[0.4.62]`): `if fmt == "json":` → `if False:` in `_Parser.error`, i.e. the pre-step state exactly — argparse always prints usage to stderr and exits 2, so `--format json --timeout abc` gives a jq pipeline empty stdin again. **One edit where M14 and M15 each needed two, and the difference is the finding**: those needed a *trigger* because a healthy docstring never refuses, whereas here the argv that says json is supplied **by the test**, so the trigger and the defect are the same line. Caught by **S3** (stdout empty again) with **every human assertion staying GREEN** — exit still 2, usage still on stderr, `--help` still 0, the healthy json run still 0 — because the human path never had the check; that asymmetry is the argument for having written S1/S13/S14/S15 as guards. **M17–M19 (the citation rule, `[0.4.82]`)** — three ways to lint green over a version nobody wrote, each with a surgical value that says *which* one: **M17** the existence test → `if False` → the token is still **counted and classified in series** but never judged (`seen ≥ 3, in_series ≥ 3, missing [], exit 0`), caught `real=1 mutant=0`; **M18** the **series fence** dropped (`in_series = list(citations)`) → the one excluded token becomes the defect (`in_series 4`, `missing ['9.9.4']`), caught `real=0 mutant=1`, i.e. red on a fixture the real rule calls clean — and its replace runs through python with `t.count(old) == 1` asserted **inside** the script, because a sed pattern of brackets and quotes that matches the wrong line edits a path no fixture exercises and comes back green; **M19** the **collection** dropped (`citations.extend([])`) → `citations_seen == 0`, nothing was scanned at all, caught `real=1 mutant=0`. M17 vs M19 is the pair that matters: both exit 0 over the defect, and only `citations_seen` (counted-but-unjudged vs never-scanned) tells them apart. Every mutant file is `[ -f ]`-checked before it is run, so a build that produced nothing cannot be reported as a catch. **M20/M21 (`[0.4.83]`, the closing line)** — the two halves of one judgement call, both planted in `_result_line`'s syntax-set test by exact-string replace with `t.count(old) == 1` asserted inside the script: **M20** `if all(…)` → `if True:` (every failure called a parse/compile failure — the pre-step constant with the count still derived) is caught by **U1** while the exit code stays **1 on both sides**, and its surgical check is a *real* syntax failure where mutant and tool say exactly the same sentence; **M21** `if all(…)` → `if False:` (a rule failure never reported as a rule) is caught by **U2** with a *syntax* fixture, and its surgical check is a rule fixture where the inverted mutant is **indistinguishable** from the real tool — which is precisely why only a wording pin on the other branch can catch it. Neither mutant changes any verdict, so no exit-code assertion sees either: the section U pins are the only thing that does. **M22 (`[0.4.84]`, the count)** — the pre-step defect planted in the one expression that decides the number: `n_files = len({f.get("path") for f in failures})` → `n_files = len(failures)`, planted by the same exact-string replace with `t.count(old) == 1` asserted inside the script. Exit code, `kinds` and `failures[]` all stay put, so **every verdict assertion in the suite is green over it**; caught by **V1** with `real_rc == mut_rc == 1` and only the digits telling them apart (`real: 1 file(s)`, `mutant: 2 file(s)`), and its surgical check is V3's fixture — one failure per file, where failures and files are equal and the mutant is **indistinguishable** from the real tool, which is precisely why V1's fixture has to separate them. **M23 (`[0.4.85]`, the coverage)** — an `EXT_LANG` entry nothing classifies (`".ts": "typescript"` planted by exact-string replace with `t.count(old) == 1` asserted inside the script). Nothing RUNS this copy, deliberately: a bare new extension lang dies in `lint()` at `cmd = {...}[lang]` with an **uncaught KeyError** (measured 2026-09-27 in a throwaway repo — traceback, exit 1, no result line; that is a separate defect class, queued as (33)), so the defect cannot be caught through an exit code at all. The catch is therefore the **analyser diverging between two sources** — the same `u7_classify` reports `dispatch_unclassified=NONE` on the tool and `dispatch_unclassified=typescript` on the mutant — which is exactly U7's shape: it reads a file, so the mutant hands it a different file. Its surgical check is that `gate=changelog,go-compile`, `rules_match=YES` and the whole `syntax=` set are byte-identical between the two sources with `emittable_unclassified=typescript` naming **one** lang, i.e. one missing classification rather than a wrecked read. **M24 (`[0.4.89]`, the mixed closing line)** — the mixed-run failure clause dropped, planted on a **copy built from section W's fixture** rather than on `$TOOL`, because the real tool cannot reproduce that run; exit codes stay **3/3 identical** and only the `, and 1 file(s) fail …` half of the last line differs (so X3's wording pin is the only assertion that can see it), with the surgical half being an errors-only run where the mutant is byte-identical to the real tool. **M17 re-scoped by `[0.4.146]`** — the bare rule reuses the same existence test, so the old one-line `sed` would have edited **both** comprehensions while the precondition still claimed "exactly once": the precondition reported `found 2 time(s)` and went red first (the drift detector doing its job, before any mutant could be planted), and the mutation is now an exact-string replace of the **bracketed** block alone with `t.count(old) == 1` inside the script, plus a second surgical check that the same mutant still judges a brackets-removed claim (`real=1`) — i.e. exactly one of the two verdicts was defeated. **M25/M26 (`[0.4.146]`, the bare rule's two halves)**: **M25** the collection dropped (`bare.extend(bare_hits(path, blob))` → `bare.extend([])`) — the census reads 0 and a brackets-removed claim goes green, caught `real=1 mutant=0`, surgical: `citations_bare == 0` while `citations_seen ≥ 1` and `citations_missing` still count (M19's pair again: "one rule missing" and "tree unscanned" both exit 0, and only *which* counter died tells them apart); **M26** the current-series fence dropped (`bare_current = list(bare_in_series)`) — an older series' prose becomes a defect, caught `real=0 mutant=1`, surgical: the mutant judges exactly `6.9.9` through `citations_bare_missing` with `citations_missing` still empty, **plus two checks naming the fences that did NOT move** — the lockfile path fence (real 0 / mutant 0) and the bracketed rule's full fence (both judge `[6.9.9]`, same message, 1/1), because a mutation that took three fences with it would be a different defect than the one it claims to plant.
$ cd /data/repo && grep -n "test_repo_lint\|repo-lint" tools/REGISTRY.md | grep -i "live\|suite" | head -10; echo "=== registry header of suite:"; grep -n "^### tests/test_repo_lint.sh\|^## .*test_repo_lint" tools/REGISTRY.md | head
540:  `source-sync-check` **and a clean `repo-lint` stub** (since 2026-09-24 this suite
656:  Live transcript (real `repo-lint` child, real tool, throwaway repo): the changelog
1653:  Live: `repo-lint --format json --sha HEAD` → `go_compile.ok true`; the dashboard
1679:- The four suites above **stub the `repo-lint` child** (`GLADEX_REPO_LINT_BIN`) and,
2629:**Test hooks (env)**: `APP_CONTRAST_SUITE` — path of the suite under test, defaulting to `tests/test_app_contrast.php`. Mutation runs point it at a mutated **copy**, so the real suite is never edited (same rule as `test_repo_lint.sh`'s mutation sections).
2680:**The refusal is machine-readable too** (`[0.4.61]`): the epilog refusal fires while `EPILOG` is still being built, i.e. before `main()` can construct the parser that would normally decide `--format` and `--sha`. The queue offered *"detect `--format json` in `sys.argv`"* — **rejected**: a hand-rolled scan is argparse's rules written out a second time (prefix matching, `--flag=value`, `--` termination, last-wins), the exact defect class this tool has been removing since `[0.4.53]`. Instead the four options live in **`_add_flags(p)`** (ONE definition), called by `main()`'s parser *and* by a throwaway `ArgumentParser(add_help=False)` whose `parse_known_args(sys.argv[1:])` reads the argv pre-parse: same definitions, same library, agreement **by construction** rather than by a test that remembers to compare. Three consequences, all pinned: `die()`, `_now()` and `default_repo()` now sit **above** the epilog build (at import none of them existed yet — `die` was defined 150 lines below the code that needs it, and `p` arrives as `None` because the parser does not exist); argparse's own rejections are swallowed during the scan (`redirect_stderr`) so the refusal stays the whole diagnosis — the defaults it falls back to are the honest answer for an argv that never got parsed; and the human line gained `die`'s prefix — `repo-lint: ERROR refusing to run - …` — while keeping its wording, its stream (stderr) and exit 3.
2689:- `bash tests/test_repo_lint.sh` → **461 assertions**, hermetic (throwaway git repos under `${TMPDIR:-/tmp}/opencode`, trap-cleaned): clean→0 with exact per-language/skip counts (`files_total = linted + skipped`), all five languages caught with path+line, the 219fd8f incident replayed **both directions** (bad worktree/clean commit → 0; clean worktree/bad commit → 1), arg/env exit contracts, exact JSON key set (now including `changelog_version`), symlink invocation (sandbox + real `/data/tools`), missing-binary→3 and hung-linter→3, read-only status proof on the live repo — plus **section R**, the epilog refusal and its machine-readable form, **section S**, the usage error's, **section T**, the citation rule **and, since `[0.4.146]`, its bare-token twin (T8–T15, 30 of these 461)**, **section U**, the human closing line (its **U7** + M23 also prove every lang the tool can *emit* is classified), **section V**, the number inside it, **section W**, a lang with no linter wired for it, and **section X**, a *mixed* run — `cannot verify` may not swallow a verified failure. **461 = 420 (2026-09-30, before this step) + 30 in T8–T15 + 10 in M25/M26 + 1 in M17's second surgical check**; section T now holds **54** of the 461.
2697:- **Pre-fix replay for `[0.4.89]`**: the new suite against `HEAD`'s tool blob swapped **in place** (old md5 `1cb2a12e2ff5fc22dca8aec7e15427ef` → new `08644e5482dd9d6272d7beafcb81579f`, restored and re-verified byte-identical; log `/tmp/opencode/prefix34/pre-fix.log`) → **411 passed / 6 failed**: **V4's needle** (`result: {n_files} file(s) fail` no longer occurs — it is the prefix the clause extraction removed, 1 of the 3 V4 assertions), **X3's last line** (the mixed line still reads the pre-step form), **X5 ×3** (0 definitions, 0 callers, and the `…error(s){clause}` literal absent — the three assertions that say "one derivation, two quotations"), and **M24's precondition** (the `clause = f", and …"` needle does not exist, so its other three assertions could not run — hence **411 counted pre-fix against 420 post-fix**: 420 − 6 − 3). Guards that passed pre-fix and thereby identify themselves: **X1**, all of **X2** (both halves were always in the JSON), **X4 ×3** (the errors-only line was already byte-identical — it is the line this step did *not* change, which is exactly why it is a guard), **X6**, **V4's remaining two** (the distinct-path derivation and the zero `{len(failures)} file(s)` count were already right), and all of sections A–W. **The backup for this swap was taken wrong and the record says so**: the capture command was `git show HEAD:tools/repo-lint > /tmp/opencode/prefix34/new-tool.bak`, which writes the **old** blob under a name meaning "new" — so the restore step `cp`'d the *pre-fix* file back over the three edits and `git status` showed only the test file still modified. It was caught by an md5 mismatch against `08644e54…` before anything was staged, the three edits were re-applied, and the reconstruction came out **byte-identical** (same md5), so the replay above still describes the file it names; `/tmp/opencode/prefix34/new-tool.bak` still holds the old blob despite its name, and the lesson is that a replay's restore path must be verified by hash *before* it is trusted, not after it fails.
2700:- **No pre-fix replay for `[0.4.85]`, and the reason is the change**: that step edits **only** the suite — `git show HEAD:tools/repo-lint | md5sum` and `md5sum tools/repo-lint` both read `0df9317ebe19afafeafb4766e3f8c405` before it, so there is no "before" tool to swap in and a replay would be the baseline re-quoted. The red this step's assertions can produce is instead demonstrated **inside** the suite by M23, which is the same claim in a checkable form: the identical `u7_classify` call returns `dispatch_unclassified=NONE` for the tool and `dispatch_unclassified=typescript` for a copy carrying one unclassified `EXT_LANG` entry. The old suite against the untouched tool was measured at **366/0** immediately before the edit; the new suite on the same tree is **374/0**, i.e. exactly the eight assertions added and nothing moved.
2709:- Live: HEAD → exit 0 (176 files — **174 → 176 with `[0.4.65]`**, its own `tools/regression-run` + `tests/test_regression_run.sh` going from untracked to tracked (`linted.bash` 24 → 25, `linted.python` 11 → 12), following **173 → 174 with `[0.4.64]`**; the pre-commit run reads **174** with `bash 24` / `python 11` because those blobs are not there yet — the stale-live-number class, re-read after the commit below — 45 module files compile clean in ~1.6s. **`[0.4.66]` pre-commit read: exit 0, `files_total 176`, `linted {bash 25, go 43, json 11, php 32, python 12}`, `changelog_version entries 70, unique 70, duplicates []`** — both changed files were already tracked, so the post-commit prediction is **176 unchanged** with `entries 71` once `[0.4.66]` lands, re-read after the commit rather than carried. **`[0.4.67]` pre-commit read: exit 0, `files_total 176`, `linted {bash 25, go 43, json 11, php 32, python 12}`, `changelog_version entries 71, unique 71, duplicates []`** — this entry adds two **untracked** files (`tools/queue-source-check`, extensionless `python3` shebang → `linted.python`; `tests/test_queue_source.sh`, `.sh` → `linted.bash`) plus its own heading, so the post-commit prediction is **178** with `bash 26`, `python 13` and `entries 72`, re-read after the commit rather than carried) with `changelog_version` = `attempted true, entries 70, unique 70, unparseable 0, duplicates [], ok true` (**69 → 70 with `[0.4.65]`**, following **68 → 69 with `[0.4.64]`**: the count is read from the COMMITTED blob, so it is re-read after the append commits rather than carried over — it read 68 while `[0.4.64]` was still uncommitted, which is the whole point of re-reading; the working-tree count was verified the anchored way, `grep -c '^## \['` → 69 with `uniq -d` empty, because the greedy `sed 's/.*\[\([^]]*\)\].*/\1/'` form reports **5 phantom duplicates** on this tree — 0.4.31/0.4.40/0.4.44/0.4.49/0.4.62 — by taking the last bracket in a heading that cites other versions. The **file** count is 173, not the 171 drafted mid-run: `[0.4.63]`'s own two mailbox files were untracked when that number was written and tracked once it committed, so 171 → 173 is this entry's own movement rather than a count carried); `--sha 219fd8f` → exit 1 naming `tests/test_mailbox_a11y.php:208 [php]`; `--sha 395b9b5` → exit 1 naming `.../status_test.go:5 [go-compile]`; unknown rev / non-repo → exit 3; `--sha probe-r9` → exit 3 with `requested_sha: probe-r9` (the R16 parity reference, live); `--format yaml` → exit 2 with **usage on stderr and an empty stdout** (no format could be read, so none is invented — `[0.4.62]`); **`--format json` + a bad argv → exit 2 with a 384-byte 15-key object on stdout and 0 bytes on stderr** (`--timeout abc`, `--nonsense`, `--timeout 0`, empty `--sha`, and the failing token placed *before* `--format`), while the same argv in human mode still gives argparse's `usage:`+`error:` with **stdout 0 bytes**; `--help` (**106 lines**, was 57 before the epilog stopped carrying its own prose, 102 before the exit-3 clause widened, 103 through `[0.4.61]`, **+3 for `[0.4.62]`'s widened exit-2 clause**) renders all seven docstring blocks verbatim under their labels; a copy with a heading renamed → `repo-lint: ERROR refusing to run - docstring section missing or empty …` + `  'env:' -> 'Environment:'` → **exit 3**, stderr only, and under `--format json` the **same refusal as an object** — `ok false`, `exit_code 3`, `error` naming the pair, **stderr 0 bytes** — which is the `| jq` consumer `[0.4.60]`'s queue described, now parsing (`--format=json` → 3; `--form json` → 3; `-- --format json` → no JSON on stdout; `--format yaml` on the broken copy → refusal only, no `usage:` leak) — **and on that same broken copy `--format json --timeout abc` now yields the 458-byte refusal object with `exit_code 3` instead of falling back to `human`**, which is `[0.4.61]`'s own queue item struck as actioned. **`[0.4.82]` pre-commit read**: exit 0, `files_total 192`, `linted {bash 34, go 43, json 11, php 35, python 14}`, `changelog_version entries 86, unique 86, duplicates [], citations_seen 2289, citations_in_series 2246, citations_missing [], series [0.1, 0.2, 0.3, 0.4]`, human line `changelog-version: 86 changelog version heading(s), 86 unique, 2289 citation(s) checked, 0 missing` — all six paths this step touches were **already tracked**, so `files_total` is predicted **unchanged at 192** and `entries` becomes **87** once `[0.4.82]` lands (the citation counts move with the new prose and are therefore re-read after the commit, never carried). **Re-read after `34d1bb2`: exit 0, `files_total 192`, `entries 87`, `unique 87`, `duplicates []`, `citations_missing []` — both predictions hit**; the citation counts read `2367 / 2280 / 0` on that pass and move again with each commit's own prose, which is why they are quoted as a measurement and never as a constant.
=== registry header of suite:
> build · mimo-v2.6-flash-free
STEP 0 is clean (0 unread, 79/79 INBOX handled). The staged tree is a nearly-complete queue item **(87)** run — it fails the pre-commit gate only because `[0.4.146]` has no CHANGELOG heading yet. Let me write that entry:
$ cd /data/repo && grep -n '^## \[0.4.14[0-5]\]' CHANGELOG.md; echo "=== how entries end:"; sed -n '6040,6046p' CHANGELOG.md; echo "=== tail:"; tail -5 CHANGELOG.md; echo "=== lines:"; wc -l CHANGELOG.md
5924:## [0.4.140] - 2026-09-30 — the value half of a metavar (queue item (73)) was committed with no heading to match: the main loop writes it here, and `repo-lint`, the `go-compile` suite and the promote-gates `commit-lint` refusal go green again
5952:## [0.4.141] - 2026-09-30 — queue item (79): the labelled `usage:` row must name every option-list pair — 25 missing pairs repaired across 11 `--help` bodies, and the reader that now holds them there
5980:## [0.4.142] - 2026-09-30 — queue item (78): a partial run can land red on `main` — every commit to this repo is now linted before it lands, by a tracked `.githooks/pre-commit` gate that lints the commit the index is about to become
6008:## [0.4.143] - 2026-09-30 — queue item (83): the `- Live:` suite figure is checked against the worktree but can only be pinned to a revision — section F now reports BOTH counts, and the red says which side moved
6028:## [0.4.144] - 2026-09-30 — queue item (85): the detached-child census reads TEXT, not runtime — the boundary now lives in the suite's own header and is enumerated as call-site records, with both of its directions asserted
6046:## [0.4.145] - 2026-09-30 — queue item (86): the `wait` argument is PARSED, not counted — arity and identity, the two opposite directions in which the counting reader was wrong
=== how entries end:
- **Live tree at this commit: 10 call sites across 3 tools, all `cmd-str`** — `go-compile-drift-verify` 337/339/399, `ip-drift-cron` 114/131, `system-status` 932/1024/1028/1316/1943 — each a `python3 -c` payload, two of them (`system-status` 1316, 1943) a whole program held in a shell variable. The construct census is unchanged by this step: **1 tool `DETACH` (`regression-run`), 1 tool `BG` (`go-compile-drift-verify`), `A2–A5` unchanged**, and **0** `eval` / `source` call sites exist today, which is why A23 is a floor and not a count.
- **STEP 0 ran first**: 0 unread `investor_to_agent` in both databases, `tools/inbox-status` → exit 0, "OK - nothing owed", **79 entries / 79 handled / 0 open**. No investor row was owed, so none was inserted. Spend **0.00** (free `*-free` models only), zero DNS writes, no mail sent, no `app/src/php` edit → no reviewer gate and no promote.

### Queue -> agent-logs/PROGRESS.md
Authoritative next-candidate queue lives in `agent-logs/PROGRESS.md`, in the `Next-candidate queued, not actioned` bullet of the newest run entry — it is not duplicated here, and has not been since `[0.4.67]`. To read the live queue, open `PROGRESS.md`; to know whether that is still true, run `tools/queue-source-check`.

## [0.4.145] - 2026-09-30 — queue item (86): the `wait` argument is PARSED, not counted — arity and identity, the two opposite directions in which the counting reader was wrong
=== tail:
- **Live tree, measured before and after**: exactly one registered tool backgrounds a child (`go-compile-drift-verify`, `pid=$!` + `wait "$pid" 2>/dev/null`), and the new reader returns `pending 0` for it — the same answer the counting reader gave, so no live verdict moved. **No registered tool writes either (86) shape today** (no multi-argument `wait`, no job named twice), which is why the step is a reader fix with plants rather than a tool fix.
- **STEP 0 ran first**: 0 unread `investor_to_agent` in both databases, `tools/inbox-status` → exit 0, "OK - nothing owed", **79 entries / 79 handled / 0 open**, `grep '^## ' INBOX.md | grep -v HANDLED` empty. No investor row was owed, so none was inserted. Spend **0.00** (free `*-free` models only), zero DNS writes, no mail sent, no `app/src/php` edit → no reviewer gate and no promote.

### Queue -> agent-logs/PROGRESS.md
Authoritative next-candidate queue lives in `agent-logs/PROGRESS.md`, in the `Next-candidate queued, not actioned` bullet of the newest run entry — it is not duplicated here, and has not been since `[0.4.67]`. To read the live queue, open `PROGRESS.md`; to know whether that is still true, run `tools/queue-source-check`.
=== lines:
6063 CHANGELOG.md
$ cd /data/repo && grep -c '^\- \*\*STEP 0' agent-logs/PROGRESS.md; grep -n "Next-candidate queued, not actioned" agent-logs/PROGRESS.md | tail -2; echo "=== queue-source-check now:"; ./tools/queue-source-check; echo "rc=$?"
164
7195:- **Next-candidate queued, not actioned**: **(85) STRUCK — EXECUTED by this run** (`INDIRECT` records + header boundary declaration, command-position anchoring, `A17`–`A25`, both sides of the boundary asserted, suite 33 → 42, seven mutation controls re-measured at 42). Carry unchanged and all standing: (2), (4)–(8), (14), (15), (17), (18), (20), (22), (23), (25), (28), (32), (36), (39), (42), (44), (47), (48), (52), (53), (54), (56), (60), (61), (62), (66), (67), (68), (70), (86), (87), (89), (91), (92), plus **(93)** (public nav → LAN-only `/docs` + `/changelog`, still the investor's call — it widens a surface), **(96) candidate (b)** (normalise `CAST(ts AS INTEGER)` on read in `app/src/php/app.php`, only if a bad row is ever detected, reviewer-gated) and **(97)** whose candidates (a) redact+guard / (b) history purge / (c) fixtures-amendment stay **blocked on the founder's A/B/C answer** to reply dev 141 / prod 106, plus **(98)** (the three metavars whose type-invalid value answers 3/3/1 rather than 2: `repo-lint --sha`, `immich-roundtrip --email`, `smtp-relay-probe --expect-open`) and **(99)** (the agent loop's script is a **dead letter** — the running pid executes a deleted inode whose md5 differs from the file on disk, so no edit to `/data/agent-loop.sh` takes effect without a service restart). **New from this run: (100)** — *the mutation controls `tools/REGISTRY.md` documents for `tests/test_detached_children.sh` are prose; nothing in the repo runs them.* Measured, not assumed: `grep -rn "test_detached_children" tests/ tools/` → **2 hits, the suite itself and its registry section**, and the file has **no in-file control section** the way `test_commit_gate.sh` ("the suite's own C section") and `test_registry_coverage.sh` have one — so the table rot-lands silently the next time a reader changes (this run re-ran all seven **by hand in sandboxes**, which is evidence, not automation). Candidates: **(a)** move them into the suite as an in-file section, each mutation asserted to have applied before it is used, or **(b)** a registered `tests/` runner that takes the seven patches. **Not actioned**: it is a second subject inside an entry that already ships three files. Live head of the machinery list: **(86)**, **(87)**, **(89)**, **(91)**, **(92)**, **(98)**, **(99)**, **(100)**. Next-candidate priority after this run: **(93)** or **(97)(a)** the moment the investor answers, otherwise the oldest carried machinery item — **(86)**.
7229:- **Next-candidate queued, not actioned**: carry items (2), (4)–(8), (14), (15), (17), (18), (20), (22), (23), (25), (28), (32), (36), (39), (42), (44), (47), (48), (52), (53), (54), (56), (60), (61), (62), (66), (67), (68), (70), (87), (89), (91), (92), (98), (99), (100) unchanged and **(93)** (public nav → LAN-only `/docs` + `/changelog`, still the investor's call — it widens a surface), **(96) candidate (b)** (normalise `CAST(ts AS INTEGER)` on read in `app/src/php/app.php`, only if a bad row is ever detected, reviewer-gated) and **(97)** whose candidates (a) redact+guard / (b) history purge / (c) fixtures-amendment stay **blocked on the founder's A/B/C answer** to reply dev 141 / prod 106 — item **(86) STRUCK — EXECUTED by `[0.4.145]`** (job identities, `name=$!` resolution, one cover per argument, operator cut, `A26`–`A29`, live `B14`–`B17`, suite 42 → 50, thirteen controls re-measured at 50). **New from this run: (101)** as above. Live head of the machinery list: **(87)**, **(89)**, **(91)**, **(92)**, **(98)**, **(99)**, **(100)**, **(101)**. Next-candidate priority after this run: **(93)** or **(97)(a)** the moment the investor answers, otherwise the oldest carried machinery item — **(87)**.
=== queue-source-check now:
queue-source-check: OK - one queue: [0.4.145] pointer-only, 111 item line(s) frozen across 102 section(s), 103 PROGRESS bullet(s)
rc=0
> build · mimo-v2.6-flash-free
Now appending the `[0.4.146]` CHANGELOG entry that the staged work already cites:
$ cd /data/repo && cat >> CHANGELOG.md <<'ENTRY'

## [0.4.146] - 2026-10-01 — queue item (87): the changelog gate reads the CLAIM, not its brackets — a bare version token in the current series is now judged like its bracketed twin, through two measured fences (current series only, lockfile paths never)

### Changed — `repo-lint` counts and judges the bare spelling of a citation

- **A citation is a CLAIM whether or not it is bracketed.** The instance was a commit that went green by *deleting* the two brackets from one citation — exit 0 reachable by hiding a report instead of satisfying it, i.e. the bracketed spelling had become a formatting convention with a verdict attached. `CHANGELOG_BARE_RE` (`(?<![\[.\d])(\d+\.\d+\.\d+)(?!\d)(?!\.\d)`, matched against the blob bytes on the same pre-dispatch walk) collects every `x.y.z` token through `bare_hits()`, and `changelog_gate()` judges it beside the bracketed list — the two spellings stay **two paths** (`citations_missing` vs `citations_bare_missing`, both emitted as `lang: changelog`, message `bare cite of N.N.N (brackets removed) but CHANGELOG.md has no such heading`) rather than one rule renamed, and `citations_missing` stays empty on a brackets-only defect so a reader can tell which spelling it wrote. The lookarounds are the shape of the false claim, not taste: `(?<![\[.\d])` refuses the `[` that marks the other spelling and refuses IP octets (`10.2.3.1`'s inner `0.2.3`), while `(?!\d)(?!\.\d)` refuse the match a plain `\d+` would settle for by BACKTRACKING — `10.100.66.156` would otherwise end its third group early and read `10.100.6` as a claim, an address sitting inside this repo's own current series.
- **The bare scope is deliberately NARROWER than the bracketed one, and the live numbers chose it**: judged only in the **current series** (the series of the changelog's highest heading) and **never for a lockfile path** (`LOCKFILE_NAMES` — machine-written dependency pins make no claims; npm's own `0.2.x` collided with this repo's old `0.2` series on the live tree). Measured, not chosen: a naive full-fence build reports **13 reds** where the shipped build reports **2**, 11 of the 13 being a lockfile or a dependency named in prose (the shape of a claim this rule must not claim), the other 2 the deliberate quotes the rule exists for. A bracketed token in a lockfile is still judged, because no lockfile has ever written one.
- **Every bare token is COUNTED regardless of fences** — `citations_bare` grows even with no `CHANGELOG.md` to compare against, and the human summary appends `, N bare token(s) counted` — so the census is never hidden by a fence that decides not to judge. Both renderings of the contract say the rule plainly, each derived from the one docstring copy so `--help` cannot drift from the source: `deleting the brackets changes the spelling, never the verdict` (exit-code 1) and `Removing the brackets is not a fix` (the gate section).
- **The rule caught its own host file on the first run, and that is the evidence it works outside a fixture**: `tools/repo-lint` over this tree reported **`bare cite of 0.4.NNN`** twice in `agent-logs/PROGRESS.md` — an older entry still quoting, verbatim, the planted token its own refusal once named — where the committed `HEAD` had been green only because those bytes were a bare token. The two quotes are elided in this same commit (patch digits replaced) rather than bypassed, and the bracketed twin in one of them is elided too, because this heading is what gives the bare rule its existence test.

### Verified — 461 assertions, a 26-mutation index, and the gate refusing this very commit first

- **`bash tests/test_repo_lint.sh` → 461 passed, 0 failed** (run this step), against the pre-step suite's **420**: **461 = 420 + 30 in T8–T15 + 10 in M25/M26 + 1 in M17's second surgical check**, section T now holding **54** of the 461. **T8** the defect itself — exit 1, `citations_bare_missing` populated, **`citations_missing` still empty** (a second rule, not a relabelling), `lang: changelog` so `promote` still renders it as a rule; **T9** the bracketed twin of the same claim, byte-for-byte unchanged; **T10** the narrower fence — a bare token in an older series exits 0 and never enters the missing list while its bracketed twin in that *same* series is still judged (same token, opposite verdict, the asymmetry the docstring declares); **T11** the path fence — a lockfile's in-series token exits 0 and the same token written as prose exits 1; **T12/T13** the two regex guards asserted as **census** comparisons rather than exit codes, because both trees exit 0; **T14** the contract's own words in what `--help` renders, asserted against a whitespace-flattened read (both sentences sit inside blocks the source hard-wraps — a literal substring missed on the *wrap* on its first run, which is why the assertion flattens); **T15** the section leaves the sandbox green.
- **Mutation index 24 → 26, each precondition-asserted**: **M25** drops the bare collection (`citations_bare == 0` while `citations_seen ≥ 1` and `citations_missing` still grows — "one rule missing" and "tree unscanned" both exit 0, so only *which* counter died tells them apart); **M26** drops the current-series fence (`real=0 mutant=1`, the mutant judging exactly the old-series fixture through `citations_bare_missing` with `citations_missing` still empty) **plus two checks naming the fences that did NOT move** — the lockfile path fence (0/0) and the bracketed rule's full fence (both judge it, same message, 1/1) — because a mutation that took three fences with it would be a different defect than the one it claims to plant. **M17 was re-scoped by this step**: the bare rule reuses the same existence test, so the old one-line `sed` would have edited **both** comprehensions while its precondition still claimed "exactly once" — the precondition reported `found 2 time(s)` and went red first (the drift detector doing its job before any mutant was planted), and the mutation is now an exact-string replace of the bracketed block alone, with a second surgical check that the same mutant still judges a brackets-removed claim.
- **The gate refused this very commit before this heading existed**: `.githooks/pre-commit` → **REFUSED, exit 1**, `citations_bare/bracketed` missing count **13** across three files — `agent-logs/PROGRESS.md` ×2, `tests/test_repo_lint.sh` ×2, `tools/REGISTRY.md` ×9 — every failure a `cites [0.4.146]` pointing at the entry being written, then **exit 0** once it was appended. A citation of a heading nobody wrote is refused *before* it lands, which is `[0.4.142]`'s promise kept on the widened rule.
- **STEP 0 ran first**: 0 unread `investor_to_agent` in both databases, `tools/inbox-status` → exit 0, "OK - nothing owed", **79 entries / 79 handled / 0 open**, `grep '^## ' INBOX.md | grep -v HANDLED` empty. No investor row was owed, so none was inserted. Spend **0.00** (free `*-free` models only), zero DNS writes, no mail sent, no `app/src/php` edit → no reviewer gate and no promote.

### Queue -> agent-logs/PROGRESS.md
Authoritative next-candidate queue lives in `agent-logs/PROGRESS.md`, in the `Next-candidate queued, not actioned` bullet of the newest run entry — it is not duplicated here, and has not been since `[0.4.67]`. To read the live queue, open `PROGRESS.md`; to know whether that is still true, run `tools/queue-source-check`.
ENTRY
echo "appended, lines now: $(wc -l < CHANGELOG.md)"; grep -c '^## \[' CHANGELOG.md
appended, lines now: 6082
151
> build · mimo-v2.6-flash-free
$ cd /data/repo && git add CHANGELOG.md && timeout 300 bash .githooks/pre-commit; echo "hook_rc=$?"
hook_rc=0
> build · mimo-v2.6-flash-free
$ cd /data/repo && bash tests/test_registry_coverage.sh 2>&1 | tail -3; echo "rc=$?"
Command moved to the background (shell ID: sh_0f4c84304001CfKJrwxTNyJD7R).
Output is streaming to: /root/.local/share/opencode/shell/fa3e85b2145a60c127b5c9261e76a7ba6d520299/sh_0f4c84304001CfKJrwxTNyJD7R.out
$ cd /data/repo && bash tests/test_commit_gate.sh 2>&1 | tail -3; bash tests/test_queue_source.sh 2>&1 | tail -3; php tests/test_changelog_api.php 2>&1 | tail -3
=================================
commit-gate suite: 41 passed, 0 failed
=================================
===============================
queue-source-check suite: 181 passed, 0 failed
===============================
  PASS: a heading the API cannot parse is reported as unparseable, not counted as an entry

=== Results: 86 passed, 0 failed ===
> build · mimo-v2.6-flash-free
$ cd /data/repo && bash tests/test_repo_lint.sh 2>&1 | tail -3; echo "=== repo-lint on committed HEAD (new tool, old blobs):"; python3 tools/repo-lint --sha HEAD 2>&1 | tail -5; echo "rc=$?"
===============================
repo-lint suite: 461 passed, 0 failed
===============================
=== repo-lint on committed HEAD (new tool, old blobs):
  go-compile: 45 module file(s) compile clean (1.944s)
  changelog-version: 150 changelog version heading(s), 150 unique, 5199 citation(s) checked, 0 missing, 4827 bare token(s) counted
FAIL agent-logs/PROGRESS.md:7131 [changelog] bare cite of 0.4.999 (brackets removed) but CHANGELOG.md has no such heading
FAIL agent-logs/PROGRESS.md:7139 [changelog] bare cite of 0.4.999 (brackets removed) but CHANGELOG.md has no such heading
result: 1 file(s) fail lint (changelog) (exit 1)
rc=0
> build · mimo-v2.6-flash-free
$ cd /data/repo && ./tools/queue-source-check --help 2>&1 | head -30
usage: queue-source-check [-h] [--format {human,json}] [--repo DIR]

Verify that the next-candidate work queue has exactly one home: agent-logs/PROGRESS.md carries the live list and CHANGELOG.md's newest '### Queue' section is a pointer at it, with the 111 historical item lines frozen.

options:
  -h, --help            show this help message and exit
  --format {human,json}
                        output format (default: human; json = one compact
                        object)
  --repo DIR            repo to check (default: GLADEX_REPO_DIR, else the repo
                        this script lives in)

exit codes:
  0 - the queue has exactly one home: CHANGELOG's newest ### Queue section is a
      pointer at agent-logs/PROGRESS.md, PROGRESS carries the live list, and the 111 historical
      item lines are unchanged
  1 - a violation: a second list exists, the pointer was dropped, the
      authoritative list is empty, one entry owns two `### Queue` sections, or
      a `### Queue` heading was not read as a section (see the violations[]
      array - every cause is reported, not just the first)
  2 - invalid arguments
  3 - cannot verify: CHANGELOG.md, agent-logs/PROGRESS.md or a ### Queue section is absent -
      NOT a pass, never reported as one
$ cd /data/repo && python3 tools/repo-lint --sha HEAD >/dev/null 2>&1; echo "repo-lint --sha HEAD rc=$?"; grep -n "PROGRESS bullet\|progress_bullet" tests/test_queue_source.sh | head -10; grep -rn "103" tools/queue-source-check | head -5
repo-lint --sha HEAD rc=1
146:assert_jget "A17 progress_bullets=1" "$OUT" 'd["rules"]["progress_bullets"]' "1"
162:        "newest_points_at_progress","progress_bullets",
255:assert_jget "F3 json progress_bullets=0" "$OUT" 'd["rules"]["progress_bullets"]' "0"
348:        "newest_points_at_progress","progress_bullets",
411:# --- L: `progress_bullets` counts ENTRY lines, not occurrences of the phrase --
416:# summary). A field named `progress_bullets` whose detail says "PROGRESS
440:assert_jget "L2 progress_bullets=3 (markerless counts, repeats and fences do not)" \
441:            "$OUT" 'd["rules"]["progress_bullets"]' "3"
442:assert_contains "L3 the human detail reports the same 3" "3 PROGRESS bullet(s)" "$OUT"
458:assert_jget "L6 progress_bullets=0 there" "$OUT" 'd["rules"]["progress_bullets"]' "0"
> build · mimo-v2.6-flash-free
While the registry-coverage suite runs, let me draft the run entry:
← Write /tmp/opencode/run-entry-87.md
Created file successfully: /tmp/opencode/run-entry-87.md
> build · mimo-v2.6-flash-free
$ grep -o '0\.4\.[0-9][0-9]*' /tmp/opencode/run-entry-87.md | sort | uniq -c; echo "=== headings exist check:"; for v in 0.4.28 0.4.142 0.4.146; do grep -q "^## \[$v\]" /data/repo/CHANGELOG.md && echo "$v OK" || echo "$v MISSING"; done
1 0.4.142
      5 0.4.146
      2 0.4.28
=== headings exist check:
0.4.28 OK
0.4.142 OK
0.4.146 OK
> build · mimo-v2.6-flash-free
$ tail -5 /root/.local/share/opencode/shell/fa3e85b2145a60c127b5c9261e76a7ba6d520299/sh_0f4c84304001CfKJrwxTNyJD7R.out 2>/dev/null || echo "not finished yet"
(no output)
> build · mimo-v2.6-flash-free
$ cd /data/repo && cat /tmp/opencode/run-entry-87.md >> agent-logs/PROGRESS.md && tail -3 agent-logs/PROGRESS.md | head -1; echo "=== queue check:"; ./tools/queue-source-check; echo "rc=$?"
- **Next-candidate queued, not actioned**: **(87) STRUCK — EXECUTED by this run** (`CHANGELOG_BARE_RE` + `bare_hits()` + `LOCKFILE_NAMES`, the two measured fences, the contract sentence derived into `--help`, T8–T15, M25/M26, M17 re-scoped by the second comprehension, suite 420 → 461, gate refusing this commit 13× then green). Carry unchanged and all standing: (2), (4)–(8), (14), (15), (17), (18), (20), (22), (23), (25), (28), (32), (36), (39), (42), (44), (47), (48), (52), (53), (54), (56), (60), (61), (62), (66), (67), (68), (70), (89), (91), (92), (98), (99), (100), (101) unchanged and **(93)** (public nav → LAN-only `/docs` + `/changelog`, still the investor's call — it widens a surface), **(96) candidate (b)** (normalise `CAST(ts AS INTEGER)` on read in `app/src/php/app.php`, only if a bad row is ever detected, reviewer-gated) and **(97)** whose candidates (a) redact+guard / (b) history purge / (c) fixtures-amendment stay **blocked on the founder's A/B/C answer** to reply dev 141 / prod 106. Live head of the machinery list: **(89)**, **(91)**, **(92)**, **(98)**, **(99)**, **(100)**, **(101)**. Next-candidate priority after this run: **(93)** or **(97)(a)** the moment the investor answers, otherwise the oldest carried machinery item — **(89)**.
=== queue check:
queue-source-check: OK - one queue: [0.4.146] pointer-only, 111 item line(s) frozen across 103 section(s), 104 PROGRESS bullet(s)
rc=0
> build · mimo-v2.6-flash-free
$ cd /data/repo && git add agent-logs/PROGRESS.md && timeout 300 bash .githooks/pre-commit; echo "hook_rc=$?"; bash tests/test_queue_source.sh 2>&1 | tail -3
hook_rc=0
===============================
queue-source-check suite: 181 passed, 0 failed
===============================
> build · mimo-v2.6-flash-free
Waiting on the registry-coverage suite before committing. Meanwhile, a quick source-sync and health snapshot:
$ cd /data/repo && ./tools/source-sync-check 2>&1 | tail -3; echo "rc=$?"
prod examples/workflows       8 files  OK
  prod src/php                 14 files  OK
result: in sync — 44 file(s) across 2 env(s) (exit 0)
rc=0
> build · mimo-v2.6-flash-free
$ cat /root/.local/share/opencode/shell/fa3e85b2145a60c127b5c9261e76a7ba6d520299/sh_0f4c84304001CfKJrwxTNyJD7R.out 2>/dev/null | tail -5; echo "---"; ps aux | grep -c '[t]est_registry_coverage'
---
4
> build · mimo-v2.6-flash-free
The registry-coverage suite (which validates `tools/REGISTRY.md` figures against live runs) is still going — it's the gate that matters before committing the inherited (87) registry edits. I'll commit the moment it reports.
exit=0

Select another run log from the list above. Only files matching run-YYYYMMDD-HHMMSS-N.log are readable.

[Thu Oct  1 02:15:58 2026] 127.0.0.1:35072 Accepted
[Thu Oct  1 02:15:58 2026] 127.0.0.1:35072 Closing
[Thu Oct  1 02:15:58 2026] 127.0.0.1:35086 Accepted
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35086 Closing
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35090 Accepted
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35090 Closing
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35092 Accepted
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35092 Closing
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35106 Accepted
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35106 Closing
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35108 Accepted
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35108 Closing
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35110 Accepted
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35110 Closing
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35126 Accepted
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35126 Closing
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35132 Accepted
[Thu Oct  1 02:15:59 2026] 127.0.0.1:35132 Closing
[Thu Oct  1 02:17:15 2026] 127.0.0.1:39060 Accepted
[Thu Oct  1 02:17:15 2026] 127.0.0.1:39060 Closing
[Thu Oct  1 02:17:15 2026] 127.0.0.1:39070 Accepted
[Thu Oct  1 02:17:15 2026] 127.0.0.1:39070 Closing
[Thu Oct  1 02:17:15 2026] 127.0.0.1:39086 Accepted
[Thu Oct  1 02:17:15 2026] 127.0.0.1:39086 Closing
[Thu Oct  1 02:17:15 2026] 127.0.0.1:39094 Accepted
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39094 Closing
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39098 Accepted
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39098 Closing
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39106 Accepted
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39106 Closing
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39112 Accepted
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39112 Closing
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39122 Accepted
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39122 Closing
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39128 Accepted
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39128 Closing
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39138 Accepted
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39138 Closing
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39148 Accepted
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39148 Closing
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39160 Accepted
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39160 Closing
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39174 Accepted
[Thu Oct  1 02:17:16 2026] 127.0.0.1:39174 Closing
[Thu Oct  1 02:19:40 2026] 127.0.0.1:57918 Accepted
[Thu Oct  1 02:19:40 2026] 127.0.0.1:57918 Closed without sending a request; it was probably just an unused speculative preconnection
[Thu Oct  1 02:19:40 2026] 127.0.0.1:57918 Closing
[Thu Oct  1 02:19:41 2026] 127.0.0.1:57932 Accepted
[Thu Oct  1 02:19:41 2026] 127.0.0.1:57932 Closed without sending a request; it was probably just an unused speculative preconnection
[Thu Oct  1 02:19:41 2026] 127.0.0.1:57932 Closing
[Thu Oct  1 02:20:12 2026] 127.0.0.1:46422 Accepted
[Thu Oct  1 02:20:12 2026] 127.0.0.1:46422 Closed without sending a request; it was probably just an unused speculative preconnection
[Thu Oct  1 02:20:12 2026] 127.0.0.1:46422 Closing
[Thu Oct  1 02:20:14 2026] 127.0.0.1:46428 Accepted
[Thu Oct  1 02:20:14 2026] 127.0.0.1:46428 Closed without sending a request; it was probably just an unused speculative preconnection
[Thu Oct  1 02:20:14 2026] 127.0.0.1:46428 Closing
[Thu Oct  1 02:22:21 2026] 127.0.0.1:39412 Accepted
[Thu Oct  1 02:22:21 2026] 127.0.0.1:39412 Closing
[Thu Oct  1 02:22:21 2026] 127.0.0.1:39420 Accepted