From f17c9367ef61b52cf0e5c494fad50b64f380db1e Mon Sep 17 00:00:00 2001 From: Zephyrus Sparkborn Date: Wed, 28 Oct 2026 13:11:15 +0000 Subject: [PATCH] zeph: Q96 -- absence cell + exhausted-stem recovery in q60_enforce.py --- wizard-work/zeph/q60_enforce.py | 64 ++++++++++++++++++++++++++++++--- 1 file changed, 59 insertions(+), 5 deletions(-) diff --git a/wizard-work/zeph/q60_enforce.py b/wizard-work/zeph/q60_enforce.py index 4b39263..c4873b3 100644 --- a/wizard-work/zeph/q60_enforce.py +++ b/wizard-work/zeph/q60_enforce.py @@ -29,9 +29,14 @@ What it does, on a checkout at a NAMED head: 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). + The beae0b1f stem rule keys on the 8-char stem, narrowed per reply + 130 section 2 / interview 117 section 1.1 (Q96): a truncated token + sharing that stem skips the longer-string look and stays + UNRECOVERED-JUSTIFIED, but a full UUID-shaped value arriving under + that stem is reported RECOVERED with its site. The old, wider rule + (any future token sharing the stem classifies exhausted without a + look) suppressed a genuine recovery; the placeholder itself is still + never a recovery. 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 @@ -41,8 +46,19 @@ 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 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). +from the population collapses the count, the check over the checker's +own directory passes (cell 7, the self-scan leg), the checker's own +source bytes do not contain the concatenated fixture value (cell 8, the +absence cell, Q96), and a full value under the exhausted beae0b1f stem +reports RECOVERED (cell 9, Q96). + +Correction, reply 130 probe D / interview 117 section 1.4: the +2026-10-27 check-in credited cell 7 with proving that no UUID-shaped +literal for the fixture exists in this source. That instrument claim is +refuted -- cell 7 prints TEST-FIXTURE for exactly that occurrence class +and stays green. The property holds today and is proven by ``full value +in source bytes: False``, which cell 8 now asserts every run; cell 7 +proves something else (the check passes over its own directory). Usage: python3 q60_enforce.py --tree [--exclude ...] @@ -184,6 +200,19 @@ def run_check(tree, excludes): break if longer: break + else: + # Q96 narrowing: a truncated token under an exhausted stem + # skips the longer-string look, but a full value that arrives + # under that stem is a recovery, not an exhaustion. The + # placeholder (and the fixture, by symmetry) never counts. + for rel, text in contents.items(): + for val in FULL_RE.findall(text): + if (val[:8] == stem8 and val != PLACEHOLDER + and val not in KNOWN_FIXTURE.values()): + longer = (val, rel) + break + if longer: + break if longer: lines.append("TOKEN %s: RECOVERED-IN-TREE %s at %s" % (stem, longer[0], longer[1])) elif stem8 in KNOWN_EXTERNAL: @@ -219,6 +248,19 @@ def selftest(): """Fixture trees; each cell asserts a behaviour, not a tautology.""" passed = [] + # Cell 8 (Q96 absence cell): the concatenated fixture value must not + # appear in this file's own bytes. The value is assembled here from + # the table, never written as a literal, so a literal re-commit of + # it in this source fails this cell while cell 7 stays green + # (TEST-FIXTURE) -- the two cells red on distinguishable faults. + # Proven both directions by the mutant runs in the landing record: + # clean source -> absent (False); literal-inserted copy -> present. + fixture_value = "".join(KNOWN_FIXTURE.values()) + with open(os.path.abspath(__file__), "rb") as fh: + assert fixture_value.encode("utf-8") not in fh.read(), \ + "fixture value literal present in checker source" + passed.append("source-absence-passes") + def check(tree, excludes, want_fail, label): _lines, failed = run_check(tree, excludes) assert failed == want_fail, "%s: want fail=%s" % (label, want_fail) @@ -269,6 +311,18 @@ def selftest(): 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 9 (Q96 exhausted-stem flip): a full value arriving under + # the exhausted beae0b1f stem reports RECOVERED with its site. + # Built by concatenation, as in cell 4, so no second UUID-shaped + # literal enters this source; the value is Timmy's probe-C value. + with open(os.path.join(d, "g.md"), "w") as fh: + fh.write("beae0b1f-" "9f2c-4d1e-8a77-3c5b6e9d0a11\n") + lines, _ = run_check(d, ["report.md"]) + assert any(l.startswith("TOKEN beae0b1f: RECOVERED-IN-TREE") + and l.endswith("at g.md") for l in lines), \ + "full value under exhausted stem did not report RECOVERED" + check(d, ["report.md"], False, "exhausted-stem-recovers") + os.remove(os.path.join(d, "g.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