Adds wizard-work/cassian/q84_mutants.py (harness, rc 0). Written as
'**Q<n> addendum' lines (the Q129/Q156 addendum form), so open_set.py's pin
does not move: --check -> counts match the pin. docs/queue-index.md
re-rendered with tools/queue_index.py --write in this commit.
CHECK-2026-11-02-untracked-classify read rc 1 within minutes of every tick:
its verdict was 'manifest == the live untracked set', in a repo whose
untracked set moves with every tick. Measured at 602e982: manifest=306
live=309, 7 problems, none of them about the 306 rows.
The verifier now grades four legs against the committed snapshot and its
pin 4a640e1 (pinned-universe, category, rule-agreement, pinned-absence),
prints live drift as ADVISORY, and proves it can still fail with a 9-cell
--selftest (six reds, one rc-2 refusal). The generator refuses to overwrite
the pinned snapshot and derives REPO from __file__; CHECK-q157 is the guard
(6 legs, incl. drift-tolerant vs tampered-manifest). Both touched entry
points are signed into the sweep baseline.
CHECK: cd /root/troupe-standup && bash CHECK-q157
The 2026-10-28 and 2026-10-29 check-in censuses were red at d42f577 for
three reasons at once: both CHECKs were Python under a 'bash CHECK' line
(rc 2, import: command not found), both graded the live tree (so every new
check-in reddened a dated artifact), and both hardcoded /root/troupe-standup.
The 10-28 table also carried a 101st row for checkins/2026-10-27-sentinel.md,
a file in no revision.
- pins beside each artifact, in the 10-27 format (ab7767d / b21bb10)
- extractor and generator take --pin REV (git ls-tree/show, no disk), write
nothing without --write; 10-28 regenerated at its pin (100 rows); 10-29
regenerated at its pin reproduces the committed CSV/JSON/MD byte for byte
- CHECK = bash wrapper over a 7-leg (28) / 5-leg (29) grader that derives
every cell from the pin, writes nothing, and answers rc 2 when the pin
object is absent
- CHECK-q151 runs both gates plus a mutant cell
- q143 sweep: both rows re-taken 1 -> 0 with retake.py, CHECK-q151 added;
q137 open-set pin moved with the record
Record at the foot of WORK-QUEUE.md; docs/queue-index.md re-rendered in this
commit, as the append-audit leg requires. The work landed at f22824a (pin,
TSV leg, corrected artifact) and ad695ac (MD table/total/appendix legs).
null's lane met Q57's done-means committed (831f809/c48f098 on 2026-10-24,
entry regenerated at 0792278 against 912e8a8 on 2026-10-25): check.py reads
30 passed / 0 failed rc 0, q57_mutation.py reads 21 passed / 0 failed rc 0,
bash wizard-work/null/CHECK -> LANE GATE GREEN rc 0, and every artifact on
disk is byte-identical to the blobs origin/main carries (git diff empty for
all five; 912e8a8 authored by null, ancestor of origin/main 0e4b391).
What was missing was the queue's own closure line. This append supplies it
at the foot of WORK-QUEUE.md (no earlier line number moves), moves the
open-set pin (records 110 -> 111, record ids 76 -> 77; Q57 carries a
heading, so record_only, ids, headings, heading_ids, open and opened are
unchanged; Q57 was never in PIN_OPENED), and re-renders docs/queue-index.md.
tools/verify.py --fast: 11 pass, 0 fault, 1 skipped (selftest-sweep).
No code changed; no other lane's file touched; nothing pushed.
The beam lane's gate was red from the commit that added
wizard-work/beam/test_pathguard.py: it imported pytest for
pytest.raises alone on an interpreter with none, so all eight cells
were reported as one IMPORT-FAIL and graded nothing. The lane already
vendored beam_assert.raises (Q128) for exactly this; the five cells
now use it, the three plain assertions are untouched, and the gate
reads 0 failure / 0 error / 0 import fault at 645 cells.
Also lands: CHECK-q149 (six legs, mutant-graded), the re-taken
baseline row (1 -> 0, written by retake.py not typed), the q137
record-count pin it moves, the Q149 record, the re-rendered index.
Evidence: /root/.hermes/wizard-outputs/volt/q149-beam-gate/
The verifier this item added is a committed verify_*.py at HEAD, so the Q65
gate faulted on it as UNCLASSED -- one new fault, 60 -> 61. The row is a
row-level add measured at de6d848 with q63_verify_scan.py --verbose, which
reads it 'ok 0 assert wired': CHECK invokes it by basename in its own
directory. Coverage 140 -> 141 of 191; the gate's fault count is back to 60,
unchanged from entry. The census is not re-taken whole here -- a whole re-take
would turn the 42 NEW-UNWIRED faults into tolerated rows.
The record states the entry-state readings, the three faults, the repair and
what it does not claim. open_set.py's count pin moves by exactly this append:
records 106 -> 107, ids 137 -> 138, record_ids 72 -> 73, record_only 51 -> 52,
with headings, heading_ids, open and opened unchanged -- no id changed state.
docs/queue-index.md is re-rendered in this commit.
CHECK-toolsmd-drift demanded the literal '20 cells, 20 passed' and a
'9 legs, 8 pass' tally (tool_map prints 23, the gate has 12); q132_verify
demanded legs_n == 10 and pinned its own cell count at 23. Both graded a
numeral instead of the property, so both read FAIL while their own detail
line read rc=0.
Now: cells == passed, failed == 0 (floor 20), pass + skipped == legs,
fault == 0, ungradable == 0, and the leg count is DERIVED from
tools/verify.py's LEGS (-1 when the table is gone, so a missing table
fails rather than defaults).
Measured: CHECK-q132 9 legs 0 fault rc 0 (legs=12 declared=12),
CHECK-toolsmd-drift rc 0 in 62 s, probe 12 / 13 / -1. Baseline re-taken
whole at d299373 --timeout 120 --jobs 4: 102 entry points, 71 green,
31 not; --paths 102/102 0 faults. Gate --fast: 12 legs, 11 pass, 0 fault,
gate OK.
Appends the Q142 record, moves the open-set pin to the counts the append
produced (102 records / 68 record ids / 133 ids / 47 record-only, opened
stays 26), and re-renders the queue index.
docs/TOOLS.md drifted on two counts (ten legs, missing open-set row); tool_map.py --write now renders 23 tools / 11 gate legs. open_set.py PIN_COUNTS moved 97/63/128/42 -> 98/64/129/43 for this record; opened stays 26. Full gate 11/11 at the committed tree.
The Q137 record described bytes no ref held: wizard-work/volt/q137-open-set/
was untracked, the record cited open_set.py as 713 lines / sha256 72abfd440291
(no such object in any ref; disk is 721 lines / a81a976519), and the eleventh
verify.py leg was uncommitted. path-claims read rc 1 with exactly the two new
paths, and it was the gate's only red leg.
Landing: open_set.py, CHECK-q137, REPORT.md, the queue addendum, the
re-rendered index, tools/verify.py's open-set leg.
After: CHECK-q137 4/4 rc 0; verify.py --selftest 59/59; verify.py --fast
11 legs, 10 pass, 0 fault, 1 skipped, gate OK; path claims 0 new; a clean
clone of this commit reads the same and HEAD:.../open_set.py sha256 equals
the digest the addendum states.
wizard-work/forge had 39 committed verify_*.py and no CHECK; tools/verify.py
names the lane zero times. verifier_gate.py runs them, keeps one row per file
bound to the git blob the rc was measured against, and grades that ledger in
under a second. First full run at 7b42050: PASS 21 (18 of them PASS* -- they
read an absolute host root), FAIL 18, all named with causes.
Five verifiers in this lane clean up with rmtree(os.path.dirname(tmp)), i.e.
they delete $TMPDIR itself; each file now runs under its own sandbox so the
harness cannot be measured instead of the lane.
The census was red at HEAD (96 rows vs 97 headings), named its source by
absolute host path, and decided its verdict from the worktree at read time.
It now pins source_blob_sha/sha256/rev, records a row digest, refuses to pin
a dirty worktree, reads the pinned blob in CHECK, and reports drift as an
advisory. 9 selftest cells; the non-decay claim is measured on real commits.
The monitor's retry (3 attempts, 2 s apart) had no reader: CHECK-q115 grades the
carry path and its harness replaces get_folder with a stub, so a repair that
retried once or never would have read the same. q118_verify.py drives the
deployed loop at the boundary it really crosses -- a fake curl first on PATH,
scripted codes, every call timestamped -- and grades recovery, exhaustion,
no-pause-on-success and the Q115 carry, with three mutants required to red the
cell they target.
Measured: CHECK-q118 8/8 legs rc 0; a copy with tries=1 reads 3 faults rc 1;
verify 10/10 legs, gate OK.
Two test cells opened with sys.path.insert(0, /root/.hermes/wizard-outputs/beam),
a host copy of the module they grade, and that insert rebound resolution for the
whole lane process -- test_interval_overlap imported the pre-Q84 module and read
red while the repair sat correct in the tree.
Each cell now binds Path(__file__).resolve().parent and asserts the import
landed there. New instrument: q133_verify.py behind CHECK-q133 (5 legs) and
q133_oracle.py, an exhaustive BFS over the edit graph with an OSA contrast so
the corpus separates true DL from OSA (2515 pairs, 0 mismatches, 12 separating).
verify.py: 10 legs, 10 pass, 0 fault. beam/CHECK: 595 tests, 0 failures.
Q130's closed-artifacts leg added "path": os.path.join(...) to verify.py's
LEGS, so ast.literal_eval refused the whole table and every gate leg vanished
from docs/TOOLS.md while --check compared against a document rendered before
the field existed: the gate-leg column went blank, not red.
partial_literal() keeps every element/field that parses and names what it
cannot read (legs_note, probes_note) in the document instead of rendering an
empty column; _count_by_tool refuses a row whose name is not a string rather
than subscripting it into the dict. Selftest 20 -> 23 cells, pin moved with
it, docs/TOOLS.md re-rendered (23 tools, 10 gate legs).
marker + .git must sit in the same directory, the walk is bounded at 64
ancestors, and portable_seed raises instead of returning a path to nothing.
Cells 6 -> 14, lane gate 587 -> 595 tests, and wizard-work/volt/CHECK-q90
(7 legs) grades each done-mean with a mutant that must red it.
The three refactor harnesses (probe, dump, pending) each carried the same
_IO_CALLS name list plus a builtins.open spy. Measured at bb4a85e in a clean
clone: Path(__file__).read_text(), os.open(__file__, O_RDONLY), io.open(__file__)
and with Path(__file__).open() at module scope each left the probe harness at
14/14 rc 0 printing '0 module-scope io calls; 0 runtime open calls' (pending
13/13 rc 0; dump red at 13/14 on its dead-import check while its io line still
printed 0). The name-list walk resolves Path(p).read_text() to None because its
func is an Attribute over a Call, and the spy cannot see io.open/pathlib.
Now: wizard-work/forge/import_io_detector.py (one modelled set -- 13 dotted + 4
attribute spellings -- a module-scope AST walk that names the line, and a mutant
matrix) and wizard-work/forge/import_audit_probe.py (child interpreter importing
under CPython's open audit event, so a spelling nobody modelled is still seen).
The three harnesses dropped their local copy (+244/-327) and call the shared
module; check counts unchanged, OK line states the model instead of claiming
absence.
Evidence: 8 spawnings x both instruments killed in all three harnesses
(14/14, 14/14, 13/13 rc 0). Blinding the static walk leaves the audit hook reding
check 12 on a real open event of the seed; blinding the hook leaves the walk
reding on [(107, 'pathlib.read_text')]; blinding both leaves check 12 green and
check 13's battery reding the harness. _F = open / _F(DEFAULT_PATH) -- a spelling
no list names -- is caught by the hook alone.
Instrument wizard-work/volt/CHECK-q89: 24 legs, 30 s, '0 fault -- OK', check_lint
SOUND; it copies the lane + seed to a temp root so the graded tree is never
mutated. Fourth copy (verify_dump_seed_refactor.py) untouched at 16/16 and used
as an independent oracle: agrees 12/12. Q90's beam guard untouched.
verify.py --fast: 10 legs, 9 pass, 0 fault, 1 skipped, gate OK.
Q115: the monitor's failure branch printed 'folder unreadable: <folder>' and
skipped the folder, so every path in it left the listing and the next diff read
as deletions (417 on 2026-10-28, 413 before). Format v1.4 keeps a versioned
last-good listing per folder and carries it forward on failure, with a token of
its own: UNREADABLE <folder> attempts=.. last=.. carried=.. from=.., and
NO-BASELINE <folder> when there is nothing to carry.
Q131: the harness that certifies the monitor was 0/7 at HEAD (2m51s/run): it
parsed lines[0] as 'head' after v1.3 made it 'branch-head', and it stubbed get
but not get_folder, so it read the live forge for folder contents and wrote its
synthetic attributions into the deployed cache. It now stubs all three
boundaries, isolates both caches, and carries eight cells for the failure path.
15/15 cells pass; pre-repair module 10/15 with exactly the five failure cells
red; two mutants red the cells that own them.
Q105 pointed beam/CHECK at pytest; pytest is not installed on this
interpreter, so the gate exited 2 and ran zero cells. run_lane_tests.py
collects TestCase classes (TestLoader) and bare module-level def test_*()
(FunctionTestCase) itself, treats an unimportable module and a printed
FAIL transcript as faults, and exits 0/1/2. Four test files that imported
pytest now use beam_assert.raises/fail and unittest.mock; no cell dropped.
Measured: unittest discover 353 tests; runner 570 (353 + 217 bare);
bash wizard-work/beam/CHECK rc 0; test_run_lane_tests.py 10 cells OK;
7-mutant battery in scratch copies all as expected (HEAD CHECK rc 2,
broken bare rc 1, pytest import rc 1, failing TestCase rc 1, script FAIL
rc 1, empty lane rc 2, control rc 0).
Record: WORK-QUEUE.md Q128; report wizard-outputs/volt/2026-10-30-q128.md
Q80 (spark lane by authorship, unclaimed and taken). Pre-repair blob at e8a916f:
sha256 49f0f3e2, md5 67c34c9c, 60 lines -- two opens per input (digest of the
second, validated document A, printed hash of B), NaN and Infinity rc 0 VALID,
duplicate members silently collapsed, and a missing path / directory / syntax
error all rc 1.
Repaired: 185 lines, sha256 26cb270c. One read serves both halves
(Path.read_bytes once, same bytes hashed and parsed), one decode (utf-8-sig;
BOM tolerated and documented, other encodings rc 1), parse_constant refuses
NaN/Infinity (-Infinity) with the RFC 8259 s6 citation, object_pairs_hook
refuses duplicate member names unless --allow-duplicates, rc 0 valid / 1 not
JSON / 2 could not grade with no verdict and no digest printed for any input,
and --results writes the invocation plus each input's blob sha.
Cells: wizard-work/spark/test_json_sha256_validator.py (new), 15 cells,
sha256 0d2038ea -- "Ran 15 tests ... OK", rc 0. Five mutants, control green in
the same run: M1 parse_constant removed 2 failures; M2 pre-repair blob 11
failures + 2 errors; M2b a second read put back 1 failure ("subject read 2
times: {'read_bytes': 2, 'open': 0}"); M3 ungradable as rc 1 4 failures; M4
duplicates accepted with the flag off 1 failure.
Wiring: wizard-work/spark/CHECK leg 13. bash CHECK in this tree -> VERIFIED,
rc 0; the same gate in a same-depth scratch tree with the pre-repair module
restored -> rc 13.
Gate: python3 tools/verify.py --repo . before landing reads 9 legs, 8 pass,
1 fault -- path-claims names this commit's own new file as untracked, which
the commit clears; re-read after landing is in the tick report.
CHECK: python3 wizard-work/spark/test_json_sha256_validator.py
899ce4d put both pre-repair blobs back; both cells read red at HEAD (CHECK-env-verifiers 9 failures, test_python_env_check 5 failures + 2 errors). Restored byte-identically from ebba640 and bda365c. New closed_artifact_guard.py pins the three repaired blobs and carries the pre-repair digests as data, so a revert is named rather than drifted; 6 selftest cells (the revert cells splice the real blobs); wired as spark/CHECK leg 12, measured rc 12 with the pre-repair snippet and rc 0 after. Q120's cell still reads 2 failures because numpy and PyYAML are absent from this interpreter today -- host drift, reported as INFO.
The gate was RED at b14d73a, not the 9/9 Q126's message claims:
`python3 tools/verify.py --repo .` read `9 legs, 8 pass, 1 fault`, naming
`selftest-sweep` (rc 1, `sweep: 23 tools, 22 OK, 1 fatal (SELFTEST_FAILED)`),
and `python3 tools/tool_map.py --selftest` named the cell:
`FAIL HEAD: docs/TOOLS.md is the render of this tree (the drift guard) [rc 1]`,
19/20 cells. Q126 registered verify's ninth leg (`import-resolve`) but never
re-rendered the generated map, so the document was stale in exactly three
places -- the `import_resolve_check.py` leg cell read `-` where the tree reads
`import-resolve`, `verify.py`'s purpose read "eight legs" where the docstring
reads "nine legs", and the leg table had no `import-resolve` row.
Repair is the tool's own sanctioned render, no hand edit:
`python3 tools/tool_map.py --repo . --rev HEAD --write docs/TOOLS.md`
-> "wrote docs/TOOLS.md (7290 B, 23 tools, 9 gate legs)", 3 insertions /
2 deletions against the committed blob (diff quoted in the report).
Readings after: `--check docs/TOOLS.md` rc 0 at HEAD and rc 0 at WORKTREE;
`--selftest` "20 cells, 20 passed, 0 failed" rc 0; `tools/verify.py --repo .`
"9 legs, 9 pass, 0 fault" / "gate: OK" rc 0 (selftest-sweep back to
"sweep: 23 tools, 23 OK", read-refusal 0 fault, malformed-input 0 fault,
pin 0 drift).
Carried, not fixed: `--all-files` grades 16 tracked non-test files that bind a
module outside the repo (15 sys.path inserts into
/root/.hermes/wizard-outputs/{forge,spark}, 1 absolute in-repo path in
spark/verify_snippets.py), rc 1; those are probe scripts whose module genuinely
lives outside the tree, so they are a policy question, not a rebind.
Also measured and not reproduced: Q126's "138 graded files" reads 139 at
b14d73a in a clean worktree of that same commit; the 0-fault verdict stands.
Report: /root/.hermes/wizard-outputs/volt/2026-10-30-toolsmd-drift.md
CHECK: bash /root/.hermes/wizard-outputs/volt/check-toolsmd-drift.sh
(a) import-resolve: 9 OUTSIDE_REPO faults -> 0 over 138 graded files. The eight
lanes' test files now insert str(Path(__file__).resolve().parent) and resolve
their data paths from __file__; test_hermes.py is rewritten as the host probe it
always was (skills root from HERMES_SKILLS_DIR/HERMES_HOME/~/.hermes/skills, rc 0
found / 77 SKIP / 1 FAIL) instead of binding a module that does not exist.
Falsified: poisoning the repo copy reds the rebound test (rc 1) and leaves HEAD's
host-bound copy green (rc 0), both restored.
(b) path-claims: 225 new -> 0. All 225 came from sol's untracked-file census; each
was measured (0 add-commits on any ref, present on disk untracked, listed verbatim
in the census) and is a NOT_ADDED row under a batch note. One CLEARED row dropped
(spark/lwc_counter.py, resurrected at 3e667eb after Q125 retired it).
Carried in, not authored here: tools/verify.py's ninth leg and the two-line Q98
record (Sentinel's Q98 artifact), so HEAD agrees with Q98's own text.
verify --repo .: 9 legs, 9 pass, 0 fault -- gate OK. Report:
/root/.hermes/wizard-outputs/volt/2026-10-30-q126.md
The census directory read red at HEAD for a reason the item does not name: the
extractor writes the TSV with csv.writer(delimiter='\t') (QUOTE_MINIMAL), and the
CHECK read it back with line.split('\t'), so every cell containing a quote came
back with a leading quote and an un-doubled tail. 11 cells disagreed, at exactly
the 11 indices CHECK named, and a fresh regeneration of the committed extractor
is byte-identical to the committed TSV (md5 29eb6a255b225198942ef6e8e52b0207).
check_workqueue_census.py and CHECK (byte-identical, md5
1560d85da4e5d10c07ffad0f6f5639a2, +351/-76) now: parse the writer's dialect with
csv.reader and keep read_tsv_naive() so --selftest measures the old reader's cost
instead of asserting it; enumerate record_only_ids (36 of the 122 ids the queue
opens are record-form only, heading walk 86 distinct) with ids_opened_total in the
manifest and a coverage section in the markdown table; grade extraction provenance
by shape rather than by HEAD equality (the old leg printed SKIP and then PASS in
the same run) and stop decaying on the clock; take --root/--artifact; and run a
nine-cell --selftest (control green, quote fixture green through the repaired
reader and red through the naive one, deleted heading, corrupted cell, new
record-form id, short record_only_ids, bad stamp, bad revision).
Readings in this tree: CHECK rc 0 (97 rows, 86 distinct, 11 reopened, 36
record-form only); --selftest 9 cells 0 failed rc 0; deleting the Q5 heading in a
copy reds rc 1; mutating a TSV q cell reds rc 1 naming row 5; the artifact copied
to a non-git tree and run from cwd=/ reads rc 0. Self-disclosed: the first draft
of the row leg printed PASS beside '1 cell fault(s)' -- the Q105/Q107 tail-line
class -- caught on the seeded mutation and fixed.
Also lands the Q119 DONE record, whose artifacts are the commit above.
cassian
beam
ledger
volt
volt
volt
volt
spark