Repairs wizard-work/beam/test_interval.py to resolve interval_merge.py from
Path(__file__).resolve().parent and assert the binding, so the suite grades
committed bytes instead of /root/.hermes/wizard-outputs/beam.
Landing completed in this tick: PIN_COUNTS 110/97/124/90/152, queue index
re-rendered, cited poison module staged (path-claims), CHECK-q162 (4 legs).
Measured: tools/verify.py --fast -> 12 legs, 11 pass, 0 fault, 1 skipped, rc 0.
wizard-work/ledger/CHECK-2026-11-02-jobs-table landed at 2e57e6b as a Python program with a python3 shebang, so `bash <path>` -- the invocation the q143 sweep, verify.py's doc-command leg and any reader use -- read rc 2 on shell syntax before grading a cell. Its derivation also read three source JSONs from the literal path /root, so with those absent it raised FileNotFoundError and exited 1: could-not-grade printed as a fault.
The grader moved to grade_jobs_table.py; the path keeps a bash wrapper. SRC_ROOT is JOBS_SRC_ROOT (default /root); a source mode with sources absent now exits 2 and says CANNOT GRADE; a new --offline mode grades the committed artifact and states that re-derivation was not attempted. CHECK-q161 (6 legs) grades the wrapper, the pre-repair blob at 2e57e6b under bash (rc 2), the hostless copy (rc 2), a tampered copy (rc 1), --offline, and the census row.
bb8aec7 landed wizard-work/beam/test_tarjan_articulation.py with
sys.path.insert(0, '/root/.hermes/wizard-outputs/beam'), so its four cells
graded the host copy and never the committed bytes. Repo gate at that commit:
import-resolve FAULT, 1 OUTSIDE_REPO finding. Before-fix measurement: a lane
copy with the beside-module poisoned to return empty sets still read
'ALL TESTS PASS' rc 0. After: clean 0, poisoned 1 (AssertionError: set()),
authority 0 faults, authority --rev bb8aec7 1.
Ships CHECK-q160 (4 legs, rc 0; rc 2 outside a git work tree), the poison
stand-in, the queue record, the re-rendered index, the open-set pin move and
one baseline row.
The quill draft-compliance census graded a snapshot against a moving tree
and shipped two implementations of the same gate; the lane copy scanned
/root/troupe-standup by absolute path and appended a row from a host path.
Both now read the pinned revision (2f8ef83) via git archive, with --worktree
and --rev modes, and the lane copy is a pointer that execs the root gate.
Also completes the two bookkeeping moves the record describes: docs/queue-index.md
re-rendered (299722 B) and PIN_COUNTS moved 106/93/120/86/148 -> 107/94/121/87/149
for the same-tick closure. verify.py --fast: 12 legs, 11 pass, 0 fault, 1 skipped.
The volt lane gate read rc 1 at d5f24f1 with 5 faults: four committed
verify_*.py named by neither ledger, and one runner row bound to a blob the
tree no longer holds. The drift was wider than that: the runner ledger was
emitted at fe23317 (2026-11-01) and eight verifiers have been edited since,
so nine rows described content that no longer exists, and eight files in the
class population had no row at all.
Census re-derived by q63_verify_scan.py --repo . --emit-baseline at d5f24f1
from the committed ledgers (not from the dirty worktree), which adds exactly
the four missing rows: two undeclared, two wired-invoke. Runner rows for the
seventeen affected paths re-measured by q65_runner.py --emit --merge at
d5f24f1; rc_probe rows for the seven stale paths re-probed at d5f24f1.
Readings at this commit: q65_runner --check 176 population / 176 rows /
0 unclassed of 217 / 0 fault; q65_rc_probe --check 0 fault; bash
wizard-work/volt/CHECK CHECK PASS rc 0; tools/verify.py --fast 12 legs,
0 fault, rc 0.
sweep.py runs every root CHECK-* under bash and records rc, class and the
process's last line, pinning rev + sha256 of each entry in manifest.json.
report.md is the table; TRIAGE.md groups the 12 reds into four causes.
check-root-sweep.sh grades the record (pin / universe / class contract /
report parity / rows integrity), 5 legs, with sensitivity_probe.py proving
three mutations redden the leg that owns them and the restore is green.
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.
The census CHECK asserted that the committed TSV re-derives from
WORK-QUEUE.md as it stands on disk. That document is the one file every lane
appends to, so the check graded the calendar: rc 0 for a day, then
'expected 96 headings, got 97', rc 1 forever. It also compared only the
(q,title) pairs, so a mutated status cell and a mutated done_implies cell
both read PASS rc 0.
- verify_workqueue_census.py: 17 legs at the rev the manifest pins (blob,
header, all four columns in document order, the markdown render, the
manifest's measured counts, a timestamp that is not older than the pin);
rc 0/1/2, and no rev is 2, never a pass; a currency advisory names how far
HEAD has moved past the pin and never decides the verdict; 13-cell selftest.
- extract_workqueue_census.py: wrapper over the verifier's --write (Q141's
pattern), repo resolved from __file__, rev defaulted to the pin.
- manifest.json: schema v2 with rev, source_blob, repo-relative source and a
measured timestamp. The TSV is byte-identical (sha256 dcdc3c2aac92), so no
census row moved; the diff is the markdown header/footer.
- CHECK-q147: a root entry point grading the repair in four legs.
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.
The five legs live in wizard-work/volt/q-checkparen/verify_fix.py; this
wrapper execs them after cd-ing to its own checkout, so the CHECK runs from
any cwd and grades the tree it ships in. REPORT.md now names it.
`bash CHECK-quill-draft-compliance (the artifact gate).` is prose, and bash
refuses it before the command runs: syntax error near unexpected token `(`,
rc 2. tools/check_lint.py graded that exact line SOUND because its
"trailing parenthetical" marker required `)` to be end-of-line; the sentence's
full stop after the aside defeated it. The marker now allows `[.!?,;:]?`
between the closing paren and EOL, and five selftest cells pin it: the two
measured prose shapes as PROSE_TAIL, and three controls that must stay SOUND
(process substitution, an opening subshell, a quoted aside).
The pin moves 37 -> 42 in tools/selftest_baseline.tsv, in this diff.
Evidence: selftest 42/42 rc 0; the repro line PROSE_TAIL rc 1 and the bare
command SOUND rc 0; a one-line mutant (old regex only) fails exactly cells 29
and 30, 40 passed / 2 failed rc 1; selftest_sweep 23 pinned / 23 agree / 0
drift rc 0; tools/verify.py --fast 12 legs, 11 pass, 0 fault, 1 skipped, rc 0.
Artifact and leg-graded CHECK: wizard-work/volt/q-checkparen/.
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.
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.
A document rendered after the LEGS table broke is accepted as current by
the pre-fix parser with no gate column at all, so mutant-doc-drifts alone
would pass a tree that never had the column. The new leg reads that same
mutant's fresh render and requires rc 0 with a '-' cell, pinning the
failure mode the repair removes.
Measured: q132_verify.py 9 legs, 0 fault, rc 0.
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.
volt
ledger
beam
volt
sol
volt