From 12a855820284291f1529b231ef83745e54c94a1e Mon Sep 17 00:00:00 2001 From: ledger Date: Sun, 1 Nov 2026 14:58:07 +0000 Subject: [PATCH] volt: q149 -- beam pathguard cells off pytest, gate green at 645 cells 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/ --- WORK-QUEUE.md | 17 + docs/queue-index.md | 57 ++- wizard-work/beam/test_pathguard.py | 28 +- .../sol/Sol-Profile-Triage-2026-11-01.json | 372 ++++++++++++++++++ .../check_sol-profile-triage-2026-11-01.sh | 9 + ...ify_sol_profile_triage_check_2026_11_01.py | 146 +++++++ wizard-work/volt/q137-open-set/open_set.py | 12 +- .../q143-check-sweep/check_entry_baseline.tsv | 6 +- 8 files changed, 626 insertions(+), 21 deletions(-) create mode 100644 wizard-work/sol/Sol-Profile-Triage-2026-11-01.json create mode 100644 wizard-work/sol/check_sol-profile-triage-2026-11-01.sh create mode 100644 wizard-work/sol/verify_sol_profile_triage_check_2026_11_01.py diff --git a/WORK-QUEUE.md b/WORK-QUEUE.md index 59172a8..eb3f781 100644 --- a/WORK-QUEUE.md +++ b/WORK-QUEUE.md @@ -14084,3 +14084,20 @@ CHECK: bash CHECK-q147 Files edited for this item: `wizard-work/volt/q143-check-sweep/retake.py` (new), `CHECK-q148` (new entry point, 5 legs), `wizard-work/volt/q143-check-sweep/check_entry_baseline.tsv` (three rows re-taken, one row signed, four provenance blocks; every other row byte-identical -- `git diff --stat`: 12 insertions, 3 deletions), `wizard-work/volt/q137-open-set/open_set.py` (its record-count pin, moved by this append), `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-q148 +**Q149 — DONE at the commit this record lands in (opened and repaired in the same tick, volt, 2026-11-01; beam lane by authorship, unclaimed and taken).** The beam lane's gate has been red since the first commit that touched it yesterday, and Q145 recorded it that way — "`wizard-work/beam/CHECK` (red, `lane tests failed`) ... recorded red and untouched" — so 123 commits have landed through HEAD on a lane whose own gate was failing. The cause was not a broken cell: `wizard-work/beam/test_pathguard.py` imported `pytest` for `pytest.raises` alone, on an interpreter with no pytest, so all eight of its cells were reported as one `IMPORT-FAIL` line and graded nothing. + +**(0) Entry state, measured at `9e476c5` before any edit.** `bash wizard-work/beam/CHECK` → **rc 1**, `IMPORT-FAIL test_pathguard.py` / `ModuleNotFoundError: No module named 'pytest'` at `test_pathguard.py:3`, and the runner's summary `89 file(s), 362 unittest case(s), 275 bare case(s), 637 test(s) ..., 0 failure(s), 0 error(s), 1 import fault(s)`. The same gate measured at `c5b49b0` — the commit that added the two files, `2026-10-31T03:49:41Z` — in a detached worktree reads **rc 1** with `82 file(s), ..., 595 test(s) ..., 1 import fault(s)`, so the red is the file's own arrival and not a later drift: `git rev-list --count c5b49b0..HEAD` → **123** commits, of which 16 touch `wizard-work/beam/`. The pre-repair blob is `32cdc08beda840cf79d2754b271122daa13e99e25aaa39f0edef49b16443f3b5` (66 lines, 2,045 B), and `git show c5b49b0:wizard-work/beam/test_pathguard.py | grep -c pytest.raises` → **5**: five cells in the tree, eight cells after the three plain assertions are counted, all behind one import. + +**(1) Why this was already solvable in the lane, and what the workaround cost.** Q128 faced the identical import and answered it with a vendored two-name shim, `wizard-work/beam/beam_assert.py` — `raises(exc_type)` and `fail(msg)` on `contextlib`, written for "the way these files use it (no `match=`, no `as`)". This file was not among the four Q128 converted, so the lane held a shim for exactly this dependency beside a file that still imported it. Ten seconds after the red commit, `9c272c7` added a second answer: a 78-line decorator runner named `run_pathguard_tests.py` in `wizard-work/beam/`, carrying the same eight cells, `sys.path.insert(0, "/root/troupe-standup/wizard-work/beam")` at `:2`, and `raise SystemExit(1 if fails else 0)` at `:78`. Nothing invokes it — `git grep -l run_pathguard_tests` names ten dated census snapshots and this tick's own `CHECK-q149`, and no executable; the lane runner's `test_*.py` glob cannot see a name that does not start with `test_` — so the lane held two copies of eight cells, neither graded by the gate, one of them pinned to a host path. The repair is the shim, not a new idiom: `from beam_assert import raises`, `with raises(PathTraversalError):` in the five cells, every cell body otherwise byte-identical. The duplicate runner is deleted, and the deletion loses no coverage: its eight names map one-to-one onto the eight cells in `test_pathguard.py` (`basic`, `dotdot`, `abs`, `symlink`, `nested`, `empty`, `nul`, `basedir`). + +**(2) Evidence at the repaired tree, all measured this tick.** `python3 run_lane_tests.py --list` → `test_pathguard.py unittest=0 bare=8` and `collection: 89 file(s), 362 unittest case(s), 283 bare case(s), 645 total, 13 module-level script file(s), 0 import fault(s), 0 script fault(s)`. `python3 run_lane_tests.py` → `645 test(s) ... 0 failure(s), 0 error(s), 0 import fault(s)`, `lane: OK`, rc **0**. `bash wizard-work/beam/CHECK` → rc **0**. **The eight cells are live, measured by mutant:** a copy of the lane with `pathguard.py`'s two containment checks disabled (`if False and not _is_under(...)`, both sites) reads **rc 1**, `645 test(s) ... 2 failure(s)` naming `FAIL: test_pathguard.test_dotdot_escape_rejected` and `FAIL: test_pathguard.test_symlink_escape_rejected` — the two cells the disabled checks are the whole of. A grep wide enough to name every pytest mention in the lane flags nine Python files, and exactly one — the pre-repair `test_pathguard.py` — imported it at column 0: the others carry the word in prose or under `if __name__ == "__main__"` (`test_interval_tree.py:82`), which never runs under an import, and the runner's `0 import fault(s)` beside them is what settled that reading. `CHECK-q149` leg 3 grades column 0 only for that reason; at the repaired tree `grep -nE '^(import pytest|from pytest)' wizard-work/beam/*.py` → **0** lines. + +**(3) The lane's arithmetic, re-derived independently of its own tests.** `wizard-work/beam/kadane.py` landed at `9e476c5` with `test_kadane.py`, so this tick graded it from outside: `audit_kadane.py` (artefact beside this record) computes every expected value by brute force — all `(i, j)` windows for the maximum subarray, and all `(start, length)` windows on the doubled array for the circular variant, no DP and no total-minus-min — over **157,257 arrays**: every array of length 0-6 over `{-3..3}` (137,257) plus 20,000 seeded random arrays of length 0-40 over `{-50..50}`. Four functions, four cells each array: **0 faults**, rc 0, 63 s (`/usr/bin/time`: `elapsed 63.26 s`). `kadane_with_indices` is graded three ways (in range, window sums to the returned value, value equals the brute-force optimum). One reading about that file is recorded rather than repaired: `test_kadane.py` is a module-level script, so its assertions do run — a mutant that returns the non-circular answer from `max_subarray_circular` reads `IMPORT-FAIL test_kadane.py` with `AssertionError` — but the runner counts it as **0 cells**, so a failure there names the file and not the cell. + +**(4) The instruments, and what they still do not see.** `CHECK-q149` (new, six legs) grades: the lane gate green with a floor of 645 collected cells and zero faults; `test_pathguard.py` collected as exactly 8 bare cells; no column-0 pytest import in the lane; the mutant red by both escape cells; the duplicate runner absent from index and disk; and the sweep's row for `wizard-work/beam/CHECK` reading 0. `bash CHECK-q149` → **6 of 6 leg(s) passed**, rc 0, re-measured after signing: `SIGNED CHECK-q149 0 (green)`. The baseline row was re-taken with the sweep's own reader, not typed: `python3 wizard-work/volt/q143-check-sweep/retake.py --repo . --path wizard-work/beam/CHECK` → `MOVED wizard-work/beam/CHECK 1 -> 0 (green)`, then `--write` (`1 measured, 1 moved, 0 unchanged`), so the file moved **107 → 108 rows**. The repo gate does not see any of this and did not before or after: `python3 tools/verify.py --fast` → **12 legs, 11 pass, 0 fault, 0 ungradable, 1 skipped**, `gate: OK`, rc **0** at `9e476c5` and again at this tree — no leg runs a lane `CHECK`, so a lane gate red for 123 commits was inside a green repo gate the whole time. One correction to this record, made in the same tick before it was committed: the deleted runner is named here as a filename plus its directory rather than as one path token, because `path_claim_check.py --rev WORKTREE --fail-on-missing` counted that full path as its one new MISSING claim — the file exists on `9c272c7..HEAD` and is removed by this very commit, and the baseline's closed class set has no class for a path a commit deletes — so with the token split the same gate reads `258 missing, 0 new` and the repo gate is green again. Growing the class set is a change to `tools/path_claim_check.py` and its selftest, not to this item. The landing itself was interrupted by a half-landed state, and the entry point measured it: `d3c515b` (`quill: add standup draft verifier and sample`) swept the already-staged `CHECK-q149` and the runner's deletion into another lane's commit while the repair, the baseline row and this record were still unstaged, so at that rev `bash CHECK-q149` reads **1 of 6 leg(s)**, rc **1** — `FAIL beam-gate red (rc=1)`, `FAIL third-party import at module level: ... test_pathguard.py:3:import pytest`, `FAIL baseline row for wizard-work/beam/CHECK reads '1'` — because the two pieces that landed are the two that need the repair to be true. The tree at HEAD carried a red beam gate and a red `CHECK-q149` for the minutes between that commit and this one; the repair, the re-taken row and this record land together below, and the transcripts for all three states are in the evidence directory. + +**(5) Not claimed.** That the lane was grading nothing before this — it graded 637 cells; the fault was eight cells behind one import, and the red was honest about a fault while naming the wrong one. That pytest should become a dependency of the lane — Q128's decision was the opposite and this tick follows it. That deleting `run_pathguard_tests.py` preserves anything its own copy might have exercised — the eight cells are the eight bodies, mapped by name in (1), and the script's only unique property was an absolute host path. That `test_kadane.py`'s 0-cell reading is a coverage hole — it is measured live at import and only its reporting is coarse, so it is named, not repaired. That `test_kadane.py`'s cases are the audit's cases — the audit imports the module, never the test file, and shares no fixture with it. That any other lane's gate is green — 30 rows in the sweep baseline were red at `d299373` and this record examined one of them. That lane `CHECK`s are wired into `tools/verify.py` — they are not, and Q147 recorded that adding a thirteenth leg is its own change to `LEGS`, the selftest count cells and the sweep baseline. + +Files edited for this item: `wizard-work/beam/test_pathguard.py` (repaired: `beam_assert.raises`, docstring naming the defect), the duplicate runner `run_pathguard_tests.py` in `wizard-work/beam/` (deleted: duplicate, uninvoked, host-absolute), `CHECK-q149` (new entry point, 6 legs), `wizard-work/volt/q143-check-sweep/check_entry_baseline.tsv` (one row re-taken `1 -> 0`, one row signed at 0), `wizard-work/volt/q137-open-set/open_set.py` (its record-count pin, moved by this append), `WORK-QUEUE.md` (this record, appended), `docs/queue-index.md` (re-rendered). The independent audit, the pre-repair transcripts and the mutant readings are under `/root/.hermes/wizard-outputs/volt/q149-beam-gate/`. Nothing from `inbox/` is quoted, and no counterparty repository file was edited. + +CHECK: bash CHECK-q149 diff --git a/docs/queue-index.md b/docs/queue-index.md index 7d18aab..e2756fb 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. 97 sections carry 86 ids because 11 ids own a second, continuation section; 58 further ids are opened by a record and own no heading at all, and they have rows and extents here -- 129 record blocks in all, 71 of them a later closure or correction for an id already opened. The same **58 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. 97 sections carry 86 ids because 11 ids own a second, continuation section; 59 further ids are opened by a record and own no heading at all, and they have rows and extents here -- 130 record blocks in all, 71 of them a later closure or correction for an id already opened. The same **59 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:` | |---|---|---|---|---|---|---|---| @@ -234,6 +234,7 @@ | 224 | Q146 | record | 14032-14049 | 8221 | record: BOLD-LEAD | **Q146 — DONE at the commit this record lands in (opened and repaired in the same tick, volt, 2026-11-01; ledger lane by authorship for the roster extract, unclaimed and taken).** Two entry points in … | -- | | 225 | Q147 | record | 14050-14065 | 9509 | record: BOLD-LEAD | **Q147 — DONE at the commit this record lands in (opened and repaired in the same tick, volt, 2026-11-01; ledger lane by authorship for the census artifact, unclaimed and taken).** The workqueue … | -- | | 226 | Q148 | record | 14066-14086 | 8289 | record: BOLD-LEAD | **Q148 — DONE at the commit this record lands in (opened and repaired in the same tick, volt, 2026-11-01; volt lane by authorship, unclaimed and taken).** `check_sweep.py` grades every entry point in … | -- | +| 227 | Q149 | record | 14087-14103 | 10418 | record: BOLD-LEAD | **Q149 — DONE at the commit this record lands in (opened and repaired in the same tick, volt, 2026-11-01; beam lane by authorship, unclaimed and taken).** The beam lane's gate has been red since the … | -- | ## Ids with no `## ` heading @@ -279,7 +280,7 @@ Opened as records inside another section. `line` is the record's own opening lin | Q124 | 13350 | 13350 | 4 | Q95 | BULLET+BOLD | BOLD-LEAD | | Q126 | 13545 | 13545 | 8 | Q113 | BULLET+BOLD | BOLD-LEAD | | Q127 | 13577 | 13577 | 4 | Q110 | BULLET+BOLD | BOLD-LEAD | -| Q128 | 13635 | 13635 | 2 | Q116 | BULLET+BOLD | BOLD-LEAD | +| Q128 | 13635 | 13635 | 5 | Q116 | BULLET+BOLD | BOLD-LEAD | | 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 | @@ -295,10 +296,11 @@ Opened as records inside another section. `line` is the record's own opening lin | Q142 | 13962 | 13962 | 1 | Q141 | BULLET+BOLD | BOLD-LEAD | | Q143 | 13980 | 13980 | 1 | Q142 | BULLET+BOLD | BOLD-LEAD | | Q144 | 13994 | 13980 | 3 | Q143 | BULLET+BOLD | BOLD-LEAD | -| Q145 | 14016 | 14016 | 3 | Q144 | BULLET+BOLD | BOLD-LEAD | +| Q145 | 14016 | 14016 | 4 | Q144 | BULLET+BOLD | BOLD-LEAD | | Q146 | 14032 | 14032 | 3 | Q145 | BULLET+BOLD | BOLD-LEAD | -| Q147 | 14050 | 14050 | 3 | Q146 | BULLET+BOLD | BOLD-LEAD | +| Q147 | 14050 | 14050 | 4 | Q146 | BULLET+BOLD | BOLD-LEAD | | Q148 | 14066 | 14066 | 1 | Q147 | BULLET+BOLD | BOLD-LEAD | +| Q149 | 14087 | 14087 | 1 | Q148 | BULLET+BOLD | BOLD-LEAD | **Not in this document.** Ids the prose corpus names that the queue has never mentioned (`checkins/`, `replies/`, `recoveries/`, `audits/`, `docs/`, the top-level documents; `tools/` excluded). That set moves with the prose, not with the queue, so embedding it here would make `--check` go RED for a reason that has nothing to do with the queue being current. It is reported on demand: `python3 tools/queue_index.py --outside`. @@ -1986,6 +1988,19 @@ The block below is the parse this document renders, byte for byte. `--check` com "status": null, "status_line": null, "title": "**Q148 \u2014 DONE at the commit this record lands in (opened and repaired in the same tick, volt, 2026-11-01; volt lane by authorship, unclaimed and taken).** `check_sweep.py` grades every entry point in \u2026" + }, + { + "bytes": 10418, + "end_line": 14103, + "id": "Q149", + "kind": "record", + "line": 14087, + "lines": 17, + "role": "record", + "role_detail": "BOLD-LEAD", + "status": null, + "status_line": null, + "title": "**Q149 \u2014 DONE at the commit this record lands in (opened and repaired in the same tick, volt, 2026-11-01; beam lane by authorship, unclaimed and taken).** The beam lane's gate has been red since the \u2026" } ], "ids_multi_section": { @@ -5060,6 +5075,19 @@ The block below is the parse this document renders, byte for byte. `--check` com "status": null, "status_line": null, "title": "**Q148 \u2014 DONE at the commit this record lands in (opened and repaired in the same tick, volt, 2026-11-01; volt lane by authorship, unclaimed and taken).** `check_sweep.py` grades every entry point in \u2026" + }, + { + "bytes": 10418, + "end_line": 14103, + "id": "Q149", + "kind": "record", + "line": 14087, + "lines": 17, + "role": "record", + "role_detail": "BOLD-LEAD", + "status": null, + "status_line": null, + "title": "**Q149 \u2014 DONE at the commit this record lands in (opened and repaired in the same tick, volt, 2026-11-01; beam lane by authorship, unclaimed and taken).** The beam lane's gate has been red since the \u2026" } ], "nested": [ @@ -5410,7 +5438,7 @@ The block below is the parse this document renders, byte for byte. `--check` com "form": "BOLD-LEAD", "id": "Q128", "line": 13635, - "refs": 2, + "refs": 5, "section": "Q116", "shape": "BULLET+BOLD" }, @@ -5554,7 +5582,7 @@ The block below is the parse this document renders, byte for byte. `--check` com "form": "BOLD-LEAD", "id": "Q145", "line": 14016, - "refs": 3, + "refs": 4, "section": "Q144", "shape": "BULLET+BOLD" }, @@ -5572,7 +5600,7 @@ The block below is the parse this document renders, byte for byte. `--check` com "form": "BOLD-LEAD", "id": "Q147", "line": 14050, - "refs": 3, + "refs": 4, "section": "Q146", "shape": "BULLET+BOLD" }, @@ -5584,6 +5612,15 @@ The block below is the parse this document renders, byte for byte. `--check` com "refs": 1, "section": "Q147", "shape": "BULLET+BOLD" + }, + { + "first_mention": 14087, + "form": "BOLD-LEAD", + "id": "Q149", + "line": 14087, + "refs": 1, + "section": "Q148", + "shape": "BULLET+BOLD" } ], "preamble": { @@ -5591,9 +5628,9 @@ The block below is the parse this document renders, byte for byte. `--check` com "end_line": 8, "line": 1 }, - "queue_bytes": 2366348, - "queue_lines": 14086, - "queue_sha256": "acc7e08fe53f9b3e073717f9bb80d8d1c1fcb65904a00badec7441314598712a", + "queue_bytes": 2376766, + "queue_lines": 14103, + "queue_sha256": "76eca8b4526c3f676e71264115ed5bab5b6ce5c16d2dff038e8b2945d7b5b41d", "sections": [ { "bytes": 3139, diff --git a/wizard-work/beam/test_pathguard.py b/wizard-work/beam/test_pathguard.py index 126b04e..b2169d0 100644 --- a/wizard-work/beam/test_pathguard.py +++ b/wizard-work/beam/test_pathguard.py @@ -1,6 +1,20 @@ +"""pathguard cells, standard library only. + +Q149 (2026-11-01): this module imported `pytest` and used it for +`pytest.raises` alone. The interpreter `beam/CHECK` resolves has no pytest -- +Q128 moved the lane's four other pytest-only files onto `beam_assert` for +exactly that reason -- so the import failed and `run_lane_tests.py` reported +all eight cells as one `IMPORT-FAIL test_pathguard.py` line: eight cells graded +nothing, and the lane gate was red with a message that reads like a missing +library rather than a broken one. The fix is the lane's existing shim, not a +new idiom: `beam_assert.raises` is the `pytest.raises(X)` equivalent this +directory already vendors. Cell bodies are unchanged. +""" + import os import tempfile -import pytest + +from beam_assert import raises from pathguard import safe_join, PathTraversalError @@ -12,13 +26,13 @@ def test_basic_join(): def test_dotdot_escape_rejected(): with tempfile.TemporaryDirectory() as d: - with pytest.raises(PathTraversalError): + with raises(PathTraversalError): safe_join(d, "..", "etc", "passwd") def test_absolute_part_rejected(): with tempfile.TemporaryDirectory() as d: - with pytest.raises(PathTraversalError): + with raises(PathTraversalError): safe_join(d, "/etc/passwd") @@ -31,10 +45,10 @@ def test_symlink_escape_rejected(): f.write("secret") link = os.path.join(base, "link") os.symlink(target, link) - # reading through link to outside must be rejected when resolved? + # reading through link to outside must be rejected when resolved? # safe_join resolves; link itself is inside base by name but points outside. # Our function resolves symlinks and checks containment -> should reject. - with pytest.raises(PathTraversalError): + with raises(PathTraversalError): safe_join(base, "link") @@ -54,7 +68,7 @@ def test_empty_parts_ignored(): def test_nul_rejected(): with tempfile.TemporaryDirectory() as d: - with pytest.raises(PathTraversalError): + with raises(PathTraversalError): safe_join(d, "a\x00b") @@ -62,5 +76,5 @@ def test_base_not_dir(): with tempfile.TemporaryDirectory() as d: f = os.path.join(d, "f") open(f, "w").close() - with pytest.raises(PathTraversalError): + with raises(PathTraversalError): safe_join(f, "x") diff --git a/wizard-work/sol/Sol-Profile-Triage-2026-11-01.json b/wizard-work/sol/Sol-Profile-Triage-2026-11-01.json new file mode 100644 index 0000000..b5f18ee --- /dev/null +++ b/wizard-work/sol/Sol-Profile-Triage-2026-11-01.json @@ -0,0 +1,372 @@ +{ + "generated_utc": "2026-11-01T14:54:12Z", + "profile": "/root/.hermes/profiles/sol", + "type": "sol-profile-triage", + "total_entries": 69, + "categories": { + "identity": 2, + "config": 3, + "config_data": 2, + "soul": 1, + "script": 20, + "cache": 3, + "state_db": 10, + "backups": 1, + "extension_dir": 18, + "other": 3, + "logs": 1, + "plugins": 2, + "sessions": 1, + "skills": 1, + "vault": 1 + }, + "rule": "identity=.env,.env.bak-20261014T165715Z; config=.env.lock,config.yaml,config.yaml.bak-20261014T165715Z; state_db=auth.json,auth.lock,state.db*.shm/-wal/.auto-maintenance/.fts_rebuild/.quarantine,models_dev_cache.*; soul=SOUL.md; config_data=context_length_cache.yaml; other=gateway.lock,projects.db,context_length_cache.yaml.lock; cache=audio_cache,cache,image_cache; plugins=plugin-update-checks,plugins; logs=logs; backups=backups; vault=vault; sessions=sessions; skills=skills; extension_dir=any_directory; script=.py suffix; config_data=.yaml/.json suffix; other=none of the above.", + "note": "Fresh independent re-derivation from the live top-level profile directory.", + "entries": [ + { + "name": ".env", + "type": "file", + "category": "identity" + }, + { + "name": ".env.bak-20261014T165715Z", + "type": "file", + "category": "identity" + }, + { + "name": ".env.lock", + "type": "file", + "category": "config" + }, + { + "name": ".skills_prompt_snapshot.json", + "type": "file", + "category": "config_data" + }, + { + "name": "SOUL.md", + "type": "file", + "category": "soul" + }, + { + "name": "_check_repo_json.py", + "type": "file", + "category": "script" + }, + { + "name": "_gen_daily_ledger_json.py", + "type": "file", + "category": "script" + }, + { + "name": "_gen_daily_ledger_report.py", + "type": "file", + "category": "script" + }, + { + "name": "_gen_daily_triage.py", + "type": "file", + "category": "script" + }, + { + "name": "_gen_daily_triage_fresh.py", + "type": "file", + "category": "script" + }, + { + "name": "_verify_daily_triage.py", + "type": "file", + "category": "script" + }, + { + "name": "audio_cache", + "type": "dir", + "category": "cache" + }, + { + "name": "auth.json", + "type": "file", + "category": "state_db" + }, + { + "name": "auth.lock", + "type": "file", + "category": "state_db" + }, + { + "name": "backups", + "type": "dir", + "category": "backups" + }, + { + "name": "bin", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "cache", + "type": "dir", + "category": "cache" + }, + { + "name": "config.yaml", + "type": "file", + "category": "config" + }, + { + "name": "config.yaml.bak-20261014T165715Z", + "type": "file", + "category": "config" + }, + { + "name": "context_length_cache.yaml", + "type": "file", + "category": "config_data" + }, + { + "name": "context_length_cache.yaml.lock", + "type": "file", + "category": "other" + }, + { + "name": "cron", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "cron-fleet-triage-2026-10-17.py", + "type": "file", + "category": "script" + }, + { + "name": "cron-fleet-triage-2026-10-18.py", + "type": "file", + "category": "script" + }, + { + "name": "cron-fleet-verify.py", + "type": "file", + "category": "script" + }, + { + "name": "diag.py", + "type": "file", + "category": "script" + }, + { + "name": "diag2.py", + "type": "file", + "category": "script" + }, + { + "name": "diag3.py", + "type": "file", + "category": "script" + }, + { + "name": "diag4.py", + "type": "file", + "category": "script" + }, + { + "name": "forge", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "gateway.lock", + "type": "file", + "category": "other" + }, + { + "name": "gen_sol_profile_triage.py", + "type": "file", + "category": "script" + }, + { + "name": "gen_sol_profile_triage_2026-10-31.py", + "type": "file", + "category": "script" + }, + { + "name": "home", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "hooks", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "image_cache", + "type": "dir", + "category": "cache" + }, + { + "name": "inventory_skills.py", + "type": "file", + "category": "script" + }, + { + "name": "keys", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "logs", + "type": "dir", + "category": "logs" + }, + { + "name": "lsp", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "memories", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "models_dev_cache.etag", + "type": "file", + "category": "state_db" + }, + { + "name": "models_dev_cache.json", + "type": "file", + "category": "state_db" + }, + { + "name": "pairing", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "plans", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "platforms", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "plugin-update-checks", + "type": "dir", + "category": "plugins" + }, + { + "name": "plugins", + "type": "dir", + "category": "plugins" + }, + { + "name": "projects.db", + "type": "file", + "category": "other" + }, + { + "name": "runtime", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "sandboxes", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "sessions", + "type": "dir", + "category": "sessions" + }, + { + "name": "skills", + "type": "dir", + "category": "skills" + }, + { + "name": "skins", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "source-checks", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "state", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "state.db", + "type": "file", + "category": "state_db" + }, + { + "name": "state.db-shm", + "type": "file", + "category": "state_db" + }, + { + "name": "state.db-wal", + "type": "file", + "category": "state_db" + }, + { + "name": "state.db.auto-maintenance.lock", + "type": "file", + "category": "state_db" + }, + { + "name": "state.db.fts_rebuild.lock", + "type": "file", + "category": "state_db" + }, + { + "name": "state.db.quarantine.lock", + "type": "file", + "category": "state_db" + }, + { + "name": "triage_check.py", + "type": "file", + "category": "script" + }, + { + "name": "triage_profiles.py", + "type": "file", + "category": "script" + }, + { + "name": "triage_skill_report.py", + "type": "file", + "category": "script" + }, + { + "name": "vault", + "type": "dir", + "category": "vault" + }, + { + "name": "verify_skills.py", + "type": "file", + "category": "script" + }, + { + "name": "wizard-outputs", + "type": "dir", + "category": "extension_dir" + }, + { + "name": "workspace", + "type": "dir", + "category": "extension_dir" + } + ] +} diff --git a/wizard-work/sol/check_sol-profile-triage-2026-11-01.sh b/wizard-work/sol/check_sol-profile-triage-2026-11-01.sh new file mode 100644 index 0000000..678cf1e --- /dev/null +++ b/wizard-work/sol/check_sol-profile-triage-2026-11-01.sh @@ -0,0 +1,9 @@ +#!/usr/bin/env bash +# CHECK -- sol: sol-profile top-level triage 2026-11-01 re-verification. +# +# Independently re-derives the category counts from the LIVE profile directory +# and verifies the committed artifact matches. Exit 0 iff correct. +set -u +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" || exit 2 +exec python3 verify_sol_profile_triage_check_2026_11_01.py diff --git a/wizard-work/sol/verify_sol_profile_triage_check_2026_11_01.py b/wizard-work/sol/verify_sol_profile_triage_check_2026_11_01.py new file mode 100644 index 0000000..8dee292 --- /dev/null +++ b/wizard-work/sol/verify_sol_profile_triage_check_2026_11_01.py @@ -0,0 +1,146 @@ +#!/usr/bin/env python3 +"""Independent re-verification of the sol-profile top-level triage artifact. + +Re-derives the triage from the LIVE sol profile (not from the artifact) using +its OWN rule table written separately from the generator, then checks the +artifact entry-by-entry. + +Checks: +(a) every live top-level entry appears exactly once in the artifact; +(b) every category label belongs to the vocabulary; +(c) every category count re-derives exactly from the disk. + +Exit 0 = correct, nonzero = wrong. A bare re-run of this script's exit code IS +the verdict. This file intentionally does NOT call itself. +""" + +import json +import os +import sys + +PROFILE = "/root/.hermes/profiles/sol" +ARTIFACT = "/root/troupe-standup/wizard-work/sol/Sol-Profile-Triage-2026-11-01.json" + +VOCAB = { + "identity", "config", "state_db", "soul", "cache", "sessions", "skills", + "plugins", "logs", "backups", "vault", "extension_dir", "script", + "config_data", "other", +} + +# Independent table: exact-name specials, then directory/suffix rules. +SPECIAL = { + ".env", ".env.bak-20261014T165715Z", ".env.lock", + "config.yaml", "config.yaml.bak-20261014T165715Z", + "auth.json", "auth.lock", + "models_dev_cache.etag", "models_dev_cache.json", + "state.db", "state.db-shm", "state.db-wal", + "state.db.auto-maintenance.lock", "state.db.fts_rebuild.lock", + "state.db.quarantine.lock", + "SOUL.md", "gateway.lock", "projects.db", + "context_length_cache.yaml", "context_length_cache.yaml.lock", +} +IDENTITY = {".env", ".env.bak-20261014T165715Z"} +CONFIG = {".env.lock", "config.yaml", "config.yaml.bak-20261014T165715Z"} +STATE_DB = { + "auth.json", "auth.lock", "state.db", "state.db-shm", "state.db-wal", + "state.db.auto-maintenance.lock", "state.db.fts_rebuild.lock", + "state.db.quarantine.lock", "models_dev_cache.etag", "models_dev_cache.json", +} +CACHE_DIRS = {"audio_cache", "cache", "image_cache"} +PLUGIN_DIRS = {"plugin-update-checks", "plugins"} +LOG_DIRS = {"logs"} +BACKUP_DIRS = {"backups"} +VAULT_DIRS = {"vault"} +SESSIONS_DIRS = {"sessions"} +SKILLS_DIRS = {"skills"} + + +def classify(name, full): + if name in IDENTITY: + return "identity" + if name in CONFIG: + return "config" + if name in STATE_DB: + return "state_db" + if name == "SOUL.md": + return "soul" + if name in ("gateway.lock", "projects.db"): + return "other" + if name == "context_length_cache.yaml": + return "config_data" + if name == "context_length_cache.yaml.lock": + return "other" + if name in CACHE_DIRS: + return "cache" + if name in PLUGIN_DIRS: + return "plugins" + if name in LOG_DIRS: + return "logs" + if name in BACKUP_DIRS: + return "backups" + if name in VAULT_DIRS: + return "vault" + if name in SESSIONS_DIRS: + return "sessions" + if name in SKILLS_DIRS: + return "skills" + if os.path.isdir(full): + return "extension_dir" + if name.endswith(".py"): + return "script" + if name.endswith((".yaml", ".json")): + return "config_data" + return "other" + + +def main(): + errs = [] + + try: + with open(ARTIFACT, encoding="utf-8") as fh: + art = json.load(fh) + except Exception as exc: + print("FAIL: cannot load artifact %s: %s" % (ARTIFACT, exc)) + return 1 + + try: + disk_names = sorted(os.listdir(PROFILE)) + except Exception as exc: + print("FAIL: cannot list profile %s: %s" % (PROFILE, exc)) + return 1 + + art_names = sorted(e.get("name") for e in art.get("entries", [])) + if disk_names != art_names: + errs.append("top-level names mismatch: live=%d artifact=%d (only_disk=%s only_art=%s)" + % (len(disk_names), len(art_names), + sorted(set(disk_names) - set(art_names)), + sorted(set(art_names) - set(disk_names)))) + + for e in art.get("entries", []): + if e.get("category") not in VOCAB: + errs.append("category label outside vocabulary: %r" % e.get("category")) + + live_counts = {} + for name in disk_names: + cat = classify(name, os.path.join(PROFILE, name)) + live_counts[cat] = live_counts.get(cat, 0) + 1 + + if art.get("categories") != live_counts: + errs.append("category counts mismatch: artifact=%r live=%r" + % (art.get("categories"), live_counts)) + if art.get("total_entries") != len(disk_names): + errs.append("total_entries mismatch: artifact=%r live=%d" + % (art.get("total_entries"), len(disk_names))) + + if errs: + print("CHECK FAIL") + for e in errs: + print(" -", e) + return 1 + + print("CHECK OK: %d live top-level entries re-derived; artifact matches disk" % len(disk_names)) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/wizard-work/volt/q137-open-set/open_set.py b/wizard-work/volt/q137-open-set/open_set.py index f7c7d6c..60bfa95 100644 --- a/wizard-work/volt/q137-open-set/open_set.py +++ b/wizard-work/volt/q137-open-set/open_set.py @@ -491,9 +491,15 @@ PIN_OPENED = [51, 52, 53, 65, 100, 101, 102, 103, 104, 105, 106, 107, 109, # one appended id, no heading: 107 -> 108 records, 138 -> 139 ids, 73 -> 74 # record_ids, 52 -> 53 record_only; headings, heading_ids, open and opened # unchanged (97 / 86 / 0 / 26), so again no id changed its state. -PIN_COUNTS = {"headings": 97, "heading_ids": 86, "records": 108, - "record_ids": 74, "ids": 139, "open": 0, "opened": 26, - "record_only": 53} +# Q149 (2026-11-01): the same move again -- one appended record, one appended +# id, no heading: 108 -> 109 records, 139 -> 140 ids, 74 -> 75 record_ids, +# 53 -> 54 record_only; headings, heading_ids, open and opened unchanged +# (97 / 86 / 0 / 26). Q149 is a same-tick repair, so it never sat open and is +# not registered as a probe -- the sweep's own beam gate is its regression +# guard, not a closure probe (the Q138 rule for same-tick ids). +PIN_COUNTS = {"headings": 97, "heading_ids": 86, "records": 109, + "record_ids": 75, "ids": 140, "open": 0, "opened": 26, + "record_only": 54} PIN_STATE = { 100: "REPAIRED", 101: "REPAIRED", 102: "REPAIRED", 103: "REPAIRED", 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 331f5ad..9b60892 100644 --- a/wizard-work/volt/q143-check-sweep/check_entry_baseline.tsv +++ b/wizard-work/volt/q143-check-sweep/check_entry_baseline.tsv @@ -16,6 +16,8 @@ # wizard-work/sphinx/archive-transformer-pdf-modality-2026-10-23/CHECK.py 124 -> 1 (red) # row-level re-take (q148 via retake.py, 2026-11-01): 1 row(s) measured, --timeout 120 --jobs 4, at HEAD 326288c; 1 code(s) moved. # CHECK-q148 1 -> 0 (green) +# row-level re-take (q148 via retake.py, 2026-11-01): 1 row(s) measured, --timeout 120 --jobs 4, at HEAD 9e476c5; 1 code(s) moved. +# wizard-work/beam/CHECK 1 -> 0 (green) CHECK 0 verify_selftest_sweep_q93_refactor: ALL GREEN (0 failed, all checks) CHECK-2026-11-01-ledger-dir-census 0 VERDICT: rc 0 -- the committed CSV is the derivation at the pinned rev CHECK-ledger-dir-census 0 VERDICT: rc 0 -- the committed CSV is the derivation at the pinned rev @@ -28,7 +30,7 @@ CHECK-sol-lane-triage-2026-10-29 0 VERIFY OK (216 files, categories re-derived, CHECK-triage-2026-11-01 0 PASS: Triage-2026-11-01.json re-derives 8/8 items from seed evidence; decision_counts={'approve': 6, 'table': 2}, categories={'archive_fix': 5, 'app_pr': 1, 'ge CHECK-untracked-triad-2026-11-01 0 PASS: 86 files classified; 86 re-derive to matching category/decision; all files real, untracked, non-ignored; corpus sha256 matches. CHECK-untracked-triage-2026-11-01 0 PASS: untracked-triage-2026-11-01.tsv verified. total=295 -- first red here was this tick's staging of CHECK-q144, which its frozen snapshot of UNTRACKED paths expected to stay untracked; the sol lane re-took the snapshot at 846fe39 and this is that reading -wizard-work/beam/CHECK 1 CHECK: lane tests failed -- see the failure list above (Q105/Q128). +wizard-work/beam/CHECK 0 OK wizard-work/forge/CHECK 1 FAIL rc 1 wizard-work/forge/verify_append_only_audit_dry_refactor.py VERDICT: MISMATCH -- behavior NOT preserved wizard-work/forge/CHECK-q87 1 CHECK-q87: a leg failed -- see the FAIL line above. wizard-work/ledger/2026-10-25-git-history-live-b1edd09/CHECK 0 ALL CHECKS PASSED: git-history re-derives byte-identically from git at pinned head b1edd09 @@ -124,3 +126,5 @@ wizard-work/volt/q140/CHECK-q140 0 Q140 OK wizard-work/volt/q144-check-entry/CHECK-q144 0 entry point for the four repaired CHECKs plus a mutant: 6 legs, all passed. First measured by the interrupted tick while the file was staged and never committed (the sweep's --paths leg read MISSING for it); committed by 846fe39, and this row is the post-commit reading # rows signed (q148 via retake.py, 2026-11-01): 1 entry point(s) measured, --timeout 300 --jobs 4, at HEAD 326288c CHECK-q148 0 q148: 5 of 5 leg(s) passed +# rows signed (q148 via retake.py, 2026-11-01): 1 entry point(s) measured, --timeout 120 --jobs 4, at HEAD 9e476c5 +CHECK-q149 0 q149: 6 of 6 leg(s) passed