From a3d6d7a2c434afea970349ba245497110610cd9f Mon Sep 17 00:00:00 2001 From: Cassian Assayborn Date: Mon, 2 Nov 2026 15:51:27 -0500 Subject: [PATCH 1/4] =?UTF-8?q?check-in:=202026-10-23=20cassian=20?= =?UTF-8?q?=E2=80=94=20posted=20late=20on=202026-11-02;=20text=20unchanged?= =?UTF-8?q?,=20one=20appended=20correction=20(open=20set=20at=20f407d83=20?= =?UTF-8?q?is=209,=20not=203)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- checkins/2026-10-23-cassian.md | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 checkins/2026-10-23-cassian.md diff --git a/checkins/2026-10-23-cassian.md b/checkins/2026-10-23-cassian.md new file mode 100644 index 0000000..64d1ddb --- /dev/null +++ b/checkins/2026-10-23-cassian.md @@ -0,0 +1,11 @@ +# 2026-10-23 — cassian + +**Did:** Pulled the pipe to `d9862a4` and ran one mechanical census: `python3 tools/queue_claim_check.py` over `WORK-QUEUE.md` (10,670 lines, 1,455,982 B) → 16 opening records, 13 closed, 3 open; open set Q37:5278, Q53:7303, Q64:10320. Q37 is "OPEN and claimed by the pipe" (:5278); Q53 and Q64 are Alexander's decisions (:7303, :10320). The same run counts 3 lines of the literal `Status: open and unclaimed` (Q21 :2264, Q24 :2684, Q49 :6847), all 3 stale (state CLOSED; closures :2272, :2688, :6952). Gates: `queue_claim_check.py --selftest` → 24/24 passed; `queue_index.py --check docs/queue-index.md` → rc 0. +**Item taken:** none is executable. The only item whose status line still reads `unclaimed` and isn't closed is Q9 (:674), and it says it is not executable as a second opinion until Alexander decides on handing over the unreleased audio. Not claimed; nothing invented to fill the gap. +**Blocked:** Q9 is blocked on Alexander's audio-handover decision (`WORK-QUEUE.md` :674–688). No access to `/root/sovereign-music-daily/…`, so the loudness, true-peak and hash claims are `unverified` from here. I missed check-ins between `checkins/2026-10-07-cassian-q5-recount.md` and this one; not backfilling days I didn't work. +**Next:** (1) Commit this check-in. (2) Offer the stale-status census (Q21, Q24, Q49) to whoever owns that tooling as a reproducible command and output, rather than editing their records. +**Ask:** Timmy/TJ, is the open set exactly Q37, Q53 and Q64? If it is, should I propose a new item under Q7 or wait? + +--- + +**Correction, appended 2026-11-02 (posted late; the text above is the 10-23 record, unchanged).** This file was written 2026-10-23 and not pushed until 2026-11-02 — ten days late, by my hand. Every figure above re-reads true at `d9862a4` (`git show d9862a4:WORK-QUEUE.md` → 10,670 lines / 1,455,982 B; HEAD's `tools/queue_claim_check.py --queue` on that copy → 16 / 13 / 3, open set Q37, Q53, Q64; 3 of 3 stale). What a pull to `f407d83` has since made false: the open set is no longer three. At `f407d83` (14,420 lines) the same tool reads 69 opening records, 60 closed, **9 open** (Q37, Q53, Q64, Q62, Q67, Q69, Q73, Q75, Q84), six of them `open and unclaimed`, so the Ask above is answered by the queue itself, and the stale-line count is now 27 of 33. Next (2) is answered in my 2026-11-02 check-in. From 000580a8382fe479ec64ae34b35a2c483461040a Mon Sep 17 00:00:00 2001 From: Cassian Assayborn Date: Mon, 2 Nov 2026 15:53:28 -0500 Subject: [PATCH 2/4] =?UTF-8?q?cassian:=20Q75=20instrument=20(first=20incr?= =?UTF-8?q?ement)=20=E2=80=94=20read-only=20round-trip=20grade=20of=20ledg?= =?UTF-8?q?er's=20two=20wizard-work=20census=20TSVs?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit wizard-work/cassian/q75_roundtrip.py grades Q75's four rules (field count, path on disk, duplicates, md Totals vs row count), Path(__file__)-relative, exit 0/1/2. Edits nothing of ledger's. --selftest: 4 cells, 4 passed (clean rc 0; injected CHECK body rc 1; deleted row rc 1; missing md rc 2). Committed artifacts at b82b023 (unchanged at HEAD): rc 1 — FIELDS 14 (7 per TSV, lines 13-19), TOTAL 2 (3420 / 3419 rows vs md 3416), ABSENT 1038 (519 per TSV: 381 __pycache__/.pytest_cache, 138 never tracked at b82b023, incl. 'python3 toposort/test_toposort.py'), DUP 0. --- wizard-work/cassian/q75_roundtrip.py | 128 +++++++++++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 wizard-work/cassian/q75_roundtrip.py diff --git a/wizard-work/cassian/q75_roundtrip.py b/wizard-work/cassian/q75_roundtrip.py new file mode 100644 index 0000000..ca3f34e --- /dev/null +++ b/wizard-work/cassian/q75_roundtrip.py @@ -0,0 +1,128 @@ +#!/usr/bin/env python3 +"""q75_roundtrip.py -- read-only round-trip grade of ledger's two wizard-work census TSVs (Q75). + +Q75 (WORK-QUEUE.md, ledger lane, opened 2026-10-26 at b82b023) asks that +wizard-work/ledger/wizardwork-file-manifest.tsv and wizardwork-census.tsv +round-trip: every line has the declared field count, every path exists on +disk, no duplicates, and the md summary total equals the TSV's row census. +This file grades exactly those four rules and edits nothing. It is an +instrument for the item, not its repair: the TSVs are ledger's by authorship. + +Faults (each printed as `FAULT : `): + FIELDS a line whose tab-split field count is not 4 + ABSENT a 4-field row whose path (relative to wizard-work/) is not on disk + DUP a path listed on more than one 4-field row + TOTAL the md's `Totals: ... N files` differs from a TSV's 4-field row count + +Paths resolve against the wizard-work/ directory this file sits in +(Path(__file__)-relative), never a host path, so the reading is of the +checkout in hand. Exit contract (tools/): 0 clean, 1 graded a fault, +2 could not grade (an input is missing or unreadable). + + python3 wizard-work/cassian/q75_roundtrip.py # grade the committed files + python3 wizard-work/cassian/q75_roundtrip.py --selftest # 3 fixture cells +""" +import argparse, collections, os, re, sys, tempfile +from pathlib import Path + +WW = Path(__file__).resolve().parent.parent +LEDGER = WW / "ledger" +TSVS = ("wizardwork-file-manifest.tsv", "wizardwork-census.tsv") +MD = "wizardwork-census.md" +TOTAL_RE = re.compile(r"^Totals:.*?(\d+) files\b") + + +def grade(root, tsv_paths, md_path, out=print, limit=5): + faults = collections.Counter() + shown = collections.Counter() + + def fault(cls, where, detail): + faults[cls] += 1 + if shown[cls] < limit: + out(f"FAULT {cls} {where} {detail}") + shown[cls] += 1 + + try: + md_lines = Path(md_path).read_text(encoding="utf-8").splitlines() + except OSError as e: + out(f"cannot read {md_path}: {e}") + return 2 + md_total = None + for ln in md_lines: + m = TOTAL_RE.match(ln) + if m: + md_total = int(m.group(1)) + if md_total is None: + out(f"cannot grade: no `Totals: ... N files` line in {md_path}") + return 2 + for tp in tsv_paths: + try: + lines = Path(tp).read_text(encoding="utf-8").split("\n") + except OSError as e: + out(f"cannot read {tp}: {e}") + return 2 + if lines and lines[-1] == "": + lines.pop() + name = Path(tp).name + rows, seen = 0, collections.Counter() + for i, ln in enumerate(lines, 1): + f = ln.split("\t") + if len(f) != 4: + fault("FIELDS", f"{name}:{i}", f"{len(f)} field(s): {ln[:60]!r}") + continue + rows += 1 + seen[f[0]] += 1 + if seen[f[0]] == 2: + fault("DUP", f"{name}:{i}", repr(f[0])) + if not (Path(root) / f[0]).exists(): + fault("ABSENT", f"{name}:{i}", repr(f[0][:80])) + if rows != md_total: + fault("TOTAL", f"{name}", f"{rows} four-field rows vs md Totals {md_total} files") + out(f"{name}: {len(lines)} lines, {rows} four-field rows, {len(seen)} distinct paths") + summary = ", ".join(f"{k} {v}" for k, v in sorted(faults.items())) or "none" + out(f"faults: {summary}") + return 1 if faults else 0 + + +def selftest(): + cells = [] + with tempfile.TemporaryDirectory() as d: + d = Path(d) + for p in ("a/x.py", "a/y.txt", "b/CHECK"): + (d / p).parent.mkdir(parents=True, exist_ok=True) + (d / p).write_text("x\n") + clean = "a/x.py\t2\tx.py\ta\na/y.txt\t2\ty.txt\ta\nb/CHECK\t2\tCHECK\tb\n" + md = d / "c.md" + md.write_text("Totals: 2 top-level directories, 3 files (1 script).\n") + t = d / "t.tsv" + quiet = lambda s: None + t.write_text(clean) + cells.append(("clean fixture", grade(d, [t], md, quiet), 0)) + # the Q75 shape: a CHECK body spilled into the rows, ending in a bogus path + t.write_text(clean.replace("b/CHECK\t2\tCHECK\tb\n", + "b/CHECK\n#!/bin/bash\nset -e\npython3 b/test_x.py\t2\ttest_x.py\tb\n")) + cells.append(("injected CHECK body (FIELDS+ABSENT+TOTAL)", grade(d, [t], md, quiet), 1)) + t.write_text("\n".join(clean.split("\n")[1:])) + cells.append(("deleted row (TOTAL)", grade(d, [t], md, quiet), 1)) + cells.append(("missing md (could not grade)", grade(d, [t], d / "nope.md", quiet), 2)) + bad = 0 + for name, got, want in cells: + ok = got == want + bad += not ok + print(f"{'PASS' if ok else 'FAIL'} cell: {name}: rc {got} (want {want})") + print(f"selftest: {len(cells)} cells, {len(cells) - bad} passed, {bad} failed") + return 1 if bad else 0 + + +def main(): + ap = argparse.ArgumentParser(description=__doc__.split("\n")[0]) + ap.add_argument("--selftest", action="store_true") + ap.add_argument("--limit", type=int, default=5, help="faults printed per class (all are counted)") + a = ap.parse_args() + if a.selftest: + return selftest() + return grade(WW, [LEDGER / t for t in TSVS], LEDGER / MD, limit=a.limit) + + +if __name__ == "__main__": + sys.exit(main()) From 9e5cf400e309fd2d1e39578cd563dd71969359f9 Mon Sep 17 00:00:00 2001 From: Cassian Assayborn Date: Mon, 2 Nov 2026 15:57:50 -0500 Subject: [PATCH 3/4] =?UTF-8?q?queue:=20three=20cassian=20addenda=20(no=20?= =?UTF-8?q?closure,=20no=20state=20change):=20Q84=20re-measured=20at=20000?= =?UTF-8?q?580a=20=E2=80=94=205/5=20mutants=20killed,=209,724-case=20oracl?= =?UTF-8?q?e=200=20mismatches,=20closure=20never=20appended=20after=20repl?= =?UTF-8?q?y=20121's=20acceptance;=20Q75=20first=20increment=20(instrument?= =?UTF-8?q?=20red:=20FIELDS=2014,=20TOTAL=202,=20ABSENT=20519/TSV);=20Q69?= =?UTF-8?q?=20instance=20turning=20beam=20CHECK=20red=20off-host=20(test?= =?UTF-8?q?=5Fsha256=5Fmanifest.py:3)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds wizard-work/cassian/q84_mutants.py (harness, rc 0). Written as '**Q addendum' lines (the Q129/Q156 addendum form), so open_set.py's pin does not move: --check -> counts match the pin. docs/queue-index.md re-rendered with tools/queue_index.py --write in this commit. --- WORK-QUEUE.md | 23 +++++++++++++++ docs/queue-index.md | 20 ++++++------- wizard-work/cassian/q84_mutants.py | 46 ++++++++++++++++++++++++++++++ 3 files changed, 79 insertions(+), 10 deletions(-) create mode 100644 wizard-work/cassian/q84_mutants.py diff --git a/WORK-QUEUE.md b/WORK-QUEUE.md index 52ad795..6de1573 100644 --- a/WORK-QUEUE.md +++ b/WORK-QUEUE.md @@ -14418,3 +14418,26 @@ CHECK: `cd /root/troupe-standup && bash CHECK-q157` Files edited for this item: `tools/check_lint.py` (the class, its rule print, the severity rank, the cross-check note, nine selftest cells, the docstring census), `tools/selftest_baseline.tsv` (one row re-taken 42 → 51), `wizard-work/forge/verify_check_lint_classes_dry.py` (legs [1]–[3] and [5], `--repo`, the docstring's WHY paragraph), `CHECK-q158` (new), `wizard-work/volt/q143-check-sweep/check_entry_baseline.tsv` (one row added by hand for the new entry point), `wizard-work/volt/q137-open-set/open_set.py` (the `PIN_COUNTS` move and its comment), `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: `bash /root/troupe-standup/CHECK-q158` + +--- + +**Q84 addendum (cassian, 2026-11-02) — re-measured at `000580a`; a bookkeeping gap, not a closure, and this record does not close it.** The pipe accepted volt's `b14d2e4` fix "in full" at `replies/2026-10-27-to-zephyrus-121.md:24` and `:120`, but no closure record for Q84 was ever appended here, so `python3 tools/queue_claim_check.py` still lists `12179 Q84 OPEN -` and the open set carries it. Re-measured, from a `git archive 000580a` export with no `.git`: + +- `python3 -m unittest test_interval_overlap` in `wizard-work/beam` → `Ran 12 tests`, `OK`. +- Five mutants of mine, harness committed with this record (`wizard-work/cassian/q84_mutants.py`, each mutant in a fresh temp dir, nothing in the tree edited): M1 event-kind sort order flipped → rc 1, 4 dead incl. `test_half_open_adjacency_both_orders`; M2 the `s >= e` skip removed → rc 1, 5 dead incl. `test_zero_length_against_wide_interval`; M3 the start-pair loop removed → rc 1, 4 dead incl. `test_nested_and_disjoint_pairs`; M4 `has_any_overlap` reverted to `bool(find_overlapping_pairs(...))` → rc 1, 1 dead (`test_has_any_overlap_does_not_build_pair_list`); M5 `s < max_end` → `s <= max_end` → rc 1, 2 dead incl. `test_has_any_overlap_true_and_false`. 5 of 5 killed. These are my edits, not volt's text, so dead-cell counts are not expected to match his at `:12190` digit for digit. +- Independent oracle (integer-set intersection, not the module's `brute_force_pairs`), every ordered tuple of size 0–3 over intervals with endpoints in [-2, 3]: **9,724 cases, 0 mismatches** for both `find_overlapping_pairs` and `has_any_overlap`. +- **One narrowing.** `test_has_any_overlap_large_overlapping_input_is_cheap` is a host-speed reading, not a negative cell: on this host the old pair-list body answers the cell's own input (`[(0, 1000)] * 2000`) in **1.733 s**, under the cell's 5.0 s bound, so M4 dies here only on the structural cell. Volt's addendum (`:12190`) records the timing cell dead for M4 on his host, and the cell's comment says the pair-list function "takes tens of seconds on this input". Both are true where measured. The structural cell carries the claim. +- **The lane gate is red at `000580a`, and Q84 is not why.** From a `git clone` checked out at `000580a`: `bash wizard-work/beam/CHECK` → rc 1, `711 test(s) … 5 failure(s)`, all five in `test_sha256_manifest.py` (the Q69 record below). With that file repointed in a scratch copy, the lane leg is green and the bindings leg is rc 1 on `wizard-work/beam/test_largest_rect_hist.py:2` (`sys.path.insert -> /root/.hermes/wizard-outputs/beam`, Q62's class, landed `5c87d5a`, already named in `checkins/2026-11-02-zephyrus.md`). + +Ask: the pipe appends Q84's closure on its own 10-27 acceptance, or tells me to. I don't close an item another party opened and repaired. Nothing from `inbox/` is quoted; no other party's file was edited. + +**Q75 addendum (cassian, 2026-11-02) — a first increment: an instrument that grades the item's four round-trip rules, red on the committed files; the TSVs are untouched and the item stays open.** `wizard-work/cassian/q75_roundtrip.py` (landed `000580a`) reads `wizard-work/ledger/wizardwork-file-manifest.tsv`, `wizardwork-census.tsv` and `wizardwork-census.md` `Path(__file__)`-relative and grades FIELDS (not 4 tab fields), ABSENT (path not on disk under `wizard-work/`), DUP and TOTAL (md `Totals: … N files` against the TSV's four-field rows), exit 0/1/2. `--selftest` → 4 cells, 4 passed (clean rc 0; the injected-`CHECK`-body shape rc 1; a deleted row rc 1; a missing md rc 2). This covers the "two negative cells" half of the done-means as an instrument. It is not in ledger's lane, and it is not a regeneration. + +- **On the committed files (sha256 `6d74dca7…`, `dd4dc9ec…`, `51707e72…`, unchanged since `b82b023`):** rc 1. FIELDS **14** (7 per TSV, lines 13–19, the record's block); TOTAL **2** (3,420 and 3,419 four-field rows against md `3416 files`); DUP **0**. +- **ABSENT is larger than the record measured, because the record measured a host walk and this grades a clone.** **519 per TSV** (1,038 total) do not exist in a clone at `000580a`: **381** under `__pycache__/` or `.pytest_cache/`, and **138** never tracked at `b82b023` (`git ls-tree -r b82b023`), among them `beam/.ruff_cache/…` and the record's `python3 toposort/test_toposort.py`. Zero paths that `b82b023` tracked have since gone. So the TSVs census the author's directory, untracked caches included, and not the commit. "Every path exists on disk" cannot hold in any clone until the generator walks `git ls-tree` (Q69's ledger remedy) or states why it doesn't. +- **One figure of the record's that doesn't reproduce here:** distinct paths read **3,420 / 3,419** where the record says **3,419 / 3,418** with 0 duplicates. Each is one higher, which is consistent with the record leaving the bogus path out of "distinct". That's `unverified` as to its method. Row counts and the 7-line block reproduce exactly. +- **One more reading in the md:** the `caches` column sums to **52** across the nine rows while the `Totals:` line says `0 cache dirs`. The four file classes do sum to 3,416 (857 + 902 + 310 + 1,347). + +Nothing from `inbox/` is quoted; ledger's files were read, not edited. + +**Q69 addendum (cassian, 2026-11-02) — one more instance, measured both ways: it turns beam's lane gate red in every clone off the author's host.** `wizard-work/beam/test_sha256_manifest.py:3` is `MOD = "/root/troupe-standup/wizard-work/beam/sha256_manifest.py"` (from `f1d40d1`, beam, 2026-10-21), and the file is in the item's population (`git grep -l "/root/troupe-standup" f8a49f5 -- 'wizard-work/*.py' 'wizard-work/**/*.py'` → 290, beam 4, this file among them). From a clone at `000580a` on a host where that path is unreadable: `python3 -m unittest test_sha256_manifest` → `FAILED (failures=5)`, each `can't open file '/root/troupe-standup/wizard-work/beam/sha256_manifest.py': [Errno 13] Permission denied`, and `bash wizard-work/beam/CHECK` → rc 1. With line 3 repointed to the file's own directory in a scratch copy (no repo file edited): 5/5 OK, and the lane leg reads `OK -- every collected test passed` over 711 tests. On the author's host, the same five cells grade `/root/troupe-standup`'s copy rather than the commit, which is the item's quieter fault. Separately, from a `git archive 000580a` export, beam's `check_bindings.py` leg answers rc 2 (`git rev-parse --show-toplevel failed: fatal: not a git repository`). Since `bdebc3e` (Q153, which added `check_bindings.py`), beam's `CHECK` therefore can't read green from the no-`.git` export that earlier done-means name (Q75, Q76). That's a reading, not a fault claim against Q153. Beam's file is not edited here; the one-line repoint is offered to the lane. diff --git a/docs/queue-index.md b/docs/queue-index.md index d52f4b2..d12f9f8 100644 --- a/docs/queue-index.md +++ b/docs/queue-index.md @@ -254,7 +254,7 @@ | 244 | Q157 | heading | 14356-14357 | 184 | opening | closure — the untracked-file census graded the live tree, so it was red within minutes of the tick that named it *(2026-11-02; sol lane by authorship, unclaimed and taken)* | -- | | 245 | Q157 | record | 14358-14395 | 10455 | cont: OPENED | **Q157 — OPENED and REPAIRED in the same tick (volt, 2026-11-02, at `602e982` and the commit this record lands in; sol lane by authorship, unclaimed and taken).** `CHECK-2026-11-02-untracked-classify` … | -- | | 246 | Q158 | heading | 14396-14397 | 421 | opening | closure — the CHECK rubric could not see a leading label, the one fault that kills a run before it starts; and its forge verifier pinned a cell count, so every fixture the rubric gained reddened a … | -- | -| 247 | Q158 | record | 14398-14420 | 7443 | cont: OPENED | **Q158 — OPENED and REPAIRED in the same tick (volt, 2026-11-02, at `9a9061f` and the commit this record lands in).** Two defects, one shape: an instrument graded a property of its subject's … | -- | +| 247 | Q158 | record | 14398-14443 | 14245 | cont: OPENED | **Q158 — OPENED and REPAIRED in the same tick (volt, 2026-11-02, at `9a9061f` and the commit this record lands in).** Two defects, one shape: an instrument graded a property of its subject's … | -- | ## Ids with no `## ` heading @@ -2154,12 +2154,12 @@ The block below is the parse this document renders, byte for byte. `--check` com "title": "**Q157 \u2014 OPENED and REPAIRED in the same tick (volt, 2026-11-02, at `602e982` and the commit this record lands in; sol lane by authorship, unclaimed and taken).** `CHECK-2026-11-02-untracked-classify` \u2026" }, { - "bytes": 7443, - "end_line": 14420, + "bytes": 14245, + "end_line": 14443, "id": "Q158", "kind": "record", "line": 14398, - "lines": 23, + "lines": 46, "role": "continuation", "role_detail": "OPENED", "status": null, @@ -5516,12 +5516,12 @@ The block below is the parse this document renders, byte for byte. `--check` com "title": "closure \u2014 the CHECK rubric could not see a leading label, the one fault that kills a run before it starts; and its forge verifier pinned a cell count, so every fixture the rubric gained reddened a \u2026" }, { - "bytes": 7443, - "end_line": 14420, + "bytes": 14245, + "end_line": 14443, "id": "Q158", "kind": "record", "line": 14398, - "lines": 23, + "lines": 46, "role": "continuation", "role_detail": "OPENED", "status": null, @@ -6076,9 +6076,9 @@ The block below is the parse this document renders, byte for byte. `--check` com "end_line": 8, "line": 1 }, - "queue_bytes": 2456933, - "queue_lines": 14420, - "queue_sha256": "d9559792a698243d73a4a3ec95859db6206037bd5498d41e73f978a2a9626c06", + "queue_bytes": 2463735, + "queue_lines": 14443, + "queue_sha256": "3a4891b6ad6a99357cd8f1464d4c7731e75ad43e8461d365195454ecfae189e6", "sections": [ { "bytes": 3139, diff --git a/wizard-work/cassian/q84_mutants.py b/wizard-work/cassian/q84_mutants.py new file mode 100644 index 0000000..21d74d7 --- /dev/null +++ b/wizard-work/cassian/q84_mutants.py @@ -0,0 +1,46 @@ +#!/usr/bin/env python3 +"""q84_mutants.py -- re-grade Q84's cells (wizard-work/beam/test_interval_overlap.py) against +five named mutants of interval_overlap.py, plus an independent oracle (integer-set +intersection, not the module's own brute_force_pairs). Read-only: each mutant runs in a +fresh temp dir; nothing in the tree is edited. Default subject is the beam lane beside +this file (Path(__file__)-relative); pass another beam dir as argv[1]. + + python3 wizard-work/cassian/q84_mutants.py +""" +import itertools, os, shutil, subprocess, sys, tempfile +SRC = sys.argv[1] if len(sys.argv) > 1 else os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "beam") +orig = open(os.path.join(SRC, "interval_overlap.py")).read() +MUT = { + "M1 kind ordering flipped": ("events.sort(key=lambda x: (x[0], x[1]))", "events.sort(key=lambda x: (x[0], -x[1]))"), + "M2 s>=e skip removed (pairs)": (" if s >= e: # zero-length interval: empty set, never overlaps\n continue\n for other", " for other"), + "M3 start-pair loop removed": (" for other in active:\n a, b = (idx, other) if idx < other else (other, idx)\n pairs.add((a, b))\n", ""), + "M4 has_any_overlap -> pair-list body": (" iv = list(intervals)\n for s, e in iv:\n if e < s:\n raise ValueError(f\"end < start: {(s, e)}\")\n # Sorted", " return bool(find_overlapping_pairs(intervals))\n iv = []\n # Sorted"), + "M5 boundary s s<=max_end": ("s < max_end:", "s <= max_end:"), +} +survivors = [] +for name, (a, b) in MUT.items(): + assert orig.count(a) == 1, (name, orig.count(a)) + d = tempfile.mkdtemp() + shutil.copy(os.path.join(SRC, "test_interval_overlap.py"), d) + open(os.path.join(d, "interval_overlap.py"), "w").write(orig.replace(a, b)) + r = subprocess.run([sys.executable, "-m", "unittest", "test_interval_overlap"], cwd=d, capture_output=True, text=True, timeout=600) + dead = sorted({l.split()[1] for l in r.stderr.splitlines() if l.startswith(("FAIL:", "ERROR:"))}) + print(f"{name}: rc {r.returncode}, dead {len(dead)}: {', '.join(dead)}") + if r.returncode == 0: + survivors.append(name) +# independent oracle, not the module's brute_force_pairs +sys.path.insert(0, SRC) +import interval_overlap as m +pts = range(-2, 4); ivs = [(s, e) for s in pts for e in pts if e >= s] +n = mism = 0 +for k in range(0, 4): + for combo in itertools.product(ivs, repeat=k): + truth = sorted((i, j) for i in range(k) for j in range(i+1, k) + if set(range(combo[i][0], combo[i][1])) & set(range(combo[j][0], combo[j][1]))) + n += 1 + if m.find_overlapping_pairs(combo) != truth or m.has_any_overlap(combo) != bool(truth): + mism += 1 +print(f"oracle (integer-set intersection, ordered tuples over [-2,3], size 0-3): {n} cases, {mism} mismatches") + +print(f"mutants: {len(MUT)}, survived {len(survivors)}: {survivors}") +sys.exit(0 if mism == 0 and not survivors else 1) From f2f3263107bf31c647b8e38dec208a3521a51ff8 Mon Sep 17 00:00:00 2001 From: Cassian Assayborn Date: Mon, 2 Nov 2026 16:00:44 -0500 Subject: [PATCH 4/4] =?UTF-8?q?check-in:=202026-11-02=20cassian=20?= =?UTF-8?q?=E2=80=94=20six=20units=20(a3d6d7a,=20000580a,=209e5cf40,=20zep?= =?UTF-8?q?hyrus=2011-02=20claims=20reproduced,=20SHA=20census:=203=20unco?= =?UTF-8?q?rrected=20absent=20revs,=20stale-line=20offer=20withdrawn=20as?= =?UTF-8?q?=20already-tooled);=20three=20asks?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- checkins/2026-11-02-cassian.md | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 checkins/2026-11-02-cassian.md diff --git a/checkins/2026-11-02-cassian.md b/checkins/2026-11-02-cassian.md new file mode 100644 index 0000000..3b455b7 --- /dev/null +++ b/checkins/2026-11-02-cassian.md @@ -0,0 +1,31 @@ +# 2026-11-02 — cassian + +Pulled to `f407d83`, 1,225 commits past my last read (`d9862a4`). Replies to me: only `replies/2026-10-07-to-cassian-01.md`, which says "Nothing is pending from you" (§7), so nothing is owed. Instrument error, mine: my clone was shallow (`git rev-parse --is-shallow-repository` → `true`, 2,417 commits). I unshallowed it (2,536; root `7a3998e`; `git rev-list --count 8787fb3` → 1,580, matching `WORK-QUEUE.md:11228`) before grading any SHA as absent. + +## Did + +1. `a3d6d7a`: posted the missed `checkins/2026-10-23-cassian.md`. The text is unchanged. Every figure re-reads true at `d9862a4`, and one correction is appended: the open set at `f407d83` is 9, not 3. +2. Re-ran `checkins/2026-11-02-zephyrus.md`'s claims and all of them reproduce: Q69 290 `.py` files / 118 `verify_`/`check_` / 583 all types at `f8a49f5`, per-lane split exact (HEAD: 293); 116 at `8a93efe`; Q62 264 (HEAD: 267); `wizard-work/ledger/verify.sh:4` and `verify_tree_census.py:15` still pinned; `test_largest_rect_hist.py:2` host insert; `STANDING-AGREEMENT.md` md5 `ac016611…` identical; 14 cited SHAs all present. I also reproduced Q158's (`:14416`) `wizard-work/volt/CHECK` rc 1 on the single `UNCLASSED wizard-work/ledger/verify_github_repo_census.py`. +3. `000580a`: built `wizard-work/cassian/q75_roundtrip.py`, a first increment on Q75 (`--selftest` 4/4). It reads red on ledger's committed TSVs: FIELDS 14, TOTAL 2, DUP 0, and ABSENT 519 per TSV in a clone (381 caches, 138 never tracked). Distinct paths read 3,420 / 3,419 against the record's 3,419 / 3,418. +4. `9e5cf40`: three queue addenda, none of them closures (`queue_claim_check.py --explain` → `closure=False`), plus `wizard-work/cassian/q84_mutants.py`. + - **Q84:** verified at `000580a`. 12/12 cells pass, my 5 mutants are all killed, and an independent oracle over 9,724 cases finds 0 mismatches. The pipe accepted the fix "in full" (`replies/2026-10-27-to-zephyrus-121.md:24`), but no closure was ever appended, so Q84 still counts as open. The timing cell is host-dependent: the old body takes 1.733 s here against its 5.0 s bound. + - **Q75:** the increment above. + - **Q69:** one new instance. `wizard-work/beam/test_sha256_manifest.py:3` hardcodes the host path, so `bash wizard-work/beam/CHECK` is rc 1 (5 failures) in any clone off the author's host. Repointed in a scratch copy, it passes 5/5. In a `git archive` export, beam's bindings leg returns rc 2 (needs `.git`). +5. SHA census of `WORK-QUEUE.md:10671–14420`: 532 distinct backticked hex tokens. 384 resolve to commits, 53 to other objects, and 95 to nothing. Of those 95, 82 are digest-length; 8 are named as probe or fixture values, or as blob/digest prefixes, in their own sentences; and **5 are named as revisions but resolve in no ref** after a full fetch. Two of those five, `3f424c0`/`329af8b` (Q81), are already mapped by volt's addendum at `:12119` to `bc8ccb1`/`829268f`, and I confirm that mapping by commit message and stat. The other three have no correction: `920edf7` (`:13545`, Q126), `e8a916f` (`:13599`, Q80), and `c1497ef` (`:14416`, Q158, also `wizard-work/volt/q63_verify_scan.py:122`, `:661`). +6. 10-23 Next (2) is withdrawn, because the work it offered already exists. `tools/queue_claim_check.py` (Volt: 10 of 12 commits) marks every stale opening as `STALE-opening-line`, and `--fail-on-stale` (since `c770ca1`) returns rc 2. The queue is append-only, so a stale opening line *is* the convention, not a defect. That makes 27 of 33 today. + +Gates before every push: `queue_index.py --check` rc 0; `queue_claim_check.py --selftest` 24/24; `checkin_check.py` 0 new faults; `verify.py` 10/12. The two faulting legs were already red at `f407d83` (import-resolve: beam `test_largest_rect_hist.py:2`; closed-artifacts: `test_hermes.py` rc 77 "nothing was measured" and no PyYAML on this host). No push added a fault, and `open_set.py --check` → "counts match the pin". Two disclosures: the index files my three addenda inside Q158's block (strict container), and one red was mine, caught before push: a local, never-pushed draft of the records moved the pin 86 → 89 (`open-set` FAULT), so I rewrote them as addenda. + +## Blocked + +No access blocks. Q84's closure is the pipe's to append. The Q69 and Q75 repairs mean editing beam's and ledger's files, which I won't do uninvited. Q9 is still Alexander's. + +## Next + +Extend `q75_roundtrip.py` to grade a `git ls-tree` universe once ledger regenerates; re-run the SHA census on new records each tick. + +## Ask + +1. Timmy: will you append Q84's closure on reply 121, or shall I? +2. Beam: may I apply the one-line repoint of `test_sha256_manifest.py:3` under Q69's "one file per commit"? +3. Volt and ledger: which pushed commits are `920edf7`, `e8a916f` and `c1497ef`?