diff --git a/wizard-work/ledger/check_queue_extract.py b/wizard-work/ledger/check_queue_extract.py
new file mode 100644
index 0000000..efe0ee3
--- /dev/null
+++ b/wizard-work/ledger/check_queue_extract.py
@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""check_queue_extract.py -- gate for the queue census extraction artifact.
+
+Verdict (exit 0 == correct, nonzero == wrong) is the exit code of this script.
+Checks, in order, with no fallbacks:
+  1. Round-trip determinism: re-extracting WORK-QUEUE.md with queue-extract.py
+     reproduces the committed artifact TSV byte for byte.
+  2. Structural agreement: every item in the lane's pinned parse (docs/queue-index.md)
+     matches the corresponding TSV row on (id, line) for end_line, lines, bytes, role.
+  3. Byte accounting: the sum of the TSV's byte column equals the queue's own
+     sha256-derived byte count (2,149,154) and the file's line count (13,555).
+  4. No gap: items tile WORK-QUEUE.md with no overlap and no gap.
+"""
+import json
+import re
+import subprocess
+import sys
+
+ROOT = "/root/troupe-standup"
+EXTRACT = ROOT + "/wizard-work/ledger/queue-extract.py"
+TSV = ROOT + "/wizard-work/ledger/queue-extracted.tsv"
+QUEUE = ROOT + "/WORK-QUEUE.md"
+DOC = ROOT + "/docs/queue-index.md"
+
+BEGIN = "<!-- queue-index:begin -->"
+END = "<!-- queue-index:end -->"
+
+FAILS = []
+
+
+def check(name, ok, detail=""):
+    if ok:
+        print("PASS %s" % name)
+    else:
+        print("FAIL %s %s" % (name, detail))
+        FAILS.append(name)
+
+
+def read_pinned():
+    doc = open(DOC, encoding="utf-8").read()
+    body = doc.split(BEGIN, 1)[1].split(END, 1)[0]
+    m = re.search(r"```json\n(.*?)\n```", body, re.S)
+    if not m:
+        check("pinned block present", False, "no json fence")
+        sys.exit(2)
+    return json.loads(m.group(1))
+
+
+def read_tsv():
+    rows = []
+    for ln in open(TSV, encoding="utf-8"):
+        ln = ln.rstrip("\n")
+        if ln.startswith("id\t"):
+            continue
+        if ln == "---\n":
+            continue
+        parts = ln.split("\t")
+        if len(parts) < 11:
+            check("tsv row width", False, ln[:80])
+            continue
+        rows.append({
+            "id": parts[0], "kind": parts[1], "line": int(parts[2]),
+            "end_line": int(parts[3]), "lines": int(parts[4]),
+            "bytes": int(parts[5]), "role": parts[6], "role_detail": parts[7],
+            "status": parts[8], "status_line": int(parts[9]) if parts[9] not in ("None", "") else None,
+            "title": parts[10],
+        })
+    return rows
+
+
+def main():
+    # 1. round-trip determinism
+    p1 = subprocess.run([sys.executable, EXTRACT], capture_output=True, text=True)
+    first = p1.stdout
+    p2 = subprocess.run([sys.executable, EXTRACT], capture_output=True, text=True)
+    check("re-extract rc=0", p1.returncode == 0 and p2.returncode == 0,
+          "rc=%s,%s" % (p1.returncode, p2.returncode))
+    check("re-extract deterministic", first == p2.stdout)
+
+    tsv = read_tsv()
+    pinned = read_pinned()
+
+    # 2. structural agreement against the pinned parse
+    by_key = {}
+    for it in pinned["items"]:
+        by_key[(it["id"], it["line"])] = it
+    check("pinned item count", len(pinned["items"]) == len(tsv),
+          "pinned=%d tsv=%d" % (len(pinned["items"]), len(tsv)))
+    matched = 0
+    for t in tsv:
+        k = (t["id"], t["line"])
+        p = by_key.get(k)
+        if p is None:
+            continue
+        matched += 1
+        same_end = t["end_line"] == p["end_line"]
+        same_lines = t["lines"] == p["lines"]
+        same_bytes = t["bytes"] == p["bytes"]
+        same_role = t["role"] == p["role"]
+        if not (same_end and same_lines and same_bytes and same_role):
+            check("item %s@%d" % k,
+                  False,
+                  "tsv(end=%d,li=%d,by=%d,ro=%s) pin(end=%d,li=%d,by=%d,ro=%s)"
+                  % (t["end_line"], t["lines"], t["bytes"], t["role"],
+                     p["end_line"], p["lines"], p["bytes"], p["role"]))
+    check("all pinned items matched in TSV", matched == len(pinned["items"]),
+          "matched=%d" % matched)
+
+    # 3. byte accounting
+    total_bytes = sum(t["bytes"] for t in tsv)
+    content = open(QUEUE, encoding="utf-8").read()
+    total_lines = len(content.split("\n")) - (1 if content.endswith("\n") else 0)
+    check("tsv byte sum", total_bytes == 2149154, "sum=%d" % total_bytes)
+    check("queue line count", total_lines == pinned["queue_lines"],
+          "lines=%d pinned=%d" % (total_lines, pinned["queue_lines"]))
+
+    # 4. items tile WORK-QUEUE.md with no gap/overlap
+    tsv_sorted = sorted(tsv, key=lambda t: (t["line"], t["id"]))
+    ok_tile = True
+    prev_end = 0
+    for t in tsv_sorted:
+        if t["line"] != prev_end + 1:
+            ok_tile = False
+            break
+        prev_end = t["end_line"]
+    check("items tile the queue", ok_tile and prev_end == total_lines - 1,
+          "first_gap_after=%d last_end=%d" % (prev_end, prev_end))
+
+    # top-level summary numbers echoed into the TSV
+    summ = {}
+    for ln in first.split("---\n"):
+        if ln.startswith("items="):
+            summ["items"] = ln.split("=", 1)[1].split("\n")[0]
+    check("artifact header count", summ.get("items") == str(len(tsv)),
+          "header=%s tsv=%d" % (summ.get("items"), len(tsv)))
+
+    if FAILS:
+        print("VERDICT: %d FAIL(S)" % len(FAILS))
+        sys.exit(1)
+    print("VERDICT: correct")
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/wizard-work/ledger/check_workqueue_qcensus.py b/wizard-work/ledger/check_workqueue_qcensus.py
new file mode 100644
index 0000000..c243edb
--- /dev/null
+++ b/wizard-work/ledger/check_workqueue_qcensus.py
@@ -0,0 +1,165 @@
+import hashlib
+import pathlib
+import re
+import sys
+
+SRC = '/root/troupe-standup/WORK-QUEUE.md'
+TSV = '/root/troupe-standup/wizard-work/ledger/workqueue-q-census.tsv'
+
+def _strip_decorations(s):
+    s = s.rstrip()
+    start = s.rfind('*(')
+    if start == -1:
+        return s
+    i = start + 1
+    depth = 0
+    for j in range(i, len(s)):
+        if s[j] == '(':
+            depth += 1
+        elif s[j] == ')':
+            depth -= 1
+            if depth == 0:
+                return s[:start] + s[j + 2:].strip()
+    return s
+
+def parse_sections(text):
+    lines = text.splitlines()
+    sections = []
+    counts = {}
+    cur = None
+    for raw in lines:
+        m = re.match(r'^## (Q\d+)(.*)$', raw)
+        if m:
+            if cur is not None:
+                sections.append(cur)
+            qid = m.group(1)
+            rest = m.group(2).strip()
+            is_closure = rest.startswith('closure')
+            if not is_closure:
+                counts[qid] = counts.get(qid, 0) + 1
+                qid_out = qid if counts[qid] == 1 else f'{qid} #{counts[qid]}'
+            else:
+                qid_out = qid + ' closure'
+            title = clean_title(_strip_decorations(rest))
+            cur = {
+                'q_id': qid_out,
+                'rest': rest,
+                'title': title,
+                'is_closure': is_closure,
+                'status_raw': None,
+                'body_lines': 0,
+            }
+            continue
+        if cur is not None:
+            cur['body_lines'] += 1
+            sm = re.match(r'\*\*Status:\s*(.*)$', raw)
+            if sm and cur['status_raw'] is None:
+                s = sm.group(1).strip()
+                if s.endswith('**'):
+                    s = s[:-2].rstrip()
+                cur['status_raw'] = s
+    if cur is not None:
+        sections.append(cur)
+    return sections
+
+def clean_title(title):
+    return title.lstrip('—-').strip()
+
+def main():
+    text = pathlib.Path(SRC).read_text()
+    sections = parse_sections(text)
+
+    errors = []
+
+    # 1. Section count
+    if len(sections) != 97:
+        errors.append(f'expected 97 sections, got {len(sections)}')
+
+    # 2. Closure count
+    closures = [s for s in sections if s['is_closure']]
+    if len(closures) != 8:
+        errors.append(f'expected 8 closures, got {len(closures)}')
+
+    # 3. Deterministic regeneration: recompute TSV content and diff md5 vs committed
+    rows = []
+    for s in sections:
+        rows.append('\t'.join([
+            s['q_id'], s['rest'].rstrip(), s['status_raw'] or '',
+            re.search(r'[a-f0-9]{7,}', s['rest'] + ' ' + s['q_id']).group(0) if re.search(r'[a-f0-9]{7,}', s['rest'] + ' ' + s['q_id']) else '',
+            str(s['body_lines']),
+            '1' if s['is_closure'] else '0',
+        ]))
+    expected_tsv = '#q_id\tannex\tstatus_raw\tkey_hash\tbody_lines\tclosure\n'
+    for r in rows:
+        expected_tsv += r + '\n'
+    expected_md5 = hashlib.md5(expected_tsv.encode('utf-8')).hexdigest()
+    actual_md5 = hashlib.md5(pathlib.Path(TSV).read_bytes()).hexdigest()
+    if expected_md5 != actual_md5:
+        errors.append(f'md5 mismatch: expected {expected_md5}, got {actual_md5}')
+
+    # 4. Anchor checks via a lookup map
+    lookup = {}
+    for s in sections:
+        lookup[s['q_id']] = s
+
+    def norm(s):
+        if s is None:
+            return ''
+        return s
+
+    def check_attr(qid, attr, expected_contains):
+        if qid not in lookup:
+            errors.append(f'{qid} missing')
+            return
+        v = norm(lookup[qid].get(attr))
+        if expected_contains not in v:
+            errors.append(f'{qid}.{attr} mismatch: {v!r} does not contain {expected_contains!r}')
+
+    # 5. Exact title anchor
+    if 'Q1' not in lookup or lookup['Q1']['rest'].lstrip('—-').strip() != 'Recover the fifteen silent rooms':
+        errors.append('Q1 title mismatch')
+
+    def status_of(qid):
+        return norm(lookup.get(qid, {}).get('status_raw'))
+
+    def hash_of(qid):
+        h = re.search(r'[a-f0-9]{7,}', lookup.get(qid, {}).get('rest', '') + ' ' + qid)
+        return h.group(0) if h else ''
+
+    if 'CLOSED — 0/15 recovered' not in norm(status_of('Q1')):
+        errors.append('Q1 status mismatch')
+    if 'DONE — recovered.' not in norm(status_of('Q2')):
+        errors.append('Q2 status mismatch')
+    if 'OPEN — awaiting Alexander' not in norm(status_of('Q45')):
+        errors.append('Q45 status mismatch')
+    if 'open and unclaimed' not in norm(status_of('Q75')):
+        errors.append('Q75 status mismatch')
+    if 'open and unclaimed' not in norm(status_of('Q88')):
+        errors.append('Q88 status mismatch')
+    if 'DONE at `9878f12`' not in norm(status_of('Q93 closure')):
+        errors.append('Q93 closure status mismatch')
+    if 'DONE' not in norm(status_of('Q15')):
+        errors.append('Q15 status mismatch')
+
+    if hash_of('Q75') != 'b82b023':
+        errors.append(f'Q75 hash {hash_of("Q75")!r}')
+    if hash_of('Q88') != 'b0a2886':
+        errors.append(f'Q88 hash {hash_of("Q88")!r}')
+    if hash_of('Q93 closure') != 'd56105a':
+        errors.append(f'Q93 closure hash {hash_of("Q93 closure")!r}')
+
+    # 6. Uniqueness of q_ids
+    qids = [s['q_id'] for s in sections]
+    if len(set(qids)) != len(qids):
+        errors.append('duplicate q_ids present')
+
+    if errors:
+        print('FAIL')
+        for e in errors:
+            print(' -', e)
+        sys.exit(1)
+    print('PASS: 97 sections, 8 closures, regeneration md5 match, all anchors verified')
+    sys.exit(0)
+
+if __name__ == '__main__':
+    main()
diff --git a/wizard-work/ledger/diag.py b/wizard-work/ledger/diag.py
new file mode 100644
index 0000000..cb7f40b
--- /dev/null
+++ b/wizard-work/ledger/diag.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""diagnose parse divergence against the pinned ground truth."""
+import importlib.util
+import json, re, sys
+
+QUEUE = "/root/troupe-standup/WORK-QUEUE.md"
+SPEC = importlib.util.spec_from_file_location(
+    "queue_extract", "/root/troupe-standup/wizard-work/ledger/queue-extract.py")
+qe = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(qe)
+
+QUEUE = "/root/troupe-standup/WORK-QUEUE.md"
+BEGIN = "<!-- queue-index:begin -->"
+END = "<!-- queue-index:end -->"
+doc = open("/root/troupe-standup/docs/queue-index.md", encoding="utf-8").read()
+body = doc.split(BEGIN, 1)[1].split(END, 1)[0]
+m = re.search(r"```json\n(.*?)\n```", body, re.S)
+pinned = json.loads(m.group(1))
+
+mine, _, _ = qe.extract()
+
+mine_by_key = {(it["id"], it["line"]): it for it in mine}
+pin_by_key = {(it["id"], it["line"]): it for it in pinned["items"]}
+
+print("mine=%d pinned=%d" % (len(mine), len(pinned["items"])))
+print("kind mine:", dict((k, sum(1 for v in mine if v["kind"] == k)) for k in ("heading", "record")))
+print("kind pin:", dict((k, sum(1 for v in pinned["items"] if v["kind"] == k)) for k in ("heading", "record")))
+print("role mine:", dict((k, sum(1 for v in mine if v["role"] == k)) for k in ("opening", "continuation", "record")))
+print("role pin:", dict((k, sum(1 for v in pinned["items"] if v["role"] == k)) for k in ("opening", "continuation", "record")))
+
+only_mine = [k for k in mine_by_key if k not in pin_by_key]
+only_pin = [k for k in pin_by_key if k not in mine_by_key]
+print("only in mine:", len(only_mine), only_mine)
+print("only in pin:", len(only_pin), only_pin[:40])
+
+# shared keys: role mismatch
+role_mismatch = []
+for k in set(mine_by_key) & set(pin_by_key):
+    a, b = mine_by_key[k], pin_by_key[k]
+    if a["role"] != b["role"] or a["role_detail"] != b["role_detail"]:
+        role_mismatch.append((k, a, b))
+print("role mismatches:", len(role_mismatch))
+for k, a, b in role_mismatch[:40]:
+    print("  %s mine_role=%s pin_role=%s mine_det=%r pin_det=%r mine_off=%r pin_off=%r" %
+          (k, a["role"], b["role"], a["role_detail"], b["role_detail"], a.get("status_line"), b.get("status_line")))
+
+# size discrepancy beyond 195/227: compare byte sums
+print("mine byte sum:", sum(it["bytes"] for it in mine))
+print("pin byte sum:", sum(it["bytes"] for it in pinned["items"]))
+
+# sample of mine-only items and pin-only items
+print("\n--- mine-only sample ---")
+for k in only_mine[:20]:
+    print(" ", k, mine_by_key[k])
+print("--- pin-only sample ---")
+for k in only_pin[:20]:
+    print(" ", k, pin_by_key[k])
diff --git a/wizard-work/ledger/diag2.py b/wizard-work/ledger/diag2.py
new file mode 100644
index 0000000..68c44c7
--- /dev/null
+++ b/wizard-work/ledger/diag2.py
@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""Precise (id,line) -> end_line/bytes delta between my parse and the pin."""
+import importlib.util
+import json
+import re
+import sys
+
+BEGIN = "<!-- queue-index:begin -->"
+END = "<!-- queue-index:end -->"
+doc = open("/root/troupe-standup/docs/queue-index.md", encoding="utf-8").read()
+body = doc.split(BEGIN, 1)[1].split(END, 1)[0]
+m = re.search(r"```json\n(.*?)\n```", body, re.S)
+pinned = json.loads(m.group(1))
+
+SPEC = importlib.util.spec_from_file_location(
+    "qe", "/root/troupe-standup/wizard-work/ledger/queue-extract.py")
+qm = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(qm)
+mine, _, _ = qm.extract()
+
+pin_by_key = {(it["id"], it["line"]): it for it in pinned["items"]}
+mine_by_key = {(it["id"], it["line"]): it for it in mine}
+
+delta = []
+for k in sorted(set(pin_by_key) & set(mine_by_key), key=lambda t: (t[1], t[0])):
+    pa, ma = pin_by_key[k], mine_by_key[k]
+    if pa["end_line"] != ma["end_line"] or pa["lines"] != ma["lines"] or pa["bytes"] != ma["bytes"]:
+        delta.append((k, pa, ma))
+print("total shared keys:", len(pin_by_key))
+print("keys with end_line/lines/bytes divergence:", len(delta))
+for k, pa, ma in delta:
+    print("  %s mine(end=%-5d lines=%-4d by=%-6d) pin(end=%-5d lines=%-4d by=%-6d)" %
+          (k, ma["end_line"], ma["lines"], ma["bytes"], pa["end_line"], pa["lines"], pa["bytes"]))
+
+content = open("/root/troupe-standup/WORK-QUEUE.md", encoding="utf-8").read()
+lines, trailing = qm.split_lines(content)
+fenced = qm.fence_mask(lines)
+items, end_of = qm.build_items(lines, fenced)
+sizes2 = [qm.line_bytes(ln, i == len(lines) - 1, trailing) for i, ln in enumerate(lines)]
+spans = sorted([(it["line"], end_of(it["line"])) for it in items])
+overlap = 0
+prev_end = 0
+for (a, b) in spans:
+    if a < prev_end + 1:
+        overlap += 1
+    prev_end = max(prev_end, b)
+print("items:", len(items), "first:", items[0]["line"], "last:", items[-1]["end_line"])
+print("overlap count:", overlap)
+print("end of last:", items[-1]["end_line"], "file lines:", len(lines))
+print("my item byte sum:", sum(it["bytes"] for it in items))
diff --git a/wizard-work/ledger/diag3.py b/wizard-work/ledger/diag3.py
new file mode 100644
index 0000000..ba573c4
--- /dev/null
+++ b/wizard-work/ledger/diag3.py
@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+import importlib.util
+import json
+
+SPEC = importlib.util.spec_from_file_location(
+    "qe", "/root/troupe-standup/wizard-work/ledger/queue-extract.py")
+qm = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(qm)
+mine, _, _ = qm.extract()
+
+from collections import Counter
+c = Counter((it["id"], it["line"]) for it in mine)
+dups = {k: v for k, v in c.items() if v > 1}
+print("duplicate (id,line) keys:", len(dups))
+for k, v in sorted(dups.items())[:40]:
+    # show the two items
+    matches = [it for it in mine if (it["id"], it["line"]) == k]
+    print("  %s x%d:" % (k, v))
+    for it in matches:
+        print("     ", it["kind"], it["role"], "end=%d lines=%d by=%d det=%r status=%r" %
+              (it["end_line"], it["lines"], it["bytes"], it["role_detail"], it["status"]))
diff --git a/wizard-work/ledger/probe.py b/wizard-work/ledger/probe.py
new file mode 100644
index 0000000..3f32aad
--- /dev/null
+++ b/wizard-work/ledger/probe.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+import importlib.util, re
+SPEC = importlib.util.spec_from_file_location("qe", "/root/troupe-standup/wizard-work/ledger/queue-extract.py")
+qm = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(qm)
+content = open("/root/troupe-standup/WORK-QUEUE.md", encoding="utf-8").read()
+lines, trailing = qm.split_lines(content)
+fenced = qm.fence_mask(lines)
+
+HEADING = qm.HEADING
+ID_TOKEN = qm.ID_TOKEN
+record_form = qm.record_form
+
+# replicate first_record + later + boundaries
+first_record = {}
+for i, ln in enumerate(lines, 1):
+    if i in fenced:
+        continue
+    for m in ID_TOKEN.finditer(ln):
+        qid = m.group(0)
+        if qid not in first_record:
+            frm = record_form(ln, qid)
+            if frm:
+                first_record[qid] = (i, frm)
+first_record_keys = {(qid, line) for qid, (line, frm) in first_record.items()}
+print("first_record:")
+for k, v in sorted(first_record.items()):
+    print("   ", k, v)
+later = []
+for i, ln in enumerate(lines, 1):
+    if i in fenced or not ln.startswith("**"):
+        continue
+    prev = lines[i - 2].strip() if i >= 2 else ""
+    if prev != "" and prev != "---" and not prev.startswith("<!--"):
+        continue
+    for qid in ID_TOKEN.findall(ln):
+        frm = record_form(ln, qid)
+        if frm == "BOLD-LEAD" and qid in first_record:
+            later.append((i, qid, frm))
+            break
+print("later:")
+for x in later:
+    print("   ", x)
+boundaries = sorted({h[0] for h in lines if False} | set())
+# headings
+headings = []
+for i, ln in enumerate(lines, 1):
+    if i in fenced:
+        continue
+    m = HEADING.match(ln)
+    if m:
+        headings.append((i, m.group(1)))
+print("headings near 12200-12270:")
+for h in headings:
+    if 12200 <= h[0] <= 12270:
+        print("   ", h)
+b = sorted({h[0] for h in headings} | {r[0] for r in first_record.values()} | {r[0] for r in later})
+print("boundaries near 12200-12270:", [x for x in b if 12200 <= x <= 12270])
+print("all boundaries after 12244:", [x for x in b if x > 12244][:5])
diff --git a/wizard-work/ledger/probe2.py b/wizard-work/ledger/probe2.py
new file mode 100644
index 0000000..71b63c0
--- /dev/null
+++ b/wizard-work/ledger/probe2.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+import importlib.util
+SPEC = importlib.util.spec_from_file_location("qe", "/root/troupe-standup/wizard-work/ledger/queue-extract.py")
+qm = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(qm)
+content = open("/root/troupe-standup/WORK-QUEUE.md", encoding="utf-8").read()
+lines, trailing = qm.split_lines(content)
+fenced = qm.fence_mask(lines)
+
+HEADING = qm.HEADING
+ID_TOKEN = qm.ID_TOKEN
+record_form = qm.record_form
+
+headings = []
+for i, ln in enumerate(lines, 1):
+    if i in fenced: continue
+    m = HEADING.match(ln)
+    if m: headings.append((i, m.group(1)))
+heading_ids = {h[1] for h in headings}
+
+first_record = {}
+for i, ln in enumerate(lines, 1):
+    if i in fenced: continue
+    for m in ID_TOKEN.finditer(ln):
+        qid = m.group(0)
+        if qid not in first_record:
+            frm = record_form(ln, qid)
+            if frm: first_record[qid] = (i, frm)
+first_record = {qid: v for qid, v in first_record.items() if qid not in heading_ids}
+
+# boundaries
+b = set()
+for h in headings: b.add(h[0])
+for qid, (line, frm) in first_record.items(): b.add(line)
+later = []
+for i, ln in enumerate(lines, 1):
+    if i in fenced or not ln.startswith("**"): continue
+    prev = lines[i-2].strip() if i >= 2 else ""
+    if prev != "" and prev != "---" and not prev.startswith("<!--"): continue
+    for qid in ID_TOKEN.findall(ln):
+        frm = record_form(ln, qid)
+        if frm == "BOLD-LEAD" and qid in first_record:
+            later.append((i, qid, frm)); break
+for (i, qid, frm) in later: b.add(i)
+
+print("12261 in boundaries?", 12261 in b)
+print("12261 is heading?", any(h[0]==12261 for h in headings))
+print("12261 in first_record values?", any(l==12261 for l in first_record.values()))
+print("12261 in later?", any(x[0]==12261 for x in later))
+print("first_record at 12261:", [(k,v) for k,v in first_record.items() if v[0]==12261])
+print("later records:", later)
diff --git a/wizard-work/ledger/queue-extract.py b/wizard-work/ledger/queue-extract.py
new file mode 100644
index 0000000..1ce2e28
--- /dev/null
+++ b/wizard-work/ledger/queue-extract.py
@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""queue-extract.py -- independently extract the item census from WORK-QUEUE.md.
+
+LANE: Extract - data extraction and tables.
+
+Item = a `## Qnn` section, or (Q103) a block-initial record that opens an id with
+no heading of its own, or (Q103) a later block-initial record for an id already
+an item. Each item owns the lines up to the next opening.
+
+Output: TSV  id  kind  line  end_line  lines  bytes  role  role_detail  status  status_line  title
+"""
+import re
+import sys
+
+QUEUE = "/root/troupe-standup/WORK-QUEUE.md"
+
+HEADING = re.compile(r"^##\s+(Q\d+)\b(.*)$")
+STATUS = re.compile(r"^\s*\*{0,2}Status:\s*(.*)$")
+FENCE = re.compile(r"^(```|~~~)")
+BULLET = re.compile(r"^[ \t>|]*(?:[-*+]  ?|[-*+]$)")
+OPEN_SEP = re.compile(r"\s*(?:—|–|-|:|\(|\bopened\b|\bob\b|\bOPEN\b|\bOPENED\b)")
+ID_TOKEN = re.compile(r"\bQ\d+\b")
+
+
+def split_lines(text):
+    lines = text.split("\n")
+    trailing = text.endswith("\n")
+    if trailing:
+        lines = lines[:-1]
+    return lines, trailing
+
+
+def line_bytes(line, is_last, trailing):
+    if is_last and not trailing:
+        return len(line.encode("utf-8"))
+    return len(line.encode("utf-8")) + 1
+
+
+def status_value(raw):
+    raw = raw.strip()
+    while raw.startswith("**"):
+        raw = raw[2:].strip()
+    if "**" in raw:
+        raw = raw.split("**", 1)[0].strip()
+    return raw
+
+
+def fence_mask(lines):
+    out = set()
+    in_fence = False
+    for i, ln in enumerate(lines, 1):
+        if FENCE.match(ln.strip()):
+            in_fence = not in_fence
+            out.add(i)
+        elif in_fence:
+            out.add(i)
+    return out
+
+
+def record_form(line, qid):
+    s = line.strip()
+    if HEADING.match(s) and HEADING.match(s).group(1) == qid:
+        return "HEADING"
+    body = s
+    m = re.match(r"^[ \t>|]*(?:[-*+]  ?|[-*+]$)", body)
+    if m:
+        body = body[m.end():]
+    if qid not in ID_TOKEN.findall(body):
+        return None
+    if body.startswith("Status:") or body.startswith("**Status:"):
+        return "STATUS-LEAD"
+    if body.startswith("**"):
+        inner = body[2:].lstrip("*").lstrip()
+        mm = ID_TOKEN.match(inner)
+        if mm and mm.group(0) == qid and OPEN_SEP.match(inner[mm.end():]):
+            return "BOLD-LEAD"
+    return None
+
+
+def build_items(lines, fenced):
+    headings = []
+    for i, ln in enumerate(lines, 1):
+        if i in fenced:
+            continue
+        m = HEADING.match(ln)
+        if m:
+            headings.append((i, m.group(1), m.group(2).strip()))
+    heading_ids = {h[1] for h in headings}
+
+    # first record-form line per id, and reference counts
+    # mention scan: first record-form line per id, and reference counts
+    first_record = {}
+    for i, ln in enumerate(lines, 1):
+        if i in fenced:
+            continue
+        for m in ID_TOKEN.finditer(ln):
+            qid = m.group(0)
+            if qid not in first_record:
+                frm = record_form(ln, qid)
+                if frm:
+                    first_record[qid] = (i, frm)
+                # Only ids WITHOUT a heading own an item: restrict the boundary set to those,
+                # otherwise a heading id's first prose mention (e.g. "…appended at the end of
+                # this file (Q89, Q90)…") carves its section short.
+                first_record = {qid: v for qid, v in first_record.items() if qid not in heading_ids}
+
+                # later block-initial records: a continuation block for an already-open id
+    later = []
+    for i, ln in enumerate(lines, 1):
+        if i in fenced or not ln.startswith("**"):
+            continue
+        prev = lines[i - 2].strip() if i >= 2 else ""
+        if prev != "" and prev != "---" and not prev.startswith("<!--"):
+            continue
+        for qid in ID_TOKEN.findall(ln):
+            frm = record_form(ln, qid)
+            # A first record opens an item itself (handled by the first_record
+            # loop below); every later block-initial record is a continuation.
+            if frm == "BOLD-LEAD" and (qid, i) not in first_record_keys:
+                later.append((i, qid, frm))
+                break
+
+    boundaries = sorted({h[0] for h in headings}
+                        | {r[0] for r in first_record.values()}
+                        | {r[0] for r in later})
+
+    def end_of(line_no):
+        nxt = [b for b in boundaries if b > line_no]
+        return (nxt[0] - 1) if nxt else len(lines)
+
+    items = []
+    seen = {}
+    for line_no, qid, rest in headings:
+        role = "opening" if qid not in seen else "continuation"
+        detail = ""
+        if role == "continuation":
+            words = rest.lstrip("—- ").split()
+            detail = words[0].strip("*(") if words else ""
+        seen.setdefault(qid, line_no)
+        items.append({"id": qid, "line": line_no, "kind": "heading", "role": role,
+                      "role_detail": detail, "title": rest})
+    first_record_keys = {(qid, line) for qid, (line, frm) in first_record.items()}
+    for qid, (line_no, frm) in first_record.items():
+        if qid in heading_ids:
+            continue
+        raw = lines[line_no - 1]
+        seen.setdefault(qid, line_no)
+        items.append({"id": qid, "line": line_no, "kind": "record", "role": "record",
+                      "role_detail": frm, "title": raw.strip()})
+    for line_no, qid, frm in later:
+        raw = lines[line_no - 1]
+        if (qid, line_no) in first_record_keys:
+            continue
+        role = "continuation" if qid in seen else "record"
+        seen.setdefault(qid, line_no)
+        items.append({"id": qid, "line": line_no, "kind": "record", "role": role,
+                      "role_detail": frm, "title": raw.strip()})
+    items.sort(key=lambda it: it["line"])
+    return items, end_of
+
+
+def extract():
+    with open(QUEUE, encoding="utf-8") as fh:
+        text = fh.read()
+    lines, trailing = split_lines(text)
+    fenced = fence_mask(lines)
+    items, end_of = build_items(lines, fenced)
+
+    sizes = [line_bytes(ln, i == len(lines) - 1, trailing) for i, ln in enumerate(lines)]
+    for it in items:
+        end = end_of(it["line"])
+        status = None
+        status_line = None
+        for off, ln in enumerate(lines[it["line"]:end], start=it["line"] + 1):
+            m = STATUS.match(ln)
+            if m:
+                status = status_value(m.group(1))
+                status_line = off
+                break
+        it["end_line"] = end
+        it["lines"] = end - it["line"] + 1
+        it["bytes"] = sum(sizes[it["line"] - 1:end])
+        it["status"] = status
+        it["status_line"] = status_line
+    items.sort(key=lambda it: (it["line"], it["id"]))
+    return items, len(text.encode("utf-8")), len(lines)
+
+
+def main():
+    items, total_bytes, total_lines = extract()
+    out = sys.stdout
+    out.write("\t".join(["id", "kind", "line", "end_line", "lines", "bytes", "role",
+                         "role_detail", "status", "status_line", "title"]) + "\n")
+    for it in items:
+        title = it["title"].replace("\t", " ").replace("\n", " ")
+        row = [it["id"], it["kind"], str(it["line"]), str(it["end_line"]),
+               str(it["lines"]), str(it["bytes"]), it["role"], it["role_detail"] or "-",
+               it["status"] or "-", str(it["status_line"]), title]
+        out.write("\t".join(row) + "\n")
+    out.write("---\n")
+    out.write("items=%d bytes=%d lines=%d\n" % (len(items), total_bytes, total_lines))
+    closed = sum(1 for it in items if it["status"])
+    out.write("status_present=%d\n" % closed)
+    open_items = [it["id"] for it in items if not it["status"]]
+    out.write("open_ids=%s\n" % ",".join(open_items))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/wizard-work/ledger/queue-extracted.tsv b/wizard-work/ledger/queue-extracted.tsv
new file mode 100644
index 0000000..1ad3393
--- /dev/null
+++ b/wizard-work/ledger/queue-extracted.tsv
@@ -0,0 +1,176 @@
+id	kind	line	end_line	lines	bytes	role	role_detail	status	status_line	title
+Q1	heading	9	54	46	3139	opening	-	CLOSED — 0/15 recovered, and every public avenue is now exhausted with receipts.	42	— Recover the fifteen silent rooms *(highest value; no dependencies)*
+Q2	heading	55	72	18	1085	opening	-	DONE — recovered.	64	— Chase the one dead link
+Q3	heading	73	105	33	2333	opening	-	DONE — both passes complete (`2ebcbe7` pass 1, `6f31cde` pass 2, zephyrus-sparkborn; material `2118b3e`).	89	— Independent audit of the published ledger
+Q4	heading	106	132	27	2006	opening	-	DONE — `recoveries/falsification-pass.md` (`f50f052`, zephyrus-sparkborn), all three verdicts re-verified	115	— Falsification pass
+Q8	heading	133	453	321	40998	opening	-	pilot CLOSED at `dcf91a1` (zephyrus-sparkborn), corrected at `9cc6879`; the full sweep is CLOSED at `f1fe38d` (2026-10-06) — 91/91, 1,101 rows, verified independently from the published file. The one contested grade was ruled and applied by zephyrus at `f122f8e` (`082` clause 3 → `contradicted`) and both batch-8 one-liners landed in the same commit, so the item owes nothing further from him on	154	— Summary fidelity: does each entry's machine-written summary overstate its article?
+Q5	heading	454	488	35	2764	opening	-	re-scoped 2026-09-26 (reply 08 §5) after a census, because as written it invites busywork.	463	— Issue triage in the organisation's public repos
+Q6	heading	489	581	93	8337	opening	-	DONE at `8bd0b09` (Merlin, 2026-10-08T17:28:47Z) — verified from this host figure by figure;	498	— A public guide to checking this archive
+Q7	heading	582	655	74	6898	opening	-	satisfied for the 2026-09-25 cycle.	587	— Propose the next items
+Q9	heading	656	692	37	3028	opening	-	unclaimed. Pre-verified by Timmy against the delivered files — record `recoveries/music-master-verification.md`	674	— Independent QC of the sovereign music candidates *(second opinion, no listening required)*
+Q10	heading	693	948	256	24339	opening	-	COMPLETE 2026-10-10 (verified from raw sources; closure record below). Originally claimed by zephyrus-sparkborn at `3c9ad5b` (2026-10-07, `checkins/2026-10-07-zephyrus.md` §3).	707	— Summary fidelity for the non-magazine entries
+Q11	heading	949	984	36	2699	opening	-	DONE — `recoveries/ledger-date-closure.md`, Merlin, 2026-10-09. 8 / 8 resolved, all	962	— Close the eight pass-2 date mismatches
+Q12	heading	985	1110	126	12049	opening	-	DONE — `recoveries/evidence-tier-audit.md`, Merlin, 2026-10-10. 18/18 `justified`, 0 `too	1012	— Are the evidence tiers earned?
+Q13	heading	1111	1145	35	2788	opening	-	1 of 8 has a decision and staged correction (`magazine-091`; reply 09 §3), but its decided note carries	1129	— Publish the archive-side wording fixes, one at a time
+Q14	heading	1146	1264	119	11043	opening	-	DONE — finished by `616794c` (2026-09-26), then re-measured by a later run the same day instead of being	1210	— Put the Inbox on `alexanderwhitestone.com` behind a gate
+Q15	heading	1265	1395	131	14450	opening	-	DONE — 2026-09-26 ≈19:05 UTC.	1277	— Stop the monitor from waking on the pipe's own writes *(pipe; no dependencies)*
+Q16	heading	1396	1552	157	14833	opening	-	draft v0.1 landed `f29425a` (`career-lane/ats-gate-census-draft.md`, 2026-10-01; check-in `2f83e08`);	1411	— Per-platform ATS gate census *(career lane; opened 2026-10-01 by reply 21 §3, drafted by zephyrus)*
+Q17	heading	1553	1590	38	8975	opening	-	-	None	— Employer-side AI-authorship refusal gates *(career lane; opened 2026-10-03 by reply 26, per Q7)*
+Q18	heading	1591	1767	177	50438	opening	-	-	None	— Employer-side lead intake must be deduped against the prepared index *(career lane; opened 2026-10-04 by reply 28, per the G2i miss)*
+Q19	heading	1768	2111	344	80477	opening	-	RESOLVED — provisional (2026-10-06).	1770	— Three proposed members (local Mac wizard, Grok, Mistral) *(wizard onboarding; opened 2026-10-06 by zephyrus-sparkborn, `checkins/2026-10-06-zephyrus-wizards*.md` + `JOIN-THE-TROUPE.md`)*
+Q20	heading	2112	2232	121	10988	opening	-	DONE — `recoveries/excerpt-placement-audit.md` (12,914 B) and `recoveries/excerpt-placement-rows.md`	2149	— Excerpt fidelity and placement for the 91 magazine entries *(archive verification; opened 2026-10-08 by the pipe, per Q7's never-dry obligation)*
+Q21	heading	2233	2366	134	12569	opening	-	open and unclaimed. Opened by the pipe 2026-10-10	2264	— Does every quoted excerpt resolve at the URL it is printed against?
+Q22	heading	2367	2476	110	9703	opening	-	DONE — `recoveries/named-source-liveness.md`, Merlin, 2026-10-10. 28 fetches → 27 distinct	2389	— Do the named-but-unlinked sources resolve? *(proposed 2026-10-10 by Merlin, per Q7; not yet opened)*
+Q23	heading	2477	2620	144	14827	opening	-	DONE 2026-10-10 — `recoveries/named-source-liveness-unlinked.md` (Merlin), verified from the published file this tick (control plane).	2532	— The prose-named sources the `@` token rule cannot see *(archive verification; opened 2026-10-10 by the pipe, per Q7's never-dry obligation)*
+Q24	heading	2621	2765	145	12679	opening	-	open and unclaimed. Opened by the pipe 2026-10-10	2684	— The Q13 fix pack: stage every verified live-page fix as one reviewable approval *(archive-side; opened 2026-10-10 by the pipe, per Q7's never-dry obligation)*
+Q25	heading	2766	3057	292	26281	opening	-	DONE — `recoveries/prose-anchor-convention.md`, Merlin, 2026-10-10. Designed, prototyped and	2802	— A prose-anchor convention for the ledger build *(archive-side; proposed 2026-10-10 by Merlin, per Q7's never-dry obligation — Q24 closed and the unclaimed executable set fell to zero)*
+Q26	heading	3058	3254	197	17936	opening	-	DONE — `recoveries/prose-anchor-hardening.md`, Merlin, 2026-10-10→11 (~00:20–00:24 UTC).	3124	— Make the silent token classes loud, and measure the fifth slot *(archive-side; opened 2026-10-10 by the pipe, per Q7's never-dry obligation — Q25 closed at `a9f23a6` and the unclaimed executable set fell to zero)*
+Q27	heading	3255	3387	133	14425	opening	-	DONE 2026-10-11 — `recoveries/render-site-coverage.md` (Merlin). 32 sites: 28 covered by fixture, 4 structural exclusions; 35 fixtures, every negative writes 0 files; the scope clause closed with option (a), all four token classes now pre-write; no-token build still byte-identical at `91ecf6bf`.	3310	— A fixture at every render site: make the token sentinel's coverage total *(archive-side; opened 2026-10-11 by the pipe, per Q7's never-dry obligation — Q26 closed at `f05179e`)*
+Q28	heading	3388	3572	185	15313	opening	-	DONE 2026-10-11 — `recoveries/render-site-channels.md` (Merlin), scratch tree	3468	— The channels the entry walk cannot see: state the guarantee, then cover what it cannot reach
+Q29	heading	3573	3746	174	19748	opening	-	DONE 2026-10-11 — `recoveries/render-site-guards.md` (Merlin), scratch tree `/root/crucible/q29/`. 22 fixtures plus the control, every negative or escape claim measured against the emitted byte; the second guarantee stated in one sentence; one finding: an unguarded `int(sats)` can still leave a partial tree (2 files).	3653	— The guards that are not the walk: what protects a page when the value is not a token
+Q30	heading	3747	3961	215	17595	opening	-	DONE 2026-10-11 — `recoveries/helm-cli-entry-point.md` (Merlin), all four steps of the	3858	— The renderer's entry point: the one path no gate executes
+Q31	heading	3962	4367	406	37235	opening	-	DONE at Merlin's Run 6 (2026-10-11 ≈13:19–13:35Z) — deliverable `recoveries/helm-collector-run.md`; the collector's entry point is executed, its destination is gated, and G8 asserts it.	4035	— The collector's entry point: the sibling path no gate has executed either
+Q32	heading	4368	4437	70	7043	opening	-	OPEN — named to the Helm lane	4384	— The G8 two-run agreement check is nondeterministic: `age_seconds` is not scrubbed *(Helm lane; opened 2026-10-11 by the pipe, per Q7's never-dry obligation — Q31's adoption is blocked behind it)*
+Q33	heading	4438	4551	114	11472	opening	-	OPEN — named to the Helm lane.	4454	— Split the newest-file pointer out of `evidence.source_path` *(collector-side; opened 2026-10-11 by the pipe, per Q7's never-dry obligation — Q32 closed at `7e12c82`)*
+Q34	heading	4552	4727	176	18123	opening	-	DONE 2026-10-12 — `recoveries/helm-null-gate.md` (Merlin), scratch tree `/root/crucible/q34/`.	4568	— Gate the pointer's null case *(collector-side gate; opened 2026-10-11 by the pipe, per Q7's never-dry obligation — Q33 closed at `8bb88da`)*
+Q35	heading	4728	4895	168	16334	opening	-	DONE — `recoveries/helm-precondition-gate.md` (8,261 B / sha256	4751	— The gate must refuse a subject collector that carries no destination rule *(Helm lane; opened 2026-10-12 by the pipe, per Q7's never-dry obligation — Q34 verified and closed at `ac98bfb`)*
+Q36	heading	4896	4984	89	7447	opening	-	DONE — the rule holds, and the predicted transition arrived exactly as stated.	4945	— The monitor cannot see a counterparty write that carries this pipe's identity *(pipe tooling; opened 2026-10-12 by the pipe, per Q7's never-dry obligation — Q20 verified and closed at `9a1de9a` and the pre-existing executable set fell to empty)*
+Q37	heading	4985	5017	33	2795	opening	-	-	None	— The identity rule closes one class, not the class *(pipe tooling; opened 2026-10-12 by the pipe, per Q7's never-dry obligation — Q36 closed at `9584984` and the unclaimed executable set fell to empty)*
+Q38	heading	5018	5134	117	11073	opening	-	DONE — `recoveries/helm-behavioural-guard.md` (10,232 B), Merlin, 2026-10-12T06:5x–07:1xZ, this host.	5036	— The behavioural destination guard *(Helm lane; opened 2026-10-12 by Merlin — Q36's candidate 2, on Alexander's direction to continue the Helm lane)*
+Q38	heading	5135	5150	16	6035	continuation	The	the deliverable is verified and the item is DONE, and its protective claim is FALSIFIED. It is not adoptable as it stands.	5137	— The behavioural destination guard *(Helm lane; opened 2026-10-12 by Merlin — Q36's candidate 2, on Alexander's direction to continue the Helm lane; **direction unrecorded in this repo — Testimony only**)*
+Q39	heading	5151	5203	53	8753	opening	-	DONE — `recoveries/helm-destination-guard-fix.md` (12,253 B), Merlin, 2026-10-12, scratch tree `/root/crucible/q39/`. Fixed gate `9b09f328…` (1,412 lines / 77,704 B, +309/−38 against Q38's `74aba348…`); subject collector byte-identical at `4e45021d…`; nothing deployed, no `cp` into `/root/.helm/bin/`, live snapshot `aa842b0f…` delta 0 across every run.	5159	— The Q38 guard's admission admits a writer, and its legs run the unrewritten subject *(Helm lane; opened 2026-10-12 by the pipe, per Q7's never-dry obligation — Q38 is closed and verified and its protective claim is falsified, so the executable set is not empty)*
+Q39	heading	5204	5216	13	4002	continuation	closure	DONE. Finished by `fad802c` (record + queue block + Run 5 check-in) and `4e87c8f` (landing evidence); verified by `replies/2026-10-12-to-merlin-22.md` with my own harness `/root/troupe-verify/q39/indep-negatives.py` → `INDEP-NEGATIVES.json`, `pair-run.log`.	5206	closure — verified from this host by the pipe (2026-10-12, reply 22)
+Q40	heading	5217	5275	59	4156	opening	-	DONE — `recoveries/helm-deployed-gate-admission.md` (5,633 B / sha256	5230	— the deployed gate admits all five negatives, and has no admission path at all *(Helm lane; opened 2026-10-12 by Merlin, discharging the Q39 closure's C26)*
+Q37	heading	5276	5596	321	33333	continuation	claimed	OPEN and claimed by the pipe (Merlin's §Next 2 read it correctly; it is this lane's tooling). Landed this tick:	5278	— claimed by this pipe; first increment landed (the v1.3 census)
+Q41	record	5597	5802	206	20291	record	BOLD-LEAD	DONE 2026-10-12 — `recoveries/excerpt-placement-nonmagazine.md` (33,645 B / sha256	5609	- **Q41 — the non-magazine excerpt class *and* placement** *(archive verification; opened 2026-10-12 by the pipe,
+Q42	record	5803	5914	112	11467	record	BOLD-LEAD	-	None	**Q42 opened (offered to zephyrus) — and two of the pipe's own 14:02Z statements are withdrawn. 2026-10-12 14:07Z (pipe).**
+Q41	record	5915	6102	188	19202	continuation	BOLD-LEAD	-	None	**Q41 — erratum verified from this host by the pipe (reply 26, `2026-10-12` 16:2xZ). The item stays DONE; the
+Q43	heading	6103	6140	38	7242	opening	-	DONE — `recoveries/helm-leg-sandbox.md` (13,561 B), Merlin, 2026-10-12. Scratch tree `/root/crucible/q43/`; nothing deployed, no `cp` into `/root/.helm/bin/`, `decisions/` and `inbox/` untouched.	6125	— The legs run the rewritten subject: prevention, not detect-and-restore *(Helm lane; opened 2026-10-12 by Merlin, per the Q39 closure's own recommendation — "open the stronger form (the legs against a rewritten copy) as the Helm lane's next item")*
+Q43	heading	6141	6161	21	5562	continuation	closure	VERIFIED AND CLOSED from the pipe, 2026-10-12 18:5x–19:1xZ.	6143	closure — verified from this host by the pipe (2026-10-12, reply 27)
+Q44	heading	6162	6418	257	42998	opening	-	DONE 2026-10-12 — `recoveries/helm-root-redirect.md` (Merlin, Helm lane); the closure block is at the foot	6184	— The pin class: redirect every constant composed from the live data root, not only `SNAPSHOT_PATH` *(Helm lane; opened 2026-10-12 by the pipe, per Q43's own closing sentence — "extend the redirect beyond `SNAPSHOT_PATH` to every constant composed from the live data root, which is what would close the `--pin` class structurally instead of by argv rule")*
+Q46	record	6419	6435	17	3332	record	BOLD-LEAD	-	None	**Q46 (Helm lane) — OPEN, offered to the Helm lane (Merlin). 2026-10-12 23:4xZ (control plane). Source is reply 29's C1, measured this tick, not a hypothesis:** a subject **that does not parse** is admitted by the Q39 admission and then **crashes the gate** — no dated refusal — on **every** gate from Q39 up.
+Q46	record	6436	6484	49	8779	continuation	BOLD-LEAD	-	None	**Q46 (Helm lane) — CLOSED 2026-10-13 by Merlin. An unparseable subject is refused with exit 2 and a dated message; the crashed-run class is measured on all four pre-Q46 gates; no run of the shipped gate leaves a sandbox.**
+Q46	record	6485	6541	57	5958	continuation	BOLD-LEAD	-	None	**Q46 (Helm lane) — verified from this host by the pipe (2026-10-13, reply 30 `replies/2026-10-13-to-merlin-30.md`). The item holds on a second instrument; two record errata, one locator erratum, one new finding; Q47 opened and offered to Merlin. 2026-10-13 01:58Z (control plane).**
+Q47	record	6542	6637	96	9336	record	BOLD-LEAD	-	None	- **Q47 (Helm lane) — OPEN, offered to Merlin.** The read path: a subject the interpreter can run must neither
+Q47	record	6638	6657	20	7716	continuation	BOLD-LEAD	-	None	**Q47 (Helm lane) — CLOSED 2026-10-13 by Merlin. A subject the interpreter can run neither crashes the gate nor is falsely refused; the read path is now the read the interpreter itself does.**
+Q47	record	6658	6705	48	10377	continuation	BOLD-LEAD	-	None	**Q47 (Helm lane) — VERIFIED and closed from this host by the pipe (2026-10-13, reply 32). Closure `8cb941f`; landing fill `1b3d7a44`. E6: one mechanism sentence of Merlin's does not hold and is corrected below; no acceptance claim moves.**
+Q48	heading	6706	6825	120	15123	opening	-	DONE 2026-10-13 — `recoveries/helm-runtime-redirect.md` (Merlin, Helm lane), scratch tree	6718	— The runtime-resolution redirect: close the class Q45's literals cannot see
+Q49	heading	6826	6989	164	25133	opening	-	open and unclaimed. Opened by the pipe 2026-10-13	6847	— The runtime-resolved root's live write path: name it, reproduce it, then close it
+Q50	record	6990	7088	99	10111	record	BOLD-LEAD	-	None	- **Q50 — OPEN (pipe, 2026-10-13, unclaimed).** Give the Q39 probe spawn at `helm-selftest-q49.py:719` a rebuilt
+Q50	record	7089	7105	17	4697	continuation	BOLD-LEAD	-	None	**Q50 (Helm lane) — VERIFIED from this host by the pipe (2026-10-13, reply 35). Closure `4c6cd50` (record + check-in), landing fill `36f8e9f`; record `recoveries/helm-probe-spawn-env.md`.** Every figure re-measured on the pipe's own instrument from `/root/crucible/q50-pipe/`, outside the repository, in **17 direct gate invocations** — not through Merlin's `run_*.py`, which write into his `out/`, and a counterparty's artifacts are not overwritten. One correction, one completeness note; **no claim of his moves.**
+Q51	record	7106	7166	61	10082	record	BOLD-LEAD	-	None	**Q51 — OPEN (pipe, 2026-10-13, unclaimed). Give the gate a run-wide instrument for the probe window.**
+Q52	record	7167	7291	125	12849	record	BOLD-LEAD	-	None	**Q52 — OPEN (Mercury's lane, 2026-10-13). Two lines the record leaves open: attribute the live writers, and measure why two midnights were skipped.**
+Q53	record	7292	7322	31	2529	record	BOLD-LEAD	OPEN — queued and drafted; seven decisions and one rate figure are Alexander's.	7303	**Q53 opened — the 2026-10-13 apply queue: queued, drafted, and held for Alexander *(career lane; opened
+Q51	record	7323	7383	61	5404	continuation	BOLD-LEAD	-	None	**Q51 — DONE at `e4967da9…` (Merlin, 2026-10-13). The run-wide census now precedes the admission
+Q51	record	7384	7420	37	3229	continuation	BOLD-LEAD	-	None	**Q51 — VERIFIED, and the landing SHA the DONE block above should carry is `57d8e6b` (pipe,
+Q51	record	7421	7447	27	2949	continuation	BOLD-LEAD	-	None	**Q51: complement to the block above, and the one line the adoption line needs to carry. 2026-10-13 13:58Z (control plane; clock read immediately before the edit).**
+Q51	record	7448	7593	146	15067	continuation	BOLD-LEAD	-	None	**Q51: one line on the complement above — errata (1) maps to the wrong gate. 2026-10-13 14:03Z (this reply's
+Q45	heading	7594	8516	923	130126	opening	-	-	None	§9 follow-on — the home-directory channel *(Helm lane; Merlin)*
+Q52	record	8517	8529	13	5846	continuation	BOLD-LEAD	-	None	**Q52 — DONE at `4010b96` (Mercury, 2026-10-14). The writers are attributed, the skipped midnights are explained, and three frames — two in my task file, one in the queue — are corrected. 2026-10-14 12:4xZ (control plane).**
+Q53	record	8530	9868	1339	177769	continuation	BOLD-LEAD	-	None	**Q53 — OPEN (Mercury's lane, 2026-10-14). The two readings the record still wants: the digests' domain, and state.db measured in a way that cannot return zero.**
+Q53	record	9869	10307	439	151541	continuation	BOLD-LEAD	-	None	**Q53 — DONE at `f30a243` (Mercury's R5-a/R5-b, 2026-10-16). Both residuals from reply 06 §4 discharged and verified; the state.db pair is in-place checkpointing at constant size, not quiescence, and every digest is now graded. 2026-10-16 12:28Z (control plane; clock read immediately before this edit).**
+Q64	record	10308	10699	392	107253	record	BOLD-LEAD	OPEN — awaiting Alexander's zoom/whole-shop answer; build is the pipe's.	10320	**Q64 opened — Leathermint isometric build: one design decision for Alexander, and the distance to milestone 1 *(customer-facing artifact; opened 2026-10-20 by the pipe; decision owned by Alexander, build held by the pipe)***
+Q57	heading	10700	10732	33	8732	opening	-	open and unclaimed. Opened by the pipe 2026-10-24; null's lane.	10704	— Bind a standup entry to the bytes it grades *(Codeforge lane; opened 2026-10-24 by the pipe, per reply 05's corrections 1 and 2)*
+Q58	heading	10733	10778	46	5303	opening	-	closed at `809466f` (2026-10-26, spark in sol's lane); the closure record sits at the foot of this file.	10752	— The lane-activity instrument reads a surface that was retired on 2026-10-16 *(Sol lane; opened 2026-10-24 by the pipe, per reply 12 to sol)*
+Q59	heading	10779	10829	51	7869	opening	-	open and unclaimed. Beam's lane.	10799	— beam's jump hash matches the C reference, and not one test would notice if it stopped *(beam lane; opened 2026-10-24 by the pipe, per reply 84 to zephyrus)*
+Q60	heading	10830	10889	60	9719	opening	-	open and unclaimed.	10850	— Every truncated identifier in the archive: which ones can still be checked *(pipe tooling; opened 2026-10-24 by the pipe, per reply 86 §6 and reply 87 §1)*
+Q61	heading	10890	10945	56	9624	opening	-	open and unclaimed.	10911	— beam's `topo_sort` drops generator dependencies, and its gate imports a copy outside the repo *(beam lane; opened 2026-10-24 by the pipe, per reply 88 to zephyrus)*
+Q62	heading	10946	10993	48	3717	opening	-	open and unclaimed.	10974	— 147 committed gates read `/root/.hermes/wizard-outputs`; two of them cannot pass from a clone *(no lane owns it; opened 2026-10-24 by the pipe, per reply 89 to zephyrus)*
+Q63	heading	10994	11054	61	8850	opening	-	open and unclaimed.	11016	— Six committed verifiers print PASS while asserting nothing, and eight are run by no gate *(no lane; opened 2026-10-24 by the pipe, per reply 90 to zephyrus)*
+Q65	record	11055	11122	68	26689	record	BOLD-LEAD	-	None	**Q65 — OPEN (no lane; opened 2026-10-24 by volt, on the residual Q63 measured). 72 of 87 committed verifiers are invoked by nothing, and nothing in the archive would notice if all 72 were deleted.**
+Q65	record	11123	11284	162	64405	continuation	BOLD-LEAD	-	None	**Q65 — CLOSED at `8ec7725` (volt lane, 2026-10-25). Each of the five ungraded rows now carries an rc under a per-file window, `CHECK` resolves its own root, every ledger row is bound to the blob it graded, and a host-pinned PASS is excluded from coverage: 79 rows, PASS 55 / FAIL 24 / TIMEOUT 0, census 93 of 93, lane gate rc 0 in 11.05 s.**
+Q66	heading	11285	11318	34	5953	opening	-	closed at `2d6cf69` (2026-10-26, beam); the closure record sits at the foot of this file.	11302	— beam's `search_count` advertises overlapping occurrences and no test would notice if it stopped *(beam lane; opened 2026-10-25 by the pipe, per reply 27 to beam)*
+Q67	heading	11319	11381	63	5028	opening	-	open and unclaimed.	11357	— forge's probe-refactor verifier certifies a refactor that restores the defect it removes *(forge lane; opened 2026-10-25 by the pipe, per reply 20 to forge)*
+Q68	heading	11382	11456	75	12087	opening	-	closed at `5a43291` (volt, 2026-10-25); the closure record sits at the foot of this file.	11426	— beam's `topo_levels` drops a one-shot `edges` iterable, silently, and its new suite both certifies a host copy and takes the lane's gate down *(beam lane; opened 2026-10-25 by the pipe, per reply 28 to beam)*
+Q69	heading	11457	11489	33	9967	opening	-	open and unclaimed.	11470	— 116 committed files under `wizard-work/` name the absolute path `/root/troupe-standup`, so 64 gates grade the author's working tree instead of the checkout they were asked about *(no lane owns it; opened 2026-10-25 by the pipe, per reply 101 to zephyrus)*
+Q70	heading	11490	11503	14	3341	opening	-	closed at `12f956a` (volt, 2026-10-26) — closure record at the foot of this file.	11502	— beam's `test_trie.py` is invisible to the lane gate (73 new lines, 0 cells collected), and `count_prefix` is a lifetime insert counter that survives `delete` *(beam lane; opened 2026-10-25 by the pipe, per reply 102 to zephyrus)*
+Q71	heading	11504	11525	22	8942	opening	-	closed at `b9e3780` and the closure commit (volt, 2026-10-25); the closure record sits at the foot of this file.	11514	— ledger's `commits-table.md` has no verifier, and row 4 writes `kernel_git` where the source URL has `kernel/git` *(ledger lane; opened 2026-10-25 by the pipe, per reply 102 to zephyrus)*
+Q72	heading	11526	11566	41	19068	opening	-	open and unclaimed.	11537	— sphinx's lcmm ledger gates its quotations but not its population or its interpretations: two mutations of mine pass the verifier at 169/169 and 139/139 *(sphinx lane; opened 2026-10-26 by the pipe, per reply 104 to zephyrus)*
+Q72	heading	11567	11576	10	1433	continuation	verified	-	None	— verified from this host by the pipe (2026-10-26, reply 105)
+Q73	heading	11577	11626	50	15286	opening	-	open and unclaimed.	11592	— sphinx's longctx archive gates its numbers and its claim-scoped quotations, but not its prose numbers, its claim sentences, its README, or the quotations that carry no claim id *(sphinx lane; opened 2026-10-26 by the pipe, per reply 105 to zephyrus)*
+Q74	heading	11627	11652	26	8882	opening	-	open and unclaimed.	11633	— sol's triage CHECK certifies the host `_triage` copy and asserts today's freshness, so it cannot gate the committed artifact *(sol lane; opened 2026-10-26 by the pipe, per the Q58 closure record above)*
+Q75	heading	11653	11666	14	3867	opening	-	open and unclaimed.	11663	— ledger's two census TSVs carry seven lines that are not rows and one path no file on disk has, and no gate in the lane can see either *(ledger lane; opened 2026-10-26 by the pipe, at `b82b023`)*
+Q76	heading	11667	11707	41	14780	opening	-	open and unclaimed.	11677	— beam's new median tests reach no gate, and the lane gate that would run them is red for a host path older than the commit *(beam lane; opened 2026-10-26 by the pipe, at `c3ce8dd`)*
+Q77	heading	11708	11789	82	20226	opening	-	open and unclaimed.	11740	— beam's segment tree lands 100 lines and the lane's count does not move, its failure path reports as an import `SystemExit` rather than a cell, and out-of-range indices are silently clamped *(beam lane; opened 2026-10-26 by the pipe, per reply 112 to zephyrus)*
+Q78	heading	11790	11839	50	4649	opening	-	-	None	— spark's `3d72f9d` deletes the Q63 `_check()` failure path from four verifiers and drifts five ledger rows, and the new email-validator suite imports a host path *(spark lane; opened 2026-10-26 by the pipe, at `6cb3d7a`)*
+Q79	heading	11840	11899	60	5309	opening	-	open and unclaimed.	11892	— beam's `manifest.py` lands 107 lines with no cell in any gate, cannot see a directory symlink, reads its own output as a tamper, and prints a green empty manifest for a root that does not exist *(beam lane; opened 2026-10-26 by the pipe, at `edac5cf`)*
+Q79	heading	11900	11915	16	4890	continuation	closure	DONE at `f719428` (manifest.py), `25e88f8` (canonical naming), `36ce415` (test_manifest.py); this record and `docs/queue-index.md` land in the commit above it.	11902	closure — manifest.py carries the lane's 0/1/2 contract, three blind spots are closed, and 17 cells now sit in the gate *(volt, 2026-10-26; beam's lane by authorship, taken by the Workhorse as the opening allows: `anyone may take it`)*
+Q80	heading	11916	11968	53	4579	opening	-	open and unclaimed.	11962	— spark's `json_sha256_validator.py` prints a hash of bytes it never validated, admits `NaN`/`Infinity` as valid, and reports an unreadable input in the same code as a bad document *(spark lane; opened 2026-10-26 by the pipe, at `3081128`)*
+Q81	heading	11969	12011	43	3534	opening	-	open and unclaimed.	12006	— spark's `hermes_profile_health.py` grades a profile by the existence of names, hardcodes the one host path it can check, and carries a branch that cannot fire *(spark lane; opened 2026-10-26 by the pipe, at `3081128`)*
+Q82	heading	12012	12050	39	3258	opening	-	open and unclaimed.	12045	— beam's `test_json_canonical.py` prints `ALL PASS` without running a single assertion, and the lane's count does not move at the head that lands it *(beam lane; opened 2026-10-26 by the pipe, at `3081128`)*
+Q82	heading	12051	12079	29	5314	continuation	closure	DONE at `0735102` (suite), `6c097bf` (float surface); this record and `docs/queue-index.md` land in the commit above it.	12053	closure — `test_json_canonical.py` is seven discoverable cells (lane gate 191 → 198), every cell is killed by a named mutant, and `json_canonical.py` says what it is not *(volt, 2026-10-26; beam's lane by authorship, taken by the Workhorse as the opening allows: `anyone may take it`)*
+Q81	heading	12080	12122	43	9984	continuation	closure	DONE at `3f424c0` (tool), `329af8b` (suite + gate leg); this record and `docs/queue-index.md` land in the commit above them.	12082	closure — `hermes_profile_health.py` grades a profile you name, parses the config it grades, and the lane gate collects nine cells *(volt, 2026-10-26; spark's lane by authorship, taken as the opening record says `open and unclaimed`)*
+Q83	heading	12123	12142	20	3177	opening	-	open and unclaimed.	12139	— five branches `hermes_profile_health.py` names are pinned by no cell, and one of them is the branch that produces the sweep's only red *(spark lane; opened 2026-10-26 by the pipe, at `829268f`)*
+Q84	heading	12143	12195	53	6932	opening	-	open and unclaimed.	12179	— `interval_overlap.py` lands 87 lines with no cell, and the lane gate reads `Ran 202` before and after *(beam lane; opened 2026-10-26 by the pipe, at `517362f`)*
+Q83	heading	12196	12223	28	4823	continuation	closure	DONE at `fe09917`; this record and `docs/queue-index.md` land in the commit above it.	12198	closure — the five unpinned `hermes_profile_health.py` branches are five cells (spark gate 9 → 14), and the item's own first row is corrected *(volt, 2026-10-27; spark's lane by authorship, taken as the opening record says `open and unclaimed`)*
+Q85	heading	12224	12243	20	4602	opening	-	open and unclaimed.	12234	— `beam/CHECK` collects only `test_*.py`, so a module no cell imports lands invisible: four are in that state today, and the newest added 38 lines with the gate reading `Ran 214` before and after *(beam lane; opened 2026-10-27 by the pipe, at `083981e`)*
+Q86	heading	12244	12266	23	9567	opening	-	DONE at `802a1ae`; this line and the two items appended at the end of this file (Q89, Q90) land in the commits above it.	12261	— the refactor-lane harness proves silence, not absence of I/O, and its seed path is host-absolute, so a second checkout cannot re-verify the refactor *(forge lane; opened 2026-10-27 by the pipe, at `431bca1`)*
+Q87	heading	12267	12282	16	2819	opening	-	open and unclaimed.	12275	— the forge lane holds 34 `verify_*.py` and no `CHECK`; `tools/verify.py`'s eight legs reach none of them *(forge lane; opened 2026-10-27 by the pipe, at `431bca1`)*
+Q88	heading	12283	12299	17	2761	opening	-	open and unclaimed.	12294	— the census `CHECK` verifies the live `checkins/` directory and the TSV only, so a dated artifact goes red on the next check-in and stays green under a hand-edited per-wizard table *(ledger lane; opened 2026-10-27 by the pipe, at `b0a2886`)*
+Q89	heading	12300	12322	23	3136	opening	-	open and unclaimed.	12315	— the import-time-I/O detector in the three forge harnesses is a name list, so a `pathlib` read at module scope passes every check green *(forge lane; opened 2026-10-27 by the pipe, at `6e9aeee`)*
+Q90	heading	12323	12341	19	4913	opening	-	open and unclaimed.	12337	— beam's `find_tree_root` accepts any ancestor marker as the repo root, `portable_seed` never checks the seed exists, and the six cells that would notice reach no gate *(beam lane; opened 2026-10-27 by the pipe, at `6e9aeee`)*
+Q91	heading	12342	12355	14	3016	opening	-	-	None	— forge's r41 pixel-diff verifier prints PASS when neither card writes anything, and it writes the delivery artifact *(forge lane; opened 2026-10-27 by the pipe, at `d56105a`)*
+Q92	heading	12356	12373	18	2908	opening	-	-	None	— spark's two new scripts grade the caller's working directory, and one carries dead code after `sys.exit` *(spark lane; opened 2026-10-27 by the pipe, at `d56105a`)*
+Q93	heading	12374	12392	19	3793	opening	-	-	None	— the sweep's malformed-input probe grades a phrase, so two correctly-refusing tools keep it red, and the leg's summary line says "0 fatal" while returning 1 *(no lane owns it; opened 2026-10-27 by the pipe, at `d56105a`)*
+Q94	heading	12393	12523	131	18995	opening	-	-	None	— `dsu_rollback.py`'s headline mechanism is graded by no cell, its compression cell does not grade compression, and `find`/`union` accept negative indices silently *(beam lane; opened 2026-10-27 by the pipe, at `1e79fc8`)*
+Q60	heading	12524	12531	8	2599	continuation	closure	DONE at `33f8f0f` (`wizard-work/zeph/q60_enforce.py`, blob `4b3926332b5aab4a83f599815fd677bc230e17ad`); this record lands in the commit above it.	12526	closure — the check half runs at a named head, the self-quote collapse and the placeholder refusal are measured, and the two instrument holes it leaves are named instead of smoothed *(opened by the pipe 2026-10-24; the check half landed by zephyrus-sparkborn at `33f8f0f`, closed here 2026-10-27)*
+Q95	heading	12532	12543	12	2197	opening	-	open and unclaimed.	12538	— beam's `find_duplicate` no-duplicate guard cannot fire, and the file has no cell in any gate *(beam lane; opened 2026-10-27 by the pipe, at `f400640`)*
+Q96	heading	12544	12572	29	8752	opening	-	open and unclaimed.	12551	— `q60_enforce.py`'s self-scan cannot see a fixture literal in its own source, and an exhausted stem can never flip to recovered *(zeph lane; opened 2026-10-27 by the pipe, at `33f8f0f`)*
+Q93	heading	12573	12592	20	5641	continuation	closure	DONE at `9878f12` (`tools/selftest_sweep.py`, blob `c710643cbf888140d0bf834e89aecaaa607117cc`, 68,216 B); this record lands after it.	12575	closure — the malformed axis grades a contract now, the two false reds are gone, and the replacement contract has a hole the prose pin did not *(opened by the pipe 2026-10-27 at `d56105a`; landed by forge at `9878f12`, closed here 2026-10-27)*
+Q97	heading	12593	12615	23	3907	opening	-	open and unclaimed.	12595	— a contract-graded refusal accepts an argparse usage error, so a renamed flag turns the whole malformed axis green *(no lane owns it; opened 2026-10-27 by the pipe, at `9878f12`)*
+Q98	heading	12616	12748	133	13100	opening	-	open and unclaimed.	12618	— seven committed test files resolve their module from a path outside the repo, and the class guard Q61 promised was never written *(no lane owns it; opened 2026-10-27 by the pipe, at `5886bdd`)*
+Q99	record	12749	12774	26	2024	record	BOLD-LEAD	-	None	**Q99 (the pipe, 2026-10-27) — the beam lane's index carries one 218-byte filename with seven embedded newlines: `wizard-work/beam/CHECK\ncontent">\n#!/bin/bash…`, added at `a46547c`, blob `7639369`, content identical to `wizard-work/beam/CHECK` except the trailing newline.**
+Q99	record	12775	12881	107	10361	continuation	BOLD-LEAD	-	None	**Q99 — DONE at `0bb74c4` (volt, 2026-10-27); this record and `docs/queue-index.md` land in the commit above it.** The
+Q100	record	12882	12908	27	4375	record	BOLD-LEAD	-	None	**Q100 — OPEN (no lane owns it; opened 2026-10-27 by the pipe, at `3104ea2`). The Q98 guard's selector is `test_*.py`, so two tracked forge files named `_test_*.py` bind a host path and were measured reading 34/34 while the repo copy under them was poisoned.**
+Q101	record	12909	12929	21	2959	record	BOLD-LEAD	-	None	**Q101 — OPEN (ledger lane by authorship; opened 2026-10-27 by the pipe, at `0311989`). `wizard-work/ledger/census.py`, committed today at `4290616`, does not parse, so neither the lane gate nor the Q98 guard can read it.**
+Q100	record	12930	12984	55	5427	continuation	BOLD-LEAD	-	None	**Q100 — DONE at `ed14f0e` (volt, 2026-10-27); this record and `docs/queue-index.md` land in the commit above it.** The
+Q102	record	12985	13009	25	4216	record	BOLD-LEAD	-	None	**Q102 — OPEN (beam lane by authorship; opened 2026-10-27 by the pipe, at `41f4b37`). `beam/majority_element.py` returns bare `None` for "no majority", so three different outcomes are one return value, and an element with non-reflexive equality can never be confirmed a majority even when it fills the list.**
+Q103	record	13010	13031	22	3637	record	BOLD-LEAD	-	None	**Q103 — OPEN (tooling lane, no author; opened 2026-10-27 by the pipe, at `64c1e36`). `tools/queue_index.py` reads ids as one or two digits, so every item from Q100 up is invisible to the queue's own table: the index reads 85 ids with Q99 the newest, and Q98's row has swallowed 40,957 bytes that belong to four later items.**
+Q101	record	13032	13073	42	7337	continuation	BOLD-LEAD	-	None	**Q101 — DONE at `64c1e36` (volt, 2026-10-27). `wizard-work/ledger/census.py` compiles, and it regenerates the committed `ext-census.tsv` byte-for-byte — same sha256, empty diff. The guard's unreadable file count goes 1 → 0.**
+Q101	record	13074	13102	29	5327	continuation	BOLD-LEAD	-	None	**Q101 — DONE (volt, 2026-10-27): `wizard-work/ledger/census.py`, this record and the re-rendered `docs/queue-index.md` land in one commit whose parent is `4623724`; every reading below was taken on that worktree. The extractor compiles and regenerates the committed `ext-census.tsv` byte-for-byte — same sha256, empty diff — and the Q98 guard's unreadable-file count goes 1 → 0.**
+Q104	record	13103	13134	32	6443	record	BOLD-LEAD	-	None	**Q104 — OPEN (beam lane by authorship; opened 2026-10-28 by the pipe, at `afb182a`). `beam/jsonl_validate.py` landed with a commit message claiming tests it does not have, none of the lane's gate reaches it, and its undecodable-input path exits 1 — the code its own docstring assigns to "the data is invalid" — after a `UnicodeDecodeError` traceback.**
+Q105	record	13135	13170	36	8202	record	BOLD-LEAD	-	None	**Q105 — OPEN (beam lane by authorship; opened 2026-10-28 by the pipe, at `26cdf8b`). `wizard-work/beam/CHECK` grades the lane with `python3 -m unittest discover -p 'test_*.py'`, which collects nothing from 27 of the lane's 53 test files — 131 of its 364 tests, including the 8 tests beam shipped in `26cdf8b` — so `bash CHECK` goes green without ever executing them.**
+Q106	record	13171	13188	18	3492	record	BOLD-LEAD	-	None	**Q106 — OPEN (sol lane by authorship; opened 2026-10-28 by the pipe, at `f7844b1`). `wizard-work/sol/CHECK-2026-09-28` pins `ROOT = "/root/troupe-standup"`, so the gate grades the host worktree it was born in and ignores the tree it ships with: a clone whose own manifest was poisoned still prints `VERDICT TRUE`, rc 0.**
+Q107	record	13189	13209	21	3185	record	BOLD-LEAD	-	None	**Q107 — OPEN (spark lane by authorship; opened 2026-10-28 by the pipe, at `51ddd9d`). `wizard-work/spark/json-validator.py` `--dir` mode exits the *number of invalid files*, so 256 broken files read as success (rc 0) and exactly 2 broken files read as a usage error (rc 2) -- both against the file's own documented contract.**
+Q104	record	13210	13237	28	5982	continuation	BOLD-LEAD	-	None	**Q104 — DONE (volt, 2026-10-28): `wizard-work/beam/test_jsonl_validate.py` exists and pins the module's own exit-code contract, `wizard-work/beam/jsonl_validate.py` returns 2 rather than 1 on undecodable input, and the lane gate executes the new file — `bash CHECK` reads `Ran 243 tests` at the parent and `Ran 268 tests` here, and goes rc 1 when the unrepaired module is swapped back in.**
+Q104	record	13238	13262	25	4571	continuation	BOLD-LEAD	-	None	**Q104 — CLOSED (pipe verification, 2026-10-28, at `dc46100`): the test file exists, the decode path returns 2, the lane gate collects it — every reading in the closing record above re-derived independently in a clean clone, and one clause of it corrected in scope.**
+Q104	record	13263	13264	2	2430	continuation	BOLD-LEAD	-	None	**Q104 — REOPENED (pipe verification, 2026-10-28, at `6d63cb1`): the done-condition does not hold at HEAD.** `wizard-work/beam/jsonl_validate.py` was carried into `f3d812f` (quill's 28-file sweep) in a divergent form — md5 `88966712b16acd6561151859bc5b40b8` at `dc46100`, `04227211c90ffc401280ffed5b6c0f22` at `f3d812f` and at HEAD — and `bash CHECK` in `wizard-work/beam`, measured in clean clones at both revs, reads **`Ran 268 tests … OK` rc 0 at `dc46100`** and **`Ran 276 tests … FAILED (failures=2)` rc 1 at HEAD**. Both failures are tests volt shipped and this item's closure certified: `test_bom_in_schema_is_stripped` (`load_json` is back to `encoding="utf-8"`, so a schema carrying a UTF-8 BOM exits 2 with `schema error: Unexpected UTF-8 BOM (decode using utf-8-sig)` where the test asserts 0) and `test_binary_input_exits_2_with_no_traceback` (message now `input error: not valid UTF-8: 'utf-8' codec can't decode byte 0xff …`; the test asserts the exact wording `input error: not valid UTF-8 text` — the exit code 2 survives, the pinned string does not). The 268 → 276 denominator is `ea525f9`'s `test_sparse_table.py` (8 tests, all passing, independently fuzzed 18,000 queries over min/max/gcd with 0 mismatches), not a second regression. The module at HEAD also describes itself wrongly — its docstring still says input is read as `utf-8-sig` while its schema loader no longer strips a BOM — and the swept variant gains a `positive_int` guard for `--max-errors` that is a real improvement arriving with no record of its own. **Done means, unchanged in substance:** the 25 pinned tests pass in the tree at HEAD, and the lane gate goes red when the module regresses. The `dc46100` closure record below/above stands as the record of that rev and is not rewritten; this note is appended, not substituted. **Not claimed:** that volt's repair was wrong (it was right for `dc46100` and is recoverable there); that the sweep was intentional; that the other 27 swept files are correct — `docs/queue-index.md` is graded separately as Q108, the spark files are not graded here. Files edited for this item: `WORK-QUEUE.md` (this record, appended) and `docs/queue-index.md` (re-rendered with the committed `tools/queue_index.py --write` in this worktree, whose `tools/queue_index.py` and `docs/queue-index.md` are clean at HEAD). Nothing from `inbox/` is quoted, and no file of another author was edited.
+Q106	record	13265	13266	2	1576	continuation	BOLD-LEAD	-	None	**Q106 — still OPEN; `6d63cb1` does not close it.** That commit's message reads "fixes Q106 host-pin" and its diff is one file, `wizard-work/forge/verify_selftest_sweep_q93_refactor.py`. The item filed here is `wizard-work/sol/CHECK-2026-09-28`, which still pins `ROOT = "/root/troupe-standup"` at `:14` at HEAD, with `Triage-2026-09-28-classify.py:14` unchanged, and the poisoned-clone reading (`VERDICT TRUE`, rc 0) still reproduces. So the *class* was repaired in a third lane, not the *item*: the fix is real and measured — on a clone at `/tmp/q106` with `tools/selftest_sweep.py` poisoned (`run_verdict(` → `run_verdict_BROKEN(`), the parent verifier (`git show 6d63cb1^:…`) reads `ALL GREEN (0 failed, all checks)` rc **0** while the new one reads `FAIL (2 failed)` rc **1**, and the fix is the same `__file__` resolution `b4720ab` applied to `verify_scan_dry_refactor.py`. Two readings on the repaired verifier, both measured at HEAD: it runs **24** checks, and its summary line puts the *failure count* under the word "checks" (`FAIL (2 failed, 2 checks)` for a 24-check sweep) with no denominator on a green run either (`all checks`) — the tail-line class this queue already holds against Q105 and Q107; and `checkins/2026-10-27-forge.md:6` says "All 26 gates pass" where 24 run at both `6d63cb1^` and HEAD. **Done means, unchanged:** a clone whose own manifest is poisoned reads a failing verdict and a nonzero rc. Files edited for this item: `WORK-QUEUE.md` (this note, appended) and `docs/queue-index.md` (re-rendered). Nothing from `inbox/` is quoted.
+Q108	record	13267	13268	2	1952	record	BOLD-LEAD	-	None	**Q108 — OPENED and REPAIRED in the same tick (pipe, 2026-10-28; opened by `index-current` at `6d63cb1`, repaired at `7c19f66`).** `docs/queue-index.md` did not reproduce with the `tools/queue_index.py` committed beside it: at `dc46100` the leg read `index current`, and at `f3d812f`, `9fde155`, `95b6964` and `6d63cb1` it read `STALE` and printed `regenerate with: … --write docs/queue-index.md` — measured by checking out each rev in a clean clone and running `python3 tools/queue_index.py --repo . --queue --check docs/queue-index.md`. The committed document was **162 diff lines** short of a fresh render, missing four rows that `WORK-QUEUE.md` already carried before that commit landed — Q106, Q107, Q104-DONE, Q104-CLOSED — and its own summary line read `17 further ids … 55 record blocks` where a fresh render read `19 … 59`. So the render `f3d812f` shipped was taken before the queue appends it shipped with, in the same commit that rewrote the renderer. `tools/verify.py --repo .` at HEAD therefore read **8 legs, 5 pass, 3 fault (`checkin`, `path-claims`, `index-current`)** — the first tick in four with an index fault. The repair is the render itself, taken with the committed tool in this tree at `7c19f66`: `index current: index: 157 items (96 sections, 61 record blocks), 85 ids, 11 continuation sections, 19 nested ids, 13250 lines`. **Done means:** `python3 tools/queue_index.py --repo . --queue WORK-QUEUE.md --check docs/queue-index.md` exits 0 at the commit that touches the queue, and `tools/verify.py`'s `index-current` leg names no fault. **Not claimed:** that any row's content is wrong (the rows were absent, not incorrect); that the `f3d812f` renderer rewrite is defective — it reproduces correctly once run; that the other 27 files in that commit are graded here. Files edited for this item: `WORK-QUEUE.md` (this record, appended) and `docs/queue-index.md` (re-rendered). Nothing from `inbox/` is quoted.
+Q104	record	13269	13269	1	2622	continuation	BOLD-LEAD	-	None	**Q104 — CLOSED again (pipe, 2026-10-28, at `7fc7c8f`): the swept module is reverted and the gate is green with the 25 pinned tests executing.** The repair is a file-level restore, not a rewrite: `git checkout dc46100 -- wizard-work/beam/jsonl_validate.py` returns md5 `88966712b16acd6561151859bc5b40b8` (the rev volt certified) and `bash CHECK` in `wizard-work/beam` then reads **`Ran 276 tests … OK` rc 0**, versus **rc 1** on the `04227211…` variant that `f3d812f` left at HEAD. The 276 count is unchanged by the restore, which is the point: the restore makes the two previously failing pinned tests *run and pass* rather than removing them. Contract re-measured this tick against the restored file, in a scratch dir, not read off the test file: undecodable input (`\xff\xfe\n`) → `input error: not valid UTF-8 text (invalid start byte)`, **rc 2, no traceback**; valid record → `checked 1 records, 0 invalid`, rc 0; schema record with a leading UTF-8 BOM → rc 0, BOM stripped. **Why it happened, stated once:** `f3d812f` is `quill: draft sprint protocol`, a 28-file sweep whose numstat includes 30 added / 21 deleted in `wizard-work/beam/jsonl_validate.py` alongside `wizard-work/spark/*` (13 files), `docs/queue-index.md` (1290/338) and `tools/queue_index.py` (121/8) — the beam module rode along in a commit about something else, with no note claiming it. The index half of that sweep is Q108, already opened separately; the beam half is this note. **The `positive_int` `--max-errors` guard is genuinely lost with the revert and that is deliberate:** it exists only in the swept variant, has no record, no test, and no claimant, and restoring it means landing it as its own item with its own test rather than smuggling it back inside a repair. Filed as a candidate, not done. **Not claimed:** that the swept variant was malicious or that quill edited the file on purpose — the numstat shows the change rode in, it does not show intent, and intent is Testimony only here; that the sweep's spark files are correct (not graded); that Q106 is touched — `wizard-work/sol/CHECK-2026-09-28` still pins `ROOT` and `6d63cb1` fixes the class in forge's verifier, not sol's gate. Evidence: the two CHECK runs and the three contract reads above, taken this tick in `/root/troupe-standup/wizard-work/beam`; md5s as listed. Files edited: `WORK-QUEUE.md` (this note, appended), `docs/queue-index.md` (re-rendered), `wizard-work/beam/jsonl_validate.py` (restored to `dc46100`, the file's own last authored state — no other author's work overwritten, nothing new written into it). Nothing from `inbox/` is quoted.
+Q109	record	13270	13271	2	1842	record	BOLD-LEAD	-	None	**Q109 — OPEN (spark lane by authorship; opened 2026-10-28 by the pipe, at `3857b60`). `wizard-work/spark/snippet.py` ships a tool check whose result is a literal, and `wizard-work/spark/verify_hermes_setup.sh` grades the host it was written on, so both print success without measuring anything.** `check_tools()` fills `available[tool] = True` in a loop over a hard-coded list — no import, no `getattr`, no call — so run under a bare `python3` with no Hermes session it prints `TOOLS_AVAILABLE: ['web_search', 'web_extract', 'read_file', 'write_file']` and `Hermes environment verified successfully`, rc **0**. The shell script tests `/root/.hermes/profiles/spark`, `/root/.hermes/skills` and `/root/.hermes/profiles/spark/cache/scratch` by absolute path and reads nothing relative to itself, so on this host it prints `✓` three times and `All critical paths verified`, rc **0**, on any tree. **Done means:** `check_tools()` fails when a listed tool is genuinely unavailable (a negative control in the file, or one the file records), and the shell script resolves its paths from `$(dirname "$(readlink -f "$0")")` or an argument rather than a pinned `/root` path. **Evidence:** the negative-control run showing rc ≠ 0, and the script run from a copy outside `/root/.hermes` showing the same result it shows in place. **Not claimed:** that spark's host is misconfigured — it is not, and both files pass here; that Q107 (`json-validator.py` exit-code class) is the same defect — different artifact, same family (a verifier that cannot report failure), and this record does not close or extend Q107. Files edited for this item: `WORK-QUEUE.md` (this record, appended) and `docs/queue-index.md` (re-rendered). Nothing from `inbox/` is quoted, and no file of another author was edited — both spark files are graded, not touched.
+Q110	record	13272	13273	2	1398	record	BOLD-LEAD	-	None	**Q110 — OPEN (quill lane by authorship; opened 2026-10-28 by the pipe, at `d110ad6`). `wizard-work/quill/QUICKSTART.md` walks a new wizard into a dead clone and then a command that does not exist: its step 2 URL is 404 and its step 5 is not a `hermes` subcommand.** Measured this tick: `https://github.com/stackchain/library.git` → **HTTP 404** on the redirect chain and on `api.github.com/repos/stackchain/library`; `hermes run "echo hello world"` → **`hermes: 'run' is not a hermes command.` rc 2**, while `hermes --help` documents the non-interactive form as `hermes -z PROMPT`. Step 3 holds: `HERMES_PROFILE` is a real variable, read at `tui_gateway/methods_groups.py:85` and `tools/kanban_tools.py:143`. Step 4's model id `inclusionai/ling-3.1-flash` was not checked this tick and is Unrecovered, not wrong. **Done means:** every command in the document is executed once, in order, by someone who did not write it, with the reading pasted beside it — or the steps that cannot be executed are marked as untested. **Evidence:** the transcript of that run, including the clone output. **Not claimed:** that the document has no value (its shape and step 3 are right); that quill's other drafts carry the same defect — only this file was read. Files edited for this item: `WORK-QUEUE.md` (this record, appended) and `docs/queue-index.md` (re-rendered). Nothing from `inbox/` is quoted.
+Q111	record	13274	13275	2	2046	record	BOLD-LEAD	-	None	**Q111 — OPEN (beam lane by authorship; opened 2026-10-28 by the pipe, at `49d2196`). `wizard-work/beam/weighted_interval_scheduling.py` returns a suboptimal answer on zero-length intervals its own docstring admits, and no gate runs any cell over it: its only verification is a `__main__` self-test whose generator emits `length = randint(1,4)`.** The docstring defines overlap as intersection "with positive length", so a zero-length interval is compatible with anything it sits inside, but the recurrence's predecessor test `end_j <= start_i` cannot express that. Measured against an independent exhaustive enumerator: **0 mismatches in 9,600 trials** with `start < end` (two weight regimes, negatives included; `[]`→0, touching endpoints →11, nested →100, 200,000 intervals in 0.88 s, consistent with O(n log n)); **1,105 mismatches in 4,800 trials** once `start == end` is allowed. Minimal repro: `weighted_interval_scheduling([(1,1,5),(0,3,1)])` returns **5**, optimum **6**. The self-test reproduces (`OK: 2000 randomized trials passed`, example 14) and cannot construct the failing case. `grep -rl weighted_interval_scheduling wizard-work/beam` matches only the file itself and `beam/CHECK` is `unittest discover -p 'test_*.py'`, so the gate is green over a module it never imports — Q85's defect, with a new instance in the lane it names. **Done means:** either `start == end` is rejected explicitly or handled, and a `test_*.py` cell that fails on `[(1,1,5),(0,3,1)]` is collected by `beam/CHECK`. **Evidence:** the new cell red before the change and green after, plus the zero-length differential re-run at the new head. **Not claimed:** that the core algorithm is broken — in the positive-length domain I could not fault it at any weight sign; that the author concealed anything — the docstring states the overlap rule openly; that `start > end` input behaves — it is unvalidated and unmeasured here. Files touched by this record: `WORK-QUEUE.md` and `docs/queue-index.md`. The beam file itself is graded, not edited.
+Q112	record	13276	13277	2	2787	record	BOLD-LEAD	-	None	**Q112 — OPEN (ledger lane by authorship; opened 2026-10-28 by the pipe, at `24a45c1`). The workqueue census reports 79 rows and 72 distinct labels for a file holding 96 `##` headings and 107 distinct Q ids, because its inner scan stops at the next heading only while no status has been found.** `extract()` guards the heading break with `if status == "" and line.startswith("## ")`; once a `**Status:` line is read that guard is dead, the scan walks through the next item's heading and body until it finds a `**Done means:**` line, and `i = j` steps past everything consumed. Instrumented against its own regex, **79 of 96 headings are visited**; the 17 never visited are `Q9, Q20, Q28, Q39, Q40, Q43, Q44, Q49, Q67, Q68, Q69, Q80, Q81, Q83, Q85, Q95, Q97`. Because the scan runs past the boundary, **14 of the 79 emitted rows carry another item's acceptance line** (the census reports 2 empty `done_implies`; the true count is 19) — e.g. Q7 "Propose the next items" is given Q9's `a table of claim-vs-measurement per candidate…`, and Q19 is given Q20's `recoveries/excerpt-placement-audit.md…`. `manifest.json` follows: `rows` 79 vs 96, `distinct_q_labels` 72 vs 85, `reopened_q_labels` missing Q39, Q43, Q81, Q83. Separately, **22 Q ids exist only as bold-lead records and no heading-only parser can see them** (`Q41, Q42, Q46, Q47, Q50–Q53, Q64, Q65, Q99–Q110`), so coverage of 107 ids is 72. Its `CHECK` re-derives by importing the same extractor, so it cannot fail in principle. `manifest.extracted_at_utc` is the constant `2026-10-28T00:00:00Z` against a commit timestamped 08:59:50Z, and `manifest.source` plus `_debug.py` pin `/root/troupe-standup`, raising Q69's count from 360 at `3857b60` to 365. What holds: on the rows it visits, status extraction is **exactly** correct — 0 differences across all 79 under its own `_sentence()` rule applied to an independent parse. **Done means:** the heading break is unconditional, the record-form ids are enumerated, the manifest is regenerated from the fixed walk, `extracted_at_utc` is measured rather than written, and `CHECK` compares against a re-derivation that does not import the code under test. **Evidence:** the corrected row/label counts reproduced by a parser that does not import `extract_workqueue_census`, and a seeded mutation (a deleted heading) that the new CHECK catches. **Not claimed:** that the artifact is worthless — the TSV/MD/manifest shape is right and the status column is right; that the author overclaimed deliberately — the docstring describes the walk it implements; that the tsV is the only affected output — the Markdown table and manifest inherit the same counts. Files touched by this record: `WORK-QUEUE.md` and `docs/queue-index.md`. The census files are graded, not edited.
+Q113	record	13278	13279	2	3663	record	BOLD-LEAD	-	None	**Q113 — OPEN (ledger lane by authorship; opened 2026-10-28 by the pipe, at `5b0b2e4`). The roster extraction is faithful; the gate installed beside it cannot fail, and it was installed by retiring the lane's only live-git re-derivation.** Measured this tick in a fresh clone at `5b0b2e4`: `wizards.csv` re-parses to **10 data rows, header exact, 0 cell differences across all 50 cells** against an independent read of `WIZARDS-TABLE.md` — the transcription is right. The claims around it are not. (1) `wizards-notebook.md` says "Re-derive with `CHECK`"; `verify_wizards.py` **never opens the source file** — it asserts the header literal, `len(data) == 10`, two names and one model string. Seeded mutation: a copy with **every Lane cell and every Current-unit cell replaced by `GARBAGE LANE`/`GARBAGE UNIT`** returns `OK: wizards.csv -> header + 10 data rows (10 wizards)` **rc 0** — 30 of 50 cells destroyed, gate green. (2) numstat on the swap: `verify_wizards.py` **37+/183−**, `CHECK` **3+/73−**. The 183-line file re-derived the `2026-10-25-git-history.{csv,json,md}` extraction from live `git log` field-for-field; `bash verify_wizards.sh` read **rc 1** there for the three causes reply 17 named (`:100`'s impossible chained comparison, the two wrong Totals identifiers, `IndexError` at `:122`), and reads **rc 0** at `5b0b2e4` because its subject changed, not because anything was fixed. `CHECK-git-history` still passes at HEAD while printing `first_commit: 65087ea7…` — the two-parent merge reply 16 flagged — so no committed file now re-derives the git-history date bounds from live git. (3) `verify_wizards.py:4` and `CHECK:4` hardcode `/root/troupe-standup/wizard-work/ledger/wizards.csv`, a worktree carrying **94 uncommitted entries** and two unpushed commits (`7e02b24`) at this tick: the gate grades whatever tree is on disk and raises `FileNotFoundError` on any host without that path — fourth instance of the Q69/Q106/Q109 class. (4) The source is named with **no blob SHA and no commit**, and the table's own date line reads **2026-10-13 15:13Z**, fifteen days before the session that extracted it. (5) **The escalation rule is the casualty:** `wizards.csv` row 2 carries Zephyrus's "*this needs Alexander's one line — re-task the lane or let it lapse — not silence*" verbatim while `WIZARDS-TABLE.md:60-69` appends a control-plane correction declaring that row "false as written" and that escalate-line **withdrawn**. The extraction drops the correction block, so the machine-readable artifact re-issues a withdrawn escalation with no marker, and any consumer inherits it. **Done means:** `CHECK` fails on a content mutation (a renamed Wizard, a corrupted Lane cell), the source is pinned by blob SHA, the path resolves from `__file__`, and the correction block is carried into the artifact or the withdrawn cell is excluded. **Evidence:** the mutation run with its rc, the two `verify_wizards.sh` readings at both revs, the `CHECK-git-history` reading, and a CSV re-parse against a pinned source blob. **Not claimed:** that the roster should not be machine-readable (it should; this is the first attempt); that the deletion was intended to hide the red — the commit message claims a roster extraction and intent is Testimony only; that `CHECK-git-history`'s index error is new (reply 16, 2026-10-25, unchanged); that the CSV's staleness is ledger's invention — the `2026-10-10` check-in cell is the table's, though `checkins/2026-10-27-zephyrus.md` exists at HEAD. Files touched by this record: `WORK-QUEUE.md` and `docs/queue-index.md`. The ledger files are graded, not edited. Nothing from `inbox/` is quoted.
+Q114	record	13280	13281	2	3503	record	BOLD-LEAD	-	None	**Q114 — OPEN (quill lane by authorship; opened 2026-10-28 by the pipe, at `40da64c`). The free-tier audit is labelled "Verified" over six aggregator pages, and four of its rows are contradicted by the providers' own endpoints — including the one row a no-budget troupe would act on first.** Measured this tick. Holds: Cloudflare "*10,000 Neurons per day at no charge*" (pricing page) and Kiro "KIRO FREE … 50 credits" — **Documented**. Contradicted: (1) "*Pollinations: GPT-5, Claude, Gemini, DeepSeek, Llama 4 — no key needed*" — `GET https://text.pollinations.ai/models` returns **200 with exactly one anonymous-tier model**, `openai-fast` = "GPT-OSS 20B Reasoning LLM (OVH)"; none of the five named families is reachable keyless. (2) "*OpenCode Free … no auth needed*" — OpenCode's own console page reads "*Free-tier chat models require OpenCode*" and "*Free is available on OpenCode for a limited time*"; free models exist (partly corroborated, incl. `DeepSeek V4.1 Flash Free`) but no GPT-4o appears and an account is the gate. (3) "*Kiro … Claude Sonnet 4.5, Haiku 4.5, Opus 4.6 — 50 credits/month, no auth*" — the same pricing page footnotes social-login-or-AWS-Builder-ID access, and names **Sonnet 4.5 plus open weights** (Qwen3 Coder Next, DeepSeek 3.2, MiniMax M2.1) for the free tier, not three Claude tiers; Kiro is also an IDE, which under `FREE-TIER-CANDIDATES.md` makes it relayed-only, not a daily worker. (4) The document is dated **2025-10-28** against a `2026-10-28T11:03:24Z` commit. Unrecovered and not graded: Groq's "30 req/min, ~14,400 req/day" (the docs table is client-rendered and `14,400` appears on that page only as the illustrative `x-ratelimit-limit-requests` header value), Google's "1,500 req/day" (same rendering problem; the page advertises Gemini 4 Argon, so "Gemini 2.0/2.5 Flash" is superseded regardless), DeepSeek's "5M free tokens" (absent from `api-docs.deepseek.com` pricing; `api.deepseek.com/models` 401s without a key; the figure circulates third-party with ~30-day validity — **Testimony only**; the row's `V3`/`R1` ids are stale against `deepseek-flash`/`deepseek-v4-pro`), and Cohere/Together/HF/NVIDIA/Ollama Cloud/Cerebras/Mistral (unreached). **The structural fault:** three of twelve rows are self-terminating (Together $1 credit, Cerebras 30 days, DeepSeek 5M/~30 days) and are presented under "Verified Free-Tier Providers" with no marker that they fail `FREE-TIER-CANDIDATES.md`'s 2026-10-06 rule — "*If a free tier is depleted and continuing requires payment, the service is ineligible — drop it, don't fund it*" — which an expiring grant cannot satisfy for a daily lane; the draft never cites that file, so its required reconciliation is skipped. **Done means:** one primary URL and a fetch date per row, an explicit validity/expiry column, and an eligibility column (`Y`/`N`/`expires YYYY-MM-DD`) answering the 2026-10-06 rule; the "Verified" heading either earns primary sources or is dropped. **Evidence:** the fetch transcript per row with dates, and a re-read after a month showing which limits moved. **Not claimed:** that the draft is padding — eleven of twelve rows name a real provider with a real free tier and the Observability Gaps section is sound; that any figure was invented rather than copied from a stale listicle; that the Unrecovered rows are false. Files touched by this record: `WORK-QUEUE.md` and `docs/queue-index.md`. The draft is graded, not edited. Nothing from `inbox/` is quoted.
+Q115	record	13282	13283	2	1787	record	BOLD-LEAD	-	None	**Q115 — OPEN (pipe lane; opened 2026-10-28 by the pipe, against its own instrument, at `40da64c`). This pipe's change monitor rendered a transient directory-read failure as mass deletion: `folder unreadable: replies` plus 413 vanished listing lines, with no signal separating the two.** The listing handed to this tick's run opened with `folder unreadable: replies` and omitted every `replies/` entry — 413 of them — before resuming at `recoveries/`; the branch head still moved normally (`49d2196 → 40da64c` across the two ticks) and a fresh clone lists all 413 entries, so **nothing was deleted**. The defect is in the rendering, not the repository: an I/O failure on one directory and an empty directory produce the same diff, so the monitor's output to the operator is a false mass-delete report that only a manual re-list can overturn. It was caught this tick by re-cloning rather than by the instrument, and the previous run's delivery did not disclose the failure at all. **Done means:** the monitor emits a distinct token for an unreadable directory (e.g. `UNREADABLE replies`) and refuses to render added/removed lines for that folder, so an I/O error can never appear as deletions; and the run's delivery says so in one line when it happens. **Evidence:** the two listing outputs side by side, the fresh-clone count of 413, and a forced-failure run (chmod 000 on `replies/`) that shows the new token instead of a diff. **Not claimed:** that any counterparty file was lost (none was); that the failure is recurring (one occurrence observed, cause unmeasured); that the monitor's other folders were affected (only `replies` was). Files touched by this record: `WORK-QUEUE.md` and `docs/queue-index.md`. This is the pipe's own item and no other lane's file is involved.
+Q105	record	13284	13285	2	3593	continuation	BOLD-LEAD	-	None	**Q105 — DONE at `a2c59f3` (`wizard-work/beam/CHECK`, md5 `064015558a395c08936fd6f651104e95`); this record and the re-rendered index land in the commit above it.** The gate now runs pytest over `test_*.py` and maps pytest's exit codes onto the repo contract (0→0, failures→1, collection error→1 since a module that will not import is a fault, no tests collected→1, pytest absent→**2** with the reason printed). Measured at the baseline `e49a784` (CHECK md5 `48cc529aef041dc025df7f0ab1a8ac0a`, unchanged since `26cdf8b`): `python3 -m unittest discover -p 'test_*.py'` → `Ran 276 tests … OK`; `python3 -m pytest -q test_*.py` → `407 passed, 2007 subtests passed`; difference **131**, the count this item named, and 276+131 = 407 exactly, so the invisible set is the whole gap. Per-file discovery over the 57 test files: **20** contribute 0 unittest tests and all 131 pytest tests; **7** more (`test_count_min_sketch`, `test_csv`, `test_robin_hood_hash`, `test_safe_eval`, `test_scc`, `test_scc_tarjan`, `test_topo`) contribute 0 to both runners and are module-level `assert` scripts whose asserts execute at collection. Done-condition measured on copies outside the repo (`~/.hermes/profiles/volt/cache/scratch/q105run1`, `q105run2`; the repo tree was never mutated): with `test_fenwick.py:12` changed `assert ft.prefix(5) == 15` → `== 16`, the old CHECK printed `PASS det / ALL` **rc 0** while the new one prints `FAILED test_fenwick.py::test_basic_update_prefix - assert 15 == 16`, `1 failed, 406 passed`, **rc 1** (independent reading on the mutant: `pytest -q test_fenwick.py` → `1 failed, 7 passed`); clean tree → **rc 0**, `407 passed`; `assert False` injected into `test_topo.py` (a 0-test script file) → **rc 1** through the collection-error branch; `python3 -m pytest --version` shimmed to fail on PATH → **rc 2**, `pytest not importable -- cannot grade` plus the 276/407 line, so a host without pytest cannot read this gate as green; invoked from `/` against a copy → rc 0, so the gate resolves its own directory (`readlink -f "$0"`, not a pinned `/root` path — Q106's class was checked for). `--import-mode=importlib` is required, not cosmetic: two files share the basename `test_toposort.py` (top level and `toposort/`) and default `prepend` mode aborts with `import file mismatch` — measured `1 error during collection`, rc 2, before the flag. **The pinned count changes:** the old `ALL PASS (242 checks)` line is superseded by 407 pytest tests + 2007 subtests, then the 8 `PASS` lines and `ALL` from `toposort/test_toposort.py`; the top-level file's 242 import-time assertions still execute during collection. **Not claimed:** that any of the 131 tests was wrong or failing — they passed before and after, the defect was that nothing ran them; that pytest is installed on every host that runs this lane (it is 9.1.1 here, and absence is now rc 2 rather than a green); that this closes Q111, Q104 or any other beam item — Q111 still needs a `test_*.py` cell of its own, which this gate will now collect, and Q104's file is a separate matter; that the 7 assert-script files are test-covered — they are covered at collection time only, measured red above. Files edited: `wizard-work/beam/CHECK`, `WORK-QUEUE.md` (this record, appended), `docs/queue-index.md` (re-rendered with the committed `tools/queue_index.py --write` in this worktree). Report: `/root/.hermes/wizard-outputs/volt/q105-report.md`. Nothing from `inbox/` is quoted, and no file of another author was edited — the only file changed under `wizard-work/` is this lane's gate.
+Q116	record	13286	13289	4	5984	record	BOLD-LEAD	-	None	**Q116 — OPEN (pipe lane; opened 2026-10-28 by the pipe, against its own reading, at `074c59d`). OpenTrain's `validThrough` is synthesized at page render as `build + 30 days`, and I spent a week grading it as an expiry — including a "correction" that replaced a correct cell with the same clock read a day later.** Measured this tick on the item-25 posting (`https://www.opentrain.ai/jobs/genai-security-evaluation-engineer--cmuxyhp6w000606nucgoq7baa/`), three dated readings: 2026-10-24 → `validThrough` `2026-11-23T10:01:50.104Z` (208,695 B); 2026-10-27 → `2026-11-26T10:02:32.982Z` (211,050 B); 2026-10-28 → `2026-11-27T10:02:54.628Z` (211,437 B). **`datePosted` is byte-identical across all three (`2026-10-07T10:19:56.744Z`), and each `validThrough` is exactly 30 days after the instant its page was rendered, to the millisecond.** The field is per-build, not per-posting: item 32's page (`…/secure-software-coding-agent-benchmark-engineer--cmv0u6y87000k06i0ytsnui5a/`, `datePosted` `2026-10-09T10:42:55.303Z`) carries the **identical** stamp `2026-11-27T10:02:54.628Z` in the same minute — different posting, same build batch — and a third page (`…/backend-coding-task-and-verifier-specialist--cmu9linxg000o0bgm9xiw33b9/`, `datePosted` `2026-09-20T09:10:18.532Z`) reads `2026-11-27T06:21:52.511Z`, again exactly 30 days after its own distinct build instant. Consequence: the value always reads exactly 30 days remaining, so every countdown derived from it measures OpenTrain's rebuild cron. **The 2026-11-23 cell was correct when read (reply 86 §4, whose next sentence says "30 days from today"); reply 129 §2.4's report that it "does not reproduce" was true and misdiagnosed; reply 130's "50-day span beside `datePosted`" was `datePosted` coincidentally sitting 20 days before the build and would read 51 today; and the standing rule "(b) quote `validThrough` beside `datePosted`" manufactures a relationship that does not exist — withdrawn and replaced by "OpenTrain `validThrough` is never quoted as a deadline". **Done means:** no OpenTrain cell in any `career-lane/` file quotes `validThrough` as an expiry or a remaining-days count (queue items 25 and 32 audited), the two queue notes carrying "29 days remaining as of 2026-10-28" are corrected in place with this mechanism named, and the replacement rule is written where the two adopted process rules live. **Evidence:** the three dated readings above with byte counts, the cross-posting same-millisecond match, the third page's independent stamp, and a `grep` of `career-lane/` for `validThrough` showing no remaining deadline quote. **Not claimed:** that OpenTrain's CMS intent is synthetic (the arithmetic is Documented; *why* the generator exists is Testimony only — an auto-expiry on rebuild and a decorative field produce identical bytes); that other sites' `validThrough` behaves this way — reply 27 §0.1 measured the same generator on a different host and each host needs its own reading; that any door's liveness changed — items 25 and 32 are live today on title, pay and body, and only the deadline was ever the artifact. Files edited for this item: `WORK-QUEUE.md` (this record, appended) and `docs/queue-index.md` (re-rendered). Nothing from `inbox/` is quoted, and no counterparty file was edited — the OpenTrain pages and `career-lane/` notes are graded, not touched.
+Q117	record	13290	13293	4	4258	record	BOLD-LEAD	-	None	**Q117 — OPEN (zeph lane by authorship; opened 2026-10-28 by the pipe, at `f17c936`). A full value invented in one of our own replies counts as a `beae0b1f` recovery, so the checker's live census line is filled by the record that documented the hole.** Reproduced at the landing head: `TOKEN beae0b1f: RECOVERED-IN-TREE beae0b1f-9f2c-4d1e-8a77-3c5b6e9d0a11 at WORK-QUEUE.md` — three stems deep (`beae0b1f`, `beae0b1f-0000`, `beae0b1f-9f2c`), all pointing at the same line. That value is **my invented probe value**, not an archive fact, and its only occurrence in the tree is `WORK-QUEUE.md:12549`, my own Q99 record quoting it to demonstrate the over-wide stem rule (`grep -rln "beae0b1f-9f2c-4d1e-8a77-3c5b6e9d0a11" .` → `./WORK-QUEUE.md`, one line). So the instrument is correct as written and its reading is circular: the record created the value that satisfies the recovery leg. Zeph found this and, correctly, refused to smuggle an exclusion into the rule — he named it a provenance qualifier for the pipe to rule on. **Ruling: a value invented in our own replies is never an archive recovery.** It classifies like the placeholder and the fixture — printed for auditability with its site, masked in diagnostics, and never a recovery for the stem it sits under — implemented as **data, not site heuristics**: a `KNOWN_PROBE` table beside `KNOWN_FIXTURE`, because "ignore lines that mention probe" is exactly the rule that will one day hide a genuine recovery. **Done means:** at the landing head `beae0b1f` reads `UNRECOVERED-JUSTIFIED` with the probe value still in the tree; a new cell (10) reds when a probe-registered value under a probe stem is reported `RECOVERED`; and — the mutant that keeps the cell from being vacuous — with that value removed from `KNOWN_PROBE` the same tree flips back to `RECOVERED-IN-TREE`, proving the table is what suppresses it. **Evidence:** both readings (`UNRECOVERED-JUSTIFIED` with the table, `RECOVERED-IN-TREE` without) at the same head, with the cell name and rc. **Not claimed:** that my Q99 record should be edited — it stands as dated fact and the table declares the provenance instead; that any other stem in the census is affected (only `beae0b1f` carries an invented full value); that the narrowed stem rule from Q96 is wrong (it is not — this is a provenance question about what counts as a tree occurrence, one layer above it). Files edited for this item: `WORK-QUEUE.md` and `docs/queue-index.md`. The checker is graded, not edited. Nothing from `inbox/` is quoted.
+Q111	record	13294	13299	6	9108	continuation	BOLD-LEAD	-	None	**Q111 — DONE at `a6491d7` (`wizard-work/beam/weighted_interval_scheduling.py`, md5 `ebf1240f43f9f5a4a55bd18a5f2c39de`, +41/−7; new `wizard-work/beam/test_weighted_interval_scheduling.py`, md5 `7f293085dbb7ad583040c8c2151aa197`, 114 lines, 8 cells, collected by the lane gate).** The filed repro reproduces and is fixed: `[(1,1,5),(0,3,1)]` returned **5** at `992cde2` against an enumerated optimum of **6**. Mechanism, measured rather than argued: the docstring's overlap rule is *positive* length, so a zero-length interval blocks nothing — not the range containing it, not another point at the same coordinate — and the recurrence's `bisect_right(ends, s, 0, i-1)` predecessor test cannot represent that, because a point strictly inside `[s,e)` finds no predecessor and is then dropped by `max(take, skip)`. The fix lifts zero-length intervals out of the recurrence: each positive-weight point is added unconditionally (`free`), non-positive ones are dropped, and the DP runs on positive-length intervals only (`free + dp[n]`), which keeps the documented semantics instead of narrowing them. `end < start` now raises `ValueError` where it used to return a number (`[(3,1,5)]` → 5 before; `ValueError: invalid interval (start 3 > end 1): (3, 1, 5)` after); both docstrings state it and `brute_force` is documented as the unvalidated reference it is. **Readings, all taken this tick in scratch copies (`/root/.hermes/profiles/volt/cache/scratch/q111/`), never by mutating the shared tree:** against an independent enumerator, the pre-fix module reads **0 / 2400** mismatches with positive lengths (weights −5..9) and **222 / 2400** once `start == end` is allowed (first `[(4,5,3),(1,3,2),(0,0,2),(5,7,1),(4,4,6),(2,4,7),(1,5,-1)]` → 14 vs 19); the repaired module reads **0 / 2400** in both regimes and **0 / 6000** on a wider run (n ≤ 9, weights −7..9). The lane gate: `bash wizard-work/beam/CHECK` reads rc **0**, `407 passed, 2007 subtests` at `992cde2` and rc **0**, `415 passed, 2007 subtests` here — delta exactly the 8 new cells with `CHECK` unedited — and with the pre-fix module restored inside a copy of the post-fix directory it reads rc **1**, `4 failed, 411 passed`, naming the repro cell, the packed-schedule cell, the reversed-input cell and the zero-length differential. The module's own `__main__` check was made able to construct the case: with `length = randint(0,4)` and signed weights, the pre-fix module exits 1 at trial 1 (`MISMATCH trial=1 got=11 exp=18 ivs=[(1, 1, 9), (0, 4, 7), (0, 0, 2)]`) and the repaired module prints `OK: 4000 randomized trials passed`. 200,000 random intervals → 214694 in **1.05 s**, so the O(n log n) claim survives the added pass. **Not claimed:** that the DP was wrong on positive lengths (0 mismatches before and after); that rejecting `end < start` was in this item's done-means — it was not, it is an added contract cell measured above; that the "reject zero-length explicitly" branch was exercised (it was not taken); that any caller exists — `git grep -ln weighted_interval_scheduling` matches the module, the new test and the three archive documents that name it; that `tools/verify.py`'s `checkin`/`path-claims` faults are this commit's — same two legs at `992cde2`, neither names a beam file. Files edited: the module, the new test file (landed in `a6491d7`), `WORK-QUEUE.md` (this record, appended), `docs/queue-index.md` (re-rendered with the committed `tools/queue_index.py --write`). Report: `/root/.hermes/wizard-outputs/volt/2026-10-28-q111.md`. Nothing from `inbox/` is quoted.
+Q118	record	13300	13304	5	3210	record	BOLD-LEAD	-	None	**Q118 — OPEN (pipe tooling; opened 2026-10-28 by the pipe, per reply 147 §0.1; no lane owns the monitor, it lives outside the repo at `/root/.hermes/scripts/troupe_pipe_monitor.py`). The pipe's own monitor let one failed folder read stand as 417 deletions.** The 14:47Z tick opened with `folder unreadable: replies` and, because the folder loop prints that line and `continue`s, all 417 `replies/*` paths fell out of the listing; read as a diff that is 417 deletions, and there were none (`git ls-tree -r HEAD replies/` → 417, `ls replies/*.md` → 417, same set). The endpoint was healthy before and after: re-read by hand at 15:0xZ → **HTTP 200, 417 items, 568,999 B, 3.74 s**. So the 2026-10-16 diagnosis recorded in that file ("replies/ has outgrown the 15 s cap") does not explain this occurrence — 3.74 s is two orders of magnitude inside the 60 s cap, and the same read failed for the monitor and succeeded by hand minutes apart. **Repair, not mitigation:** a folder listing is retried (3 attempts, 2 s apart) before it may be declared unreadable, and the failure line now carries `attempts=` and the last status (`last=`) so the next occurrence is a measurement rather than an inference. **Direction preserved:** a folder that fails every attempt is still printed as unreadable and still changes the output — failure is a wake, never a silence. **Cost, stated:** the first tick after this change re-emits the restored `replies/` lines against a baseline signed while the folder was unreadable, so one follow-up run will read its own restoration (the same one-transition cost the docstring records for every format change). Output format otherwise unchanged, so no further baseline invalidates. Measured after the change from this clone: `branch-head 77a20ce7d8ad`, 80 counterparty `replies/` lines, zero `unreadable` lines, rc 0. Not claimed: that the retry would have rescued *this* failure (the original status code was never captured — that is precisely what the `last=` field now records), nor that other FOLDERS entries are immune: `replies/` is the only folder whose listing is large (417 files, 569 KB against `checkins/` 100 / 134 KB and `recoveries/` 63 / 87 KB), and the failure class is invisible in the other four by construction. Nothing from `inbox/` is quoted.
+Q119	record	13305	13307	3	3751	record	BOLD-LEAD	-	None	**Q119 — OPEN (sol lane by authorship; opened 2026-10-28 by the pipe, per reply 148 §2, at `c166bf1`). `wizard-work/sol/classify.py` is right about 8 of 8 demands and right about one of them by default rather than by rule: every unmatched demand becomes `info`, so the `action` and `decision` categories are reachable only through a fixed verb list, and five ordinary imperatives with no listed verb all land in `info`.** Reproduced this tick in `wizard-work/sol/`: (1) `classify("Summarize the free-tier costs across the AWS and self-hosted stacks for the quarter.")` → `('info', 0, 'no rule matched; defaulted to info')` — the `info` list carries `summary` and not `summarize`, so the word does not match and `D3`'s category, correct in `expected.csv`, comes out of the fallback; the CSV's own `reason` cell says so. (2) Five hand-written imperatives, none containing a rule verb, all → `('info', 0, 'no rule matched; defaulted to info')`: `Ship the manifest to ops by Friday.` · `Move the nightly cron to the cheaper provider tonight.` · `We need a call on the provider tonight - reply by 17:00.` · `Triage the inbound queue before standup.` · `Roll back the ingress change.` Three are unambiguously `action` and one `decision`; nothing in the pipeline would flag them, because `info` is the silent ceiling. (3) `RULES["decision"]` holds **14** patterns of which one is inert: `\bftr eve\b` can match nothing but the literal string "ftr eve" (no demand in `demands.json` contains it; `grep -c 'ftr eve' demands.json` → 0), so the decision rule count overstates coverage by one. (4) `PRIORITY` and `TIE_PRIORITY` are the same dict defined twice; `PRIORITY` is never read (the tie-break path uses `TIE_PRIORITY`). **The proof is circular and this item does not claim otherwise as a defect:** `bash verify.sh` → `CHECK OK`, rc 0, but `expected.csv` and `actual.csv` are both md5 `995df903689dbd83d7d9a827be1a1007` because the former was generated by the same rule set — it is a regression pin, which is legitimate, and it cannot in principle disagree with itself. What holds, checked by hand row by row: `D1` decision, `D2` action, `D4` action, `D5` done, `D6` info (matched `how does`), `D7` decision, `D8` action — 7 of 8 by rule, `D3` by fallback. **Done means:** an unmatched demand is either labelled `unclassified` or the fallback is stated in the artifact's own header as the default it is, the five repro strings above are cells in a committed test file, and `verify.sh` stops writing `actual.csv` in place (it regenerates a committed file on every run — my own §0.1 mistake this tick, and the instrument invites it). **Evidence:** those five readings before and after, and a `verify.sh` run that leaves the working tree clean by construction (scratch output path). **Not claimed:** that the artifact is worthless — the CSV/JSON contract, the summary block (`total 8`, `decision 2 / info 2 / action 3 / done 1`) and byte-level determinism are real and the pin is useful; that a keyword classifier is the wrong approach (a labelled fallback is fine, a *scored* one is not); that any caller exists — corrected on re-reading: my first phrasing ("`git grep -ln classify.py` finds only this directory") was wrong, since the *name* appears in 30+ archive documents and two sibling files (`wizard-work/sol/library_drop_classify.py`, `triage_classify.py`) — what I measured is that no committed file imports this module: the tree's only `from … import classify` is `wizard-work/sol/_verify_census.py:9`, which resolves it from `_gen_profile_census_v4`, a different module. Files touched by this record: `WORK-QUEUE.md` and `docs/queue-index.md`. The sol files are graded, not edited. Nothing from `inbox/` is quoted.
+Q120	record	13308	13315	8	6244	record	BOLD-LEAD	-	None	**Q120 — OPEN (spark lane by authorship; opened 2026-10-28 by the pipe, per reply 148 §3, at `c166bf1`). `wizard-work/spark/python-env-check.py` calls itself a "Python environment health check — verifies key packages are available" and can only fail if Python's own standard library is broken; the one function that would make it a health check, `check_package()`, is defined and never called.** Measured this tick: the script's three checked imports are `json`, `subprocess` and `datetime`, all stdlib, so its failure condition is unreachable on a working interpreter — `python3 python-env-check.py` → `all_ok: true`, rc 0. The failure *mechanism* works and is not the fault: a scratch copy with `json` replaced by `certainly_not_a_module` exits **rc 1** with `"status": "missing"`, so the reporter is sound and the target list is empty. `check_package(name, import_name)` — the version-reporting function, `getattr(mod, "__version__", "unknown")` — appears only at its own definition (`grep -n check_package` → `15:def check_package(...)`, one line); nothing calls it, so no package version is ever read and no third-party package is ever looked for. This is the Q92 class (dead code in a spark script) in a file that landed after Q92 was opened, and the Q117/Q119 class (a check whose green means nothing was measured) by construction. **Done means:** a declared list of the packages the lane actually depends on is imported by name with versions reported, a missing one turns the reading red, and a cell proves that redness with a package that is genuinely absent. **Evidence:** the same scan with one dependency removed from the environment, rc and output pasted, plus the version block for the packages that are present. **Not claimed:** that importing stdlib can never fail (a broken venv does fail; that is what the script measures, and it is worth one line, not the document's headline); that spark's other scripts share the defect — `grep -rn "check_package" wizard-work/spark/` finds this file only. Files touched by this record: `WORK-QUEUE.md` and `docs/queue-index.md`. The spark script is graded, not edited. Nothing from `inbox/` is quoted.
+Q103	record	13316	13327	12	4025	continuation	BOLD-LEAD	-	None	**Q103 — DONE at `e3bbe87` (volt), re-measured and closed at `74a0e5e`: the id class carries no width, every record-opened id from `Q100` up has a row, and the repair was falsified rather than re-read.**
+Q107	record	13328	13341	14	10346	continuation	BOLD-LEAD	-	None	**Q107 — DONE (volt, 2026-10-28): the `--dir` exit code is a class, not a count — both named readings are fixed, and both are now cells that go red on the pre-repair module.** Reproduced at HEAD (`9e0cc76`) before the file was touched: `--dir` over 3 valid + 2 broken files exits **2** (the tally, read as a usage error) and `--dir` over 256 broken files exits **0** (`256 % 256`), against a docstring that says 0 = all valid, 1 = one or more invalid, 2 = usage error and a line 11 that says the opposite ("Returns count of invalid files as exit code for --dir mode"). A 7-case probe over the shipped script read **2 mismatches** (`dir 2 invalid` → 2, `dir 256 invalid` → 0); the other five already matched (all-valid 0, missing dir 2, no args 2, invalid file 1, valid file 0).
+Q121	record	13342	13343	2	2048	record	BOLD-LEAD	-	None	**Q121 — OPEN (zeph lane by authorship; opened 2026-10-28 by the pipe, per the interview reply of the same date, `replies/2026-10-28-to-zephyrus-interview.md` §1.3). `wizard-work/zeph/q60_enforce.py` builds its source-absence cell from `fixture_value = "".join(KNOWN_FIXTURE.values())` (`:258`) and asserts that one joined string absent at `:260`. With the single entry the table carries today the join *is* the value and the cell is sound; with two entries the join is `value1value2`, which appears nowhere, so the assertion passes vacuously and neither value is checked — the cell stops working by passing, which is the failure mode Q96 existed to kill.** At HEAD `21ff264` the table holds exactly one entry (`:120-122`, `3d79ba82…`), the join is at `:258`, the assert at `:260`, `passed.append("source-absence-passes")` at `:262`. The two-entry mutant (second fixture entry added, its full literal appended to the source) reads **9 cells, 0 failed, rc 0**, and the standalone tree scan reads **VERDICT=PASS, rc 0, no line at all** — no `TEST-FIXTURE`, no `FAIL`, because the complete-but-wrong leg only inspects values whose 8-prefix is in `KNOWN_FULL`, which a new fixture's prefix would not be. That mutant was measured in the interview tick at `f17c936`, not re-run this tick; what this record measures at HEAD is the table size, the join and the single assertion. **Done means:** the cell iterates `KNOWN_FIXTURE.values()` and asserts each value's absence separately, and a committed cell goes red when one of two values is inserted into the source. **Evidence:** the two-entry mutant red by the name of the inserted value, and the clean source green, both in one run. **Not claimed:** that Q96 is reopened — the property holds at `f17c936` and the close stands; that the tree scan's prefix rule should change — that is a separate instrument and only its blindness is described here. Files touched by this record: `WORK-QUEUE.md` and `docs/queue-index.md`. The zeph file is graded, not edited. Nothing from `inbox/` is quoted.
+Q122	record	13344	13345	2	2748	record	BOLD-LEAD	-	None	**Q122 — OPEN (ledger lane by authorship; opened 2026-10-28 by the pipe, after `21ff264`). `wizard-work/ledger/workqueue-census-v2/CHECK` gates its own verdict on wall-clock freshness — `abs((now - dt).total_seconds()) < 120` against the frozen `extracted_at_utc` `2026-10-28T18:31:34Z` — so the committed artifact can be green only inside a 120-second window after generation and is red on every clone thereafter; and the README's documented invocation `bash CHECK` cannot run at all, because the file is Python.** Measured in a clean clone at `21ff264` (`~/.hermes/cache/scratch/q150`), 2026-10-28T18:37:13Z: `python3 wizard-work/ledger/workqueue-census-v2/CHECK` → **9 PASS, 1 FAIL** — `FAIL extracted_at_utc recency 'auto=2026-10-28T18:31:34Z now=2026-10-28T18:37:13Z delta=339.53s'`, rc **1**; `bash wizard-work/ledger/workqueue-census-v2/CHECK` → rc **2**, `syntax error near unexpected token '('` at `:27`. The artifact's README claims "CHECK exit code: 0"; that reading was true for the 120 seconds ending 18:33:34Z — the commit landed at 18:33:00Z, 26 seconds before its own gate shut — so the claim cannot be reproduced from the artifact by anyone who reads it afterwards. **What holds, re-derived independently:** the table is right. `grep -cE '^#{2,} *Q[0-9]+' WORK-QUEUE.md` → **96** headings over **85** distinct ids, matching the manifest's `rows 96 / distinct 85 / reopened 11`, and the CHECK's own row-count, qid+title identity and manifest legs PASS. **The v1 defect that ledger self-reported is confirmed, and the correction is credited rather than assumed:** `wizard-work/ledger/2026-10-28-workqueue-census/CHECK:22` is `import extract_workqueue_census as extractor` (a checker that re-imports the thing it checks), and its manifest carried the hardcoded `"extracted_at_utc": "2026-10-28T00:00:00Z"`. v2 fixed the tautology and then bound its verdict to a timestamp that can never be recent again — the same fault class (a time value that is not a measurement of anything the checker can see) inverted. **Done means:** the freshness leg becomes a format-and-provenance check that does not decay, or the verdict takes the reference time as an argument so it is a function of the artifact and not of when it is run; `CHECK` runs under the one interpreter the README names; and a committed cell proves the checker red with the timestamp moved by one day. **Evidence:** those three runs, before and after. **Not claimed:** that the 96 rows or the titles are wrong — they are not; that provenance should be dropped — it should not, it just cannot be a clock. Files touched by this record: `WORK-QUEUE.md` and `docs/queue-index.md`. The ledger artifact is graded, not edited. Nothing from `inbox/` is quoted.
+Q123	record	13346	13349	4	11398	record	BOLD-LEAD	-	None	**Q123 — DONE (volt, 2026-10-28; opened and closed in the same tick, at `49ce70f`). The repo gate's two standing faults were ledger bookkeeping, not code: all four new `path-claims` rows and the one new `checkin` row are now stated tolerances that print on every run, and `tools/verify.py` reads 8 of 8 legs green for the first time in the tick range below.** `tools/verify.py --repo .` at `49ce70f` read **8 legs, 6 pass, 2 fault (`checkin`, `path-claims`)**, and the same pair is named at `b7b4400`, `74a0e5e`, `992cde2` and `c6f1ea2`, each of whose records notes the two legs belong to no change of theirs — true, and also nobody's: this tick takes them. **(1) path-claims, four NEW rows, each adjudicated by measurement rather than by reading the citing sentence.** `checkins/2026-10-27-sentinel.md` (1,849 B, sha256 `a23f773a62b73c20…`) and `inbox/dump_seed.py` (922 B, sha256 `7444cba891b99702…`) are on disk, untracked, and `git log --all --diff-filter=A` returns **0 commits** for each, so both are `NOT_ADDED`; the dump_seed sha256 is the one `wizard-work/forge/DUMP_SEED_REFACTOR_VERIFICATION.md:8` already records, so the citing document and the file agree and the gap is the commit, not the claim. `inbox/seed-...json` is an **elision**, not a filename: `replies/2026-10-27-to-zephyrus-126.md:155` elides the inbox name (inbox content is not quoted) and the `...` is path-shaped, while its referent `inbox/seed-2026-09-26.json` is tracked at HEAD — class `EXAMPLE`. `tools/kanban_tools.py` is in the **Hermes app tree**: Q110's step-3 check at `WORK-QUEUE.md:13257` cites it beside `tui_gateway/methods_groups.py:85`, read from the install workspace where `:85` is the `HERMES_PROFILE` getenv and `kanban_tools.py:143` (67,763 B, md5 `a441f13cf66cc1df79d26b0a427f34ff`) names the `HERMES_PROFILE` pin — class `FOREIGN_TREE`. Five rows the census reported CLEARED (`docs/deepseek-cost-routing.md`, `wizard-work/beam/test_jsonl_validate.py`, `wizard-work/forge/_repro_bounds_original.py`, `wizard-work/forge/verify_ops_pulse_refactor.py`, `wizard-work/ledger/verify_dates.py`) were **deleted** after `git ls-files --error-unmatch` confirmed each is tracked at HEAD — the disposal the ledger's own header prescribes, and the reason the ledger now reads `34 entries, 34 matched, 0 new, 0 cleared, 0 dead`. **(2) checkin, one row, and a structural finding that is escalated rather than decided.** `python3 tools/checkin_check.py --emit-baseline | diff - tools/checkin_baseline.tsv` is exactly one line — `2026-10-27-forge.md` / `UNKNOWN_HANDLE` — so nothing else in the 100-file archive is hiding. The file is headed `# 2026-10-27 — forge (Refactor lane)`; the roster is `WIZARDS-TABLE.md` ∪ `.mailmap` = **10 handles** and `forge` is not one. The class is genuine and structural, not a checker defect: `wizard-work/` holds **10 lane directories** (`beam forge ledger null quill sol spark sphinx volt zeph`) of which only **2** (`volt`, `beam`) are roster handles, and the archive's signers are lane identities — `git log --format=%an | sort | uniq -c` reads Timmy 556, ledger 217, timmy 209, Volt 187, spark 181, Zephyrus Sparkborn 123, Merlin 118, beam 96, sol 75, quill 69, volt 63, forge 62, sphinx 32, null 28, Mercury 20. Tolerated as **one** stated row, the way `tools/reply_baseline.tsv` holds Merlin's live mis-addressed reply and prints it as known-faulting on every run, and **escalated, not decided**: either `WIZARDS-TABLE.md` gains the lanes (an append to a shared file, Timmy's or Alexander's) or check-ins must be signed by a wizard handle. Until one lands, every lane-signed check-in reds this leg again — the ledger behaving exactly as written. **Falsification controls, both run on the same tree with the row removed:** the ledger minus the four rows → `path_claim_check` rc **1**, `4 missing path(s)`, naming exactly those four with their first citing lines; the ledger minus the forge row → `checkin_check` rc **1**, `1 new fault(s)`, naming `2026-10-27-forge.md UNKNOWN_HANDLE`. **Readings after the rows land:** `python3 tools/path_claim_check.py --rev WORKTREE --fail-on-missing` → `4157 distinct paths, 34 missing, 0 new against the baseline`, rc **0**; `python3 tools/checkin_check.py --fail --baseline tools/checkin_baseline.tsv` → `100 files, 0 new fault(s), 36 known-faulting`, rc **0**; both selftests green (`31 cells, 31 passed`; `36 cells, 36 passed`); `python3 tools/verify.py --repo .` → `8 legs, 8 pass, 0 fault, 0 ungradable, 0 skipped` / `gate: OK -- 8 of 8 graded leg(s) passed`, rc **0**. **Done means:** every MISSING path the census produces is named in the ledger with a class, no row outlives its cleared path, and both standing faults are gone with their causes recorded rather than absorbed. **Not claimed:** that the untracked check-in or `inbox/dump_seed.py` should stay uncommitted — they are pending work whose owners are not this lane, and a row is a reading, not a release; that `forge` is a legitimate signer — that is the open question above and it needs the table; that either tool was defective — both are quoted doing what their docstrings say and both selftests were re-run; that the other 34 tolerated path rows were re-adjudicated this tick — they were printed and left alone; that the 82 advisory heading-less check-ins moved — they did not. **Report:** `/root/.hermes/wizard-outputs/volt/2026-10-28-gate-ledger-adjudication.md`. Files edited for this item: `tools/path_claim_baseline.tsv` (four rows appended, five cleared rows deleted), `tools/checkin_baseline.tsv` (comment block and one row appended), `WORK-QUEUE.md` (this record, appended), `docs/queue-index.md` (re-rendered with the committed `tools/queue_index.py --write` in this tree). No other lane's artifact was edited, both graded artifacts are files this lane's gate owns, and nothing from `inbox/` is quoted.
+Q124	record	13350	13352	3	3669	record	BOLD-LEAD	-	None	**Q124 — DONE (pipe, 2026-10-28; opened and closed on Volt's Q123 escalation, at `635cdc1`). The `checkin` leg's last tolerated row was a roster gap, not a fault: eight of the ten working lanes could not sign a check-in, so the gate reddened the first lane-signed one. The roster now carries them, the tolerance row is gone, and the class still faults.**
+Q122	record	13353	13357	5	4920	continuation	BOLD-LEAD	-	None	**Q122 — DONE (volt, 2026-10-28, at the head this record's commit names; ledger lane by authorship, unclaimed and taken). The gate no longer reads the wall clock, and it runs under the interpreter its README names.** Both filed defects reproduce at `e4f521a` with the pre-repair blob (`wizard-work/ledger/workqueue-census-v2/CHECK`, md5 `ad43b6acc307e283bc3b2252793aaba3`), in a `--depth 1` clone as well as in the shared worktree: `python3 CHECK` → `FAIL extracted_at_utc recency 'auto=2026-10-28T18:31:34Z now=2026-10-28T21:47:17Z delta=11743.030562s'`, `1 check(s) FAILED`, rc **1** at 21:47Z against a 120-second window that shut at 18:33:34Z; `bash CHECK` → rc **2**, `syntax error near unexpected token '('` at `:27`, after bash ran the module docstring as commands. **The repair** (md5 `3658e1066be3b5ea256bf9c73157121d`, 327 lines, `+297/−116`) restructures the script into `parse_args()` / `rederive()` / `run(here, repo_root, now_ref)` / `selftest()` / `main()` and changes two things. (1) Recency becomes an argument: the wall-clock read is gone (`grep -n 'datetime.now\|time.time\|date.today' CHECK` → no matches, rc 1), `extracted_at_utc` is graded on what the artifact proves about itself (parses as `%Y-%m-%dT%H:%M:%SZ`, is not the v1 stale constant `2026-10-28T00:00:00Z`) plus a new provenance leg (`schema == workqueue-census-v2`, non-empty `generated_by`), and its *recency* is graded only against a reference time the caller supplies (`--now=...`); with no reference the one leg prints `SKIP` and the rest of the gate decides. (2) The interpreter is named once — shebang kept, file mode 755, `README.md`'s Verification section now documents `python3 CHECK` — and two legs pin the agreement instead of trusting prose: `CHECK is executable`, `README documents the python3 invocation` (scoped to that section, so the repair note below it may still quote the old broken command). `--selftest` now runs the full gate against its own tree first and aborts red if the tree is wrong, then builds six scratch trees (a copy of `WORK-QUEUE.md` plus the five artifact files, so the shipped `HERE/../../..` resolution is exercised) and mutates one thing per cell. **Readings in the clone at `e4f521a` with the repaired files:** `python3 CHECK` rc **0**, 15 PASS + `SKIP extracted_at_utc recency`, `ALL CHECKS PASSED (96 rows, 85 distinct labels, 11 reopened)`; `./CHECK` rc **0**; `python3 CHECK --now=2026-10-28T18:31:34Z` rc **0** with `PASS extracted_at_utc recency`; `python3 CHECK --bogus` rc **2**; `python3 CHECK --selftest` rc **0**, `SELFTEST OK (6 cells: 2 green controls, 4 red mutations)`. The cells as printed: `control-with-reference` rc 0 · `control-no-reference-skips` rc 0 (`SKIP`) · `timestamp-plus-one-day` rc **1** (`FAIL extracted_at_utc recency` — the cell this item asks for by name, manifest stamp `+1 day` against the true reference) · `stale-constant` rc **1** with no reference at all · `malformed-stamp` rc **1** · `tsv-title-corrupted` rc **1**. **The precondition bites:** one TSV row title suffixed ` MUTANT` in the clone reads `1 check(s) FAILED` then `SELFTEST ABORTED: the in-tree artifact is already red (1 check(s))`, rc **1**; the clone was restored and re-read green. **Independent reproduction:** `/root/.hermes/wizard-outputs/volt/verify_q122.py` drives the directory as a black box (imports nothing from it, builds its own scratch trees) → 15 PASS, `all Q122 readings reproduce`, rc 0, including the md5 pin and the three mutants. **Not claimed:** that the 120-second window was the only possible anchor — a git-commit-time anchor (`git log -1 --format=%ct -- extract_manifest.json`) is the stronger provenance form and is *not* implemented, because it is red between regeneration and commit and would need a stated tolerance; the argument form is the one Q122 allows and the one that landed; that `manifest.source` is repaired — it still reads the absolute host path `/root/troupe-standup/WORK-QUEUE.md` (the Q69/Q106/Q109 class), and the gate resolves the source it *grades* from `__file__` while leaving that provenance string as it shipped; that the census is complete — Q112's heading-only-walk finding is untouched, along with the TSV, MD and manifest bytes; that `bash CHECK` should now work — it should not, and no shell wrapper papers over it; that anything outside this directory was read, or that the v1 census was re-graded. **Gate:** `python3 tools/verify.py --repo .` reads `8 legs, 8 pass, 0 fault` at HEAD before this commit, and is re-read after. **Report:** `/root/.hermes/wizard-outputs/volt/2026-10-28-q122.md`. Files edited for this item: `wizard-work/ledger/workqueue-census-v2/CHECK`, `wizard-work/ledger/workqueue-census-v2/README.md`, `WORK-QUEUE.md` (this record, appended), `docs/queue-index.md` (re-rendered with the committed `tools/queue_index.py --write` in this tree). Nothing from `inbox/` is quoted.
+Q125	heading	13358	13399	42	10590	opening	-	open and unclaimed.	13360	— the spark lane holds eleven line/word/char counters, and the newest one replaced its predecessor's capabilities without retiring its verifier *(spark lane; opened 2026-10-28 by the pipe, at `6b5197b`)*
+Q120	record	13400	13401	2	3580	continuation	BOLD-LEAD	-	None	**Q120 — DONE (volt, 2026-10-29; this record and `docs/queue-index.md` land in the commit above it; spark lane by authorship, unclaimed and taken).** The health check now fails. Before: `python3 wizard-work/spark/python-env-check.py` printed `"all_ok": true` rc **0** over `json`, `subprocess`, `datetime` — three standard-library modules — and `check_package` appeared exactly once, at its own definition (`git show HEAD:wizard-work/spark/python-env-check.py | grep -n check_package` → `15:def check_package(name, import_name=None):`), so no version was ever read; old blob `3d00d9ce5d4111cde7becab78ff0287a52ff34ed`. After: `DEPENDENCIES` is the lane's measured third-party imports — PyYAML/`yaml` (`debug_yaml.py:2`), numpy (`qc_analyze.py:7`), Pillow/`PIL` (`ascii_tool.py:12`, `qc_analyze.py:6`), jsonschema (`validate_json_schema.py:14`) — each imported by name with its version from `importlib.metadata` (fallback `__version__`), `missing` on ImportError, `broken` on any other import-time exception, `all_ok` false and rc **1** when anything is not `ok`, rc **2** on a usage error. `email_validator` is deliberately not declared: `wizard-work/spark/email_validator.py` is a local stdlib-only module (`import re`) and `test_email_validator.py:6` imports that, not the PyPI distribution. Readings: green `"missing": [], "dependencies_declared": 4` with PIL 12.3.0 / jsonschema 4.26.0 / numpy 2.5.4 / yaml 6.0.3, rc **0**; `--require flask` (genuinely absent here, `find_spec` is None) → `"missing": ["flask"]`, rc **1**; `--require` with no value → rc **2**. New `wizard-work/spark/test_python_env_check.py` carries 7 cells and runs the script as a subprocess (it imports nothing from it): no stdlib name may be declared, the declared set is exactly the lane's four, every dependency reports a real version, `all_ok` agrees with `missing` and rc, a genuinely absent package reds the reading (the test measures which candidate is absent, skipping only if all seven are installed), a usage error is rc 2, and the reading is identical from `/`. Control `Ran 7 tests … OK` rc 0 from the lane directory and from `/tmp`. Four mutants, four killed, control green: the old script `FAILED (failures=5, errors=2)`; `email-validator` declared `3 failed`; version pinned to `"unknown"` `1 failed`; `return 0` regardless of `missing` `1 failed`. Cost stated: the healthy run imports numpy/Pillow/jsonschema and takes 0.71–1.24 s across three runs. **Not claimed:** that the lane gate collects the new cells — `wizard-work/spark/CHECK` still grades `/root/.hermes/wizard-outputs/spark/...` by absolute path and runs no `wizard-work/spark/test_*.py` (Q109's class, untouched); that all four packages are needed by every script (import sites measured, some imports are lazy); that `--require` substitutes for a declared dependency (it is the falsification hook, one run only); that the local `email_validator.py` cannot shadow the PyPI distribution if it is ever installed ahead of the lane directory (unmeasured); that the lane's other scripts are healthy (only this file and its new cell file were changed and graded). Files edited: `wizard-work/spark/python-env-check.py`, `wizard-work/spark/test_python_env_check.py` (new), `WORK-QUEUE.md` (this record, appended), `docs/queue-index.md` (re-rendered with the committed `tools/queue_index.py --write` in this tree). No other lane's artifact was edited and nothing from `inbox/` is quoted. Report and CHECK: `/root/.hermes/wizard-outputs/volt/2026-10-29-q120.md`, `/root/.hermes/wizard-outputs/volt/q120-check.sh`.
+Q121	record	13402	13403	2	5321	continuation	BOLD-LEAD	-	None	**Q121 — DONE (volt, 2026-10-29; zeph lane by authorship, unclaimed and taken; this record and `docs/queue-index.md` land in the commit above the head `5623170` the item was measured against). The fixture-absence cell now tests every table entry on its own, and the two-entry mutant that used to pass it is red and names the entry it finds.** Reproduced first, against the pre-repair source read with `git show 5623170:wizard-work/zeph/q60_enforce.py` (md5 `eb09086ad1b7a4897360133409802bc3`, 17,589 B), with the mutant this record's opening paragraph describes — a second `KNOWN_FIXTURE` entry plus that entry's full literal appended to the source: the value `5e0c7a91` **is** in the mutant's source bytes, the joined two-entry string is **not**, and `--selftest` reads **`SELFTEST: 9 cells passed, 0 failed`, rc 0**, `SELFTEST PASS source-absence-passes`. That is the vacuity: one fixture value sitting in the source, green. **The repair**, in `wizard-work/zeph/q60_enforce.py` (md5 `91b04a491a6eea7c1320c8c37fcd214c`, sha256 `892671f2233a0512dbf19038c02b614fa7766666404c5dbc7db8ff0818eef26e`, 399 lines, `+57/−13`), is three things. (1) `fixture_literals_in_source(blob, table=None)` iterates `sorted(table)` and tests each value's bytes separately, returning one masked diagnostic per hit — `stem (len N)`, never the value — which is the file's own rule that a red report must not re-commit the value it reports. (2) Cell 8 calls it over `__file__`'s bytes with the committed table, so the cell's strength no longer depends on the table's size: the old form was sound only while the table held exactly one entry. (3) New **cell 10** (`absence-scan-per-entry`) builds the case the joined form could not express — a two-entry table (the real fixture plus `5e0c7a91`) with each entry's literal inserted into a copy of the source, asserted to be named individually, then both inserted and both asserted, with the clean source under the same two-entry table asserted to report nothing as the cell's own control. `wizard-work/zeph/test_q60_absence.py` (new, md5 `52ceecc8b8f4c3221e59872db7736c6a`, sha256 `0851de9a9d32e7a4ea151a8dcfe1ccedd0345adbd38f58c6be095d826452ef80`, 134 lines) is the lane's first grader for this file and is black box: it runs the module as a subprocess and imports nothing from it, so the cells cannot agree with the code by sharing its table. **Readings after the repair:** `python3 wizard-work/zeph/q60_enforce.py --selftest` → `SELFTEST: 10 cells passed, 0 failed`, rc **0**, including `SELFTEST PASS absence-scan-per-entry`; `python3 wizard-work/zeph/test_q60_absence.py` → `Ran 5 tests … OK`, rc **0**. **Mutants, one run each, control in the same run:** control rc 0; M1 (the queue's two-entry-plus-literal construction, built by the new test module itself) rc **1** — `AssertionError: fixture value literal(s) present in checker source: 5e0c7a91 (len 36)`; M2 (join-semantics restored inside the new cell) rc **1** — `insertion of 3d79ba82 reported [], want [3d79ba82 (len 36)]`; M3 (a scan returning only its first fault) rc **1** — `both-inserted scan did not name both stems`. **The grader is falsified in the other direction too:** the new module copied beside the pre-repair source and run there reads `Ran 5 tests … FAILED (failures=4, skipped=1)`, rc **1**, with `AssertionError: 0 == 0 : two-entry mutant stayed green -- vacuous cell is back` — so its green readings above are the repair, not a gate agreeing with itself. **Unchanged behaviour, measured not assumed:** the check's normal mode over the whole repo reads `OCC=131 DISTINCT=24 FILES=39 … VERDICT=PASS`, rc **0**, the same shape before and after the edit (the change touches only `selftest()`); `python3 tools/verify.py --repo .` reads `8 legs, 8 pass, 0 fault, 0 ungradable, 0 skipped` / `gate: OK`, rc **0**. **CHECK:** `python3 wizard-work/zeph/test_q60_absence.py` (graded SOUND by `tools/check_lint.py --check`, 44 columns). **Not claimed:** that the tree scan's complete-but-wrong leg should change — it only inspects values whose 8-prefix is already in `KNOWN_FULL`, so a new fixture entry is invisible to it, and the opening record calls that a separate instrument and leaves it; that `KNOWN_FIXTURE` should gain a second real entry — the table still holds one, and the cell exercises a two-entry table as an argument, which is the only way a module can test a size its own table does not have; that the zeph lane now has a gate — it has no `CHECK` file, the new module is a grader a lane gate or a human can call, and the absolute-path class named at Q109 is not addressed; that the rest of `q60_enforce.py` was audited — cells 1–7 and 9 and the population and recovery legs were run, not reviewed; that Q96 is reopened — the property it closed holds and cell 8 still asserts it, now per entry. **Report:** `/root/.hermes/wizard-outputs/volt/2026-10-29-q121.md`. Files edited for this item: `wizard-work/zeph/q60_enforce.py`, `wizard-work/zeph/test_q60_absence.py` (new), `WORK-QUEUE.md` (this record, appended), `docs/queue-index.md` (re-rendered with the committed `tools/queue_index.py --write` in this tree). The zeph file was graded and repaired on the opening record's `unclaimed` clause; nothing from `inbox/` is quoted and no other lane's artifact was touched.
+Q109	record	13404	13431	28	7753	continuation	BOLD-LEAD	-	None	**Q109 — DONE (volt, 2026-10-29; spark lane by authorship, unclaimed and taken). The tool check measures the import now, and the shell script grades the tree it is handed. Both named readings reproduce red, the pre-repair pair is fifteen cells red, and the repaired pair is green under a gate of its own.**
+Q117	record	13432	13433	2	2223	continuation	BOLD-LEAD	-	None	**Q117 — DONE (zeph, 2026-10-29; zeph lane by authorship; measured at `ebba640`, this record and `docs/queue-index.md` land in the commit above it).** The `KNOWN_PROBE` table now sits beside `KNOWN_FIXTURE` in `wizard-work/zeph/q60_enforce.py`, the probe value built by concatenation so no literal for it exists in the source (`grep -c "beae0b1f-9f2c"` over the file returns 0); the recovery leg skips probe values in both branches (general longer-string look and the exhausted-stem full-value look), so a stem whose only in-tree longer string is a probe value reads `UNRECOVERED-JUSTIFIED` with the value still in the tree. Cell 9 (Q96 exhausted-stem flip) is reworked to a non-probe synthetic value under the stem, because the probe-C value no longer counts as a recovery by design; new cell 11 `probe-value-not-a-recovery` owns the probe case: a tree holding the truncated stem plus the probe value reads `UNRECOVERED-JUSTIFIED` with the gate green, and with the table cleared the SAME tree flips to `RECOVERED-IN-TREE` at its site, table restored afterwards, so the cell is not vacuous. Evidence, all this host: `--selftest` 11 cells passed, 0 failed, rc 0 (10 at the Q121 landing); standalone tree both readings quoted in the check-in (with table `UNRECOVERED-JUSTIFIED`, without table `RECOVERED-IN-TREE beae0b1f-9f2c-4d1e-8a77-3c5b6e9d0a11 at n.md`); full tree at `ebba640` with these edits uncommitted: `OCC=132 DISTINCT=24 FILES=40`, `VERDICT=PASS`, rc 0, all three `beae0b1f` stems `UNRECOVERED-JUSTIFIED`, zero FAIL lines; `wizard-work/zeph/test_q60_absence.py` 5 tests OK after its count pin moved 10 to 11 (docstring line and assertion only, the pin's purpose unchanged); `tools/check_lint.py --check` SOUND on the module. Numbering note: Q117 was filed asking for "a new cell (10)", but Q121 landed first and took that number, so the probe cell is cell 11 and the done-means are unchanged. **Not claimed:** that the Q99 record was edited (it stands as dated fact; the table declares the provenance instead); that any other stem is affected (only `beae0b1f` carries an invented full value); that the narrowed Q96 stem rule is wrong (it is not -- this is provenance, one layer above it). Close call Timmy's.
+Q106	record	13434	13447	14	5422	continuation	BOLD-LEAD	-	None	**Q106 — DONE (volt, 2026-10-29, at the head this record's commit names; sol lane by authorship, unclaimed and taken). `CHECK-2026-09-28` now grades the tree it ships in: a clone whose own manifest is doctored reads `VERDICT FALSE`, rc 1, over the clone's cells, where it used to read `VERDICT TRUE`, rc 0, over the host's.** The filed defect reproduces at `a9bc1f7` (`wizard-work/sol/CHECK-2026-09-28`, md5 `ff9a28a2103184ffb96d650503572a36`, `ROOT = "/root/troupe-standup"` at `:14`): a `--depth 5` clone reads green on its own manifest, and with one item flipped `archive_fix` → `app_pr` (aggregate rewritten to `{6,4,2,0}` so the only defect is provenance) the committed CHECK still prints `VERDICT TRUE (categories={'archive_fix': 7, 'app_pr': 3, 'general': 2, 'other': 0} table=12)` rc **0** — the host worktree's cells, from a clone that carries neither of those numbers.
+Q102	record	13448	13461	14	4987	continuation	BOLD-LEAD	-	None	**Q102 — DONE (volt, 2026-10-29, at `062e278`; beam lane by authorship, unclaimed and taken). `majority()` now has three outcomes on three channels, and a non-reflexive element that fills the list is confirmed: `EmptySequence` for an empty sequence, `NoMajority` for a sequence without a majority, the element itself -- `None`, `float('nan')` or any other object -- otherwise.**
+Q119	record	13462	13479	18	7662	continuation	BOLD-LEAD	-	None	**Q119 — DONE (volt, 2026-10-29, at the commit above this record; sol lane by authorship, unclaimed and taken). The classifier no longer files an unmatched demand under a real category, its five repro strings are committed cells, and `verify.sh` grades without writing into the tree it grades — but the artifact Q119 was opened against is not the artifact at HEAD, and that divergence is named here rather than repaired back.**
+Q112	record	13480	13524	45	16448	continuation	BOLD-LEAD	-	None	**Q112 — DONE (volt, 2026-10-29, at the commit above this record; ledger lane by authorship, unclaimed and taken). The census was right and its verifier was wrong: the committed `CHECK` could not read the format its own extractor writes, so the artifact it ships beside was reported as 11 faults; the reader now parses the writer's dialect, the record-form ids are enumerated (36 of the 122 ids the queue opens), the revision leg no longer prints a PASS it did not measure, and `--selftest` mutates a fixture tree nine ways with the pre-repair reader measured inside the battery.**
+Q113	record	13525	13544	20	12052	continuation	BOLD-LEAD	-	None	**Q113 — DONE (volt, 2026-10-29, at the commit above this record; ledger lane by authorship, unclaimed and taken). The roster gate could not fail, graded its own hardcoded copy of the CSV, never opened the source, and re-issued a withdrawn escalation — and the artifact it guarded had gone stale by eight rows. It now re-derives all 18 roster rows from the pinned table cell by cell, reds on a single corrupted Lane cell, and carries the table's correction into the artifact.**
+Q126	record	13545	13555	11	6951	record	BOLD-LEAD	-	None	**Q126 — DONE (volt, 2026-10-30; both faults were unowned tooling debt and both are closed by measurement: the nine host-bound test files now bind the module beside them, and the path-claims ledger names all 225 census-listed MISSING paths).** Entry state at HEAD `920edf7`: `python3 tools/verify.py --repo . --fast` read `9 legs, 6 pass, 2 fault` naming `path-claims` and `index-current`; the index fault was the uncommitted two-line `Q98 — CLOSED` append this commit carries in, disclosed at the end of this record.
+---
+items=171 bytes=2149154 lines=13555
+status_present=90
+open_ids=Q17,Q18,Q37,Q42,Q41,Q46,Q46,Q46,Q47,Q47,Q47,Q50,Q50,Q51,Q52,Q51,Q51,Q51,Q51,Q45,Q52,Q53,Q53,Q65,Q65,Q72,Q78,Q91,Q92,Q93,Q94,Q99,Q99,Q100,Q101,Q100,Q102,Q103,Q101,Q101,Q104,Q105,Q106,Q107,Q104,Q104,Q104,Q106,Q108,Q104,Q109,Q110,Q111,Q112,Q113,Q114,Q115,Q105,Q116,Q117,Q111,Q118,Q119,Q120,Q103,Q107,Q121,Q122,Q123,Q124,Q122,Q120,Q121,Q109,Q117,Q106,Q102,Q119,Q112,Q113,Q126
diff --git a/wizard-work/ledger/work-queue-table.md b/wizard-work/ledger/work-queue-table.md
new file mode 100644
index 0000000..86785f9
--- /dev/null
+++ b/wizard-work/ledger/work-queue-table.md
@@ -0,0 +1,104 @@
+# Work queue — extracted item table
+
+Source: `WORK-QUEUE.md` (repo `main`), 2.1 MB. One row per `## Q# — …` marker, in source order.
+`Kind` is a derivative of the marker's own wording (closure / claimed / follow-on / open).
+
+| Q# | Title | Kind |
+|---|---|---|
+| Q1 | Recover the fifteen silent rooms *(highest value; no dependencies)* | queue-item |
+| Q2 | Chase the one dead link | queue-item |
+| Q3 | Independent audit of the published ledger | queue-item |
+| Q4 | Falsification pass | queue-item |
+| Q8 | Summary fidelity: does each entry's machine-written summary overstate its article? | queue-item |
+| Q5 | Issue triage in the organisation's public repos | queue-item |
+| Q6 | A public guide to checking this archive | queue-item |
+| Q7 | Propose the next items | queue-item |
+| Q9 | Independent QC of the sovereign music candidates *(second opinion, no listening required)* | queue-item |
+| Q10 | Summary fidelity for the non-magazine entries | queue-item |
+| Q11 | Close the eight pass-2 date mismatches | queue-item |
+| Q12 | Are the evidence tiers earned? | queue-item |
+| Q13 | Publish the archive-side wording fixes, one at a time | queue-item |
+| Q14 | Put the Inbox on `alexanderwhitestone.com` behind a gate | queue-item |
+| Q15 | Stop the monitor from waking on the pipe's own writes *(pipe; no dependencies)* | queue-item |
+| Q16 | Per-platform ATS gate census *(career lane; opened 2026-10-01 by reply 21 §3, drafted by zephyrus)* | queue-item |
+| Q17 | Employer-side AI-authorship refusal gates *(career lane; opened 2026-10-03 by reply 26, per Q7)* | queue-item |
+| Q18 | Employer-side lead intake must be deduped against the prepared index *(career lane; opened 2026-10-04 by reply 28, per the G2i miss)* | queue-item |
+| Q19 | Three proposed members (local Mac wizard, Grok, Mistral) *(wizard onboarding; opened 2026-10-06 by zephyrus-sparkborn, `checkins/2026-10-06-zephyrus-wizards*.md` + `JOIN-THE-TROUPE.md`)* | queue-item |
+| Q20 | Excerpt fidelity and placement for the 91 magazine entries *(archive verification; opened 2026-10-08 by the pipe, per Q7's never-dry obligation)* | queue-item |
+| Q21 | Does every quoted excerpt resolve at the URL it is printed against? | queue-item |
+| Q22 | Do the named-but-unlinked sources resolve? *(proposed 2026-10-10 by Merlin, per Q7; not yet opened)* | queue-item |
+| Q23 | The prose-named sources the `@` token rule cannot see *(archive verification; opened 2026-10-10 by the pipe, per Q7's never-dry obligation)* | queue-item |
+| Q24 | The Q13 fix pack: stage every verified live-page fix as one reviewable approval *(archive-side; opened 2026-10-10 by the pipe, per Q7's never-dry obligation)* | queue-item |
+| Q25 | A prose-anchor convention for the ledger build *(archive-side; proposed 2026-10-10 by Merlin, per Q7's never-dry obligation — Q24 closed and the unclaimed executable set fell to zero)* | queue-item |
+| Q26 | Make the silent token classes loud, and measure the fifth slot *(archive-side; opened 2026-10-10 by the pipe, per Q7's never-dry obligation — Q25 closed at `a9f23a6` and the unclaimed executable set fell to zero)* | queue-item |
+| Q27 | A fixture at every render site: make the token sentinel's coverage total *(archive-side; opened 2026-10-11 by the pipe, per Q7's never-dry obligation — Q26 closed at `f05179e`)* | queue-item |
+| Q28 | The channels the entry walk cannot see: state the guarantee, then cover what it cannot reach | queue-item |
+| Q29 | The guards that are not the walk: what protects a page when the value is not a token | queue-item |
+| Q30 | The renderer's entry point: the one path no gate executes | queue-item |
+| Q31 | The collector's entry point: the sibling path no gate has executed either | queue-item |
+| Q32 | The G8 two-run agreement check is nondeterministic: `age_seconds` is not scrubbed *(Helm lane; opened 2026-10-11 by the pipe, per Q7's never-dry obligation — Q31's adoption is blocked behind it)* | queue-item |
+| Q33 | Split the newest-file pointer out of `evidence.source_path` *(collector-side; opened 2026-10-11 by the pipe, per Q7's never-dry obligation — Q32 closed at `7e12c82`)* | queue-item |
+| Q34 | Gate the pointer's null case *(collector-side gate; opened 2026-10-11 by the pipe, per Q7's never-dry obligation — Q33 closed at `8bb88da`)* | queue-item |
+| Q35 | The gate must refuse a subject collector that carries no destination rule *(Helm lane; opened 2026-10-12 by the pipe, per Q7's never-dry obligation — Q34 verified and closed at `ac98bfb`)* | queue-item |
+| Q36 | The monitor cannot see a counterparty write that carries this pipe's identity *(pipe tooling; opened 2026-10-12 by the pipe, per Q7's never-dry obligation — Q20 verified and closed at `9a1de9a` and the pre-existing executable set fell to empty)* | queue-item |
+| Q37 | The identity rule closes one class, not the class *(pipe tooling; opened 2026-10-12 by the pipe, per Q7's never-dry obligation — Q36 closed at `9584984` and the unclaimed executable set fell to empty)* | queue-item |
+| Q38 | The behavioural destination guard *(Helm lane; opened 2026-10-12 by Merlin — Q36's candidate 2, on Alexander's direction to continue the Helm lane)* | queue-item |
+| Q38 | The behavioural destination guard *(Helm lane; opened 2026-10-12 by Merlin — Q36's candidate 2, on Alexander's direction to continue the Helm lane; **direction unrecorded in this repo — Testimony only**)* | queue-item |
+| Q39 | The Q38 guard's admission admits a writer, and its legs run the unrewritten subject *(Helm lane; opened 2026-10-12 by the pipe, per Q7's never-dry obligation — Q38 is closed and verified and its protective claim is falsified, so the executable set is not empty)* | queue-item |
+| Q39 | closure — verified from this host by the pipe (2026-10-12, reply 22) | closure |
+| Q40 | the deployed gate admits all five negatives, and has no admission path at all *(Helm lane; opened 2026-10-12 by Merlin, discharging the Q39 closure's C26)* | queue-item |
+| Q37 | claimed by this pipe; first increment landed (the v1.3 census) | claimed |
+| Q43 | The legs run the rewritten subject: prevention, not detect-and-restore *(Helm lane; opened 2026-10-12 by Merlin, per the Q39 closure's own recommendation — "open the stronger form (the legs against a rewritten copy) as the Helm lane's next item")* | queue-item |
+| Q43 | closure — verified from this host by the pipe (2026-10-12, reply 27) | closure |
+| Q44 | The pin class: redirect every constant composed from the live data root, not only `SNAPSHOT_PATH` *(Helm lane; opened 2026-10-12 by the pipe, per Q43's own closing sentence — "extend the redirect beyond `SNAPSHOT_PATH` to every constant composed from the live data root, which is what would close the `--pin` class structurally instead of by argv rule")* | queue-item |
+| Q48 | The runtime-resolution redirect: close the class Q45's literals cannot see | queue-item |
+| Q49 | The runtime-resolved root's live write path: name it, reproduce it, then close it | queue-item |
+| Q45 | §9 follow-on — the home-directory channel *(Helm lane; Merlin)* | follow-on |
+| Q57 | Bind a standup entry to the bytes it grades *(Codeforge lane; opened 2026-10-24 by the pipe, per reply 05's corrections 1 and 2)* | queue-item |
+| Q58 | The lane-activity instrument reads a surface that was retired on 2026-10-16 *(Sol lane; opened 2026-10-24 by the pipe, per reply 12 to sol)* | queue-item |
+| Q59 | beam's jump hash matches the C reference, and not one test would notice if it stopped *(beam lane; opened 2026-10-24 by the pipe, per reply 84 to zephyrus)* | queue-item |
+| Q60 | Every truncated identifier in the archive: which ones can still be checked *(pipe tooling; opened 2026-10-24 by the pipe, per reply 86 §6 and reply 87 §1)* | queue-item |
+| Q61 | beam's `topo_sort` drops generator dependencies, and its gate imports a copy outside the repo *(beam lane; opened 2026-10-24 by the pipe, per reply 88 to zephyrus)* | queue-item |
+| Q62 | 147 committed gates read `/root/.hermes/wizard-outputs`; two of them cannot pass from a clone *(no lane owns it; opened 2026-10-24 by the pipe, per reply 89 to zephyrus)* | queue-item |
+| Q63 | Six committed verifiers print PASS while asserting nothing, and eight are run by no gate *(no lane; opened 2026-10-24 by the pipe, per reply 90 to zephyrus)* | queue-item |
+| Q66 | beam's `search_count` advertises overlapping occurrences and no test would notice if it stopped *(beam lane; opened 2026-10-25 by the pipe, per reply 27 to beam)* | queue-item |
+| Q67 | forge's probe-refactor verifier certifies a refactor that restores the defect it removes *(forge lane; opened 2026-10-25 by the pipe, per reply 20 to forge)* | queue-item |
+| Q68 | beam's `topo_levels` drops a one-shot `edges` iterable, silently, and its new suite both certifies a host copy and takes the lane's gate down *(beam lane; opened 2026-10-25 by the pipe, per reply 28 to beam)* | queue-item |
+| Q69 | 116 committed files under `wizard-work/` name the absolute path `/root/troupe-standup`, so 64 gates grade the author's working tree instead of the checkout they were asked about *(no lane owns it; opened 2026-10-25 by the pipe, per reply 101 to zephyrus)* | queue-item |
+| Q70 | beam's `test_trie.py` is invisible to the lane gate (73 new lines, 0 cells collected), and `count_prefix` is a lifetime insert counter that survives `delete` *(beam lane; opened 2026-10-25 by the pipe, per reply 102 to zephyrus)* | queue-item |
+| Q71 | ledger's `commits-table.md` has no verifier, and row 4 writes `kernel_git` where the source URL has `kernel/git` *(ledger lane; opened 2026-10-25 by the pipe, per reply 102 to zephyrus)* | queue-item |
+| Q72 | sphinx's lcmm ledger gates its quotations but not its population or its interpretations: two mutations of mine pass the verifier at 169/169 and 139/139 *(sphinx lane; opened 2026-10-26 by the pipe, per reply 104 to zephyrus)* | queue-item |
+| Q72 | verified from this host by the pipe (2026-10-26, reply 105) | queue-item |
+| Q73 | sphinx's longctx archive gates its numbers and its claim-scoped quotations, but not its prose numbers, its claim sentences, its README, or the quotations that carry no claim id *(sphinx lane; opened 2026-10-26 by the pipe, per reply 105 to zephyrus)* | queue-item |
+| Q74 | sol's triage CHECK certifies the host `_triage` copy and asserts today's freshness, so it cannot gate the committed artifact *(sol lane; opened 2026-10-26 by the pipe, per the Q58 closure record above)* | queue-item |
+| Q75 | ledger's two census TSVs carry seven lines that are not rows and one path no file on disk has, and no gate in the lane can see either *(ledger lane; opened 2026-10-26 by the pipe, at `b82b023`)* | queue-item |
+| Q76 | beam's new median tests reach no gate, and the lane gate that would run them is red for a host path older than the commit *(beam lane; opened 2026-10-26 by the pipe, at `c3ce8dd`)* | queue-item |
+| Q77 | beam's segment tree lands 100 lines and the lane's count does not move, its failure path reports as an import `SystemExit` rather than a cell, and out-of-range indices are silently clamped *(beam lane; opened 2026-10-26 by the pipe, per reply 112 to zephyrus)* | queue-item |
+| Q78 | spark's `3d72f9d` deletes the Q63 `_check()` failure path from four verifiers and drifts five ledger rows, and the new email-validator suite imports a host path *(spark lane; opened 2026-10-26 by the pipe, at `6cb3d7a`)* | queue-item |
+| Q79 | beam's `manifest.py` lands 107 lines with no cell in any gate, cannot see a directory symlink, reads its own output as a tamper, and prints a green empty manifest for a root that does not exist *(beam lane; opened 2026-10-26 by the pipe, at `edac5cf`)* | queue-item |
+| Q79 | closure — manifest.py carries the lane's 0/1/2 contract, three blind spots are closed, and 17 cells now sit in the gate *(volt, 2026-10-26; beam's lane by authorship, taken by the Workhorse as the opening allows: `anyone may take it`)* | closure |
+| Q80 | spark's `json_sha256_validator.py` prints a hash of bytes it never validated, admits `NaN`/`Infinity` as valid, and reports an unreadable input in the same code as a bad document *(spark lane; opened 2026-10-26 by the pipe, at `3081128`)* | queue-item |
+| Q81 | spark's `hermes_profile_health.py` grades a profile by the existence of names, hardcodes the one host path it can check, and carries a branch that cannot fire *(spark lane; opened 2026-10-26 by the pipe, at `3081128`)* | queue-item |
+| Q82 | beam's `test_json_canonical.py` prints `ALL PASS` without running a single assertion, and the lane's count does not move at the head that lands it *(beam lane; opened 2026-10-26 by the pipe, at `3081128`)* | queue-item |
+| Q82 | closure — `test_json_canonical.py` is seven discoverable cells (lane gate 191 → 198), every cell is killed by a named mutant, and `json_canonical.py` says what it is not *(volt, 2026-10-26; beam's lane by authorship, taken by the Workhorse as the opening allows: `anyone may take it`)* | closure |
+| Q81 | closure — `hermes_profile_health.py` grades a profile you name, parses the config it grades, and the lane gate collects nine cells *(volt, 2026-10-26; spark's lane by authorship, taken as the opening record says `open and unclaimed`)* | closure |
+| Q83 | five branches `hermes_profile_health.py` names are pinned by no cell, and one of them is the branch that produces the sweep's only red *(spark lane; opened 2026-10-26 by the pipe, at `829268f`)* | queue-item |
+| Q84 | `interval_overlap.py` lands 87 lines with no cell, and the lane gate reads `Ran 202` before and after *(beam lane; opened 2026-10-26 by the pipe, at `517362f`)* | queue-item |
+| Q83 | closure — the five unpinned `hermes_profile_health.py` branches are five cells (spark gate 9 → 14), and the item's own first row is corrected *(volt, 2026-10-27; spark's lane by authorship, taken as the opening record says `open and unclaimed`)* | closure |
+| Q85 | `beam/CHECK` collects only `test_*.py`, so a module no cell imports lands invisible: four are in that state today, and the newest added 38 lines with the gate reading `Ran 214` before and after *(beam lane; opened 2026-10-27 by the pipe, at `083981e`)* | queue-item |
+| Q86 | the refactor-lane harness proves silence, not absence of I/O, and its seed path is host-absolute, so a second checkout cannot re-verify the refactor *(forge lane; opened 2026-10-27 by the pipe, at `431bca1`)* | queue-item |
+| Q87 | the forge lane holds 34 `verify_*.py` and no `CHECK`; `tools/verify.py`'s eight legs reach none of them *(forge lane; opened 2026-10-27 by the pipe, at `431bca1`)* | queue-item |
+| Q88 | the census `CHECK` verifies the live `checkins/` directory and the TSV only, so a dated artifact goes red on the next check-in and stays green under a hand-edited per-wizard table *(ledger lane; opened 2026-10-27 by the pipe, at `b0a2886`)* | queue-item |
+| Q89 | the import-time-I/O detector in the three forge harnesses is a name list, so a `pathlib` read at module scope passes every check green *(forge lane; opened 2026-10-27 by the pipe, at `6e9aeee`)* | queue-item |
+| Q90 | beam's `find_tree_root` accepts any ancestor marker as the repo root, `portable_seed` never checks the seed exists, and the six cells that would notice reach no gate *(beam lane; opened 2026-10-27 by the pipe, at `6e9aeee`)* | queue-item |
+| Q91 | forge's r41 pixel-diff verifier prints PASS when neither card writes anything, and it writes the delivery artifact *(forge lane; opened 2026-10-27 by the pipe, at `d56105a`)* | queue-item |
+| Q92 | spark's two new scripts grade the caller's working directory, and one carries dead code after `sys.exit` *(spark lane; opened 2026-10-27 by the pipe, at `d56105a`)* | queue-item |
+| Q93 | the sweep's malformed-input probe grades a phrase, so two correctly-refusing tools keep it red, and the leg's summary line says "0 fatal" while returning 1 *(no lane owns it; opened 2026-10-27 by the pipe, at `d56105a`)* | queue-item |
+| Q94 | `dsu_rollback.py`'s headline mechanism is graded by no cell, its compression cell does not grade compression, and `find`/`union` accept negative indices silently *(beam lane; opened 2026-10-27 by the pipe, at `1e79fc8`)* | queue-item |
+| Q60 | closure — the check half runs at a named head, the self-quote collapse and the placeholder refusal are measured, and the two instrument holes it leaves are named instead of smoothed *(opened by the pipe 2026-10-24; the check half landed by zephyrus-sparkborn at `33f8f0f`, closed here 2026-10-27)* | closure |
+| Q95 | beam's `find_duplicate` no-duplicate guard cannot fire, and the file has no cell in any gate *(beam lane; opened 2026-10-27 by the pipe, at `f400640`)* | queue-item |
+| Q96 | `q60_enforce.py`'s self-scan cannot see a fixture literal in its own source, and an exhausted stem can never flip to recovered *(zeph lane; opened 2026-10-27 by the pipe, at `33f8f0f`)* | queue-item |
+| Q93 | closure — the malformed axis grades a contract now, the two false reds are gone, and the replacement contract has a hole the prose pin did not *(opened by the pipe 2026-10-27 at `d56105a`; landed by forge at `9878f12`, closed here 2026-10-27)* | closure |
+| Q97 | a contract-graded refusal accepts an argparse usage error, so a renamed flag turns the whole malformed axis green *(no lane owns it; opened 2026-10-27 by the pipe, at `9878f12`)* | queue-item |
+| Q98 | seven committed test files resolve their module from a path outside the repo, and the class guard Q61 promised was never written *(no lane owns it; opened 2026-10-27 by the pipe, at `5886bdd`)* | queue-item |
+| Q125 | the spark lane holds eleven line/word/char counters, and the newest one replaced its predecessor's capabilities without retiring its verifier *(spark lane; opened 2026-10-28 by the pipe, at `6b5197b`)* | queue-item |
diff --git a/wizard-work/ledger/workqueue-q-census.md b/wizard-work/ledger/workqueue-q-census.md
new file mode 100644
index 0000000..19a0809
--- /dev/null
+++ b/wizard-work/ledger/workqueue-q-census.md
@@ -0,0 +1,112 @@
+# Work queue Q-section census
+
+Source: `WORK-QUEUE.md` (source of the orchard work queue).
+Rows: `97` (97 `## Q#` section headings, incl. 8 closure records).
+`body_lines` counts lines from after the heading to the next `## ` heading.
+
+## TSV
+
+```tsv
+#q_id	title	status_raw	key_hash	body_lines	closure
+Q1	Recover the fifteen silent rooms	CLOSED — 0/15 recovered, and every public avenue is now exhausted with receipts.		45	0
+Q2	Chase the one dead link	DONE — recovered.** `recoveries/dead-link.md` (`3ca3d3c`, zephyrus-sparkborn) found the `x.com` snapshot		17	0
+Q3	Independent audit of the published ledger	DONE — both passes complete (`2ebcbe7` pass 1, `6f31cde` pass 2, zephyrus-sparkborn; material `2118b3e`).		32	0
+Q4	Falsification pass	DONE — `recoveries/falsification-pass.md` (`f50f052`, zephyrus-sparkborn), all three verdicts re-verified		26	0
+Q8	Summary fidelity: does each entry's machine-written summary overstate its article?	pilot CLOSED at `dcf91a1` (zephyrus-sparkborn), corrected at `9cc6879`; the full sweep is CLOSED at `f1fe38d` (2026-10-06) — 91/91, 1,101 rows, verified independently from the published file. The one contested grade was ruled and applied by zephyrus at `f122f8e` (`082` clause 3 → `contradicted`) and both batch-8 one-liners landed in the same commit, so the item owes nothing further from him on		320	0
+Q5	Issue triage in the organisation's public repos	re-scoped 2026-09-26 (reply 08 §5) after a census, because as written it invites busywork.** Measured over		34	0
+Q6	A public guide to checking this archive	DONE at `8bd0b09` (Merlin, 2026-10-08T17:28:47Z) — verified from this host figure by figure;		92	0
+Q7	Propose the next items	satisfied for the 2026-09-25 cycle.** Zeph's three proposals (`2a0cb01`) are now queue items: the Q8		73	0
+Q9	Independent QC of the sovereign music candidates	unclaimed. Pre-verified by Timmy against the delivered files — record `recoveries/music-master-verification.md`		36	0
+Q10	Summary fidelity for the non-magazine entries	COMPLETE 2026-10-10 (verified from raw sources; closure record below). Originally claimed by zephyrus-sparkborn at `3c9ad5b` (2026-10-07, `checkins/2026-10-07-zephyrus.md` §3).		255	0
+Q11	Close the eight pass-2 date mismatches	DONE — `recoveries/ledger-date-closure.md`, Merlin, 2026-10-09. 8 / 8 resolved, all		35	0
+Q12	Are the evidence tiers earned?	DONE — `recoveries/evidence-tier-audit.md`, Merlin, 2026-10-10. 18/18 `justified`, 0 `too		125	0
+Q13	Publish the archive-side wording fixes, one at a time	** 1 of 8 has a decision and staged correction (`magazine-091`; reply 09 §3), but its decided note carries		34	0
+Q14	Put the Inbox on `alexanderwhitestone.com` behind a gate	DONE — finished by `616794c` (2026-09-26), then re-measured by a later run the same day instead of being		118	0
+Q15	Stop the monitor from waking on the pipe's own writes	DONE — 2026-09-26 ≈19:05 UTC.** Fixed in `/root/.hermes/scripts/troupe_pipe_monitor.py` (outside this		130	0
+Q16	Per-platform ATS gate census	draft v0.1 landed `f29425a` (`career-lane/ats-gate-census-draft.md`, 2026-10-01; check-in `2f83e08`);		156	0
+Q17	Employer-side AI-authorship refusal gates			37	0
+Q18	Employer-side lead intake must be deduped against the prepared index			176	0
+Q19	Three proposed members (local Mac wizard, Grok, Mistral)	RESOLVED — provisional (2026-10-06).		343	0
+Q20	Excerpt fidelity and placement for the 91 magazine entries	DONE — `recoveries/excerpt-placement-audit.md` (12,914 B) and `recoveries/excerpt-placement-rows.md`		120	0
+Q21	Does every quoted excerpt resolve at the URL it is printed against?	open and unclaimed. Opened by the pipe 2026-10-10** because Q12 closed at `67b892d` and the unclaimed		133	0
+Q22	Do the named-but-unlinked sources resolve?	DONE — `recoveries/named-source-liveness.md`, Merlin, 2026-10-10. 28 fetches → 27 distinct		109	0
+Q23	The prose-named sources the `@` token rule cannot see	DONE 2026-10-10 — `recoveries/named-source-liveness-unlinked.md` (Merlin), verified from the published file this tick (control plane).		143	0
+Q24	The Q13 fix pack: stage every verified live-page fix as one reviewable approval	open and unclaimed. Opened by the pipe 2026-10-10** because Q23 closed at `8b56abe` and the unclaimed		144	0
+Q25	A prose-anchor convention for the ledger build	DONE — `recoveries/prose-anchor-convention.md`, Merlin, 2026-10-10. Designed, prototyped and		291	0
+Q26	Make the silent token classes loud, and measure the fifth slot	DONE — `recoveries/prose-anchor-hardening.md`, Merlin, 2026-10-10→11 (~00:20–00:24 UTC).	a9f23a6	196	0
+Q27	A fixture at every render site: make the token sentinel's coverage total	DONE 2026-10-11 — `recoveries/render-site-coverage.md` (Merlin). 32 sites: 28 covered by fixture, 4 structural exclusions; 35 fixtures, every negative writes 0 files; the scope clause closed with option (a), all four token classes now pre-write; no-token build still byte-identical at `91ecf6bf`.	f05179e	132	0
+Q28	The channels the entry walk cannot see: state the guarantee, then cover what it cannot reach	DONE 2026-10-11 — `recoveries/render-site-channels.md` (Merlin), scratch tree		184	0
+Q29	The guards that are not the walk: what protects a page when the value is not a token	DONE 2026-10-11 — `recoveries/render-site-guards.md` (Merlin), scratch tree `/root/crucible/q29/`. 22 fixtures plus the control, every negative or escape claim measured against the emitted byte; the second guarantee stated in one sentence; one finding: an unguarded `int(sats)` can still leave a partial tree (2 files).		173	0
+Q30	The renderer's entry point: the one path no gate executes			214	0
+Q31	The collector's entry point: the sibling path no gate has executed either	DONE at Merlin's Run 6 (2026-10-11 ≈13:19–13:35Z) — deliverable `recoveries/helm-collector-run.md`; the collector's entry point is executed, its destination is gated, and G8 asserts it.** The item's four steps: (1) the two safe legs run — `--dry-run --skip-tests` exit 0 / 15,187 B pure-JSON stdout and `--out <scratch>` exit 0 / 15,187 B, both with the live snapshot unchanged (`aa842b0f…`); the two bodies are the same measurement (only `observed_at` clocks and one `rtt_seconds` differ, `q31-compare.py`). (2) **The destination rule: `SNAPSHOT_PATH` is gated behind an explicit `--deploy`** — the same shape as the renderer's `OUT_DEFAULT` gate, so both entry points now behave alike; `--dry-run` is never gated (it writes nothing), a scratch `--out` is the default expectation, and the live path (bare default *or* explicit `--out`, matched by `.resolve()`) is refused at exit 2 **before any collector runs** (0.13 s refusal vs ~1.9 s collect). Gated collector `60229227216fb4ab…` (701 lines / 28,808 B). (3) **Gate G8 — the collector's CLI in a subprocess, 18 assertions** → `helm-selftest: 137 passed, 0 failed`, VERDICT: ALL GATES PASS; the gate discriminates (pre-gate `ee0b36a8…` with `SNAPSHOT_PATH` patched to scratch writes its default bare; gated refuses). (4) **`email` UNREACHABLE is correct** — `himalaya` is ABSENT on PATH and both config paths are absent, so `collect_email()` fails closed with `himalaya unavailable: command not found: himalaya` and lands in `red_sources`, never `green`. **An incident, logged first in the deliverable §6:** the first negative control ran the pre-gate revision bare against the live default and overwrote the live snapshot; restored byte-exact from a pre-run `snap-before.json` (`aa842b0f…`, 14,039 B, mtime back to `2026-10-08T17:12:59.475780303Z`), and the control now patches `SNAPSHOT_PATH` before any run. **Nothing deployed** — the gated collector and G8 selftest are scratch-local in `/root/crucible/q31/`; the deployed `helm-collect.py` is unchanged at `ee0b36a8…` and `helm-selftest.py` at `7ed1bca8…` (still 119 passed). Adoption is a §4 deploy decision, Alexander's, the same gate Q26–Q30 state. Mercury's day-3 unit is Q31's first slice (the two safe legs); this run executed them first and Mercury's `/tmp/mercury-q31/` was empty at 13:29Z, so no duplication occurred — the unit is satisfied here and stays open for Mercury to land his own artifact.		405	0
+Q32	The G8 two-run agreement check is nondeterministic: `age_seconds` is not scrubbed	OPEN — named to the Helm lane**, ahead of the Q31 `cp` decision so that the gate that ships is the one that		69	0
+Q33	Split the newest-file pointer out of `evidence.source_path`	OPEN — named to the Helm lane.** A snapshot key rename touches every consumer of `evidence.source_path`	7e12c82	113	0
+Q34	Gate the pointer's null case	DONE 2026-10-12 — `recoveries/helm-null-gate.md` (Merlin), scratch tree `/root/crucible/q34/`.	8bb88da	175	0
+Q35	The gate must refuse a subject collector that carries no destination rule	DONE — `recoveries/helm-precondition-gate.md` (8,261 B / sha256	ac98bfb	167	0
+Q36	The monitor cannot see a counterparty write that carries this pipe's identity	DONE — the rule holds, and the predicted transition arrived exactly as stated.** Measured at the first	9a1de9a	88	0
+Q37	The identity rule closes one class, not the class		9584984	32	0
+Q38	The behavioural destination guard	DONE — `recoveries/helm-behavioural-guard.md` (10,232 B), Merlin, 2026-10-12T06:5x–07:1xZ, this host.		116	0
+Q38 #2	The behavioural destination guard	the deliverable is verified and the item is DONE, and its protective claim is FALSIFIED. It is not adoptable as it stands.** Finished by `0776480` (guard + queue block + Run 4 check-in) and `4ed1da9` (landing evidence); verified from this host by reply 21, `replies/2026-10-12-to-merlin-21.md`.		15	0
+Q39	The Q38 guard's admission admits a writer, and its legs run the unrewritten subject	DONE — `recoveries/helm-destination-guard-fix.md` (12,253 B), Merlin, 2026-10-12, scratch tree `/root/crucible/q39/`. Fixed gate `9b09f328…` (1,412 lines / 77,704 B, +309/−38 against Q38's `74aba348…`); subject collector byte-identical at `4e45021d…`; nothing deployed, no `cp` into `/root/.helm/bin/`, live snapshot `aa842b0f…` delta 0 across every run.		52	0
+Q39 closure	closure — verified from this host by the pipe (2026-10-12, reply 22)	DONE. Finished by `fad802c` (record + queue block + Run 5 check-in) and `4e87c8f` (landing evidence); verified by `replies/2026-10-12-to-merlin-22.md` with my own harness `/root/troupe-verify/q39/indep-negatives.py` → `INDEP-NEGATIVES.json`, `pair-run.log`.		12	1
+Q40	the deployed gate admits all five negatives, and has no admission path at all	DONE — `recoveries/helm-deployed-gate-admission.md` (5,633 B / sha256		58	0
+Q37 #2	claimed by this pipe; first increment landed (the v1.3 census)	OPEN and claimed by the pipe (Merlin's §Next 2 read it correctly; it is this lane's tooling). Landed this tick:** the `branch-head` census line in `troupe_pipe_monitor.py` v1.3, sha256 `bb532da8c4f01b98eab4034ce74dc76b0e3939508bfd6cadd5d3d650020449f8`; v1.2 preserved at `/root/troupe-verify/q37/troupe_pipe_monitor.py.v1.2.bak` (`ce3950b5…`), reversible with one `cp`; record `recoveries/monitor-identity-census.md`.		826	0
+Q43	The legs run the rewritten subject: prevention, not detect-and-restore	DONE — `recoveries/helm-leg-sandbox.md` (13,561 B), Merlin, 2026-10-12. Scratch tree `/root/crucible/q43/`; nothing deployed, no `cp` into `/root/.helm/bin/`, `decisions/` and `inbox/` untouched.		37	0
+Q43 closure	closure — verified from this host by the pipe (2026-10-12, reply 27)	VERIFIED AND CLOSED from the pipe, 2026-10-12 18:5x–19:1xZ.** Finished by `0fb8b20` (deliverable + queue block + Run 9 check-in section) and `2ddbe68` (landing evidence); verified by `replies/2026-10-12-to-merlin-27.md` with the pipe's own harness `/root/crucible/q43z/timmy_verify_q43.py` (reads Merlin's tree, writes nothing into `/root/crucible/q43/`). Adoption is unchanged and stays Alexander's: subject `4e45021d…` + gate `c22601ec…`, nothing `cp`ed, deployed bin still `ee0b36a8…` / `7ed1bca8…` / `5c67473d…`.		20	1
+Q44	The pin class: redirect every constant composed from the live data root, not only `SNAPSHOT_PATH`	DONE 2026-10-12 — `recoveries/helm-root-redirect.md` (Merlin, Helm lane); the closure block is at the foot		543	0
+Q48	The runtime-resolution redirect: close the class Q45's literals cannot see	DONE 2026-10-13 — `recoveries/helm-runtime-redirect.md` (Merlin, Helm lane), scratch tree		119	0
+Q49	The runtime-resolved root's live write path: name it, reproduce it, then close it	open and unclaimed. Opened by the pipe 2026-10-13**, because the Helm lane's executable set is empty		767	0
+Q45	§9 follow-on — the home-directory channel	OPEN — awaiting Alexander's zoom/whole-shop answer; build is the pipe's.** Evidence paths: `/var/www/leathermint/v2/index.html` (+ `phaser.min.js`), ledger commit `58e7eaa` (15:25:39Z) holding the verification record; queue index re-rendered in that same commit. No issue, PR, release or deploy surface beyond this static path; no secret printed.		3105	0
+Q57	Bind a standup entry to the bytes it grades	open and unclaimed. Opened by the pipe 2026-10-24; null's lane.		32	0
+Q58	The lane-activity instrument reads a surface that was retired on 2026-10-16	closed at `809466f` (2026-10-26, spark in sol's lane); the closure record sits at the foot of this file.** Opened by the pipe 2026-10-24.		45	0
+Q59	beam's jump hash matches the C reference, and not one test would notice if it stopped	open and unclaimed. Beam's lane.		50	0
+Q60	Every truncated identifier in the archive: which ones can still be checked	open and unclaimed.** Opened by the pipe 2026-10-24. Anyone's lane; zephyrus has first		59	0
+Q61	beam's `topo_sort` drops generator dependencies, and its gate imports a copy outside the repo	open and unclaimed.** Opened by the pipe 2026-10-24. beam's lane by authorship; anyone may take it.		55	0
+Q62	147 committed gates read `/root/.hermes/wizard-outputs`; two of them cannot pass from a clone	open and unclaimed.** No lane owns it by authorship; anyone may take it, one file per commit.		47	0
+Q63	Six committed verifiers print PASS while asserting nothing, and eight are run by no gate	open and unclaimed.** No lane owns it; anyone may take it, one file per commit.		290	0
+Q66	beam's `search_count` advertises overlapping occurrences and no test would notice if it stopped	closed at `2d6cf69` (2026-10-26, beam); the closure record sits at the foot of this file.** Beam's lane by authorship; the remedy was one assertion,		33	0
+Q67	forge's probe-refactor verifier certifies a refactor that restores the defect it removes	open and unclaimed.** Forge's lane by authorship; the remedy is four small edits		62	0
+Q68	beam's `topo_levels` drops a one-shot `edges` iterable, silently, and its new suite both certifies a host copy and takes the lane's gate down	closed at `5a43291` (volt, 2026-10-25); the closure record sits at the foot of this file.** Beam's lane by authorship; anyone may take it. Done means: `edges`		74	0
+Q69	116 committed files under `wizard-work/` name the absolute path `/root/troupe-standup`, so 64 gates grade the author's working tree instead of the checkout they were asked about	open and unclaimed.** One file per commit, each needing the repo-relative-or-stated decision; `wizard-work/ledger` is the entry to take first because its artifact is otherwise correct and its gate is the one measured green-on-wrong.		32	0
+Q70	beam's `test_trie.py` is invisible to the lane gate (73 new lines, 0 cells collected), and `count_prefix` is a lifetime insert counter that survives `delete`	closed at `12f956a` (volt, 2026-10-26) — closure record at the foot of this file.** Beam's lane by authorship; anyone may take it. Evidence: `replies/2026-10-25-to-zephyrus-102.md` §2; probes `/root/.hermes/cache/scratch/trie_probe.py`; clone `/root/tcheck-q68` at `dbc2c4f`. Nothing from `inbox/` is quoted. No other lane's file was edited.		13	0
+Q71	ledger's `commits-table.md` has no verifier, and row 4 writes `kernel_git` where the source URL has `kernel/git`	closed at `b9e3780` and the closure commit (volt, 2026-10-25); the closure record sits at the foot of this file.** Ledger's lane by authorship; anyone may take it. Evidence: `replies/2026-10-25-to-zephyrus-102.md` §3; response body retained at `/tmp/torvalds.json` on this host (re-fetchable, one request). Nothing from `inbox/` is quoted. No other lane's file was edited.		21	0
+Q72	sphinx's lcmm ledger gates its quotations but not its population or its interpretations: two mutations of mine pass the verifier at 169/169 and 139/139	open and unclaimed.** Sphinx's lane by authorship; anyone may take it. Evidence: `replies/2026-10-26-to-zephyrus-104.md` §2–§3; clone `/root/.hermes/cache/scratch/lcmm-v2` at `d6a9253`; mutation harness `/root/.hermes/cache/scratch/lcmm_mut.py` with trees `lcmm-mut/{A_drop3,B_swap,C_role,D_fig}`; independent claim/byte check `lcmm_indep.py`; verifier log `lc-verify.log` (169 lines), battery log `lc-mut.log`; error bodies `atom-live.xml` (14 B), `atom-full-live.xml` (126 B). Nothing from `inbox/` is quoted. No other lane's file was edited.		40	0
+Q72 #2	verified from this host by the pipe (2026-10-26, reply 105)			9	0
+Q73	sphinx's longctx archive gates its numbers and its claim-scoped quotations, but not its prose numbers, its claim sentences, its README, or the quotations that carry no claim id	open and unclaimed.** Sphinx's lane by authorship; anyone may take it. Evidence: `replies/2026-10-26-to-zephyrus-105.md` §2–§3; export `/root/.hermes/cache/scratch/lcx1/cloneA`; verify log `lcx1/verify_full.txt`; live re-fetch `lcx1/live_ids.xml` (403,802 B); harness `lcx1/mut.py`, trees `lcx1/mut/{A_prose_number,B_claim_prose,C_readme,D_quote_unclaimed,E_drop_papers,F_swap_quotes,H_fabricated}`, log `lcx1/mut_log.txt`. Nothing from `inbox/` is quoted. No other lane's file was edited.		49	0
+Q74	sol's triage CHECK certifies the host `_triage` copy and asserts today's freshness, so it cannot gate the committed artifact	open and unclaimed.** Sol's lane by authorship; anyone may take it. Evidence: export `/root/.hermes/cache/scratch/q58x` (`git archive 809466f`, no `.git`), fixtures `q58x/fix`, transcripts of the four runs in the Q58 closure record above. Nothing from `inbox/` is quoted. No other lane's file was edited.		25	0
+Q75	ledger's two census TSVs carry seven lines that are not rows and one path no file on disk has, and no gate in the lane can see either	open and unclaimed.** Ledger's lane by authorship; anyone may take it. Evidence: readback of both files in Python against an `os.walk` of `/root/troupe-standup/wizard-work` at 2026-10-26 ≈09:30Z, `check_ledger_extract.py` rc 0, `grep -rn CHECK-wizardwork-census` (one hit, the docstring). Ledger's files by authorship; read, not edited. Nothing from `inbox/` is quoted. No other lane's file was edited.	b82b023	13	0
+Q76	beam's new median tests reach no gate, and the lane gate that would run them is red for a host path older than the commit	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: reply 110 §1–§3; export `/root/.hermes/cache/scratch/t110/export` (`c3ce8dd`) and `…/t110/pre` (`c3ce8dd^`); transcripts `/tmp/t110_check_masked_after.txt` and `…_masked_pre.txt` (rc 0, `Ran 151 tests`, both), `/tmp/t110_check_after.txt` and `…_pre.txt` (rc 1, ImportError at line 29); mutant battery `t110/mut.py` → `t110mut/` (8 trees, 8 killed); oracles `t110/fuzz.py`, `t110/fuzz2.py`. Nothing from `inbox/` is quoted. No other lane's file was edited.	c3ce8dd	40	0
+Q77	beam's segment tree lands 100 lines and the lane's count does not move, its failure path reports as an import `SystemExit` rather than a cell, and out-of-range indices are silently clamped	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: reply 112 §1; lane		81	0
+Q78	spark's `3d72f9d` deletes the Q63 `_check()` failure path from four verifiers and drifts five ledger rows, and the new email-validator suite imports a host path		3d72f9d	49	0
+Q79	beam's `manifest.py` lands 107 lines with no cell in any gate, cannot see a directory symlink, reads its own output as a tamper, and prints a green empty manifest for a root that does not exist	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: reply 116 §2–§4;	edac5cf	59	0
+Q79 closure	closure — manifest.py carries the lane's 0/1/2 contract, three blind spots are closed, and 17 cells now sit in the gate	DONE at `f719428` (manifest.py), `25e88f8` (canonical naming), `36ce415` (test_manifest.py); this record and `docs/queue-index.md` land in the commit above it.** The opening record's own text is quoted in a code span above so this line opens nothing.		15	1
+Q80	spark's `json_sha256_validator.py` prints a hash of bytes it never validated, admits `NaN`/`Infinity` as valid, and reports an unreadable input in the same code as a bad document	open and unclaimed.** Spark's lane by authorship; anyone may take it. Evidence: reply 118 §1–§3,	3081128	52	0
+Q81	spark's `hermes_profile_health.py` grades a profile by the existence of names, hardcodes the one host path it can check, and carries a branch that cannot fire	open and unclaimed.** Spark's lane by authorship. Evidence: reply 118 §4; probes	3081128	42	0
+Q82	beam's `test_json_canonical.py` prints `ALL PASS` without running a single assertion, and the lane's count does not move at the head that lands it	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: measured at	3081128	38	0
+Q82 closure	closure — `test_json_canonical.py` is seven discoverable cells (lane gate 191 → 198), every cell is killed by a named mutant, and `json_canonical.py` says what it is not	DONE at `0735102` (suite), `6c097bf` (float surface); this record and `docs/queue-index.md` land in the commit above it.** The opening record's own `Status: open and unclaimed.` line is left standing, as append-only discipline requires; the closure is this line, not an edit above it.		28	1
+Q81 closure	closure — `hermes_profile_health.py` grades a profile you name, parses the config it grades, and the lane gate collects nine cells	DONE at `3f424c0` (tool), `329af8b` (suite + gate leg); this record and `docs/queue-index.md` land in the commit above them.** The opening record's own `Status: open and unclaimed.` line is left standing, as append-only discipline requires; the closure is this line, not an edit above it.		42	1
+Q83	five branches `hermes_profile_health.py` names are pinned by no cell, and one of them is the branch that produces the sweep's only red	open and unclaimed.** Spark's lane by authorship. Evidence: reply 119 §2; mutants and behaviour probes `/root/.hermes/wizard-outputs/ledger/q81_mutants_mine.py` (13 trees, incl. the M0–M8 reproduction) and `/root/.hermes/wizard-outputs/ledger/q81_survivor_probe.py` (the five rows, baseline rc vs mutant rc vs suite rc), results `/root/.hermes/wizard-outputs/ledger/q81-mutant-battery-mine.json`. Nothing from `inbox/` is quoted; no file another party authored was edited.	829268f	19	0
+Q84	`interval_overlap.py` lands 87 lines with no cell, and the lane gate reads `Ran 202` before and after	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: reply 120 §1–§3;	517362f	52	0
+Q83 closure	closure — the five unpinned `hermes_profile_health.py` branches are five cells (spark gate 9 → 14), and the item's own first row is corrected	DONE at `fe09917`; this record and `docs/queue-index.md` land in the commit above it.** The opening record's own `Status: open and unclaimed.` line is left standing, as append-only discipline requires; the closure is this line, not an edit above it. Report: `/root/.hermes/wizard-outputs/volt/q83-report.md`.		27	1
+Q85	`beam/CHECK` collects only `test_*.py`, so a module no cell imports lands invisible: four are in that state today, and the newest added 38 lines with the gate reading `Ran 214` before and after	open and unclaimed.** Beam's lane by authorship. Evidence: reply 121 §3–§4; independent checks `/root/.hermes/cache/scratch/q83m9/` (the Q83 M9 mutant tree) and the reply-121 scripts in this repo's history. Nothing from `inbox/` is quoted; no file another party authored was edited.	083981e	19	0
+Q86	the refactor-lane harness proves silence, not absence of I/O, and its seed path is host-absolute, so a second checkout cannot re-verify the refactor	DONE at `802a1ae`; this line and the two items appended at the end of this file (Q89, Q90) land in the commits above it.** The opening `Status: open and unclaimed.` line and reply 124's "four of six files remain" are left standing, append-only; both are stale as of `802a1ae` and this line supersedes them. Re-measured by the pipe at `6e9aeee`, not read off volt's transcript: probe pair **14/14**, dump pair **14/14**, pending pair **13/13**, all rc 0; `grep -c '/root/troupe-standup/inbox'` across the six files **`0, 0, 0, 1, 1, 1`**, the three survivors being the harnesses' `HOST_SEED_LITERAL` (used only to assert the *original* keeps the smell); my own M6 on `_triage_probe_refactored.py` in a scratch clone → **13/14, rc 1**, `FAIL: static io-call(s) at module scope: [(57, 'json.load'), (57, 'open')]`. **The residual is not closed and is not a re-opening of this item:** the detector is a static name list (`verify_triage_probe_refactor.py:404-407`) plus a `builtins.open` spy, so a module-scope `Path(...).read_text()` appended to the refactored module still returns **14/14, rc 0** with `OK: no import-time I/O` — filed as Q89, because this item's own done-means (builtins.open wrapper *or* AST walk of the module body) is met by `802a1ae` and moving its goalposts now would be a different item wearing the old number.	431bca1	22	0
+Q87	the forge lane holds 34 `verify_*.py` and no `CHECK`; `tools/verify.py`'s eight legs reach none of them	open and unclaimed.** Forge's lane by authorship; anyone may take it. Evidence: reply 21 §4; `ls wizard-work/forge/verify_*.py | wc -l` = 34, `ls wizard-work/forge/CHECK` = absent, at `431bca1`. Nothing from `inbox/` is quoted.	431bca1	15	0
+Q88	the census `CHECK` verifies the live `checkins/` directory and the TSV only, so a dated artifact goes red on the next check-in and stays green under a hand-edited per-wizard table	open and unclaimed.** Ledger's lane by authorship; anyone may take it. Evidence: reply 122 §2; scratch tree `/tmp/censusbomb` (copy, CHECK re-run at `b0a2886`, both measurements above). Nothing from `inbox/` is quoted; no file another party authored was edited.	b0a2886	16	0
+Q89	the import-time-I/O detector in the three forge harnesses is a name list, so a `pathlib` read at module scope passes every check green	open and unclaimed.** Forge's lane by authorship; anyone may take it. Evidence: reply 125 §0 and §1; scratch clone `/tmp/q86evade` (both evasions above, run from a copy, no repo file edited). Nothing from `inbox/` is quoted.	6e9aeee	22	0
+Q90	beam's `find_tree_root` accepts any ancestor marker as the repo root, `portable_seed` never checks the seed exists, and the six cells that would notice reach no gate	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: reply 125 §1; scratch dirs `/root/.hermes/cache/scratch/beamguard/` (the five variant table) and the `/tmp/tmp*` decoy/symlink constructions in that reply; gate counts measured at `6e9aeee` in the worktree. Nothing from `inbox/` is quoted; no file another party authored was edited.	6e9aeee	18	0
+Q91	forge's r41 pixel-diff verifier prints PASS when neither card writes anything, and it writes the delivery artifact		d56105a	13	0
+Q92	spark's two new scripts grade the caller's working directory, and one carries dead code after `sys.exit`		d56105a	17	0
+Q93	the sweep's malformed-input probe grades a phrase, so two correctly-refusing tools keep it red, and the leg's summary line says "0 fatal" while returning 1		d56105a	18	0
+Q94	`dsu_rollback.py`'s headline mechanism is graded by no cell, its compression cell does not grade compression, and `find`/`union` accept negative indices silently		1e79fc8	130	0
+Q60 closure	closure — the check half runs at a named head, the self-quote collapse and the placeholder refusal are measured, and the two instrument holes it leaves are named instead of smoothed	DONE at `33f8f0f` (`wizard-work/zeph/q60_enforce.py`, blob `4b3926332b5aab4a83f599815fd677bc230e17ad`); this record lands in the commit above it.** Re-verified here from a fresh anonymous clone at that head, run from outside the tree: `--selftest` **7 cells passed, 0 failed, rc 0**; full tree **`OCC=110 DISTINCT=22 FILES=29`, `VERDICT=PASS`, rc 0, zero FAIL lines**; the three former FAIL sites (`WORK-QUEUE.md`, reply 113, reply interview) print `TEST-FIXTURE … (len 36)` with their site and do not fail; the anonymous raw GET is byte-identical (`cmp` clean, 14,374 B). Four probes on copies outside the repo: (A) `run_check` gutted to `return ["VERDICT=PASS"], False` reds cell 1 — the positive control is real; (B) the fixture value written into a new file prints `TEST-FIXTURE` and passes rc 0, the residual zephyrus named himself; (C) a real full value under the exhausted stem `beae0b1f` still reads `UNRECOVERED-JUSTIFIED` with rc 0; (D) a fixture literal appended to the checker's own source leaves `--selftest` at **7/7 rc 0** and the self-scan printing `TEST-FIXTURE … at q60_enforce.py`.	33f8f0f	7	1
+Q95	beam's `find_duplicate` no-duplicate guard cannot fire, and the file has no cell in any gate	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: reply 130 §4; the exhaustive sweep and the import count are re-runnable as written there. Nothing from `inbox/` is quoted; no file another party authored was edited.	f400640	11	0
+Q96	`q60_enforce.py`'s self-scan cannot see a fixture literal in its own source, and an exhausted stem can never flip to recovered	open and unclaimed.** Zeph's lane by authorship; anyone may take it. Evidence: reply 130 §1 probes C and D, `/root/.hermes/cache/scratch/q60probe/`. Nothing from `inbox/` is quoted.	33f8f0f	28	0
+Q93 closure	closure — the malformed axis grades a contract now, the two false reds are gone, and the replacement contract has a hole the prose pin did not	DONE at `9878f12` (`tools/selftest_sweep.py`, blob `c710643cbf888140d0bf834e89aecaaa607117cc`, 68,216 B); this record lands after it.	d56105a	19	1
+Q97	a contract-graded refusal accepts an argparse usage error, so a renamed flag turns the whole malformed axis green	open and unclaimed.** Anyone may take it; the shape is `tools/selftest_sweep.py`'s and forge's lane by authorship, so it goes to forge first if forge wants it.	9878f12	22	0
+Q98	seven committed test files resolve their module from a path outside the repo, and the class guard Q61 promised was never written	open and unclaimed.** Beam's lane by authorship for the first row, spark's for the next five, ledger's for the last; anyone may take it, and a scan cell is the point rather than seven edits.	5886bdd	741	0
+Q125	the spark lane holds eleven line/word/char counters, and the newest one replaced its predecessor's capabilities without retiring its verifier	open and unclaimed.** Opened after reply 15's consolidation request (2026-10-22, `62e3f33`) went six days without a contract behind it; this item is that contract. Reply 15 named five word counters plus `file_analyzer.py`; the population went up, not down.	6b5197b	197	0
+```
+
+## Verifier
+
+`CHECK: python3 /root/troupe-standup/wizard-work/ledger/check_workqueue_qcensus.py`
diff --git a/wizard-work/ledger/workqueue-q-census.tsv b/wizard-work/ledger/workqueue-q-census.tsv
new file mode 100644
index 0000000..b321d51
--- /dev/null
+++ b/wizard-work/ledger/workqueue-q-census.tsv
@@ -0,0 +1,98 @@
+#q_id	title	status_raw	key_hash	body_lines	closure
+Q1	Recover the fifteen silent rooms	CLOSED — 0/15 recovered, and every public avenue is now exhausted with receipts.		45	0
+Q2	Chase the one dead link	DONE — recovered.** `recoveries/dead-link.md` (`3ca3d3c`, zephyrus-sparkborn) found the `x.com` snapshot		17	0
+Q3	Independent audit of the published ledger	DONE — both passes complete (`2ebcbe7` pass 1, `6f31cde` pass 2, zephyrus-sparkborn; material `2118b3e`).		32	0
+Q4	Falsification pass	DONE — `recoveries/falsification-pass.md` (`f50f052`, zephyrus-sparkborn), all three verdicts re-verified		26	0
+Q8	Summary fidelity: does each entry's machine-written summary overstate its article?	pilot CLOSED at `dcf91a1` (zephyrus-sparkborn), corrected at `9cc6879`; the full sweep is CLOSED at `f1fe38d` (2026-10-06) — 91/91, 1,101 rows, verified independently from the published file. The one contested grade was ruled and applied by zephyrus at `f122f8e` (`082` clause 3 → `contradicted`) and both batch-8 one-liners landed in the same commit, so the item owes nothing further from him on		320	0
+Q5	Issue triage in the organisation's public repos	re-scoped 2026-09-26 (reply 08 §5) after a census, because as written it invites busywork.** Measured over		34	0
+Q6	A public guide to checking this archive	DONE at `8bd0b09` (Merlin, 2026-10-08T17:28:47Z) — verified from this host figure by figure;		92	0
+Q7	Propose the next items	satisfied for the 2026-09-25 cycle.** Zeph's three proposals (`2a0cb01`) are now queue items: the Q8		73	0
+Q9	Independent QC of the sovereign music candidates	unclaimed. Pre-verified by Timmy against the delivered files — record `recoveries/music-master-verification.md`		36	0
+Q10	Summary fidelity for the non-magazine entries	COMPLETE 2026-10-10 (verified from raw sources; closure record below). Originally claimed by zephyrus-sparkborn at `3c9ad5b` (2026-10-07, `checkins/2026-10-07-zephyrus.md` §3).		255	0
+Q11	Close the eight pass-2 date mismatches	DONE — `recoveries/ledger-date-closure.md`, Merlin, 2026-10-09. 8 / 8 resolved, all		35	0
+Q12	Are the evidence tiers earned?	DONE — `recoveries/evidence-tier-audit.md`, Merlin, 2026-10-10. 18/18 `justified`, 0 `too		125	0
+Q13	Publish the archive-side wording fixes, one at a time	** 1 of 8 has a decision and staged correction (`magazine-091`; reply 09 §3), but its decided note carries		34	0
+Q14	Put the Inbox on `alexanderwhitestone.com` behind a gate	DONE — finished by `616794c` (2026-09-26), then re-measured by a later run the same day instead of being		118	0
+Q15	Stop the monitor from waking on the pipe's own writes	DONE — 2026-09-26 ≈19:05 UTC.** Fixed in `/root/.hermes/scripts/troupe_pipe_monitor.py` (outside this		130	0
+Q16	Per-platform ATS gate census	draft v0.1 landed `f29425a` (`career-lane/ats-gate-census-draft.md`, 2026-10-01; check-in `2f83e08`);		156	0
+Q17	Employer-side AI-authorship refusal gates			37	0
+Q18	Employer-side lead intake must be deduped against the prepared index			176	0
+Q19	Three proposed members (local Mac wizard, Grok, Mistral)	RESOLVED — provisional (2026-10-06).		343	0
+Q20	Excerpt fidelity and placement for the 91 magazine entries	DONE — `recoveries/excerpt-placement-audit.md` (12,914 B) and `recoveries/excerpt-placement-rows.md`		120	0
+Q21	Does every quoted excerpt resolve at the URL it is printed against?	open and unclaimed. Opened by the pipe 2026-10-10** because Q12 closed at `67b892d` and the unclaimed		133	0
+Q22	Do the named-but-unlinked sources resolve?	DONE — `recoveries/named-source-liveness.md`, Merlin, 2026-10-10. 28 fetches → 27 distinct		109	0
+Q23	The prose-named sources the `@` token rule cannot see	DONE 2026-10-10 — `recoveries/named-source-liveness-unlinked.md` (Merlin), verified from the published file this tick (control plane).		143	0
+Q24	The Q13 fix pack: stage every verified live-page fix as one reviewable approval	open and unclaimed. Opened by the pipe 2026-10-10** because Q23 closed at `8b56abe` and the unclaimed		144	0
+Q25	A prose-anchor convention for the ledger build	DONE — `recoveries/prose-anchor-convention.md`, Merlin, 2026-10-10. Designed, prototyped and		291	0
+Q26	Make the silent token classes loud, and measure the fifth slot	DONE — `recoveries/prose-anchor-hardening.md`, Merlin, 2026-10-10→11 (~00:20–00:24 UTC).	a9f23a6	196	0
+Q27	A fixture at every render site: make the token sentinel's coverage total	DONE 2026-10-11 — `recoveries/render-site-coverage.md` (Merlin). 32 sites: 28 covered by fixture, 4 structural exclusions; 35 fixtures, every negative writes 0 files; the scope clause closed with option (a), all four token classes now pre-write; no-token build still byte-identical at `91ecf6bf`.	f05179e	132	0
+Q28	The channels the entry walk cannot see: state the guarantee, then cover what it cannot reach	DONE 2026-10-11 — `recoveries/render-site-channels.md` (Merlin), scratch tree		184	0
+Q29	The guards that are not the walk: what protects a page when the value is not a token	DONE 2026-10-11 — `recoveries/render-site-guards.md` (Merlin), scratch tree `/root/crucible/q29/`. 22 fixtures plus the control, every negative or escape claim measured against the emitted byte; the second guarantee stated in one sentence; one finding: an unguarded `int(sats)` can still leave a partial tree (2 files).		173	0
+Q30	The renderer's entry point: the one path no gate executes			214	0
+Q31	The collector's entry point: the sibling path no gate has executed either	DONE at Merlin's Run 6 (2026-10-11 ≈13:19–13:35Z) — deliverable `recoveries/helm-collector-run.md`; the collector's entry point is executed, its destination is gated, and G8 asserts it.** The item's four steps: (1) the two safe legs run — `--dry-run --skip-tests` exit 0 / 15,187 B pure-JSON stdout and `--out <scratch>` exit 0 / 15,187 B, both with the live snapshot unchanged (`aa842b0f…`); the two bodies are the same measurement (only `observed_at` clocks and one `rtt_seconds` differ, `q31-compare.py`). (2) **The destination rule: `SNAPSHOT_PATH` is gated behind an explicit `--deploy`** — the same shape as the renderer's `OUT_DEFAULT` gate, so both entry points now behave alike; `--dry-run` is never gated (it writes nothing), a scratch `--out` is the default expectation, and the live path (bare default *or* explicit `--out`, matched by `.resolve()`) is refused at exit 2 **before any collector runs** (0.13 s refusal vs ~1.9 s collect). Gated collector `60229227216fb4ab…` (701 lines / 28,808 B). (3) **Gate G8 — the collector's CLI in a subprocess, 18 assertions** → `helm-selftest: 137 passed, 0 failed`, VERDICT: ALL GATES PASS; the gate discriminates (pre-gate `ee0b36a8…` with `SNAPSHOT_PATH` patched to scratch writes its default bare; gated refuses). (4) **`email` UNREACHABLE is correct** — `himalaya` is ABSENT on PATH and both config paths are absent, so `collect_email()` fails closed with `himalaya unavailable: command not found: himalaya` and lands in `red_sources`, never `green`. **An incident, logged first in the deliverable §6:** the first negative control ran the pre-gate revision bare against the live default and overwrote the live snapshot; restored byte-exact from a pre-run `snap-before.json` (`aa842b0f…`, 14,039 B, mtime back to `2026-10-08T17:12:59.475780303Z`), and the control now patches `SNAPSHOT_PATH` before any run. **Nothing deployed** — the gated collector and G8 selftest are scratch-local in `/root/crucible/q31/`; the deployed `helm-collect.py` is unchanged at `ee0b36a8…` and `helm-selftest.py` at `7ed1bca8…` (still 119 passed). Adoption is a §4 deploy decision, Alexander's, the same gate Q26–Q30 state. Mercury's day-3 unit is Q31's first slice (the two safe legs); this run executed them first and Mercury's `/tmp/mercury-q31/` was empty at 13:29Z, so no duplication occurred — the unit is satisfied here and stays open for Mercury to land his own artifact.		405	0
+Q32	The G8 two-run agreement check is nondeterministic: `age_seconds` is not scrubbed	OPEN — named to the Helm lane**, ahead of the Q31 `cp` decision so that the gate that ships is the one that		69	0
+Q33	Split the newest-file pointer out of `evidence.source_path`	OPEN — named to the Helm lane.** A snapshot key rename touches every consumer of `evidence.source_path`	7e12c82	113	0
+Q34	Gate the pointer's null case	DONE 2026-10-12 — `recoveries/helm-null-gate.md` (Merlin), scratch tree `/root/crucible/q34/`.	8bb88da	175	0
+Q35	The gate must refuse a subject collector that carries no destination rule	DONE — `recoveries/helm-precondition-gate.md` (8,261 B / sha256	ac98bfb	167	0
+Q36	The monitor cannot see a counterparty write that carries this pipe's identity	DONE — the rule holds, and the predicted transition arrived exactly as stated.** Measured at the first	9a1de9a	88	0
+Q37	The identity rule closes one class, not the class		9584984	32	0
+Q38	The behavioural destination guard	DONE — `recoveries/helm-behavioural-guard.md` (10,232 B), Merlin, 2026-10-12T06:5x–07:1xZ, this host.		116	0
+Q38 #2	The behavioural destination guard	the deliverable is verified and the item is DONE, and its protective claim is FALSIFIED. It is not adoptable as it stands.** Finished by `0776480` (guard + queue block + Run 4 check-in) and `4ed1da9` (landing evidence); verified from this host by reply 21, `replies/2026-10-12-to-merlin-21.md`.		15	0
+Q39	The Q38 guard's admission admits a writer, and its legs run the unrewritten subject	DONE — `recoveries/helm-destination-guard-fix.md` (12,253 B), Merlin, 2026-10-12, scratch tree `/root/crucible/q39/`. Fixed gate `9b09f328…` (1,412 lines / 77,704 B, +309/−38 against Q38's `74aba348…`); subject collector byte-identical at `4e45021d…`; nothing deployed, no `cp` into `/root/.helm/bin/`, live snapshot `aa842b0f…` delta 0 across every run.		52	0
+Q39 closure	closure — verified from this host by the pipe (2026-10-12, reply 22)	DONE. Finished by `fad802c` (record + queue block + Run 5 check-in) and `4e87c8f` (landing evidence); verified by `replies/2026-10-12-to-merlin-22.md` with my own harness `/root/troupe-verify/q39/indep-negatives.py` → `INDEP-NEGATIVES.json`, `pair-run.log`.		12	1
+Q40	the deployed gate admits all five negatives, and has no admission path at all	DONE — `recoveries/helm-deployed-gate-admission.md` (5,633 B / sha256		58	0
+Q37 #2	claimed by this pipe; first increment landed (the v1.3 census)	OPEN and claimed by the pipe (Merlin's §Next 2 read it correctly; it is this lane's tooling). Landed this tick:** the `branch-head` census line in `troupe_pipe_monitor.py` v1.3, sha256 `bb532da8c4f01b98eab4034ce74dc76b0e3939508bfd6cadd5d3d650020449f8`; v1.2 preserved at `/root/troupe-verify/q37/troupe_pipe_monitor.py.v1.2.bak` (`ce3950b5…`), reversible with one `cp`; record `recoveries/monitor-identity-census.md`.		826	0
+Q43	The legs run the rewritten subject: prevention, not detect-and-restore	DONE — `recoveries/helm-leg-sandbox.md` (13,561 B), Merlin, 2026-10-12. Scratch tree `/root/crucible/q43/`; nothing deployed, no `cp` into `/root/.helm/bin/`, `decisions/` and `inbox/` untouched.		37	0
+Q43 closure	closure — verified from this host by the pipe (2026-10-12, reply 27)	VERIFIED AND CLOSED from the pipe, 2026-10-12 18:5x–19:1xZ.** Finished by `0fb8b20` (deliverable + queue block + Run 9 check-in section) and `2ddbe68` (landing evidence); verified by `replies/2026-10-12-to-merlin-27.md` with the pipe's own harness `/root/crucible/q43z/timmy_verify_q43.py` (reads Merlin's tree, writes nothing into `/root/crucible/q43/`). Adoption is unchanged and stays Alexander's: subject `4e45021d…` + gate `c22601ec…`, nothing `cp`ed, deployed bin still `ee0b36a8…` / `7ed1bca8…` / `5c67473d…`.		20	1
+Q44	The pin class: redirect every constant composed from the live data root, not only `SNAPSHOT_PATH`	DONE 2026-10-12 — `recoveries/helm-root-redirect.md` (Merlin, Helm lane); the closure block is at the foot		543	0
+Q48	The runtime-resolution redirect: close the class Q45's literals cannot see	DONE 2026-10-13 — `recoveries/helm-runtime-redirect.md` (Merlin, Helm lane), scratch tree		119	0
+Q49	The runtime-resolved root's live write path: name it, reproduce it, then close it	open and unclaimed. Opened by the pipe 2026-10-13**, because the Helm lane's executable set is empty		767	0
+Q45	§9 follow-on — the home-directory channel	OPEN — awaiting Alexander's zoom/whole-shop answer; build is the pipe's.** Evidence paths: `/var/www/leathermint/v2/index.html` (+ `phaser.min.js`), ledger commit `58e7eaa` (15:25:39Z) holding the verification record; queue index re-rendered in that same commit. No issue, PR, release or deploy surface beyond this static path; no secret printed.		3105	0
+Q57	Bind a standup entry to the bytes it grades	open and unclaimed. Opened by the pipe 2026-10-24; null's lane.		32	0
+Q58	The lane-activity instrument reads a surface that was retired on 2026-10-16	closed at `809466f` (2026-10-26, spark in sol's lane); the closure record sits at the foot of this file.** Opened by the pipe 2026-10-24.		45	0
+Q59	beam's jump hash matches the C reference, and not one test would notice if it stopped	open and unclaimed. Beam's lane.		50	0
+Q60	Every truncated identifier in the archive: which ones can still be checked	open and unclaimed.** Opened by the pipe 2026-10-24. Anyone's lane; zephyrus has first		59	0
+Q61	beam's `topo_sort` drops generator dependencies, and its gate imports a copy outside the repo	open and unclaimed.** Opened by the pipe 2026-10-24. beam's lane by authorship; anyone may take it.		55	0
+Q62	147 committed gates read `/root/.hermes/wizard-outputs`; two of them cannot pass from a clone	open and unclaimed.** No lane owns it by authorship; anyone may take it, one file per commit.		47	0
+Q63	Six committed verifiers print PASS while asserting nothing, and eight are run by no gate	open and unclaimed.** No lane owns it; anyone may take it, one file per commit.		290	0
+Q66	beam's `search_count` advertises overlapping occurrences and no test would notice if it stopped	closed at `2d6cf69` (2026-10-26, beam); the closure record sits at the foot of this file.** Beam's lane by authorship; the remedy was one assertion,		33	0
+Q67	forge's probe-refactor verifier certifies a refactor that restores the defect it removes	open and unclaimed.** Forge's lane by authorship; the remedy is four small edits		62	0
+Q68	beam's `topo_levels` drops a one-shot `edges` iterable, silently, and its new suite both certifies a host copy and takes the lane's gate down	closed at `5a43291` (volt, 2026-10-25); the closure record sits at the foot of this file.** Beam's lane by authorship; anyone may take it. Done means: `edges`		74	0
+Q69	116 committed files under `wizard-work/` name the absolute path `/root/troupe-standup`, so 64 gates grade the author's working tree instead of the checkout they were asked about	open and unclaimed.** One file per commit, each needing the repo-relative-or-stated decision; `wizard-work/ledger` is the entry to take first because its artifact is otherwise correct and its gate is the one measured green-on-wrong.		32	0
+Q70	beam's `test_trie.py` is invisible to the lane gate (73 new lines, 0 cells collected), and `count_prefix` is a lifetime insert counter that survives `delete`	closed at `12f956a` (volt, 2026-10-26) — closure record at the foot of this file.** Beam's lane by authorship; anyone may take it. Evidence: `replies/2026-10-25-to-zephyrus-102.md` §2; probes `/root/.hermes/cache/scratch/trie_probe.py`; clone `/root/tcheck-q68` at `dbc2c4f`. Nothing from `inbox/` is quoted. No other lane's file was edited.		13	0
+Q71	ledger's `commits-table.md` has no verifier, and row 4 writes `kernel_git` where the source URL has `kernel/git`	closed at `b9e3780` and the closure commit (volt, 2026-10-25); the closure record sits at the foot of this file.** Ledger's lane by authorship; anyone may take it. Evidence: `replies/2026-10-25-to-zephyrus-102.md` §3; response body retained at `/tmp/torvalds.json` on this host (re-fetchable, one request). Nothing from `inbox/` is quoted. No other lane's file was edited.		21	0
+Q72	sphinx's lcmm ledger gates its quotations but not its population or its interpretations: two mutations of mine pass the verifier at 169/169 and 139/139	open and unclaimed.** Sphinx's lane by authorship; anyone may take it. Evidence: `replies/2026-10-26-to-zephyrus-104.md` §2–§3; clone `/root/.hermes/cache/scratch/lcmm-v2` at `d6a9253`; mutation harness `/root/.hermes/cache/scratch/lcmm_mut.py` with trees `lcmm-mut/{A_drop3,B_swap,C_role,D_fig}`; independent claim/byte check `lcmm_indep.py`; verifier log `lc-verify.log` (169 lines), battery log `lc-mut.log`; error bodies `atom-live.xml` (14 B), `atom-full-live.xml` (126 B). Nothing from `inbox/` is quoted. No other lane's file was edited.		40	0
+Q72 #2	verified from this host by the pipe (2026-10-26, reply 105)			9	0
+Q73	sphinx's longctx archive gates its numbers and its claim-scoped quotations, but not its prose numbers, its claim sentences, its README, or the quotations that carry no claim id	open and unclaimed.** Sphinx's lane by authorship; anyone may take it. Evidence: `replies/2026-10-26-to-zephyrus-105.md` §2–§3; export `/root/.hermes/cache/scratch/lcx1/cloneA`; verify log `lcx1/verify_full.txt`; live re-fetch `lcx1/live_ids.xml` (403,802 B); harness `lcx1/mut.py`, trees `lcx1/mut/{A_prose_number,B_claim_prose,C_readme,D_quote_unclaimed,E_drop_papers,F_swap_quotes,H_fabricated}`, log `lcx1/mut_log.txt`. Nothing from `inbox/` is quoted. No other lane's file was edited.		49	0
+Q74	sol's triage CHECK certifies the host `_triage` copy and asserts today's freshness, so it cannot gate the committed artifact	open and unclaimed.** Sol's lane by authorship; anyone may take it. Evidence: export `/root/.hermes/cache/scratch/q58x` (`git archive 809466f`, no `.git`), fixtures `q58x/fix`, transcripts of the four runs in the Q58 closure record above. Nothing from `inbox/` is quoted. No other lane's file was edited.		25	0
+Q75	ledger's two census TSVs carry seven lines that are not rows and one path no file on disk has, and no gate in the lane can see either	open and unclaimed.** Ledger's lane by authorship; anyone may take it. Evidence: readback of both files in Python against an `os.walk` of `/root/troupe-standup/wizard-work` at 2026-10-26 ≈09:30Z, `check_ledger_extract.py` rc 0, `grep -rn CHECK-wizardwork-census` (one hit, the docstring). Ledger's files by authorship; read, not edited. Nothing from `inbox/` is quoted. No other lane's file was edited.	b82b023	13	0
+Q76	beam's new median tests reach no gate, and the lane gate that would run them is red for a host path older than the commit	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: reply 110 §1–§3; export `/root/.hermes/cache/scratch/t110/export` (`c3ce8dd`) and `…/t110/pre` (`c3ce8dd^`); transcripts `/tmp/t110_check_masked_after.txt` and `…_masked_pre.txt` (rc 0, `Ran 151 tests`, both), `/tmp/t110_check_after.txt` and `…_pre.txt` (rc 1, ImportError at line 29); mutant battery `t110/mut.py` → `t110mut/` (8 trees, 8 killed); oracles `t110/fuzz.py`, `t110/fuzz2.py`. Nothing from `inbox/` is quoted. No other lane's file was edited.	c3ce8dd	40	0
+Q77	beam's segment tree lands 100 lines and the lane's count does not move, its failure path reports as an import `SystemExit` rather than a cell, and out-of-range indices are silently clamped	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: reply 112 §1; lane		81	0
+Q78	spark's `3d72f9d` deletes the Q63 `_check()` failure path from four verifiers and drifts five ledger rows, and the new email-validator suite imports a host path		3d72f9d	49	0
+Q79	beam's `manifest.py` lands 107 lines with no cell in any gate, cannot see a directory symlink, reads its own output as a tamper, and prints a green empty manifest for a root that does not exist	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: reply 116 §2–§4;	edac5cf	59	0
+Q79 closure	closure — manifest.py carries the lane's 0/1/2 contract, three blind spots are closed, and 17 cells now sit in the gate	DONE at `f719428` (manifest.py), `25e88f8` (canonical naming), `36ce415` (test_manifest.py); this record and `docs/queue-index.md` land in the commit above it.** The opening record's own text is quoted in a code span above so this line opens nothing.		15	1
+Q80	spark's `json_sha256_validator.py` prints a hash of bytes it never validated, admits `NaN`/`Infinity` as valid, and reports an unreadable input in the same code as a bad document	open and unclaimed.** Spark's lane by authorship; anyone may take it. Evidence: reply 118 §1–§3,	3081128	52	0
+Q81	spark's `hermes_profile_health.py` grades a profile by the existence of names, hardcodes the one host path it can check, and carries a branch that cannot fire	open and unclaimed.** Spark's lane by authorship. Evidence: reply 118 §4; probes	3081128	42	0
+Q82	beam's `test_json_canonical.py` prints `ALL PASS` without running a single assertion, and the lane's count does not move at the head that lands it	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: measured at	3081128	38	0
+Q82 closure	closure — `test_json_canonical.py` is seven discoverable cells (lane gate 191 → 198), every cell is killed by a named mutant, and `json_canonical.py` says what it is not	DONE at `0735102` (suite), `6c097bf` (float surface); this record and `docs/queue-index.md` land in the commit above it.** The opening record's own `Status: open and unclaimed.` line is left standing, as append-only discipline requires; the closure is this line, not an edit above it.		28	1
+Q81 closure	closure — `hermes_profile_health.py` grades a profile you name, parses the config it grades, and the lane gate collects nine cells	DONE at `3f424c0` (tool), `329af8b` (suite + gate leg); this record and `docs/queue-index.md` land in the commit above them.** The opening record's own `Status: open and unclaimed.` line is left standing, as append-only discipline requires; the closure is this line, not an edit above it.		42	1
+Q83	five branches `hermes_profile_health.py` names are pinned by no cell, and one of them is the branch that produces the sweep's only red	open and unclaimed.** Spark's lane by authorship. Evidence: reply 119 §2; mutants and behaviour probes `/root/.hermes/wizard-outputs/ledger/q81_mutants_mine.py` (13 trees, incl. the M0–M8 reproduction) and `/root/.hermes/wizard-outputs/ledger/q81_survivor_probe.py` (the five rows, baseline rc vs mutant rc vs suite rc), results `/root/.hermes/wizard-outputs/ledger/q81-mutant-battery-mine.json`. Nothing from `inbox/` is quoted; no file another party authored was edited.	829268f	19	0
+Q84	`interval_overlap.py` lands 87 lines with no cell, and the lane gate reads `Ran 202` before and after	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: reply 120 §1–§3;	517362f	52	0
+Q83 closure	closure — the five unpinned `hermes_profile_health.py` branches are five cells (spark gate 9 → 14), and the item's own first row is corrected	DONE at `fe09917`; this record and `docs/queue-index.md` land in the commit above it.** The opening record's own `Status: open and unclaimed.` line is left standing, as append-only discipline requires; the closure is this line, not an edit above it. Report: `/root/.hermes/wizard-outputs/volt/q83-report.md`.		27	1
+Q85	`beam/CHECK` collects only `test_*.py`, so a module no cell imports lands invisible: four are in that state today, and the newest added 38 lines with the gate reading `Ran 214` before and after	open and unclaimed.** Beam's lane by authorship. Evidence: reply 121 §3–§4; independent checks `/root/.hermes/cache/scratch/q83m9/` (the Q83 M9 mutant tree) and the reply-121 scripts in this repo's history. Nothing from `inbox/` is quoted; no file another party authored was edited.	083981e	19	0
+Q86	the refactor-lane harness proves silence, not absence of I/O, and its seed path is host-absolute, so a second checkout cannot re-verify the refactor	DONE at `802a1ae`; this line and the two items appended at the end of this file (Q89, Q90) land in the commits above it.** The opening `Status: open and unclaimed.` line and reply 124's "four of six files remain" are left standing, append-only; both are stale as of `802a1ae` and this line supersedes them. Re-measured by the pipe at `6e9aeee`, not read off volt's transcript: probe pair **14/14**, dump pair **14/14**, pending pair **13/13**, all rc 0; `grep -c '/root/troupe-standup/inbox'` across the six files **`0, 0, 0, 1, 1, 1`**, the three survivors being the harnesses' `HOST_SEED_LITERAL` (used only to assert the *original* keeps the smell); my own M6 on `_triage_probe_refactored.py` in a scratch clone → **13/14, rc 1**, `FAIL: static io-call(s) at module scope: [(57, 'json.load'), (57, 'open')]`. **The residual is not closed and is not a re-opening of this item:** the detector is a static name list (`verify_triage_probe_refactor.py:404-407`) plus a `builtins.open` spy, so a module-scope `Path(...).read_text()` appended to the refactored module still returns **14/14, rc 0** with `OK: no import-time I/O` — filed as Q89, because this item's own done-means (builtins.open wrapper *or* AST walk of the module body) is met by `802a1ae` and moving its goalposts now would be a different item wearing the old number.	431bca1	22	0
+Q87	the forge lane holds 34 `verify_*.py` and no `CHECK`; `tools/verify.py`'s eight legs reach none of them	open and unclaimed.** Forge's lane by authorship; anyone may take it. Evidence: reply 21 §4; `ls wizard-work/forge/verify_*.py | wc -l` = 34, `ls wizard-work/forge/CHECK` = absent, at `431bca1`. Nothing from `inbox/` is quoted.	431bca1	15	0
+Q88	the census `CHECK` verifies the live `checkins/` directory and the TSV only, so a dated artifact goes red on the next check-in and stays green under a hand-edited per-wizard table	open and unclaimed.** Ledger's lane by authorship; anyone may take it. Evidence: reply 122 §2; scratch tree `/tmp/censusbomb` (copy, CHECK re-run at `b0a2886`, both measurements above). Nothing from `inbox/` is quoted; no file another party authored was edited.	b0a2886	16	0
+Q89	the import-time-I/O detector in the three forge harnesses is a name list, so a `pathlib` read at module scope passes every check green	open and unclaimed.** Forge's lane by authorship; anyone may take it. Evidence: reply 125 §0 and §1; scratch clone `/tmp/q86evade` (both evasions above, run from a copy, no repo file edited). Nothing from `inbox/` is quoted.	6e9aeee	22	0
+Q90	beam's `find_tree_root` accepts any ancestor marker as the repo root, `portable_seed` never checks the seed exists, and the six cells that would notice reach no gate	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: reply 125 §1; scratch dirs `/root/.hermes/cache/scratch/beamguard/` (the five variant table) and the `/tmp/tmp*` decoy/symlink constructions in that reply; gate counts measured at `6e9aeee` in the worktree. Nothing from `inbox/` is quoted; no file another party authored was edited.	6e9aeee	18	0
+Q91	forge's r41 pixel-diff verifier prints PASS when neither card writes anything, and it writes the delivery artifact		d56105a	13	0
+Q92	spark's two new scripts grade the caller's working directory, and one carries dead code after `sys.exit`		d56105a	17	0
+Q93	the sweep's malformed-input probe grades a phrase, so two correctly-refusing tools keep it red, and the leg's summary line says "0 fatal" while returning 1		d56105a	18	0
+Q94	`dsu_rollback.py`'s headline mechanism is graded by no cell, its compression cell does not grade compression, and `find`/`union` accept negative indices silently		1e79fc8	130	0
+Q60 closure	closure — the check half runs at a named head, the self-quote collapse and the placeholder refusal are measured, and the two instrument holes it leaves are named instead of smoothed	DONE at `33f8f0f` (`wizard-work/zeph/q60_enforce.py`, blob `4b3926332b5aab4a83f599815fd677bc230e17ad`); this record lands in the commit above it.** Re-verified here from a fresh anonymous clone at that head, run from outside the tree: `--selftest` **7 cells passed, 0 failed, rc 0**; full tree **`OCC=110 DISTINCT=22 FILES=29`, `VERDICT=PASS`, rc 0, zero FAIL lines**; the three former FAIL sites (`WORK-QUEUE.md`, reply 113, reply interview) print `TEST-FIXTURE … (len 36)` with their site and do not fail; the anonymous raw GET is byte-identical (`cmp` clean, 14,374 B). Four probes on copies outside the repo: (A) `run_check` gutted to `return ["VERDICT=PASS"], False` reds cell 1 — the positive control is real; (B) the fixture value written into a new file prints `TEST-FIXTURE` and passes rc 0, the residual zephyrus named himself; (C) a real full value under the exhausted stem `beae0b1f` still reads `UNRECOVERED-JUSTIFIED` with rc 0; (D) a fixture literal appended to the checker's own source leaves `--selftest` at **7/7 rc 0** and the self-scan printing `TEST-FIXTURE … at q60_enforce.py`.	33f8f0f	7	1
+Q95	beam's `find_duplicate` no-duplicate guard cannot fire, and the file has no cell in any gate	open and unclaimed.** Beam's lane by authorship; anyone may take it. Evidence: reply 130 §4; the exhaustive sweep and the import count are re-runnable as written there. Nothing from `inbox/` is quoted; no file another party authored was edited.	f400640	11	0
+Q96	`q60_enforce.py`'s self-scan cannot see a fixture literal in its own source, and an exhausted stem can never flip to recovered	open and unclaimed.** Zeph's lane by authorship; anyone may take it. Evidence: reply 130 §1 probes C and D, `/root/.hermes/cache/scratch/q60probe/`. Nothing from `inbox/` is quoted.	33f8f0f	28	0
+Q93 closure	closure — the malformed axis grades a contract now, the two false reds are gone, and the replacement contract has a hole the prose pin did not	DONE at `9878f12` (`tools/selftest_sweep.py`, blob `c710643cbf888140d0bf834e89aecaaa607117cc`, 68,216 B); this record lands after it.	d56105a	19	1
+Q97	a contract-graded refusal accepts an argparse usage error, so a renamed flag turns the whole malformed axis green	open and unclaimed.** Anyone may take it; the shape is `tools/selftest_sweep.py`'s and forge's lane by authorship, so it goes to forge first if forge wants it.	9878f12	22	0
+Q98	seven committed test files resolve their module from a path outside the repo, and the class guard Q61 promised was never written	open and unclaimed.** Beam's lane by authorship for the first row, spark's for the next five, ledger's for the last; anyone may take it, and a scan cell is the point rather than seven edits.	5886bdd	741	0
+Q125	the spark lane holds eleven line/word/char counters, and the newest one replaced its predecessor's capabilities without retiring its verifier	open and unclaimed.** Opened after reply 15's consolidation request (2026-10-22, `62e3f33`) went six days without a contract behind it; this item is that contract. Reply 15 named five word counters plus `file_analyzer.py`; the population went up, not down.	6b5197b	197	0