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.
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
(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 old check imported json, subprocess and datetime -- all stdlib -- so
its failure condition was unreachable, and its version-reporting helper
check_package was defined and never called. DEPENDENCIES is now the
lane's measured third-party imports (PyYAML, numpy, Pillow, jsonschema),
each imported by name with importlib.metadata version; missing -> rc 1,
broken -> rc 1, usage error -> rc 2. email_validator is not declared:
spark's own email_validator.py is a local stdlib-only module.
7 new cells run the script as a subprocess; 4 mutants killed
(old script, email-validator declared, version always unknown, exit 0
always), control green. Queue Q120 closed with the record appended and
docs/queue-index.md re-rendered in the same commit.
A scan of wizard-work/spark for every remaining reference to the 25 paths
retired in a979e63 turns up six files, and each exists only to exercise or
describe one of them. They are retired here rather than repointed, because a
repointed cell would be a new test of the survivor wearing an old tool's name:
check.py imported count_words from word_counter.py through a
sys.path.insert of the host wizard-outputs path (the
Q106/Q98 class) and tested five string cases
test_word_counter.py the same five cases against word_counter.py
test_wordcount.py ran wordcount.py and compared to `wc -w`
verify_snippets.py the lane's "snippet verification", whose one check was
word_counter.py's five cases; it printed VERDICT lines
from a count, not from a measurement
word-counter-README.md documented word-counter.py's interface and a
7-word example, i.e. prose for a file that is gone
scratch_word_counter.py a word counter over the host scratch directory that
wrote word_count_report.json to a fixed host path
What replaces them: wizard-work/spark/test_line_counter.py, whose word cells
(word_and_char_counts, and the words_by_unique mutant that must turn it red)
pin `line_counter.py --words` on a fixture that is in the tree. check.py's and
test_word_counter.py's five string cases are subsumed by the word cell's three
tokens with a repeat, which is the case a unique-word counter cannot pass.
Not retired, and deliberately: word_count_report.json and the fixtures
test_words.txt / test-input.txt / test-empty.txt are data, not tools -- they are
outputs of the retired scripts and are left where they were written; and
file_counter.py, file-counter.py, count_functions.py, json_key_counter.py,
count_verified_skills.py, verify_count.py, passwd_lines.py and generate_stats.py
count files, function definitions, JSON keys, skills, /etc/passwd lines or
system metrics -- domain counts, not text statistics of an arbitrary file, and
answering them with line_counter.py would be a different tool. The boundary is
stated in the Q125 record.
Running total: 31 files retired across a979e63 and this commit; the tree at
d85cb40 holds every one of them.
line_counter.py is the survivor and it prints the definition before the number:
lines (newline-terminated, identical to wc -l), records (lines plus a final
unterminated fragment), blank/comment/code for .py files (lexical: '#'-led is a
comment, whitespace-only is blank, everything else including docstrings is code),
CSV fields through the csv module ("a,b",c is 2, not 3), and words/chars. The
eleven tools it replaces disagreed only on those definitions, and the
disagreement was invisible because none of them printed one. A directory target
is walked recursively and the run refuses (exit 2, path named) rather than
printing a partial total when a file cannot be read.
Retired, and where each behaviour went:
count_python.py file/line walk -> `line_counter.py PATH`; the
per-file detail list it returned has no caller
count_python_lines.py code/comment/blank breakdown -> PATH report
py_loc.py same breakdown, same key names
loc_counter.py same breakdown; its argparse surface goes with it
linecount_pycount.py totals -> lines/records keys, its code count -> `code`
code_stats.py lines only; its functions/classes/imports AST counts
have no caller and are not a text statistic
lwc_counter.py -> `--words` (lines, words, chars)
text_stats.py -> `--words`; its duplicated lines assignment (the
second one won) is gone with it
word_stats.py -> `--words`; unique/top-5 tables have no caller
file_stats.py -> `--words`
file_analyzer.py -> `--words`; its size_bytes is `wc -c`
quick_stats.py -> `--words`; bytes is `wc -c`; unique/top-5 retired
wordcount.py -> `--words` (its JSON envelope is not kept)
word_counter.py -> `--words`
word_counter_simple.py -> `--words`
word-counter.py -> `--words`
wordfreq.py -> `--words`; frequency table retired, no caller
word_freq.py -> `--words`; frequency table retired, no caller
Retired in the same commit because each graded a tool that no longer exists:
test_linecount.py, test_text_stats.py, verify_lines.py, verify_lwc.py,
verify_wordcount.py, verify_word_freq.sh, check_word_count_report.py
verify_line_counter.sh is repaired rather than deleted. It pinned
/root/.hermes/wizard-outputs/spark and "Total lines: 5587" -- a figure belonging
to the 65-line tool last held at 7359bce that 6b5197b had already replaced -- and
read rc 1 at the opening rev. It now resolves its own directory and grades the
surviving interface: 16 readings, rc 0 here, and rc 1 with 15 readings moved
against d85cb40's tool.
test_line_counter.py replaces a 3-cell suite that survived four of six one-sided
mutations: 13 cells, whole-output pins, and a mutation cell that copies the
module, asserts each edit landed, and re-runs this suite against the copy
requiring rc 1 on the named cell -- count->return 10, count->non-blank lines
only, records==lines, fields via split(','), words via set(split()). Five
mutants, five killed. Against d85cb40's tool the same suite reads 0/13, rc 1.
Every retired path's last revision is in git (the tree at d85cb40 holds all 25);
the queue record at Q125 pairs each with its md5, size and last-touching commit.
tools/path_claim_baseline.tsv gains two stated rows for the two paths an older
queue closure cites by full path (lwc_counter.py, verify_lwc.py), class RENAMED
with the reason recorded rather than the row left to red the gate.
Files: wizard-work/spark/line_counter.py, test_line_counter.py,
verify_line_counter.sh (repaired), README.md, VERIFICATION.md, 25 deletions,
tools/path_claim_baseline.tsv.
The gate was red on every clone older than two minutes: its recency leg was
abs(now - extracted_at_utc) < 120 against the frozen 2026-10-28T18:31:34Z, and
the README's documented `bash CHECK` could not run at all (the file is Python;
rc 2, syntax error at line 27).
- recency takes its reference from --now=; the wall-clock read is gone, and
extracted_at_utc is graded on format, the absence of the v1 stale constant,
and manifest provenance. No reference -> one SKIP line, gate still decides.
- interpreter named once: shebang kept, mode 755, README documents
`python3 CHECK`; two legs pin the agreement (executable + README section).
- --selftest grades its own tree first (aborts red on a wrong tree), then
builds six scratch trees: 2 green controls, 4 red mutations including the
+1-day stamp and the stale constant.
Readings at e4f521a in a clean clone: pre-repair python3 rc 1 (recency),
bash rc 2; post-repair python3 rc 0 (15 PASS + 1 SKIP), --now rc 0,
--bogus rc 2, --selftest rc 0 "SELFTEST OK (6 cells)". Independent
reproduction: wizard-outputs/volt/verify_q122.py, 15 PASS, rc 0.
Also lands the Q111 landed-count addendum left uncommitted at 7c36185 (its
2-line append and its index render were still in the worktree).
Repair: 960469d. Pre-fix cell + 11 ms scheduler gap -> rc 1, dt 0.03897-0.03912
(the observed 0.03909 at 7c36185 minus its 10.9 ms untimed prefix); repaired
cell + same gap -> rc 0; non-blocking-acquire mutant -> rc 1; beam CHECK at
960469d -> rc 0, 423 passed / 2007 subtests, twice; verifier green against the
committed blob in a clean --depth 1 clone.
Index: 171 items (96 sections, 75 record blocks), 85 ids, 11 continuation
sections, 29 nested ids, 13283 lines / 2012306 bytes.
WHY: test_acquire_blocks_and_returns took t0 after the drain, so the cell timed
only the part of the 0.05 s refill that happened after the scheduler returned to
it. Observed red in a loaded full-suite run at 7c36185:
'assert 0.03909331373870373 >= 0.04' -- 10.9 ms of untimed prefix. Deterministic
repro: pre-fix cell + 11 ms injected gap -> 0.03897/0.03912, rc 1.
FIX: t0 now precedes try_acquire(1.0), which is where the bucket sets _last, so
dt is >= 0.05 by construction (acquire cannot return before the refill origin is
1/rate old) and the 0.04 floor has ~10 ms of margin instead of 1 ms.
MEASURED: repo cell 9 passed; pre control rc 1 dt 0.03897-0.03912; post control
rc 0; same-gap in-process dt pre 0.039119 / post 0.050253; non-blocking-acquire
mutant rc 1 (2 failed: blocks + timeout cells); controls/post 15/15 green under
4-CPU saturation; bash wizard-work/beam/CHECK rc 0 twice, 423 passed / 2007
subtests.
CHECK: python3 /root/.hermes/wizard-outputs/volt/2026-10-28-q122/verify.py
Measured on this worktree (parent 4623724): py_compile rc 1 -> 0; default run rows=3344 total=3344; regeneration sha256 6288352e31a9f80de0913886c833214e0d8fc604b3f5de970169d9ecdd478c6f, identical to the committed table, diff empty; the Q98 guard's --all-files run goes rc 2 / "cannot grade: 1 file(s) unreadable" to rc 1 / 825 graded / 16 pre-existing non-test faults / no cannot-grade line (825 .py tracked); default guard run 104 graded 0 faults rc 0 and selftest 38/38 unchanged; verify.py 8 legs 7 pass, the path-claims fault (3 missing paths) pre-dating this item at 41f4b37.
Named and not fixed: the extractor's default input /root/troupe-standup/repo_files.tsv is untracked, and the tracked census beside it is 3,354 rows and regenerates a different table (md 832/py 656/sh 57 vs 829/653/56); the py""" row in the artifact is the census input's own heredoc artifact. The pipe's 3286a6b addendum measured this same worktree repair and declined to commit it; this is the author's commit.
The eight test files Q98 leaves open (plus test_bfs.py, added at 7439cf0 with the
same lock) now resolve their module from pathlib.Path(__file__).resolve().parent
instead of /root/.hermes/wizard-outputs/<lane>.
tools/import_resolve_check.py --repo . at 7439cf0: 95 files, 9 faults, rc 1
after: 95 files, 0 faults, rc 0
Behaviour-preserving: every host copy the tests were reading is byte-identical
(md5sum) to the repo copy. Three absolute literals in spark/test_validator.py
that the static leg does not grade (load_json(...) argument strings at pre-fix
lines 12/16/25) are re-pointed too.
ledger/test_scratch_manifest.py was red before any edit (str ROOT vs
gen_manifest ROOT.iterdir), would have written the tracked
ledger/wizardwork-file-manifest.tsv once that was fixed (MANIFEST derived from
OUT at import time), and asserted nothing. It now re-points ROOT/OUT/MANIFEST,
guards MANIFEST inside a tempfile.mkdtemp(), and asserts the exact manifest row.
Non-vacuity: scratch/q98b/poison_probe.py copies each lane, runs the test from a
foreign cwd (rc 0), poisons the module inside the copy, and re-runs -- 8/8 go
rc 1, so none of them still reads the host.
Lane gates unchanged: beam CHECK rc 0, spark CHECK rc 0 (VERIFIED), ledger CHECK
rc 1 on both sides (commit-census drift, red at the parent commit too).
c30f372 landed tools/import_resolve_check.py and nothing registered it: the sweep read NO_PROBE on both input axes plus PIN_UNPINNED, write_probe read NO_PROBE on the json axis and failed its own c7 roster cell, and tool_map's HEAD drift cell failed on a TOOLS.md that did not name the tool. Measured at 7ffd177: verify.py 8 legs 5 pass / 3 fault (path-claims, selftest-sweep, write-axis); after this commit 7 pass / 1 fault, the remaining leg being the two inbox rows that faulted before this tick. Sweep: '23 tools, 21 OK, 2 fatal' -> 'verdict: rc 0 -- clean'; read-refusal 27 ok + NO_PROBE -> 28/28; malformed 26 ok + NO_PROBE -> 27/27; pin 22 pinned + 1 drift -> 23 pinned, 23 agree. write_probe: selftest 14/15 (c7 tool-only=['import_resolve_check.py']) -> 15/15, live axis 27 probed / 27 ok. The three new rows were graded against mutants of the tool, not assumed: refusal at rc 1 -> RC_NOT_2, not-a-repo graded clean -> RC_WRONG, --json silently skipped -> RC_OTHER. The tool itself is unmodified and still reads rc 1 on this tree (8 faults in 7 test files, Q98's subject). No other lane's file edited.
Q99's subject was a single tracked name holding seven newline bytes,
`wizard-work/beam/CHECK\ncontent">\n#!/bin/bash\n...`, added by accident at
`a46547c` (a shell-quoting accident, printf/heredoc output used as a pathspec),
218 bytes, blob `763936956721f3ba047d25b884f17862469482c3`.
Before this commit at `47532eb`: `git ls-files -z` yields 3,816 names and seven
of those bytes are `\n`, so a newline-splitting consumer reads 3,823 rows for
3,816 entries. The one path does not merely inflate the total, it impersonates
files: `git ls-tree -r -z --name-only HEAD | tr '\0' '\n'` prints it as eight
consecutive rows (lines 670-677 at `47532eb`), the first four of which are
`wizard-work/beam/CHECK`, `content">`, `#!/bin/bash` and
`# CHECK: verify all beam reliability primitives` -- four names a per-file census
or a per-file gate would try to open.
Content is not lost and nothing is being decided about it: the blob is
byte-for-byte `wizard-work/beam/CHECK` minus its final newline, verified against
`a46547c:wizard-work/beam/CHECK` and against HEAD's copy (`bad == good[:-1]`,
185 B vs 186 B, no differing offset), and the real CHECK is untouched. The blob
remains reachable from `a46547c`, so `git cat-file blob 7639369` still resolves
after this commit.
Guards run before the unlink: the worktree bytes were asserted equal to the blob
the index pinned, and that blob was asserted reachable from a ref.
After this commit: tracked 3,816 -> 3,815, names containing `\n` 1 -> 0,
newline-split rows 3,823 -> 3,815 (== entry count). An index-derived census keyed
on backslash-escaped names (`q99_census.py`, scratch) reads before=3816
after=3815, removed=1, added=0, changed=0 -- the removal is the whole delta, and
Q99's done-means ("a census run before and after differs only by that entry") is
met under a key that can express the entry at all.
Gate A/B on a scratch clone, committed there so HEAD moved: `tools/verify.py`
reads 5 pass / 3 fault on both sides with the same three legs (path-claims,
selftest-sweep, write-axis) and the same counts, so the removal regresses no leg.
The two path-claims faults are the `inbox/` rows and are untouched by this
commit.
Probes (read-only, outside the repo, under the volt profile cache):
/root/.hermes/profiles/volt/cache/scratch/q99/
newpath_probe.py, pin_content.py, q99_census.py, q99_worktree_state.py,
q99_apply_live.py, census_before.tsv, census_after.tsv, verify_after.txt
Two mutants that were green on HEAD's cells now die on named cells:
M-GUARD (all six _check_index call sites deleted) was rc 0 / Ran 12 on HEAD
and is rc 1 failing exactly the two new refusal cells; journalled path
compression passed all 12 HEAD cells and fails only the rebuilt compression
cell. Lane CHECK rc 0, Ran 232 (230 + 2). Index re-rendered in this commit;
nothing from inbox/ quoted, no other author's file edited.
ledger