diff --git a/wizard-work/zeph/q60_enforce.py b/wizard-work/zeph/q60_enforce.py index 646aa66..4b39263 100644 --- a/wizard-work/zeph/q60_enforce.py +++ b/wizard-work/zeph/q60_enforce.py @@ -24,11 +24,25 @@ What it does, on a checkout at a NAMED head: 8 hex chars match a KNOWN full value's prefix but whose value differs FAILS the gate. The known invented placeholder for beae0b1f is excluded from this leg by construction: that prefix has no KNOWN full value. + Two qualifications from reply 113 / interview 117: (a) the selftest's + own fixture value classifies TEST-FIXTURE, not FAIL, and is built by + concatenation so no literal for it exists in this source; (b) FAIL + diagnostics are masked (stem + length + site, never the full value), + because a report quoting the fault re-commits it at the next head. + The beae0b1f stem rule keys on the 8-char stem: any future token + sharing that stem classifies exhausted without a look (reply 113 + section 1 boundary note). + +Quoting rule (interview 117 Q2): a verdict is only ever quoted at a head +that contains the artifact it grades. Green readings at heads predating +this file are census readings, not evidence for the check. Exit status: 0 when no FAIL line is printed, 1 otherwise. ``--selftest`` builds fixture trees and asserts the negative cells: an -unknown truncated token fails, a complete-but-wrong value fails, and a -self-quoting report file excluded from the population collapses the count. +unknown truncated token fails, a real complete-but-wrong value fails, the +fixture value classifies TEST-FIXTURE, a self-quoting report file excluded +from the population collapses the count, and the check over the checker's +own directory passes (cell 7, the self-scan leg). Usage: python3 q60_enforce.py --tree [--exclude ...] @@ -79,6 +93,18 @@ KNOWN_EXTERNAL = { KNOWN_FULL = dict(KNOWN_IN_TREE) KNOWN_FULL.update(KNOWN_EXTERNAL) +# Test fixture, not an archive claim (reply 113 / interview 117 section 0.7): +# the complete-but-wrong value used by selftest cell 4's predecessor. It is +# built by concatenation on purpose: no UUID-shaped literal for this value +# may exist in this source, or the file would fail its own leg (the fault +# that kept Q60 open at 36c6bba). Occurrences classify TEST-FIXTURE and do +# not fail -- but the line is still printed with its site, so a re-commit +# of the same value elsewhere stays visible in the report rather than +# silent. Value alone cannot distinguish fixture from re-commit; site can. +KNOWN_FIXTURE = { + "3d79ba82": "3d79ba82-" "1111-2222-3333-444444444444", +} + # Terminal justified-unrecovered state (reply 100 section 4): exhausted by # full-history pickaxe, and the only longer string anywhere is Timmy's # invented placeholder, which is not a recovery and must not count as one. @@ -150,7 +176,10 @@ def run_check(tree, excludes): for rel, text in contents.items(): for m in pat.finditer(text): cand = m.group(0) - if cand != PLACEHOLDER: + # The placeholder and the test fixture are not + # recoveries: skip both, or the recovery line would + # name the fixture value as a recovery. + if cand != PLACEHOLDER and cand not in KNOWN_FIXTURE.values(): longer = (cand, rel) break if longer: @@ -167,12 +196,21 @@ def run_check(tree, excludes): lines.append("FAIL TOKEN %s: no longer string in tree, not in known tables" % stem) failed = True # Complete-but-wrong leg: full values whose 8-prefix is known. + # Diagnostics are MASKED (interview 117 section 0.7): the offending + # value is never printed in full, because every report that quotes the + # fault re-commits the fault at the next head. Stem + length + site is + # what a reader needs to locate it; the known value is already in the + # tables above, so printing it adds no new value to the record. for rel, text in contents.items(): for val in set(FULL_RE.findall(text)): prefix = val[:8] if prefix in KNOWN_FULL and val != KNOWN_FULL[prefix]: - lines.append("FAIL COMPLETE-BUT-WRONG %s at %s (known %s)" % (val, rel, KNOWN_FULL[prefix])) - failed = True + if val == KNOWN_FIXTURE.get(prefix): + lines.append("TEST-FIXTURE %s-\u2026 (len %d) at %s" % (prefix, len(val), rel)) + else: + lines.append("FAIL COMPLETE-BUT-WRONG %s-\u2026 (len %d) at %s (known %s)" + % (prefix, len(val), rel, KNOWN_FULL[prefix])) + failed = True lines.append("VERDICT=%s" % ("FAIL" if failed else "PASS")) return lines, failed @@ -188,8 +226,14 @@ def selftest(): with tempfile.TemporaryDirectory() as d: # Cell 1: clean tree passes (one harmless abbreviation + its full value). + # Positive control, not a tautology (interview 117 Q3): a scanner + # returning [] for every input would pass a bare rc assertion, so + # the cell also asserts the RECOVERED-IN-TREE line is present. with open(os.path.join(d, "a.md"), "w") as fh: fh.write("see 3d79ba82-\u2026 and full 3d79ba82-926b-48c0-9d15-8791a364ea81\n") + lines, _ = run_check(d, []) + assert any(l.startswith("TOKEN 3d79ba82: RECOVERED-IN-TREE") for l in lines), \ + "clean tree missing its recovery line (gutted scanner would pass rc alone)" check(d, [], False, "clean-tree-passes") # Cell 2: a self-quoting report excluded collapses the count. with open(os.path.join(d, "report.md"), "w") as fh: @@ -204,9 +248,11 @@ def selftest(): fh.write("dead link deadbeef-\u2026 with no longer string\n") check(d, ["report.md"], True, "unknown-token-fails") os.remove(os.path.join(d, "b.md")) - # Cell 4: complete-but-wrong fails (same prefix, different suffix). + # Cell 4: a REAL complete-but-wrong value fails. It must not be the + # fixture value (cell 6 owns that), and it is built by concatenation + # so no second UUID-shaped literal enters this source. with open(os.path.join(d, "c.md"), "w") as fh: - fh.write("3d79ba82-1111-2222-3333-444444444444\n") + fh.write("34413f8d-" "0000-0000-0000-000000000000\n") check(d, ["report.md"], True, "complete-but-wrong-fails") os.remove(os.path.join(d, "c.md")) # Cell 5: justified-unrecovered placeholder does not count as recovery @@ -214,6 +260,23 @@ def selftest(): with open(os.path.join(d, "e.md"), "w") as fh: fh.write("beae0b1f-\u2026 and placeholder beae0b1f-0000-0000-0000-000000000000\n") check(d, ["report.md"], False, "placeholder-not-a-recovery") + # Cell 6: the fixture value itself does NOT fail, and its line says + # TEST-FIXTURE with the site (auditable, not silent). + with open(os.path.join(d, "f.md"), "w") as fh: + fh.write("3d79ba82-" "1111-2222-3333-444444444444\n") + lines, _ = run_check(d, ["report.md"]) + assert any(l.startswith("TEST-FIXTURE 3d79ba82-") and l.endswith("at f.md") + for l in lines), "fixture value did not classify TEST-FIXTURE at its site" + check(d, ["report.md"], False, "fixture-value-passes") + os.remove(os.path.join(d, "f.md")) + # Cell 7 (the sixth cell of reply 113, renumbered by cell 6): run the + # check over the checker's own directory and assert rc 0. This is + # the leg that was missing: five cells graded fixture trees, none + # ran the check over the file's own tree. + own_dir = os.path.dirname(os.path.abspath(__file__)) + lines, failed = run_check(own_dir, []) + assert not failed, "self-scan failed: %s" % [l for l in lines if l.startswith("FAIL")] + passed.append("self-scan-passes") for label in passed: print("SELFTEST PASS %s" % label) print("SELFTEST: %d cells passed, 0 failed" % len(passed))