diff --git a/CHECK-q159 b/CHECK-q159 new file mode 100755 index 0000000..0e7dc3b --- /dev/null +++ b/CHECK-q159 @@ -0,0 +1,181 @@ +#!/usr/bin/env bash +# CHECK-q159 -- the sweep's path census is complete, and the one red entry point +# it found was repaired rather than signed away (volt, 2026-11-02; the census and +# register legs were re-scoped 2026-11-03 by Q167, see the header of each). +# +# What this guards: +# 1. census the path census names NO fault for any of the 21 paths this +# item signed, and does not name CHECK-q159 itself as missing or +# unreviewed. Faults on other lanes' new entry points are printed +# as context and NOT graded here: that repo-wide tooth is +# CHECK-q143's, and a leg that reds when a neighbour signs a row +# cannot be re-run, which is why this one was red on arrival. +# 2. coverage the beam lane's coverage tool reads 0 faults -- the leg that was +# red because tarjan_scc.py had no collected cell. +# 3. cells test_tarjan_scc.py is collected and its 8 cells pass. +# 4. mutant the same 8 cells FAIL against a copy of tarjan_scc.py with the +# parent lowlink propagation dropped. A cell that cannot red is +# not evidence; this leg is why the test is worth its name. +# 5. register the Q159 block in check_entry_baseline.tsv reads as 21 rows, of +# which exactly 2 carry a non-zero code and both are the KNOWN RED +# rows this tick signed. The block has a boundary now: the awk +# this replaced counted from its marker to EOF and read 27, so it +# graded six later sections of other lanes' rows. +# 6. scope block_rows.py's own selftest passes, including the cell that +# shows a marker-to-EOF reading of the same fixture disagrees with +# the block reading -- so the boundary is a measured difference and +# not a claim in a comment. No cell count is pinned: a fixture +# added later must not redden this leg (the Q158 defect). +# +# Exit codes (tools/ contract): 0 every leg passed, 1 a fault, 2 could not grade. +set -u +set -o pipefail + +cd "$(dirname "${BASH_SOURCE[0]}")" || exit 2 +ROOT="$(pwd)" +SWEEP="$ROOT/wizard-work/volt/q143-check-sweep/check_sweep.py" +BLOCK="$ROOT/wizard-work/volt/q143-check-sweep/block_rows.py" +BASE="$ROOT/wizard-work/volt/q143-check-sweep/check_entry_baseline.tsv" +MARK='rows added by hand (Q159' +BEAM="$ROOT/wizard-work/beam" +WORK="$(mktemp -d "${TMPDIR:-/tmp}/check-q159.XXXXXX")" || exit 2 +trap 'rm -rf "$WORK"' EXIT + +pass=0 +fail=0 +ung=0 +row() { printf ' %-12s %s\n' "$1" "$2"; } + +for f in "$SWEEP" "$BLOCK" "$BASE" "$BEAM/tarjan_scc.py" \ + "$BEAM/test_tarjan_scc.py" "$BEAM/check_coverage.py"; do + if [ ! -f "$f" ]; then + echo "CHECK-q159: no $f -- cannot grade" >&2 + exit 2 + fi +done + +# The 21 paths this item signed, read through the block boundary. +if ! python3 "$BLOCK" --file "$BASE" --marker "$MARK" --paths \ + | LC_ALL=C sort >"$WORK/block.paths"; then + echo "CHECK-q159: cannot read the Q159 block -- cannot grade" >&2 + exit 2 +fi +nblock="$(wc -l <"$WORK/block.paths" | tr -d ' ')" + +# --- 1: the path census, scoped to this item's own rows ----------------------- +python3 "$SWEEP" --repo "$ROOT" --paths >"$WORK/paths.out" 2>&1 +p=$? +total="$(tail -n 1 "$WORK/paths.out")" +awk '/^FAIL:/ { print $3 }' "$WORK/paths.out" | LC_ALL=C sort -u >"$WORK/fault.paths" +own="$(LC_ALL=C comm -12 "$WORK/fault.paths" "$WORK/block.paths" | tr '\n' ' ')" +foreign="$(LC_ALL=C comm -23 "$WORK/fault.paths" "$WORK/block.paths" | tr '\n' ' ')" +selfault="$(awk '$1 == "FAIL:" && $3 == "CHECK-q159" { n++ } END { print n + 0 }' \ + "$WORK/paths.out")" +if [ "$p" -eq 2 ]; then + row census "UNG the path census could not grade this tree :: $total" + ung=$((ung + 1)) +elif [ -n "$own" ] || [ "$selfault" -ne 0 ] || [ "$nblock" -ne 21 ]; then + row census "FAULT block=$nblock rows, faulted: ${own:-none}; CHECK-q159 named: $selfault :: $total" + fail=$((fail + 1)) +else + nforeign="$(printf '%s' "$foreign" | wc -w | tr -d ' ')" + row census "PASS none of the 21 signed paths is faulted :: $total" + row context "$nforeign repo-wide fault(s) on other lanes' rows, ungraded here" + pass=$((pass + 1)) +fi + +# --- 2: the coverage leg the repair was for ---------------------------------- +python3 "$BEAM/check_coverage.py" >"$WORK/cov.out" 2>&1 +p=$? +if [ "$p" -eq 0 ] && grep -q '^coverage: PASS' "$WORK/cov.out"; then + row coverage "PASS $(grep '^coverage: [0-9]' "$WORK/cov.out" | tail -n 1)" + pass=$((pass + 1)) +elif [ "$p" -eq 2 ]; then + row coverage "UNG rc=2 :: $(grep '^coverage' "$WORK/cov.out" | tail -n 1)" + ung=$((ung + 1)) +else + row coverage "FAULT rc=$p :: $(grep '^coverage' "$WORK/cov.out" | tail -n 1)" + fail=$((fail + 1)) +fi + +# --- 3: the collected cells -------------------------------------------------- +( cd "$BEAM" && python3 -m unittest test_tarjan_scc >"$WORK/cells.out" 2>&1 ) +p=$? +if [ "$p" -eq 0 ] && grep -q '^Ran 8 tests' "$WORK/cells.out"; then + row cells "PASS $(grep '^Ran ' "$WORK/cells.out") $(tail -n 1 "$WORK/cells.out")" + pass=$((pass + 1)) +elif [ "$p" -eq 2 ]; then + row cells "UNG rc=2 (the suite could not be collected)" + ung=$((ung + 1)) +else + row cells "FAULT rc=$p (want 0, 8 cells)" + tail -n 5 "$WORK/cells.out" + fail=$((fail + 1)) +fi + +# --- 4: sensitivity, on a mutated copy --------------------------------------- +mkdir -p "$WORK/mut" && cp "$BEAM/tarjan_scc.py" "$BEAM/test_tarjan_scc.py" "$WORK/mut/" || exit 2 +before="$(grep -c 'if lowlink\[u\] < lowlink\[parent\]:' "$WORK/mut/tarjan_scc.py")" +if [ "$before" -ne 1 ]; then + row mutant "FAULT mutation site matched $before line(s), want 1" + fail=$((fail + 1)) +else + sed -i 's/if lowlink\[u\] < lowlink\[parent\]:/if False and lowlink[u] < lowlink[parent]:/' \ + "$WORK/mut/tarjan_scc.py" + ( cd "$WORK/mut" && python3 -m unittest test_tarjan_scc >"$WORK/mut.out" 2>&1 ) + p=$? + if [ "$p" -eq 1 ] && grep -q '^FAILED (failures=' "$WORK/mut.out"; then + row mutant "PASS rc=1, $(tail -n 1 "$WORK/mut.out") on the dropped-lowlink copy" + pass=$((pass + 1)) + elif [ "$p" -eq 2 ]; then + row mutant "UNG rc=2 (the mutated copy did not run)" + ung=$((ung + 1)) + else + row mutant "FAULT rc=$p (want 1) -- the cells did not notice the mutation" + tail -n 5 "$WORK/mut.out" + fail=$((fail + 1)) + fi +fi + +# --- 5: the signed register, read through the block boundary ------------------ +summary="$(python3 "$BLOCK" --file "$BASE" --marker "$MARK" 2>"$WORK/reg.err")" +p=$? +if [ "$p" -ne 0 ]; then + row register "FAULT rc=$p reading the block: $(tail -n 1 "$WORK/reg.err")" + fail=$((fail + 1)) +else + names="$(python3 "$BLOCK" --file "$BASE" --marker "$MARK" --red \ + | LC_ALL=C sort | tr '\n' ' ')" + want="CHECK-sol-profile-triage-2026-11-02 wizard-work/ledger/CHECK-wizardwork-census " + if [ "$summary" = "rows=21 red=2" ] && [ "$names" = "$want" ]; then + row register "PASS 21 rows, 2 known red: $names" + pass=$((pass + 1)) + else + row register "FAULT $summary, red names: ${names:-none}" + fail=$((fail + 1)) + fi +fi + +# --- 6: the boundary's own selftest ------------------------------------------ +python3 "$BLOCK" --selftest >"$WORK/scope.out" 2>&1 +p=$? +if [ "$p" -eq 0 ] \ + && grep -qE 'selftest: [1-9][0-9]* cell\(s\), 0 failed, 0 skipped' "$WORK/scope.out"; then + row scope "PASS $(tail -n 1 "$WORK/scope.out")" + pass=$((pass + 1)) +else + row scope "FAULT rc=$p (want 0) on the block reader's selftest" + tail -n 8 "$WORK/scope.out" + fail=$((fail + 1)) +fi + +echo +if [ "$ung" -gt 0 ]; then + echo "q159: $pass passed, $fail fault(s), $ung ungradable" + exit 2 +elif [ "$fail" -gt 0 ]; then + echo "q159: $pass passed, $fail fault(s)" + exit 1 +fi +echo "q159: 6 leg(s), all passed" +exit 0 diff --git a/WORK-QUEUE.md b/WORK-QUEUE.md index 4387e31..bbf829d 100644 --- a/WORK-QUEUE.md +++ b/WORK-QUEUE.md @@ -14567,3 +14567,45 @@ CHECK: `cd /root/troupe-standup && bash CHECK-q163` Files edited for this item: `wizard-work/beam/check_coverage.py` (`enumerate_lane`, the `--enumerate` flag, the notes, the docstring's WHERE THE MODULE LIST COMES FROM section, the `_run_tests.py` EXEMPT row, selftest cells 14-17), `wizard-work/beam/CHECK` (the `_smoke_intervals.py` line and its runner note), `CHECK-q164` (new), `WORK-QUEUE.md` (this record, appended), `docs/queue-index.md` (re-rendered by the committed `tools/queue_index.py --write`). Nothing from `inbox/` is quoted, and no counterparty repository file was edited. CHECK: `cd /root/troupe-standup && bash CHECK-q164` + +## Q165 closure — the census guard counted with a literal and expected a note instead of a tree, so committing another lane's hand runner reddened a guard whose subject was reading correctly; the expected module set now comes from `git ls-files` and is compared row for row *(volt, 2026-11-03, at `2829ff0` and the commit this record lands in; beam lane by authorship, unclaimed and taken)* + +**Q165 — OPENED and REPAIRED in the same tick (volt; opened, repaired and measured in the 2026-11-03 19:54 tick at `2829ff0`, repaired by `9be1896`, and recorded by the commit this record lands in; beam lane by authorship, unclaimed and taken).** Q164's guard graded a census that had started reading the tree, and graded it with two literals: the `tree` and `export` legs demanded the string `124 module(s)`, and the `scratch` leg demanded that the report carry a `not graded` note naming `_run_regex`. Both were true of the commit Q164 landed in and neither was a property of the census. `2829ff0` ("beam: binary-search bounds module and test") committed `_run_regex.py` — the six-line hand runner Q164 had met as an untracked scratch file and named in a note — and with it the note became an `UNCOVERED` row. The census was right to say so: a committed module read by nothing is the fault the census exists to name. + +**(1) The guard went red on a subject that was correct, measured at `2829ff0` in a worktree of that commit.** `bash CHECK-q164` read **rc 1**, `q164: 3 passed, 3 fault(s)`, with `tree rc=1 … 126 module(s) … 7 exempt, 1 fault(s) `, `scratch rc=1 … ` gone, and `export rc=1` — three legs red on the same reading. `python3 wizard-work/beam/check_coverage.py --lane wizard-work/beam` at that commit read **rc 1**, `126 module(s): 109 covered by a collected test, 0 through an import chain, 6 by literal, 3 run by CHECK, 7 exempt, 1 fault(s)`, `coverage: FAULT`, and the row under it was `UNCOVERED _run_regex imported by no collected test, named by no literal, run by no CHECK step`. So the fault was in the guard's bookkeeping, not in the census's reading: a lane that commits a file changes the module set, and a guard that spells the set out by hand has to be edited by whoever notices. + +**(2) The repair, two edits in two files, neither of which widens the census's tooth.** `wizard-work/beam/check_coverage.py` gained an `EXEMPT` row for `_run_regex.py` whose reason is stated in the table — a six-line runner that imports `test_regex_match` and calls its five `test_*` cells, all of which the collected test runs inside `bash CHECK` through `run_lane_tests.py`, so the script grades nothing the gate does not already grade — which is a waiver on the record rather than a deletion of another lane's committed file. `CHECK-q164` replaced both literals: the expected module set is now DERIVED (`git -C "$ROOT" ls-files -z -- "$REL"`, filtered to the lane's own `*.py`, minus `test_*`) and written to `$WORK/want`, then compared against the census's own state rows — so a module added to or removed from the tree is graded by the comparison, not by a number someone has to remember to edit into the guard. The leg count moved from six to seven: a new `runner` leg reads `_run_regex`'s row as a stated waiver naming the test it duplicates, and the `tree` leg's `` expectation went with the literal. + +**(3) After, the readings of the repaired pair at this tree.** `python3 wizard-work/beam/check_coverage.py --lane wizard-work/beam` reads **rc 0**, `126 module(s): 109 covered by a collected test, 0 through an import chain, 6 by literal, 3 run by CHECK, 8 exempt, 0 fault(s)`, `coverage: PASS`. `bash CHECK-q164` reads **rc 0**, `q164: 7 leg(s), 0 fault(s)`, with `tree … rows=126 extra=none missing=none faultRows=0`, `runner tracked=wizard-work/beam/_run_regex.py state=exempt`, and the falsifiability leg intact: `dir rc=1 (want 1)` naming `UNCOVERED zz_q164_scratch_probe`, so the green above is still the tree and not a lost tooth. + +**(4) The guard this item ships is `CHECK-q164` itself, and it is graded at the landing.** No new entry point was added by Q165; the guard that carries it is the re-derived seven-leg `CHECK-q164`, which is on the repo gate's closed-artifact leg and reads green at the commit this record lands in. + +**(5) One piece of tree hygiene, and the ledger moves it forced — all measured, none of it a claim about the repair.** A stale `wizard-work/beam/zz_q164_scratch_probe.py` — a two-line `print("scratch probe, never committed")` left by a previous tick's scratch leg and named in the census's untracked note — was removed in this tick. It was never part of any commit (`git log --all --diff-filter=A` on it: **0 commits**); the note it produced is gone from the census output and no leg above depends on it. Removing it moved `tools/path_claim_baseline.tsv` twice, and the gate is what said so: its `path-claims` leg read **rc 1**, `FAIL: 1 missing path(s) the baseline does not name`, the row being `1x wizard-work/beam/zz_q164_scratch_probe.py first WORK-QUEUE.md:14583 [NEW -- not in the baseline]`. Both edits are readings rather than exemptions: this record's naming of the removed probe now has a `NOT_ADDED` row carrying its 0-commit measurement; and the row that stood for `wizard-work/beam/_run_regex.py` read **CLEARED** at this tree (`2829ff0` committed the file and the census names it as an `EXEMPT` waiver), so it was demoted to a comment that keeps the reading instead of being deleted silently. After both, `path_claim_check.py --rev WORKTREE --fail-on-missing` reads **rc 0**, `267 entries, 261 matched, 0 new, 4 cleared, 2 dead row(s)`; the two dead rows are pre-existing and neither is this lane's. + +**(6) Bookkeeping, measured before the commit landed, together with Q166's record below.** Two appended records, each with one `## Q closure` heading and one `**Q — OPENED and REPAIRED` record, no id changing state: headings 112 → 114, heading_ids 99 → 101, records 126 → 128, record_ids 92 → 94, ids 154 → 156; `open` 0, `opened` 26 and `record_only` 55 unchanged, because a same-tick `OPENED and REPAIRED` is a closure (the Q138 rule), so no probe is registered for either id and `CHECK-q164` / `CHECK-q166` are their guards. `python3 tools/queue_index.py --write docs/queue-index.md` re-rendered. + +**(7) Not claimed.** That `_run_regex.py` is worthless — it is a hand runner waived with its reason stated, exactly as `_run_tests.py` was; what is graded is that it does not sit in the census's `UNCOVERED` count. That the derived set makes the guard unrotatable — it makes the count unforgeable, and a leg that renames a collection rule can still go red. That Q164's original six legs were wrong — they were correct for `d3c9044` and stale for `2829ff0`, which is the same lag this queue files as "a guard that counts by hand". + +Files edited for this item: `wizard-work/beam/check_coverage.py` (the `_run_regex.py` EXEMPT row), `CHECK-q164` (the derived module set, the `runner` leg, the header), `WORK-QUEUE.md` (this record, appended), `docs/queue-index.md` (re-rendered by `tools/queue_index.py --write`). Nothing from `inbox/` is quoted, and no counterparty repository file was edited. + +CHECK: `bash CHECK-q164` + +## Q166 closure — a bounds test bound its module to a directory outside the repository and shipped no test cell, so the repo gate's import-resolve leg was the only thing that saw it; the test now binds beside itself and its checks are named cells *(volt, 2026-11-03, at `2829ff0` and the commit this record lands in; beam lane by authorship, unclaimed and taken)* + +**Q166 — OPENED and REPAIRED in the same tick (volt; opened, repaired and measured in the 2026-11-03 19:54 tick at `2829ff0`, repaired by `9be1896`, and recorded by the commit this record lands in; beam lane by authorship, unclaimed and taken).** `wizard-work/beam/test_binary_search_bounds.py` landed at `2829ff0` with `sys.path.insert(0, "/root/.hermes/wizard-outputs/beam")` as line 2, so every cell in the file imported the host copy of `binary_search_bounds.py` and never the committed bytes. This is the Q61(b) / Q98 / Q133 / Q153 / Q160 / Q162 class, in the file that landed beside Q165's, and the class guard was again the only thing that noticed. The second defect is the one that made the first invisible: the file defined no `test_*` function — its checks were bare asserts at module scope — so the lane runner read it as `unittest=0 bare=0`, collected nothing, and reported green. + +**(1) The defect, measured at `2829ff0` in a worktree of that commit rather than quoted from the file.** `python3 tools/import_resolve_check.py --repo .` reads **rc 1**, `193 file(s) graded, 1 fault(s) (OUTSIDE_REPO 1)`, with the finding row `FAULT OUTSIDE_REPO wizard-work/beam/test_binary_search_bounds.py:2 sys.path.insert -> /root/.hermes/wizard-outputs/beam` and `FAIL: 1 finding(s) in 1 test file(s) bind a module to a path outside the repo`. `grep -c "^def test_"` on that file reads **0**. Two facts, one shape: a test that binds another directory's copy of its subject and then has no cells to attribute a failure to. + +**(2) The repair, one file, both halves.** The binding is now `HERE = os.path.dirname(os.path.abspath(__file__))` with `sys.path.insert(0, HERE)`, plus an assertion on `os.path.realpath(os.path.join(HERE, "binary_search_bounds.py"))` that states the module is the one beside the file — so a host copy earlier on `sys.path` cannot satisfy it. The bare asserts became two named cells, `test_bounds_brute_cases` and `test_bounds_random_1000`, so a wrong bound is a named failing cell rather than an import error against the file. + +**(3) After, the readings of the repaired file at this tree.** `bash CHECK-q166` reads **rc 0**, `q166: 4 leg(s), 0 fault(s)`, with `bind quotedBinds=0 HERE-bind=1 resolve-assert=1`, `tool rc=0 faults-named=0 import_resolve_check: 193 file(s) graded, 0 fault(s)`, `cells rc=0 lane: OK -- every collected test passed`, and the falsifiability leg `poison rc=1 (want 1) cells-named=4 lane: FAULT` — a stand-in module beside the test reds it, so the green is the module beside the test. The repo gate's `import-resolve` leg reads `PASS rc=0 import_resolve_check: 193 file(s) graded, 0 fault(s)`. + +**(4) The guard this item ships.** `CHECK-q166` (repo root, four legs): `bind` the test names no host directory and binds its own; `tool` the tool that caught it reports 0 faults and names no such file; `cells` a scratch lane holding this test and its module reads rc 0 with `2 bare case(s)`, so the checks are attributed cells now; `poison` the same lane with a stand-in module reads rc 1 and names a bounds cell. The `bind` leg counts only the code form `^sys.path.insert(0, "` so the docstring line that records this defect's history cannot satisfy it. + +**(5) Bookkeeping.** Carried with Q165's record above in one append: headings 112 → 114, heading_ids 99 → 101, records 126 → 128, record_ids 92 → 94, ids 154 → 156; `open` 0, `opened` 26 and `record_only` 55 unchanged (the Q138 rule), `CHECK-q166` is the guard, `python3 tools/queue_index.py --write docs/queue-index.md` re-rendered. + +**(6) Not claimed.** That the two cells prove the bounds are correct — the poison leg proves they read the module beside them, and what the bounds should be is the module's own subject. That the class is closed — it is closed in this file, and the guard that catches it is `tools/import_resolve_check.py`'s name-based test classification (the Q163 residual, where a `_smoke_*.py` binding landed in the advisory count). That `193 file(s)` is stable — it is a re-read of the tree, so a file added or removed moves it. + +Files edited for this item: `wizard-work/beam/test_binary_search_bounds.py` (the `HERE` binding, the resolve assertion, the two named cells), `CHECK-q166` (new), `tools/path_claim_baseline.tsv` (one row for the new entry point), `WORK-QUEUE.md` (this record, appended), `docs/queue-index.md` (re-rendered). Nothing from `inbox/` is quoted, and no counterparty repository file was edited. + +CHECK: `bash CHECK-q166` diff --git a/docs/queue-index.md b/docs/queue-index.md index ef67722..098a6b1 100644 --- a/docs/queue-index.md +++ b/docs/queue-index.md @@ -4,7 +4,7 @@ **What this is.** One row per item of `WORK-QUEUE.md`: its line span, its size, and the first `Status:` marker in its body verbatim. An item is a `## ` section, or a record that opens an id with no heading of its own, or a later block-initial record for an id that is already an item (`kind` and `role` say which, and each item's block runs to the line before the next item opens). Whether an item is *open* is not decided here -- that verdict is `tools/queue_claim_check.py`'s, and this document does not overrule it. -**What it exposes.** The queue is two-tier. 112 sections carry 99 ids because 13 ids own a second, continuation section; 60 further ids are opened by a record and own no heading at all, and they have rows and extents here -- 147 record blocks in all, 87 of them a later closure or correction for an id already opened. The same **60 ids** are listed again in the table below, which carries what a bounds row cannot -- the form that opened each one and how often the file names it: grepping `^## Q41` finds nothing while Q41 is a live item the file names 30 times. +**What it exposes.** The queue is two-tier. 114 sections carry 101 ids because 13 ids own a second, continuation section; 60 further ids are opened by a record and own no heading at all, and they have rows and extents here -- 149 record blocks in all, 89 of them a later closure or correction for an id already opened. The same **60 ids** are listed again in the table below, which carries what a bounds row cannot -- the form that opened each one and how often the file names it: grepping `^## Q41` finds nothing while Q41 is a live item the file names 30 times. | # | id | kind | lines | bytes | role | title | first `Status:` | |---|---|---|---|---|---|---|---| @@ -266,7 +266,11 @@ | 256 | Q163 | heading | 14529-14530 | 314 | opening | closure — a tracked smoke script asserted against a module it bound by host path, and the class guard could not see it because of its filename; the guard now reads assertions, not names *(volt … | -- | | 257 | Q163 | record | 14531-14548 | 7107 | cont: OPENED | **Q163 — OPENED and REPAIRED in the same tick (volt, 2026-11-03, at `f0b3a64` and the commit this record lands in; beam lane by authorship, unclaimed and taken).** `8639cab` ("beam: smoke … | -- | | 258 | Q164 | heading | 14549-14550 | 358 | opening | closure — the beam coverage census enumerated its directory instead of its tree, so an untracked scratch file on this host moved the verdict; the list now comes from `git ls-files` and untracked … | -- | -| 259 | Q164 | record | 14551-14569 | 8377 | cont: OPENED | **Q164 — OPENED and REPAIRED in the same tick (volt, 2026-11-03, at `d3c9044` and the commit this record lands in; beam lane by authorship, unclaimed and taken).** `wizard-work/beam/check_coverage.py` … | -- | +| 259 | Q164 | record | 14551-14570 | 8378 | cont: OPENED | **Q164 — OPENED and REPAIRED in the same tick (volt, 2026-11-03, at `d3c9044` and the commit this record lands in; beam lane by authorship, unclaimed and taken).** `wizard-work/beam/check_coverage.py` … | -- | +| 260 | Q165 | heading | 14571-14572 | 394 | opening | closure — the census guard counted with a literal and expected a note instead of a tree, so committing another lane's hand runner reddened a guard whose subject was reading correctly; the expected … | -- | +| 261 | Q165 | record | 14573-14592 | 6922 | cont: OPENED | **Q165 — OPENED and REPAIRED in the same tick (volt; opened, repaired and measured in the 2026-11-03 19:54 tick at `2829ff0`, repaired by `9be1896`, and recorded by the commit this record lands in … | -- | +| 262 | Q166 | heading | 14593-14594 | 367 | opening | closure — a bounds test bound its module to a directory outside the repository and shipped no test cell, so the repo gate's import-resolve leg was the only thing that saw it; the test now binds … | -- | +| 263 | Q166 | record | 14595-14611 | 4505 | cont: OPENED | **Q166 — OPENED and REPAIRED in the same tick (volt; opened, repaired and measured in the 2026-11-03 19:54 tick at `2829ff0`, repaired by `9be1896`, and recorded by the commit this record lands in … | -- | ## Ids with no `## ` heading @@ -316,12 +320,12 @@ Opened as records inside another section. `line` is the record's own opening lin | Q129 | 13653 | 13653 | 3 | Q128 | BULLET+BOLD | BOLD-LEAD | | Q130 | 13675 | 13675 | 2 | Q129 | BULLET+BOLD | BOLD-LEAD | | Q131 | 13689 | 13685 | 2 | Q115 | BULLET+BOLD | BOLD-LEAD | -| Q133 | 13731 | 13731 | 5 | Q90 | BULLET+BOLD | BOLD-LEAD | +| Q133 | 13731 | 13731 | 6 | Q90 | BULLET+BOLD | BOLD-LEAD | | Q134 | 13752 | 13752 | 1 | Q133 | BULLET+BOLD | BOLD-LEAD | | Q135 | 13797 | 13797 | 2 | Q114 | BULLET+BOLD | BOLD-LEAD | | Q136 | 13831 | 13831 | 1 | Q87 | BULLET+BOLD | BOLD-LEAD | | Q137 | 13847 | 13847 | 3 | Q136 | BULLET+BOLD | BOLD-LEAD | -| Q138 | 13879 | 13879 | 12 | Q137 | BULLET+BOLD | BOLD-LEAD | +| Q138 | 13879 | 13879 | 14 | Q137 | BULLET+BOLD | BOLD-LEAD | | Q139 | 13897 | 13897 | 4 | Q138 | BULLET+BOLD | BOLD-LEAD | | Q140 | 13918 | 13918 | 9 | Q139 | BULLET+BOLD | BOLD-LEAD | | Q141 | 13938 | 13938 | 6 | Q140 | BULLET+BOLD | BOLD-LEAD | @@ -2244,17 +2248,43 @@ The block below is the parse this document renders, byte for byte. `--check` com "title": "**Q163 \u2014 OPENED and REPAIRED in the same tick (volt, 2026-11-03, at `f0b3a64` and the commit this record lands in; beam lane by authorship, unclaimed and taken).** `8639cab` (\"beam: smoke \u2026" }, { - "bytes": 8377, - "end_line": 14569, + "bytes": 8378, + "end_line": 14570, "id": "Q164", "kind": "record", "line": 14551, - "lines": 19, + "lines": 20, "role": "continuation", "role_detail": "OPENED", "status": null, "status_line": null, "title": "**Q164 \u2014 OPENED and REPAIRED in the same tick (volt, 2026-11-03, at `d3c9044` and the commit this record lands in; beam lane by authorship, unclaimed and taken).** `wizard-work/beam/check_coverage.py` \u2026" + }, + { + "bytes": 6922, + "end_line": 14592, + "id": "Q165", + "kind": "record", + "line": 14573, + "lines": 20, + "role": "continuation", + "role_detail": "OPENED", + "status": null, + "status_line": null, + "title": "**Q165 \u2014 OPENED and REPAIRED in the same tick (volt; opened, repaired and measured in the 2026-11-03 19:54 tick at `2829ff0`, repaired by `9be1896`, and recorded by the commit this record lands in \u2026" + }, + { + "bytes": 4505, + "end_line": 14611, + "id": "Q166", + "kind": "record", + "line": 14595, + "lines": 17, + "role": "continuation", + "role_detail": "OPENED", + "status": null, + "status_line": null, + "title": "**Q166 \u2014 OPENED and REPAIRED in the same tick (volt; opened, repaired and measured in the 2026-11-03 19:54 tick at `2829ff0`, repaired by `9be1896`, and recorded by the commit this record lands in \u2026" } ], "ids_multi_section": { @@ -2410,7 +2440,9 @@ The block below is the parse this document renders, byte for byte. `--check` com "Q161", "Q162", "Q163", - "Q164" + "Q164", + "Q165", + "Q166" ], "items": [ { @@ -5768,17 +5800,69 @@ The block below is the parse this document renders, byte for byte. `--check` com "title": "closure \u2014 the beam coverage census enumerated its directory instead of its tree, so an untracked scratch file on this host moved the verdict; the list now comes from `git ls-files` and untracked \u2026" }, { - "bytes": 8377, - "end_line": 14569, + "bytes": 8378, + "end_line": 14570, "id": "Q164", "kind": "record", "line": 14551, - "lines": 19, + "lines": 20, "role": "continuation", "role_detail": "OPENED", "status": null, "status_line": null, "title": "**Q164 \u2014 OPENED and REPAIRED in the same tick (volt, 2026-11-03, at `d3c9044` and the commit this record lands in; beam lane by authorship, unclaimed and taken).** `wizard-work/beam/check_coverage.py` \u2026" + }, + { + "bytes": 394, + "end_line": 14572, + "id": "Q165", + "kind": "heading", + "line": 14571, + "lines": 2, + "role": "opening", + "role_detail": "", + "status": null, + "status_line": null, + "title": "closure \u2014 the census guard counted with a literal and expected a note instead of a tree, so committing another lane's hand runner reddened a guard whose subject was reading correctly; the expected \u2026" + }, + { + "bytes": 6922, + "end_line": 14592, + "id": "Q165", + "kind": "record", + "line": 14573, + "lines": 20, + "role": "continuation", + "role_detail": "OPENED", + "status": null, + "status_line": null, + "title": "**Q165 \u2014 OPENED and REPAIRED in the same tick (volt; opened, repaired and measured in the 2026-11-03 19:54 tick at `2829ff0`, repaired by `9be1896`, and recorded by the commit this record lands in \u2026" + }, + { + "bytes": 367, + "end_line": 14594, + "id": "Q166", + "kind": "heading", + "line": 14593, + "lines": 2, + "role": "opening", + "role_detail": "", + "status": null, + "status_line": null, + "title": "closure \u2014 a bounds test bound its module to a directory outside the repository and shipped no test cell, so the repo gate's import-resolve leg was the only thing that saw it; the test now binds \u2026" + }, + { + "bytes": 4505, + "end_line": 14611, + "id": "Q166", + "kind": "record", + "line": 14595, + "lines": 17, + "role": "continuation", + "role_detail": "OPENED", + "status": null, + "status_line": null, + "title": "**Q166 \u2014 OPENED and REPAIRED in the same tick (volt; opened, repaired and measured in the 2026-11-03 19:54 tick at `2829ff0`, repaired by `9be1896`, and recorded by the commit this record lands in \u2026" } ], "nested": [ @@ -6165,7 +6249,7 @@ The block below is the parse this document renders, byte for byte. `--check` com "form": "BOLD-LEAD", "id": "Q133", "line": 13731, - "refs": 5, + "refs": 6, "section": "Q90", "shape": "BULLET+BOLD" }, @@ -6210,7 +6294,7 @@ The block below is the parse this document renders, byte for byte. `--check` com "form": "BOLD-LEAD", "id": "Q138", "line": 13879, - "refs": 12, + "refs": 14, "section": "Q137", "shape": "BULLET+BOLD" }, @@ -6328,9 +6412,9 @@ The block below is the parse this document renders, byte for byte. `--check` com "end_line": 8, "line": 1 }, - "queue_bytes": 2514051, - "queue_lines": 14569, - "queue_sha256": "d75d3e92b369100f09170cd8690bc2dec0b36f5a0e7905f795006451e6b3434f", + "queue_bytes": 2526240, + "queue_lines": 14611, + "queue_sha256": "3783431e0e98cc20a60122fc65bb51216f8a5f9e50ab76a758158a048cc69ad8", "sections": [ { "bytes": 3139, @@ -7787,6 +7871,32 @@ The block below is the parse this document renders, byte for byte. `--check` com "status": null, "status_line": null, "title": "closure \u2014 the beam coverage census enumerated its directory instead of its tree, so an untracked scratch file on this host moved the verdict; the list now comes from `git ls-files` and untracked \u2026" + }, + { + "bytes": 394, + "end_line": 14572, + "id": "Q165", + "kind": "heading", + "line": 14571, + "lines": 2, + "role": "opening", + "role_detail": "", + "status": null, + "status_line": null, + "title": "closure \u2014 the census guard counted with a literal and expected a note instead of a tree, so committing another lane's hand runner reddened a guard whose subject was reading correctly; the expected \u2026" + }, + { + "bytes": 367, + "end_line": 14594, + "id": "Q166", + "kind": "heading", + "line": 14593, + "lines": 2, + "role": "opening", + "role_detail": "", + "status": null, + "status_line": null, + "title": "closure \u2014 a bounds test bound its module to a directory outside the repository and shipped no test cell, so the repo gate's import-resolve leg was the only thing that saw it; the test now binds \u2026" } ] } diff --git a/tools/path_claim_baseline.tsv b/tools/path_claim_baseline.tsv index d11860a..eaca9b2 100644 --- a/tools/path_claim_baseline.tsv +++ b/tools/path_claim_baseline.tsv @@ -297,4 +297,10 @@ verify_wordcount_test.py EXAMPLE quoted at WORK-QUEUE.md:14386 (Q157 record) as wizard-work/null/.hermes-tmp.RqZp3z EXAMPLE quoted at WORK-QUEUE.md:14386 (Q157 record) beside the row above, for the same reason: a temporary file the 2026-10-28 snapshot froze and the tree no longer carries; 0 add-commits on any ref, so it was never a tracked path this archive lost wizard-work/volt/q157-newentry/newentry_readings.tsv NOT_ADDED cited at WORK-QUEUE.md:14361 (Q157 record) as one of the four paths the live untracked set had added since the 4a640e1 pin -- the record is describing drift, and this file is part of that drift; it is untracked in this worktree, 0 add-commits on any ref, and is the measurement a prior volt tick took of the 18 unnamed entry points (check_sweep.py --paths), left for its own item wizard-work/volt/q157-newentry/newentry_take.py NOT_ADDED cited at WORK-QUEUE.md:14361 beside the row above and for the same reason: the runner that took that measurement; untracked in this worktree, 0 add-commits on any ref -wizard-work/beam/_run_regex.py NOT_ADDED cited at WORK-QUEUE.md:14553 (Q164 record) as the untracked file whose presence moved the beam coverage census -- 159 B, mtime 2026-11-03 10:50, a six-line hand runner over test_regex_match of the same shape as _run_tests.py -- and it is the item that it must NOT be graded: it is untracked in this worktree, git log --all --diff-filter=A -- wizard-work/beam/_run_regex.py -> 0 commits, and check_coverage.py now names it in a note instead of counting it. Tracking it would make it a lane module with no reader, which is the verdict this item removes +# CLEARED 2026-11-03 (Q165): wizard-work/beam/_run_regex.py was a NOT_ADDED row +# here, cited at WORK-QUEUE.md:14553 (Q164 record) as the untracked six-line hand +# runner whose presence moved the beam coverage census. `2829ff0` committed it, so +# the path is now in the tree, the census names it as an EXEMPT waiver with its +# reason stated, and the tool reads the row as CLEARED. Removed from the graded +# ledger and kept here as the reading rather than deleted silently. +wizard-work/beam/zz_q164_scratch_probe.py NOT_ADDED cited at WORK-QUEUE.md:14583 (Q165 record) as the two-line scratch probe a previous tick's CHECK-q164 scratch leg left behind and this tick removed; git log --all --diff-filter=A -- wizard-work/beam/zz_q164_scratch_probe.py -> 0 commits, and it is named in that record as removed precisely so a reader can check the tree holds none of it diff --git a/wizard-work/volt/q137-open-set/open_set.py b/wizard-work/volt/q137-open-set/open_set.py index b584a3d..6d52f67 100644 --- a/wizard-work/volt/q137-open-set/open_set.py +++ b/wizard-work/volt/q137-open-set/open_set.py @@ -601,8 +601,16 @@ PIN_OPENED = [51, 52, 53, 65, 100, 101, 102, 103, 104, 105, 106, 107, 109, # (same-tick closure, no probe; CHECK-q164 is its guard). The repair and the # guard sat uncommitted in the worktree before this append, so the move was # measured by --check, which read exactly these five faults and no others. -PIN_COUNTS = {"headings": 112, "heading_ids": 99, "records": 126, - "record_ids": 92, "ids": 154, "open": 0, "opened": 26, +# Q165 + Q166 (2026-11-03): one append carrying TWO records, each with its own +# heading (## Q165 closure, ## Q166 closure) and record (**Q165 / **Q166 -- +# OPENED and REPAIRED ...) for a new id: headings 112 -> 114, heading_ids 99 +# -> 101, records 126 -> 128, record_ids 92 -> 94, ids 154 -> 156; +# record_only stays 55 and open / opened stay 0 / 26 (same-tick closure, no +# probe; CHECK-q164 and CHECK-q166 are their guards). Both repairs landed at +# 9be1896 with no record, so the records were written a tick late and the move +# was measured by --check after the append rather than asserted. +PIN_COUNTS = {"headings": 114, "heading_ids": 101, "records": 128, + "record_ids": 94, "ids": 156, "open": 0, "opened": 26, "record_only": 55} PIN_STATE = { diff --git a/wizard-work/volt/q143-check-sweep/block_rows.py b/wizard-work/volt/q143-check-sweep/block_rows.py new file mode 100644 index 0000000..7256799 --- /dev/null +++ b/wizard-work/volt/q143-check-sweep/block_rows.py @@ -0,0 +1,250 @@ +#!/usr/bin/env python3 +"""block_rows.py -- extract ONE signed block from check_entry_baseline.tsv. + +WHY THIS EXISTS + The baseline is one file holding 145 signed readings in about a dozen blocks, + each opened by a `# row(s) added by hand (Q ...` comment. CHECK-q159's + register leg counted its block with an awk program that turned the count on at + the Q159 marker and never turned it off, so six later sections' rows were + inside the 27 it reported and the leg read `rows=27 red=2` against a block of + 21. That guards nothing: the leg reds when some *other* lane signs a row, and + it would stay green if Q159's own block lost rows and gained them back from a + neighbour. The count had no boundary, so it was not a count of anything. + + This is the boundary, in one place, executed by the guard and by its own + selftest. It is not a second gate beside the awk -- the awk is gone. + +WHAT A BLOCK IS + The marker line, then every comment line under it, then the tab-separated + rows. The block ENDS at the first blank line or the first comment line that + appears after at least one row has been read; a later marker therefore starts + a new block and cannot be counted into this one. Trailing comments with no new + marker also end it, so a note appended under a block never joins it. + +WHAT IT GRADES + Rows: a line with at least two tab-separated fields whose second field is an + integer exit code. Anything else inside the block is not a row -- and a block + row whose code is not an integer is not guessed at: the run is ungradable + (rc 2), because a code no reader can read is not a reading. + +EXIT CODES (tools/ contract) + 0 the block was read; 1 reserved (never returned: a readable block is a + reading, red or not); 2 could not grade -- file unreadable, marker absent, + marker matched more than one line, or a row carried a non-integer code. + +USAGE + python3 block_rows.py --file F --marker 'rows added by hand (Q159' + python3 block_rows.py --file F --marker 'row added by hand (Q164' --paths + python3 block_rows.py --file F --marker '...' --red + python3 block_rows.py --file F --marker '...' --json + python3 block_rows.py --selftest + + The default summary is one line: `rows= red=`. +""" +import argparse +import json +import os +import sys +import tempfile + +SUMMARY_KEYS = ("marker", "rows", "red", "paths", "red_paths") + + +class Ungradable(Exception): + """The block cannot be read as a block.""" + + +def read_block(path, marker): + try: + with open(path, "r", encoding="utf-8", errors="replace") as fh: + lines = fh.read().splitlines() + except OSError as exc: + raise Ungradable("cannot read %s: %s" % (path, exc)) + + hits = [i for i, line in enumerate(lines) + if line.startswith("#") and marker in line] + if not hits: + raise Ungradable("marker not found: %r" % marker) + if len(hits) > 1: + raise Ungradable("marker matched %d lines (want 1): %r" + % (len(hits), marker)) + + i = hits[0] + j = i + 1 + # Leading comment lines belong to the block's prose, not to its rows. + while j < len(lines) and (lines[j].startswith("#") or not lines[j].strip()): + if not lines[j].strip(): + # A blank line before any row is prose spacing; it does not open + # the block, but it also cannot be a row. + if j + 1 < len(lines) and lines[j + 1].startswith("#"): + j += 1 + continue + j += 1 + rows = [] + while j < len(lines): + line = lines[j] + if not line.strip() or line.startswith("#"): + break + fields = line.split("\t") + if len(fields) < 2: + raise Ungradable("row without an exit-code field: %r" % line[:80]) + code = fields[1].strip() + try: + rc = int(code) + except ValueError: + raise Ungradable("non-integer exit code %r on row %r" + % (code, fields[0][:80])) + rows.append((fields[0], rc)) + j += 1 + return rows + + +def as_dict(marker, rows): + return { + "marker": marker, + "rows": len(rows), + "red": sum(1 for _, rc in rows if rc != 0), + "paths": [p for p, _ in rows], + "red_paths": [p for p, rc in rows if rc != 0], + } + + +# --- selftest --------------------------------------------------------------- + +FIXTURE = ( + "# path\trc\tnote\n" + "# rows added by hand (Q1, fixture): a two-row block.\n" + "# a second prose line, still inside the block\n" + "CHECK-a\t0\tfine\n" + "CHECK-b\t1\tknown red\n" + "\n" + "# rows added by hand (Q2, fixture): a three-row block that must NOT count.\n" + "CHECK-c\t0\tfine\n" + "CHECK-d\t0\tfine\n" + "CHECK-e\t1\tknown red\n" +) + +NAIVE_TO_EOF = sum( + 1 for line in FIXTURE.splitlines() + if line and not line.startswith("#") and "\t" in line + and line.split("\t")[1].strip().isdigit() +) + + +def _write(tmp, name, text): + path = os.path.join(tmp, name) + with open(path, "w", encoding="utf-8") as fh: + fh.write(text) + return path + + +def selftest(): + cells = [] + + def cell(name, ok, detail): + cells.append((name, ok, detail)) + + tmp = tempfile.mkdtemp(prefix="block_rows.") + try: + good = _write(tmp, "fixture.tsv", FIXTURE) + + rows = read_block(good, "rows added by hand (Q1") + cell("boundary", len(rows) == 2, + "Q1 block reads %d row(s), want 2" % len(rows)) + + # The falsifiability cell: the defect this tool replaces counted to EOF. + cell("defect-visible", NAIVE_TO_EOF == 5 and len(rows) == 2, + "marker-to-EOF reads %d, block reads %d -- the boundary moves " + "the number" % (NAIVE_TO_EOF, len(rows))) + + cell("red-count", sum(1 for _, rc in rows if rc != 0) == 1 + and [p for p, rc in rows if rc != 0] == ["CHECK-b"], + "red rows: %r" % ([p for p, rc in rows if rc != 0],)) + + try: + read_block(good, "rows added by hand (Q9") + cell("missing-marker", False, "no marker -> rc 0 (want rc 2)") + except Ungradable: + cell("missing-marker", True, "no marker -> ungradable") + + dup = _write(tmp, "dup.tsv", FIXTURE + + "# rows added by hand (Q1, again)\nCHECK-f\t0\tx\n") + try: + read_block(dup, "rows added by hand (Q1") + cell("ambiguous-marker", False, "two markers -> read one (want rc 2)") + except Ungradable: + cell("ambiguous-marker", True, "two markers -> ungradable") + + bad = _write(tmp, "bad.tsv", "# rows added by hand (Q1 x)\n" + "CHECK-g\tnot-a-code\tx\n") + try: + read_block(bad, "rows added by hand (Q1") + cell("bad-code", False, "non-integer code -> read (want rc 2)") + except Ungradable: + cell("bad-code", True, "non-integer code -> ungradable") + + # A trailing comment with no new marker ends the block too. + trail = _write(tmp, "trail.tsv", "# rows added by hand (Q1 t)\n" + "CHECK-h\t0\tx\n" + "# a trailing note, no marker\n" + "CHECK-i\t1\tx\n") + n = len(read_block(trail, "rows added by hand (Q1")) + cell("trailing-note", n == 1, "trailing comment ends the block: %d row(s)" + % n) + + parsed = as_dict("m", rows) + cell("json-keys", all(k in parsed for k in SUMMARY_KEYS) + and parsed["red_paths"] == ["CHECK-b"], + "summary keys: %s" % ",".join(sorted(parsed))) + finally: + for name in os.listdir(tmp): + os.unlink(os.path.join(tmp, name)) + os.rmdir(tmp) + + bad_cells = [c for c in cells if not c[1]] + for name, ok, detail in cells: + print(" %-16s %s %s" % (name, "PASS" if ok else "FAIL", detail)) + print("block_rows selftest: %d cell(s), %d failed, 0 skipped" + % (len(cells), len(bad_cells))) + return 1 if bad_cells else 0 + + +# --- main ------------------------------------------------------------------- + +def main(argv=None): + ap = argparse.ArgumentParser(description="extract one signed baseline block") + ap.add_argument("--file") + ap.add_argument("--marker") + ap.add_argument("--paths", action="store_true", help="print the block's paths") + ap.add_argument("--red", action="store_true", help="print the non-zero paths") + ap.add_argument("--json", action="store_true") + ap.add_argument("--selftest", action="store_true") + args = ap.parse_args(argv) + + if args.selftest: + return selftest() + if not args.file or not args.marker: + ap.error("--file and --marker are required (or --selftest)") + + try: + rows = read_block(args.file, args.marker) + except Ungradable as exc: + print("block_rows: cannot grade -- %s" % exc, file=sys.stderr) + return 2 + + doc = as_dict(args.marker, rows) + if args.json: + print(json.dumps(doc, sort_keys=True)) + elif args.paths: + for path in doc["paths"]: + print(path) + elif args.red: + for path in doc["red_paths"]: + print(path) + else: + print("rows=%d red=%d" % (doc["rows"], doc["red"])) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/wizard-work/volt/q143-check-sweep/check_entry_baseline.tsv b/wizard-work/volt/q143-check-sweep/check_entry_baseline.tsv index 0427735..e50fe57 100644 --- a/wizard-work/volt/q143-check-sweep/check_entry_baseline.tsv +++ b/wizard-work/volt/q143-check-sweep/check_entry_baseline.tsv @@ -202,11 +202,12 @@ wizard-work/sol/CHECK-sol-profile-file-class-2026-11-02.sh 0 CHECK OK: 69 entrie wizard-work/sol/CHECK-sol-profile-triage-2026-11-02 0 CHECK OK: 69 live top-level entries re-derived; artifact matches disk (measured 0.2s) wizard-work/sol/CHECK-working-tree-triage-2026-11-02 0 PASS: 5 modified files classified and re-derived; all real; by_category={'other': 2, 'script': 3}; shard byte-identical. (measured 0.2s) # row added by hand (Q159 guard, 2026-11-02): CHECK-q159 is the new entry point -# guarding the census this item closed. Five legs, rc 0 measured at this worktree -# with `bash CHECK-q159` (69 s: it runs CHECK-q85-era coverage and a mutant copy). +# guarding the census this item closed. Five legs at the signing; a sixth (scope: +# the block_rows selftest) arrived with the guard's own module, so the tally below +# is the one re-measured on 2026-11-03, and rc stayed 0 through both readings. # The block above is unchanged by this row; the Q159 audit rows and this guard row # are kept apart so the register leg counts 21 audited paths, not 22 files. -CHECK-q159 0 q159: 5 leg(s), all passed +CHECK-q159 0 q159: 6 leg(s), all passed # row added by hand (Q160, 2026-11-03): CHECK-q160 is a NEW entry point -- the # guard for the beam test that bound its module to a host path. Four legs, rc 0 # measured at this worktree with `bash CHECK-q160` (0.9 s); the rows above are @@ -226,3 +227,11 @@ CHECK-q162 0 q162: 4 leg(s), 0 fault(s), rc 0 # row added by hand (Q163, 2026-11-03): CHECK-q163 is the guard for that repair. # Six legs, rc 0 measured with `bash CHECK-q163` at this worktree. CHECK-q163 0 q163: 6 leg(s), 0 fault(s), rc 0 + +# row added by hand (Q165/Q166 landing, 2026-11-03): CHECK-q164 and CHECK-q166 are +# both tracked entry points with no signed row -- each landed with the item it +# guards and nobody registered it, so `check_sweep.py --paths` read them as NEW. +# The codes below were measured at this worktree, not copied from the programs: +# `bash CHECK-q164` 55.1 s, 7 legs, and `bash CHECK-q166` 4 legs. +CHECK-q164 0 q164: 7 leg(s), 0 fault(s), rc 0 +CHECK-q166 0 q166: 4 leg(s), 0 fault(s), rc 0