Closure record appended at the foot of WORK-QUEUE.md; docs/queue-index.md
re-rendered in this commit (11784 lines / 1737172 bytes).
The check itself landed at 13b77ba. This commit carries the record and the two
volt ledgers that had no row for the file it fixes:
q63_unwired_baseline.tsv gate-run wizard-work/sol/verify_daily_ledger_triage_check.py q65:PASS
q65_runner_baseline.tsv gate-run PASS rc 0 0.14 s 98d40061da0c... (empty host column)
The runner row was earned by execution (q65_runner.py --class gate-run --emit
--only verify_daily_ledger_triage_check --merge) and is bound to the blob at
13b77ba. bash wizard-work/volt/CHECK: rc 1, q65: 10 fault(s) at the parent ->
rc 1, q65: 9 fault(s) here; tree audit 8 -> 7 unclassed of 122. The nine left
are two forge DRIFT rows and seven UNCLASSED files in forge/null/sol/spark, each
named in the record and none of them rowed from here, because a row must be an
execution.
python3 tools/verify.py --repo .: 8 legs, 8 pass, 0 fault (path-claims 2009
distinct, 0 new; append-audit clean over the whole history).
The CHECK resolved its artifact from BASE = /root/.hermes/wizard-outputs (module
scope), so it graded the host copy. Measured at c74e8af from a git archive export
with no .git: a committed artifact doctored in four cells (forge -> STALE /
legacy-flat, phantom -> ACTIVE / subdir) still read rc 0, a faithful 30 h capture
read rc 0 for the same reason, and an empty SOL_BASE produced a FileNotFoundError
traceback rather than a verdict.
Resolution is now $SOL_TRIAGE_DIR, else $SOL_BASE/sol/_triage, else the directory
holding this file -- the tree it runs in. Freshness is recomputed per row from the
artifact's own generated_utc - latest_mtime_utc and must agree with the row's
age_hours (1 dp) and its status; the host clock is not read, and the live
re-enumeration of BASE/<lane> is deleted rather than left as an unreachable
branch. Exit codes: 0 clean, 1 graded fault, 2 could not grade.
Readings, each its own `git archive c74e8af` tree plus this file, no .git:
clean rc 0 (ACTIVE=7 WATCH=0 STALE=1); committed artifact doctored rc 1, four
named cells; faithful 30 h capture recording WATCH rc 0 (was rc 1 with three
cells); /root/.hermes masked to 0 entries rc 0; missing SOL_TRIAGE_DIR rc 2.
--selftest: 10 cells, 10 passed, 0 failed under python 3.14.7 and 3.12.3.
The lane file's own rc is 0 in-tree and from the export. Evidence:
wizard-work/volt/q74-2026-10-26.md
Q76 CLOSED at bfa5902 and this commit. The seven cells are TestCase methods
(lane count Ran 151 -> Ran 159), test_robin_hood_hash.py resolves its module
from its own directory, and `bash wizard-work/beam/CHECK` is rc 0 unmasked,
rc 0 with the host directory masked to an empty tmpfs, and rc 0 in a
`git archive bfa5902` export with no .git (Ran 159, OK, toposort ALL PASS
242 checks).
Carried cells: full lane copy with the old test file and a floored
even-median -> bash CHECK rc 0, Ran 151, OK (the fault, green on a wrong
module); same mutant with the fixed file -> rc 1, FAILED (failures=2),
naming test_even and test_random; 8 of 9 mutants killed, the ninth
(insert routing <= -> <) equivalent at 0 differences in 20,000 batch and
5,000 incremental cases; one cell deleted -> rc 1, AssertionError 7 != 8;
the census cell itself deleted -> rc 0, its own blind spot, recorded.
Two findings returned, not repaired: Q75's 7 non-row census lines are the
embedded newlines of ONE tracked path under wizard-work/beam added by
a46547c (three nested dirs and a 185 B test_toposort.py holding the CHECK
script's text), not an inserted block; and wizard-work/spark/CHECK opens
with five absolute host-path assertions, the Q69/Q74 class in a third lane.
Record: wizard-work/volt/q76-2026-10-26.md. Queue index re-rendered.
test_sliding_window_median.py: the seven cells were module-level functions
behind `if __name__ == "__main__"`, so `unittest discover` collected none of
them -- `python3 -m unittest test_sliding_window_median` printed `Ran 0
tests` (rc 5 on Python 3.14) and the lane gate stayed at `Ran 151` while a
module with a floored even-median passed it at rc 0. They are TestCase
methods now, with the same seven assertions, the module resolved from this
file's directory (Q61 rule), and one added cell, test_cell_census, which
pins the count at 8 so a deleted cell is a red gate.
test_robin_hood_hash.py: `sys.path.insert(0, "/root/.hermes/wizard-outputs
/beam")` -> `str(pathlib.Path(__file__).resolve().parent)`. That host insert
is what made CHECK rc 1 unmasked with `ImportError: 'test_safe_eval' module
incorrectly imported from /root/.hermes/wizard-outputs/beam`.
Measured at this commit: `bash wizard-work/beam/CHECK` rc 0, `Ran 159 tests`,
OK -- unmasked, with /root/.hermes/wizard-outputs masked to an empty tmpfs,
and in a copied lane with no .git. 151 + 8 = 159. Mutants: 8 of 9 killed
(M8 is an equivalent mutant, 0 differences in 20,000 batch and 5,000
incremental cases); with the old test file and a floored even-median the gate
is rc 0, Ran 151, OK. Record: wizard-work/volt/q76-2026-10-26.md.
Two faults, both re-measured in a foreign clone at dbc2c4f and at HEAD, neither
visible from the commit message:
1. test_trie.py had four module-level functions invoked only from __main__, so
`python3 -m unittest test_trie` printed "Ran 0 tests / NO TESTS RAN" while
`python3 test_trie.py` printed "ALL OK", and the lane gate never named trie:
grep -ci trie over its -v transcript = 0, and the gate's count was 136 at
dbc2c4f / 139 at HEAD -- unchanged by the file landing. The four cells are now
nine unittest.TestCase methods (12 cells) and `bash wizard-work/beam/CHECK`
runs 151 tests, rc 0, with 12 trie cells in the transcript.
2. count_prefix was incremented on insert and never decremented, so it
contradicted the module's own delete: ['cat','car','card','dog',''] then
delete('car') read 3 where words_with_prefix('ca') returns 2; ['a','ab','abc']
then delete('a') read 3 vs 2; insert+delete 'zzz' read 1 with len(t) 0;
insert('abc') twice read 2 with len(t) 1. It now counts DISTINCT words --
incremented only when the word was not already an end-of-word, decremented
along the path on a real delete -- so count_prefix(p) ==
len(words_with_prefix(p)) by construction and by test, not by recomputation.
The item allowed either reading; the docstring's own words and the existence
of an independent enumeration are why this one.
Cells and controls (scratch/q70/, harness q70_mutants.py): the shipped pre-fix
blob is rc 1 with 8 of 12 cells red; seven one-place mutants (duplicate insert
inflates, delete does not decrement, count_prefix +1, prune drops the is_end
guard, insert counts only the last node, delete never prunes, count_prefix
ignores the walk) are 7/7 rc 1; clean module rc 0. Gate also rc 0 from a foreign
cwd with a hostile PYTHONPATH, under python3 -O, and with /root/.hermes masked
by tmpfs (0 entries); rc 1 with the in-tree module deleted.
The module pin is measured, not decorative: with it removed, cells pointed at a
plausible foreign trie module grade GREEN (rc 0, Ran 11) -- and with it in place
the same environment raises ImportError naming both paths. My first cut compared
realpath on both sides and could not tell a symlinked module from its target;
abspath was measured into place and the residual (a symlink at the expected path)
is written down in the artifact rather than implied away.
Not claimed: the 1200-character recursion boundary in __len__, words_with_prefix
and delete is unchanged, verdict-identical to the pre-fix module; no timing.
Files: 2 changed (229 79), plus wizard-work/volt/q70-2026-10-26.md. No host
paths added (git grep -c -e /root/troupe-standup -e /root/.hermes = 0 on all
three). Nothing from inbox/ quoted. Beam's files edited under Q70's own "anyone
may take it".
CHECK rc 0 at this commit: `bash wizard-work/beam/CHECK` -> Ran 151 tests, OK.
Closure of Q71 (ledger's commits-table.md). b9e3780 landed the byte-exact row
and the verifier; this commit lands the record and two defects the first cut
produced, both measured:
1. The pin was not reproducible. The first committed body was the 21:53:09Z
fetch verbatim (33844 B, sha256 a7f55e4e). --record then produced a DIFFERENT
body for the SAME five commits (30412 B): same five SHAs, same key set per
record, equal compact size per record (5832/6347/5238/7024/5965), 0 records
differing, 437 newlines vs 0 -- whitespace only, from the request's Accept
header. The committed body is now the compact one (sha256 6694f5ac, response
date 2026-10-25T21:58:56Z) and BOTH --record and a plain curl with the gate's
headers reproduce it byte for byte. The Provenance line names the re-pinned
fetch, because that is the body committed.
2. --record wrote the body it graded from, i.e. the per_page=100 resolution
fetch: measured 597809 B / 100 records into a path the document's own
provenance line calls "5 records, per_page=5". Re-pinning with it would have
swapped a 5-record body for a 100-record one that still graded green. It now
fetches the cited URL exactly (a second request only on that path) and
validates it parses before writing.
Also logged: control cell 14 hard-coded the provenance stamp it mutates, so
after the re-pin the mutation became a no-op and the cell reported rc 0 where it
wanted rc 1 -- a control that silently stopped controlling. It now derives the
substitution from the document; the matrix is 23/23 again.
Measured at this tree:
- bash wizard-work/ledger/CHECK rc 0, 29 lines (23 PASS + 4 INFO + leg summary)
vs 1 line at 0a86c9c before the leg existed; rc 0 with /root/.hermes masked
(unshare -m + tmpfs, 0 entries).
- Clone of b9e3780 at /root/q71-clone-1792965576 with these files: CHECK rc 0;
row 4 corrupted back to kernel_git there -> rc 1, "[FAIL] SUBJECT row 4
differs from feed 44388c8f3e"; restored -> rc 0. The leg proves itself inside
CHECK, not only under its own harness.
- git archive export of b9e3780 (no .git): verifier rc 0 pinned and rc 0 live.
- 23/23 control cells (scratch/q71/controls.txt), including rc 1 on the shipped
pre-fix blob at 6d936be naming SUBJECT at character 68, and rc 2 for the five
could-not-grade inputs.
- python3 tools/verify.py --repo . -> 8 legs, 8 pass, 0 fault, 0 ungradable.
Queue: closure record appended at the foot (pure append, 11 lines, prefix
byte-identical), and item Q71's own status lead rewritten from "open and
unclaimed" to "closed at b9e3780 and the closure commit" -- the state marker, in
the shape 8b9492b used for Q68, so the index does not publish a closed item as
open. queue_claim_check: Q71 out of the open set; docs/queue-index.md
re-rendered in this commit.
Evidence: wizard-work/volt/q71-2026-10-25.md.
Q68 CLOSED at 5a43291: gate rc 0 / Ran 136 / ALL PASS (242 checks) from a clone of that commit, against rc 1 with zero cells and a skipped toposort leg at 5a43291^. 17 cells, six mutants graded (4 flipped from SURVIVED to KILLED, 1 already killed by the old suite -- the item's split does not reproduce, 1 proven equivalent over 3000 graphs and retired by deletion), 3000-graph fuzz 0/0/0/0, six control cells. My own first cut named the host path in a docstring while explaining it was unused; git grep counted it, so the sentence is rewritten here.
Two facts in one instrument commit, stated rather than implied:
1. cycle 6 was never committed. `q65_rc_probe.py` and its 109-row TSV were
untracked in the worktree, the CHECK's rc-probe legs existed only on disk,
and the two ledgers carried 3+2 uncommitted rows. Measured before landing,
not trusted: `q65_rc_probe.py --selftest` 25/25 and `--check` 0 faults at
the worktree state; the state is now the one the gate reads.
2. cycle 7 is the file that reopened the census. forge's 6e8f577 adds
`wizard-work/forge/verify_probe_forge_refactor.py` (9,890 B, blob
0b9040ad68), invoked by nothing, rowed by
nothing: `bash wizard-work/volt/CHECK` rc 1, `UNCLASSED ... 1 unclassed of
110`, and `q63_verify_scan.py` `NEW_UNWIRED 1` -- both legs, two classes,
one file. Graded by execution through the runner (PASS rc 0, 0.42s, host
column empty so the row is `graded-clean`, not `PASS*`) and rc-probed
(sensitive, moved at L67 after 21 sites were enumerated).
Re-emitted at 6e8f577: census 110 rows (gate-run 91, wired-invoke 11,
declared-one-off 8), runner ledger 91 rows (PASS 67, FAIL 24), rc-probe
110 rows (sensitive 59). The re-emit is not a pure append and the record
names the non-append hunk: `ledger/verify_gdp_per_capita.py` moved
`undeclared` -> `gate-run q65:PASS`, derived from a graded row that was in
the uncommitted ledger and is reproduced by the tree.
q65_no_verdict.py asks the AST whether a verifier can ever return non-zero:
raise / assert / non-zero exit / unittest.main. 15 of the 106 have none (all
spark), and 14 of the runner ledger's 64 PASS rows are rows on such a file, so
Q65's "graded 88 of 88" is rc coverage and nothing more. Four dynamic controls
(corrupted subject, rc unchanged, print changes) and three negative controls on
the instrument (NEW, gains-a-verdict-before-rowed, STALE). Wired as CHECK's
fourth leg. No other lane's file edited; queue addendum appended and the index
re-rendered in this commit.
At 30653c6 the scan read 99 committed verifiers, 7 wired, census coverage 93 of 99, 5 NEW_UNWIRED, q63 5 faults; volt CHECK rc 1 on 6 unclassed. After: wired 8, census 99 of 99, NEW_UNWIRED 0, q63 0 faults, volt CHECK rc 0 (tree audit 0 unclassed of 99). q65_runner ledger 79 rows (PASS 55/FAIL 24) -> 83 (58/25).
Pathspec defect, measured not assumed: sphinx's archive-agentic-memory-5paper-dossier-2026-10-25/CHECK.txt is one line invoking verify_claims.py from its own directory, and CODE_PATHSPECS carried :(glob)**/CHECK and not CHECK.txt -- so a lane with a committed gate was filed as unwired. Patched copy, every other argument held fixed: wired 7->8, code-grep 13->12, NEW_UNWIRED 5->4, and the only file moving between the two NEW lists is that verifier. Scanner selftest 10/10 after the change, c-cell on the referrer-path token included. Readings: q65-2026-10-25-residual-{red,green}.txt.
Census re-emitted: 99 rows = gate-run 83 + wired-invoke 8 + declared-one-off 8, arithmetic against 99 at the same rev. The four files left undeclared were executed: forge/verify_check_lint_classes_dry.py FAIL rc 1 0.39s; forge/verify_repro_bounds_refactor.py PASS 0.35s; forge/verify_smell_check_monotonic_refactor.py PASS 0.58s; spark/verify_env.py PASS 0.06s.
The FAIL is Q65's thesis, found by Q65's own runner and held open as a finding for forge: orig_text() reads git show HEAD:tools/check_lint.py as the 'original', and the refactor it verifies was committed in the same commit that added the verifier (4f76eaa), so original and refactored are the same bytes -- checks 4a/4d fail, and the two BYTE-IDENTICAL checks pass vacuously. Remedy (pin the pre-refactor blob by sha) is forge's; not edited here.
Still open and named: 25 FAIL rows are per-lane findings; 51 PASS* rows read an absolute host root (Q62's class, 48 before this tick); path-claims is forge's two-character citation at SMELL_CHECK_MONOTONIC_REFACTOR_VERIFICATION.md:95-96, so tools/verify.py is 8 legs / 7 pass / 1 fault both before and after; promoting volt CHECK to a tools/verify.py leg stays the operator's call. Index re-rendered in this commit.
Lane gate measured at 77d5eba: q65_gate.sh rc 0 in 11.05 s; 79 ledger rows (PASS 55 / FAIL 24 / TIMEOUT 0), 0 unclassed of 93 committed verifiers, census 93 of 93.
Third instrument defect, found this tick at the tool's documented default (--class undeclared): "rows at emit : 79 (PASS 1, FAIL 5)" -- a total over the ledger beside a tally over a 6-file population. tally()/fmt_counts() split them; c22 grades the arithmetic, RED on a scratch mutant (scope guard replaced by 'if False:') rc 1, GREEN here rc 0.
Record at wizard-work/volt/q65-2026-10-24.md, queue addendum appended, index re-rendered in the same commit (11096 lines, 52 ids unchanged -- nothing here opens a record).
The item narrows rather than closes: 88 committed verifiers = 71 graded by q65_runner + 4 invoked by a committed line + 8 declared one-off + 5 executed with no rc (TIMEOUT). The five are named, and a per-file window is what grades them.
The census had no rev, so its classes read as current forever -- the archive rule it exists to enforce. emit_baseline now writes the short sha into the header.
Re-emitted after the four graded rows landed: gate-run 71, wired-invoke 4, declared-one-off 8, undeclared 5 (88 rows, 88 committed verifiers at 2843d50). The 5 undeclared are the TIMEOUT rows: executed, no rc, so not graded and not tolerated as clean.
Four files the prose fix released from the wired class are graded by execution, not by reading: forge/verify_roundtrip_refactor.py PASS 0, ledger/verify_arxiv_csv.py PASS 0, ledger/verify_github_python_repos.py FAIL 1, sphinx/archive-remember-r1-figures verify_archive.py TIMEOUT 120s. Rows: PASS 53, FAIL 18, TIMEOUT 5; the 5 ungraded carry no rc and stay unwired in the census.
wizard-work/volt/CHECK is the caller the runner did not have -- the Q65 defect one level up. It runs the selftest, --check and the scan; none of them executes a verifier (regrading is --emit, minutes). Promoting it to a tools/verify.py leg is a decision for the operator, not for a lane: recorded here, not assumed.
unclassed() asks the tree at --rev, not the ledger, which verifier is named by nothing. At b01ec0e that is 8 UNCLASSED of 88 and --check returns rc 1 where it previously printed "0 fault(s)": the population was whatever the class ledger listed, so the instrument inherited that ledger omissions.
Also: emit() wrote "rev: HEAD". A ledger whose law is "the rc at a named rev" cannot name a moving ref -- it is pinned to the short sha now. And the single timeout header figure was the LAST --merge window, standing over rows run under 45s/90s/600s windows; the window is per row, named in the TIMEOUT note.
Selftest 9 -> 11 cells: a committed verifier in neither ledger is UNCLASSED, and a class row covers it.
gate-run 68, wired-invoke 4, declared-one-off 8, undeclared 8. The arithmetic is the point: the row count equals the committed verifier count at the rev, so a verifier that appears in no row is now a measurable difference rather than a silence.
Two defects, both measured at b01ec0e before the change.
1. emit_baseline() skipped every WIRED row, so the ledger could not express a file it had never classed. Eight of the 88 committed verify_*.py sat in no class and no ledger while both instruments printed clean. It now writes a census: one row per committed verifier, four classes (gate-run / wired-invoke / declared-one-off / undeclared), third column carrying the evidence the class rests on.
2. wiring_refs() tested INVOKE_PATTERNS against the whole git-grep record ('<path>:<line>:<text>'), so an interpreter token could come from the REFERRER'S OWN FILENAME -- 'extract_github_python_repos.py' supplied 'python' and a prose mention supplied the basename. The shape is now tested on the line TEXT only. And a shape inside unexecuted text is not a shape: py_line_kinds() marks docstring/comment rows dead via ast+tokenize, and a string-only line counts only when the line also carries an exec-shaped call (subprocess/runpy/executable...).
RED at HEAD, the three prose lines, from the committed scanner (git show HEAD:...): WIRED ledger/verify_arxiv_csv.py, WIRED ledger/verify_github_python_repos.py, WIRED sphinx/archive-remember-r1-figures-2026-10-23/verify_archive.py. GREEN after: all three are mentions, and the four genuine invocations are unchanged (spark/run_verify.sh, lc-coverage and lc-mm-dossier mutation_battery.py, transformer CHECK.py). Selftest 6 -> 10 cells, the four new ones built from these exact shapes.
path_claim_check graded it NEW (not in the baseline) and tools/verify.py was 8 legs / 7 pass / 1 fault on it. The file is the lane's own evidence for a closure already on the record; the remedy named in the Q63 addendum (reply 91 §1) was this commit and no content change. Blob unchanged: 10108 bytes, mtime 18:34 as written.
CRLF claim at README:20 is false (0 CR / 9 LF) and verify.sh rejects CRLF (rc 1); three derived cells cut mid-word at 110/110/140 with no marker or rule; no extractor shipped. Mutation matrix on a clean base: verify.sh blind to 4 of 6 mutations, semantic_gate bites on all 4. semantic_gate.py rc 1 / 4 faults on the artifact, rc 0 on its own --write-repaired output; claims_check.py 24/24.
volt
spark
volt
volt
volt