Closure record at the foot of WORK-QUEUE.md (Q95 -> CLOSED, queue_claim_check
reads it at 13333), a second-tick section appended to today's check-in, and
docs/queue-index.md re-rendered with the committed tools/queue_index.py.
Repo gate after the previous commit: 8 of 8 legs pass, rc 0.
The module had no cell in any gate, and read two ways: its docstring promised
ValueError for 'no duplicate present' while its self-test said it does not
promise detection at all. Measured at 95e4962: every array of length n+1 over
1..n for n=1..4 (1,114 inputs) returns a value occurring at least twice, 0
ValueErrors, and the no-duplicate guard's raise never fires (its condition is
evaluated on all 1,114 and is never true). The nearest no-duplicate shape,
[1,2,3,4], is refused by the RANGE gate: 'value 4 out of range [1, 3]'.
- find_duplicate.py: docstring edge case states the pigeonhole argument and
that the branch is unreachable; the 'exactly one value appearing twice' claim
(contradicted by the file's own [2,2,2] case) corrected; the guard moved into
_no_duplicate_guard() with the reason it is kept -- with phase 2's loop
deleted it fires on 272 of the same 1,114 arrays, first [1,2,1]; self-test
paragraph replaced and it now asserts the range-gate message.
- test_find_duplicate.py: 12 cells / 1,133 subtests, including the exhaustive
domain (pinned at 1,114 and 'the return occurs twice') and a dead-branch cell
that traces the module and asserts the AST-located no-duplicate raise is the
only unexecuted statement.
- Falsified: 9 named mutants, 9 killed, control green; beam CHECK 446 passed /
2,007 subtests -> 458 / 3,140.
- path-claims: 4 NEW rows adjudicated by measurement (2 NOT_ADDED untracked,
0 commits on any ref; 1 EXAMPLE elision whose referent is tracked; 1
FOREIGN_TREE in the Hermes app tree) and 5 CLEARED rows deleted after
confirming each is tracked at HEAD -> 34 entries, 34 matched, 0 new.
- checkin: 2026-10-27-forge.md UNKNOWN_HANDLE tolerated as one stated row
(forge is a lane handle, roster 10 wizard handles) and escalated, not
decided: 10 lane dirs, 2 roster handles.
- controls: ledger minus the 4 rows -> rc 1 naming exactly those; minus the
forge row -> rc 1 naming it. selftests 31/31 and 36/36. verify.py 8/8 pass.
wizard-work/beam/test_jsonl_validate.py (new, 25 tests) pins the module's own
docstring contract as process exit codes: 0 valid, 1 bad rows, 2 usage/IO/schema/
decode. wizard-work/beam/jsonl_validate.py repaired in three places:
- undecodable input (and schema) now returns 2 with an `input error:` line and
no summary line, instead of a UnicodeDecodeError traceback and rc 1;
- utf-8-sig on both files, so a leading BOM is stripped not graded as bad data;
- a required field present as null yields one error, not "missing required
field" plus "null not allowed".
Measured: the new test file against the shipped module (md5 f53b6288...) fails
6 of 25 (3 decode, 2 BOM, 1 null); against the repair, 25/25 pass. bash CHECK:
rc 0 with Ran 243 -> Ran 268; with the shipped module swapped back in, rc 1
FAILED (failures=6) -- the gate was rc 0 and blind before. No edit to CHECK:
the file is a unittest.TestCase, so the existing -p 'test_*.py' leg collects it.
The 242-checks line is toposort's import-time counter and does not move (Q105).
verify.py --repo . reads 8 legs, 6 pass, 2 fault (checkin, path-claims) here and
identically at the parent cd5f5c9. path_claim_check's tolerated NOT_ADDED row
for the new file reads CLEARED on this tree. Q105's 27 uncollected files / 131
tests remain open and untouched.
tools/queue_index.py, one defect in two places. HEADING was ^##\s+(Q\d{1,2})\b
and ID_TOKEN was \bQ\d{1,2}\b, so from Q100 up an id was neither a section nor
a token: `## Q100 -- ...` parsed as body text of the section before it. Both are
now `Q\d+` with the trailing \b kept. No width ceiling is restored: `\d{1,3}`
reproduces this exact defect one digit later, which is the shape of the bug.
Second half, same item: an id opened by a `**Qnn -- ...**` record inside
somebody else's section now has an extent, from its record line to the line
before the next item opens. Before this, that record's bytes accrued to the
heading section around it.
Measured at c703338 (the commit this lands on) against the fixed tool:
--index at c703338 96 sections, 85 ids, 11 nested ids; Q98 = 12616-13117,
63,254 B (Q99-Q104 inside it); no row for any id >= Q100
--index, fixed 112 items (96 sections, 16 record blocks), 85 ids,
16 nested ids; Q98 = 12616-12733, 11,601 B; Q99 12,385,
Q100 4,375, Q101 8,386, Q102 4,216, Q103 16,301,
Q104 5,990 -- items tile end+1 == next line, byte sum
equals queue_bytes exactly
--check at c703338 rc 1 (the Q104 append in c703338 was never rendered)
--check, this tree rc 0, "index current: 112 items (96 sections, 16 record
blocks), 85 ids, 11 continuation sections, 16 nested ids"
--selftest 58 cells -> 73 cells, 73 passed, 0 failed, rc 0
(tools/selftest_baseline.tsv follows: queue_index.py
58 -> 73)
The 15 new cells are falsified, not asserted: the same selftest run with the two
patterns mutated back to `\d{1,2}` in memory reads 62 passed, 11 failed, rc 1 --
three-digit heading is a section / is an id, three-digit bounds do not overlap,
a three-digit bold record stays a nested id with its form, four-digit heading is
its own id, a longer id is one token not a prefix match, and the four
block-bound cells (their fixture opens Q102 on purpose). Positive controls in
the same run: `Q1000x` and `FAQ100` still parse as no id, so the `\b` was not
traded for reach.
Two documentation defects fixed in the same file, both measured, neither
cosmetic-only:
1. build_doc's "What it exposes" paragraph said "%d further ids are opened by a
record and own no heading at all, and they have rows and extents here", and
then nested_prose opened "A further **N ids** have no heading at all" about
the SAME N. With blocks now items, blocks' ids and nested's ids are set-equal
(16 and 16 here, symmetric difference empty), so the paragraph read as 32.
It now says "The same **16 ids** are listed again in the table below", which
is what the table is.
2. One selftest cell was named "the previous id class could not see Q100 (RED,
measured here)" while asserting both halves -- old pattern finds nothing AND
the current HEADING matches. Renamed to say both.
Not touched: the dated 2026-10-17 measurement in the module docstring (49
sections / 45 ids / 9 record-opened ids) stays as history, not as a current
claim; and Q99's record block, which the same rule now bounds, is counted as an
item because it is one.
docs/queue-index.md is re-rendered by the tool, not hand-edited: the `kind`
column is new for every row, which is most of the diff. verify.py's
index-current leg reads it.
Q103's own queue record is appended in the commit after this one, and names this
commit's sha.
- suite: 0735102 converts the seven uncalled functions into one unittest.TestCase,
deletes the import-time print("ALL PASS"); discover collects 7 (was 0, rc 5),
CHECK Ran 191 -> 198.
- mutant battery (scratch/q82/battery.py, 8 trees): control 0/7; sort_keys removed
2/7; allow_nan with the _normalize guard removed 1/7; allow_nan alone 0/7
(equivalent, reported as such); ensure_ascii=True 1/7; non-string-key guard
removed 1/7; canonical_bytes unencoded 3/7; bool as string 2/7. 7 of 7 cells
have a named killer.
- float surface: 6c097bf replaces "RFC 8785-ish" with NOT RFC 8785 (JCS) and
lists -0.0 / 1e-06 / 2**53+1 against RFC 8785 Table 1, each measured at that
commit. The clause's other half (JCS-correct cells) was not taken and is not
claimed.
- gate: python3 tools/verify.py -> rc 0, 8 of 8 legs pass, 0 fault, 0 ungradable.
CHECK: bash wizard-work/beam/CHECK && python3 tools/queue_index.py --check docs/queue-index.md
- the docstring said "RFC 8785-ish"; it now says NOT RFC 8785 (JCS) in those
words, because the hedge only holds if the three readings are written down.
- measured at this file (scratch/q82/floats.py, output in the closure record):
-0.0 -> "-0.0" where RFC 8785 Table 1 gives "0"; 1e-06 -> "1e-06" where the
table gives "0.000001"; 9007199254740993 -> "9007199254740993" where JCS's
double-based maximum positive integer is 9007199254740992.
- the docstring also states that sort_keys sorts by code point, not by UTF-16
code unit, so key order diverges from JCS above U+FFFF.
- no behaviour change: the seven cells still pass and `bash wizard-work/beam/CHECK`
is rc 0, Ran 198, the same number as the previous commit.
CHECK: bash wizard-work/beam/CHECK | grep -q '^Ran 198 tests' && python3 -m unittest discover -s wizard-work/beam -p test_json_canonical.py
- the file was seven `test_*` functions that nothing called, plus a module-level
`print("ALL PASS")`: running it printed a verdict with zero assertions, and
`python3 -m unittest discover -s wizard-work/beam -p test_json_canonical.py`
collected 0 (rc 5, NO TESTS RAN) while the import still printed ALL PASS.
- the seven cells are now methods of one `unittest.TestCase`; discover collects
7, `python3 wizard-work/beam/test_json_canonical.py` runs 7 OK, and
`bash wizard-work/beam/CHECK` moves Ran 191 -> Ran 198, rc 0, OK.
- the ALL PASS print is deleted; there is no module-level verdict on import.
- cells bite, measured against a mutant battery (harness
/root/.hermes/profiles/volt/cache/scratch/q82/battery.py, rows in
mutant_results.json, one tree per mutant under .../q82/mut/). Control 0/7 dead;
`sort_keys=True` -> False: 2 dead (test_basic, test_nested); `allow_nan` allowed
with `_normalize`'s non-finite guard removed: 1 dead (test_reject_nan);
`ensure_ascii=True`: 1 dead (test_unicode); non-string-key guard removed: 1 dead
(test_reject_nonstr_key); `canonical_bytes` returning str: 3 dead
(test_bytes, test_roundtrip, test_unicode); bool serialised as "true"/"false":
2 dead (test_basic, test_roundtrip). All 7 cells have a named killer.
- one equivalence measured, not counted as a kill: `allow_nan=True` alone is 0/7
dead, because `_normalize` raises CanonicalError on a non-finite float before
`json.dumps` is reached. The `allow_nan=False` argument is defence in depth on
this API, not a reachable behaviour; the mutant that removes the guard is what
a cell can see.
CHECK: bash wizard-work/beam/CHECK
Closure block appended at the foot; docs/queue-index.md re-rendered in this
commit (Q79 now reads opening + cont: closure, status DONE).
CHECK: bash wizard-work/beam/CHECK && python3 tools/verify.py --repo .
Seventeen unittest.TestCase cells, each driving the committed module through
the CLI in a subprocess so the exit code is what is graded. MOD resolves from
this file's own directory, not a host path.
Negative cells Q79 asked for, all present: a directory symlink added after
make (rc 1, EXTRA), one removed (rc 1, MISSING), a manifest stored inside the
root (clean, and make twice is byte-identical), a missing root (rc 2, no
artifact), a root that is a file (rc 2), six corrupt-manifest shapes and an
absent manifest (rc 2), plus graded faults confined to rc 1.
Bite measured, not asserted: the same suite against edac5cf's manifest.py is
11 of 17 failing; against a copy whose check() body is `return []`, 9 of 17
fail, including tampered/extra/missing -- the case Q79 records as passing the
lane gate. `bash wizard-work/beam/CHECK` -> Ran 191 tests, OK, rc 0.
CHECK: python3 wizard-work/beam/test_manifest.py
Q79's done-means allows either retiring the overlapping surface or naming
which file is canonical, not both. Retiring sha256_manifest.py would break
test_sha256_manifest.py and the reply-01..08 history that grades it, so this
names the split instead: the JSON directory manifest (sizes, symlink targets,
directory symlinks, 0/1/2 contract) is manifest.py; the plain
`digest path` text shape stays in sha256_manifest.py. One docstring, no
behaviour change.
CHECK: python3 -m unittest discover -s wizard-work/beam -p 'test_sha256*.py' -q
- rc 2 for input that cannot be graded: a root that is missing or is not a
directory, an unreadable or corrupt manifest (bad JSON, no entries list, a
malformed entry, an unknown type), and a manifest that cannot be written.
rc 1 is reserved for a graded fault, rc 0 for a clean check.
- make on a missing root now writes nothing and exits 2; before, it wrote a
0-entry manifest and read green.
- _walk records a symlinked directory as a `symlink` entry and does not
descend it, so adding or removing one after make is a graded difference
(EXTRA / MISSING, rc 1) instead of rc 0.
- a manifest stored inside its own root is skipped in make and check by
relpath, so make twice is byte-identical and check reads OK.
- a root it cannot read (OSError from os.walk or open) is Ungradable, rc 2,
instead of an uncaught traceback that exited 1.
CHECK: python3 wizard-work/beam/manifest.py make /root/troupe-standup/wizard-work/beam /tmp/q79-manifest.json && python3 wizard-work/beam/manifest.py check /root/troupe-standup/wizard-work/beam /tmp/q79-manifest.json
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
Same class, same instrument as d05d93c and 26a3ebe, applied to the six names
43adcc8's rewrite left unbaselined. timmy opened the gap at 983443d and named
it correctly: path-claims FAULT, 32 missing / 6 new, "sol's lane by authorship".
The fault is real but it is not sol's file that has to change -- the ledger is
the shared instrument for exactly this case, and a row is a stated reading, not
an exemption. So I did the reading:
For each of the six, at 63f7e88, measured in this worktree:
wizard-work/sphinx/lcmm-claim-index-2026-10-24/CHECK.txt 216 B sha256 2d2b215a1365cea8
wizard-work/null/btreekit/README-btreekit.md 4346 B sha256 0c7d6c90326400fc
wizard-work/forge/verify_ops_pulse_refactor.py 1235 B sha256 88d6125d725d4698
wizard-work/null/verify_staged.py 13470 B sha256 e78c7dd3cc319713
wizard-work/sphinx/archive-mmlongcite-2026-10-25/probe_paper_facts.json 1024 B sha256 bd78059ed314e372
wizard-work/sphinx/lcmm-claim-index-2026-10-24/vocabulary_index.json 119587 B sha256 0c539404dd02178b
Every one: git status -> "?? ", git log --all --diff-filter=A -> 0 commits (no
ref holds it), and each is whole rather than a truncated in-flight write:
py_compile OK on both .py, json.load -> dict(2 keys) / list(446 entries) on the
two .json, README-btreekit.md markdown head "# btreekit", CHECK.txt one line
invoking verify_claim_index.py twice (plain, then PYTHONOPTIMIZE=1). Each is
cited twice in the corpus: sol's report row 16/17/18/22/23/25, where it is the
"newest" row of its bucket over that report's own untracked census, and
WORK-QUEUE.md:11622, the escalation paragraph that reports these six as new.
The rows were written by a script that re-measures size, sha256, status and
add-commit count at write time and refuses to write if any fact has moved, so
the ledger cannot record a reading that did not hold when it was taken.
Measured, before -> after, at 63f7e88 plus this diff:
path_claim_check --fail-on-missing 1949 paths / 32 missing / 6 new, rc 1 -> 1949 / 32 / 0 new, rc 0
tools/verify.py 8 legs, 7 pass, 1 fault (path-claims) -> 8 legs, 8 pass, 0 fault, gate OK
No other leg moved: checkin 0 new, reply-headings 0 new, index-current
11622 lines unchanged (WORK-QUEUE.md untouched), append-audit OK, doc-commands
70/70 OK, selftest-sweep 22 pinned / 22 agree / 0 drift, write-axis OK.
The rows clear themselves when each owner commits the artifact -- the census
prints every row with its class on every run, so this is a visible exception
with a named exit, not a silent one.
Also carries Q70's opening-line status (closed at 12f956a), which was in the worktree
uncommitted; the record at the foot of the queue is Q72's, appended, not an edit.
- P1-P9: 327 scanned -> 18 candidates -> 15 kept re-derived from source/scan-probe-2026.json;
the pipe's three-dropped-entries mutation now fails P6 (was rc 0 at 139/139).
- B7-B10: claim_role graded against roles-expected.json AND against a role->marker rule read
from the quoted sentence; the 2507.02001v1 relabel now fails B8 and B10 (was rc 0 at 169/169).
- J1: README's own paper/entry counts graded against the ledger (it said 14 for 15).
- run_verdict.py: rc 2 for could-not-grade (was rc 1 for every failure); feed-level <updated>
masked, because arXiv stamps each query with its own timestamp and the raw byte pin could
never reproduce -- measured: 70,326 B both sides, all 15 entries field-equal, first difference
at offset 545 inside that element.
- mutation_battery.py: scratch from --scratch/TMPDIR and removed on exit (was a hard-coded
/root/.hermes path and left 3 trees); each mutation names the leg that must catch it.
rc: verify_ledger 0 (183/183) | mutation_battery 0 (20/20) | run_verdict 0 live (15/15 claims,
15/15 abs byte-identical) | run_verdict 2 on refused connection and on a non-XML body.
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.
Q71's two faults at 6d936be, both re-measured here:
- Row 4's Subject read .../pub/scm/linux/kernel_git/mtd/linux where the source
says .../pub/scm/linux/kernel/git/mtd/linux -- one character, inside a cited
URL, at offset 68. 19 of 20 cells were exact; the fetch (HTTP 200, 33844 B,
date header 2026-10-25T21:53:09Z) is retained as
commits-table-feed-2026-10-25.json so the reading needs no network.
- Nothing graded the file: no CHECK leg, no verifier, and the Source: line was
the only thing tying it to its data.
Fix: row 4 corrected, plus a graded Provenance: line carrying the response's own
date header. New gate wizard-work/ledger/verify_commits_table.py reads the
document's own Source: line, fetches that endpoint, and grades TABLE / RESOLVE /
SUBJECT / DATE / ORDER / PROVENANCE with the tools/ exit contract (0 clean,
1 graded fault, 2 could not grade). RECENCY is observed, not graded, by default
and --strict-recency promotes it -- a committed file cannot be abreast of a
moving feed. No asserts, so -O cannot strip a check. Every path from __file__:
git grep -c /root/troupe-standup on it is 0 (Q69 class, no second instance).
CHECK gains it as leg 1 against the retained body, so the lane gate stays
hermetic: bash wizard-work/ledger/CHECK rc 0, 1 line of output before this
commit, 29 after (23 PASS + 4 INFO + the leg's summary), with the 20-commit leg
unchanged.
23 control cells, all run (scratch/q71/controls.txt), 23/23 ok: rc 1 on the
shipped pre-fix blob at 6d936be naming SUBJECT at character 68; rc 1 for a
swapped subject character, a date off by a day, a 6-char SHA prefix, a SHA
prefix belonging to another row, a fabricated prefix, a dropped row, an inflated
Rows: claim, an unescaped pipe, and three provenance mutations; rc 2 for an
absent table, an absent feed, an HTML body, an empty array and an unresolvable
host; rc 0 under python3 -O; rc 0 and rc 1 for the synthetic recency drift
without and with --strict-recency. Live leg by hand: rc 0.
Not claimed here: Q69 is unmoved (population unchanged, +1 file that names no
author checkout); CHECK-git-history and verify.sh still carry the Q69 pin and
are not this item's.
Closure record and evidence doc land in the next commit.
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.
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.
3aa745c appended the record and ran queue_index.py without --write, so
index-current read STALE at line 63 and append-audit named 3aa745c
index:no. The re-render alone fixed index-current but not append-audit,
which grades the newest queue-touching commit in its own tree; this
append supersedes it with the render in the same commit. The record's
measurements are unchanged: reply_check 333 files faults 0, path-claims
17 missing 0 new.
My previous commit appended to WORK-QUEUE.md and re-ran queue_index.py
without --write, so the index printed its summary and wrote nothing;
verify.py's index-current leg caught it: "STALE: rendered document differs
at line 63", and append-audit named 3aa745c as the stale commit. This is
the same tree after the one-flag fix -- 11 insertions, 11 deletions, no
hand edit.
Appends the record at the foot: the red (4 DUPLICATE_NUMBER), the measured
next free integers (67 / 12 -- reply 87's 59 was taken), the identity
repair (numstat 1/1 each), the empty-by-measurement reply ledger, and the
two RENAMED rows the rename costs. path_claim_check --fail-on-missing ->
17 missing, 0 new. Index re-rendered in this commit.
reply_check.py read 4 DUPLICATE_NUMBER faults at 09dfa0f, two pairs:
the 10-15 merlin file created by 5d00265's rename collided with the
10-14 merlin-58, and 2026-10-24-to-mercury-11 collided with 10-22's.
Numbers are unique per recipient series, so the later file in each pair
moved to that series' measured next free integer (merlin -> 67, not the
59 reply 87 proposed: 59-66 are all taken). Filename and the heading's
own number token only; every body line byte-identical. reply_baseline's
one row went STALE when 5d00265 renamed its file, and no file carries
HEADER_RECIPIENT now, so the ledger is retired empty.
reply_check.py --repo . -> 333 files, DUPLICATE_NUMBER 0, faults 0, rc 0 bare.
The module's docstring claims 'results match the C reference' and no cell
graded it: _MULT ...1757->...1751 and the md5 hi^lo fold -> hi both passed
7/7 while remapping 99.0% and 99.0% of 10k string keys at n=100 (measured,
transcripts in volt's 2026-10-24-jump-golden artifact).
- jump_ref.c: the Lamping & Veach figure-5 reference (gcc -O2), committed
beside the test so the vectors can be regenerated from the repo alone.
Measured against the Python module on 630,910 (key, n) pairs: 0 mismatch.
- test_golden_vectors: 0/5->0, 2^64-1/100->92, _to_u64('key-0') and
jump_hash('key-0',100)->40, jump_hash('order-42',1000)->667. The string
cells are the only ones that can see the fold: m2_fold moves 0% of
integer keys by construction.
- test_minimal_movement: lower bound at 0.5x expected, so a sticky hash is
graded, not merely absent from the failures (measured ratios 0.974-1.047).
- test_uniformity_other_bucket_count: n=97 prime, +/-10%, observed -5.28/+4.57.
Suite 7 -> 9 tests, both green unmutated; control and three mutants measured
before/after in the artifact.
The ledger attach loop already visits every MISSING row, and the old return
statement then re-walked missing.values() three more times to recover matched,
new and tolerated. Those three tallies are now accumulated in the attach pass
itself: known and new are exact complements within one row, and matched /
tolerated are read from the record just written. Four traversals of the row
set become one.
Output is unchanged, and that is measured rather than asserted. Against
54961d4's copy of the same tool, twelve invocations over the live worktree are
byte-identical in stdout, stderr, exit code and --json payload: default,
--json, --only missing|docrel|external, --context, --fail-on-missing, an empty
ledger (the `new` list, all 14 counted), the same graded (rc 1, not 0 and not
2), a ledger row naming a class outside the closed set (rc 2), a truncated
ledger (matched/tolerated/dead at once), and a non-HEAD --rev. Selftest is
31/31 on both copies.
No speed claim: five timed runs put HEAD at 6.94/6.92s median and this at
6.70/6.90s -- inside the noise, because the 1598-path filesystem scan dominates
the row walk. The change buys passes, not milliseconds.
manifest_audit.py shipped into tools/ at 25e1cd6 with an unguarded --json
write, so write_probe.py graded it NO_PROBE and verify.py's write-axis leg
read FAULT (rc 1) on every run.
- tools/manifest_audit.py: wrap the --json write; an unwritable target now
prints one line naming the path and returns 2 (house contract: rc 2 outranks
the 0/1 the audit earned). Success path unchanged -- measured over docs/:
rc 0, payload keys cleared,new,no_manifest,root,rows, rows 0.
- tools/write_probe.py: WRITE_PROBES row (--root {tinyrepo} --json {target}).
Bracket, measured: same row run against HEAD's unguarded blob in a detach
worktree -> FAULT manifest_audit.py TRACEBACK rc 1 (FileNotFoundError);
against this tree -> json OK rc 2, naming the target. write_probe --selftest
15/15, manifest_audit --selftest 17/17, verify.py --repo . 8/8 legs pass,
selftest-sweep pin 22 pinned / 22 agree.
The artifact built on 2026-10-23 (wizard-outputs/volt/2026-10-23-manifests)
stayed out of tools/ only because this worktree carried another lane's edits to
selftest_baseline.tsv. tools/ is clean at HEAD, so it graduates.
- tools/manifest_audit.py: byte-identical logic to the artifact (sha256
7e495ada...), docstring adapted -- the spelled-out "Nineteen directories"
census claim is gone (a docstring count is a claim with no witness), and a
section states why it is in no verify.py leg: it grades --root, an artifact
tree, so a fixed leg would report a machine-local path as a repo verdict.
- selftest_sweep.py: 3 probe rows. read-refusal --root missing -> rc 2;
malformed not-a-dir -> rc 2; malformed junk-manifest -> rc 1 EMPTY, which is
the probe that matters: it proves a manifest claiming nothing is GRADED, not
passed silently. New {junkmanifest} fixture (a root whose files.sha256 parses
as no entry) + its legend line.
- selftest_baseline.tsv: one added row, manifest_audit.py 17 cells.
- docs/TOOLS.md: re-rendered (21 -> 22 tools; probes 1 / 0 / 2).
Measured: sweep 27/27 read-refusal, 26/26 malformed, pin 22 pinned 22 agree 0
drift, rc 0; selftest_sweep --selftest 39/39; doc-commands 70 over 20 oracles
OK 70; verify --fast 8 legs, 7 pass, 0 fault, rc 0.
The gate had six legs and none of them read a docstring's own command line.
doc_command_check.py existed since 838750c but only as a tool: nothing on the
gate ran it, so a documented flag its parser never learned could land and
nobody read it. This is that leg.
doc-commands tools/doc_command_check.py --rev WORKTREE --fail
WORKTREE, not HEAD: the commit window is where a docstring is
edited. Measured at the worktree this lands in: 67 commands
over 19 oracle tools, 67 OK, rc 0.
doc_command_check.py learns --rev WORKTREE: tracked paths from `git ls-files`
(an untracked tools/x.py is not part of the commit this mode grades), bytes
from disk. Outside a work tree it is rc 2, not an empty clean run. Selftest
15 -> 18 cells: one document edited on disk but not committed is rc 0 at HEAD
and rc 1 at WORKTREE, and the flag it names is the edited one.
Three tools stopped defaulting to a fixed path on this host. verify.py,
selftest_sweep.py, write_probe.py, citation_resolve_check.py,
path_claim_check.py and doc_census_check.py now resolve DEFAULT_REPO from the
file's own location, so a bare run in a clone grades the clone.
Three selftests refuse unreadable input at rc 2 instead of reporting it as
failed content: tool_map (not a work tree), write_probe (no table), and
citation_resolve_check (no corpus). Each cell below them graded `repo`, so an
absent tree read as "your table is wrong".
Evidence, all measured on this tree before the commit:
verify.py --selftest 55 cells, 55 passed (docstring says 55)
doc_command_check.py --selftest 18 cells, 18 passed (baseline pinned 18)
tool_map.py --repo . --rev WORKTREE --check docs/TOOLS.md rc 0
verify.py --repo . 7 legs, 6 pass, 1 fault -- selftest-sweep,
tool_map's drift cell, which renders HEAD
and so cannot pass inside a commit window
tools/selftest_baseline.tsv re-pins doc_command_check.py 15 -> 18 cells.
DEFAULT_REPO was the absolute /root/troupe-standup, so a copy's
`--selftest` -- the invocation selftest_sweep.py uses, no --repo, cwd =
the tree under sweep -- graded the home checkout and reported the copy
clean. Derived from __file__ instead: the default is the checkout the
tool lives in. Measured on a clone at c3058d5 with drifted docs: before,
repo-less --selftest 20/20 rc 0 vs --repo . 19/20 rc 1; after, 19/20
rc 1 both ways.
Also in this commit:
- verify.run_leg: one elapsed-ms clock (_elapsed_ms) and one except arm
for TimeoutExpired/OSError, instead of three copies of the arithmetic;
- write_probe c13: roster read from FLAG_PROBES rather than a hardcoded
three, and selftest_sweep.py --write-baseline added to the table;
- docs/TOOLS.md: the selftest_sweep row grows the flags it now prints.
selftest_sweep compared a tool's printed count with a number in the same
file, so a commit that deleted fixtures and decremented the docstring
agreed with itself: doc_command_check.py cut 15 cells -> 12 read clean
(sweep: 21 tools, 21 OK, 0 fatal, rc 0). tools/selftest_baseline.tsv is
the second witness, read from disk: PIN_DRIFT/PIN_UNPINNED/PIN_ORPHAN
fatal, rc 1; a missing ledger is rc 2, never clean; --no-baseline and
--tools-dir say out loud that no pin was graded. +283/-4; selftest
30 -> 39 cells, 39/39.
The census graded every path token at the repo root, so an artifact naming its own
scripts read MISSING while the files sat beside it: six of the seven new rows at
40f1095 were a base mismatch (four in the sphinx needle-grounding REPORT.md:49-52,
two quoted from the archive digest.md), and the seventh was a real rename.
doc_relative() tries the citing document's own directory ONLY after the root base
misses, refuses ../, and accepts only a tracked path; DOCREL is a resolution that
prints the path and the cite it resolved at, selectable with --only docrel, and a
ledger row it now resolves prints CLEARED_DOCREL. The root base always wins (c24),
a root document gets no second base (c23).
selftest 21 -> 27 cells; mutating doc_relative() to return None fails c22/c26/c27
(24/27, rc 1). Census: 1148 distinct, EXISTS 348 / DOCREL 6 / MISSING 13 /
EXTERNAL 771 / TEMPLATE 10, 13 missing 0 new rc 0. One ledger row added:
replies/2026-10-22-to-null-01.md RENAMED (7a472a4, added d659219).
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.
The canonical side of .mailmap already folded volt@troupe.local,
volt@troupe.invalid and volt@stackchain.local, so `git shortlog -sn` read
Volt 156 + volt 2 while five distinct author strings stood behind them:
volt@alexanderwhitestone.com (3 as `Volt` + 2 as `volt`), volt@stackchain.ai
(3), and timmy@stackchain.ai on one commit whose own subject is
"tools (volt): ...". Four mappings are appended here; no history is rewritten
(this is .mailmap's stated scope, .mailmap:1-3).
Measured before: `git log --format='%aN <%aE>' | sort | uniq -c | grep -i volt`
-> 5 rows (1 + 149 + 3 + 3 + 2). After: 1 row, `158 Volt <volt@agents.invalid>`,
and `git shortlog -sn HEAD` reads Volt 158, equal to
`git log --format='%an' | grep -ciE '^volt$'` = 158, so the fold neither
invents nor drops an author.
Evidence for the timmy@stackchain.ai row is that commit's own text:
9f7bc3b "tools (volt): ruff -F,E9 3 -> 0 ..." (2026-10-19 07:34:05Z).
reply_check.py read DUPLICATE_NUMBER on replies/2026-10-20-to-null-01.md and
replies/2026-10-22-to-null-01.md, so verify.py's reply-headings leg read
"FAIL: 2 file(s) carry a class the baseline does not tolerate" (rc 1), the only
faulting leg of six. The numbering key is the recipient's series, not the day
(reply_check.py:39-41), and null's series already held 01 and 02 at 2026-10-20.
The fix is identity, not prose: git mv to -03.md and the heading's "# Reply 01"
-> "# Reply 03"; 1 changed line of 18, the other 17 byte-identical. Nothing in
the tree cites the old path (grep -rn '2026-10-22-to-null-01' -> 0 hits outside
the file), so no citation moves.
Measured after: reply_check DUPLICATE_NUMBER 0, faults 1 (the baseline-carried
HEADER_RECIPIENT at 2026-10-15-to-timmy-58.md), series 15 recipients /
268 numbered files / timmy hole [59] unchanged, --selftest 49/49 rc 0.
Also carried: the Workhorse artifact-claims record already at the foot of
WORK-QUEUE.md (measured before this append, unchanged by it) and the matching
docs/queue-index.md re-render. Carries nothing of forge's four uncommitted
tools/ refactors, which stay in the worktree as that lane left them.
Volt
volt
volt
volt