[FIX] The jurist's three conditions on the rejection log, made structural; §9 fix corrected

CONDITION 1, and it is the one that had to stop being an intention: log_rejection()
refuses an empty `why`, and acceptable() returns an empty `why` EXACTLY when the line
passed. So there is no call site from which an accepted line could be written — logging
one would require inventing a violation it does not have. The same guarantee render()
takes from its signature, applied to the clause the jurist named as the condition under
which this log is not a §9 breach. Both polarities asserted.

CONDITION 2: deletion tracked as its own DEFERRED-DECISION on 2026-09-08, so retaining
it requires an act rather than an omission. A corpus of suppressed speech would let
someone reconstruct a register — the hazard PENDING-153's freeze exists to prevent.

CONDITION 3: not read for content before then. ⚠ Not clean already, and the item says so:
the executor displayed one rejected line to the steward earlier today, before the
condition existed. Disclosed rather than left to be discovered.

⚠ THE §9 [FIX] WAS OVER-APPLIED AND THE EXECUTOR APPLIED IT AS GIVEN. The clause is a
disjunction with one live branch; only the jurist half is unreachable. The first edit
struck the whole thing and rewrote the clause. A [FIX] tag licenses implementing
directly; it does not license implementing UNREAD, and the disjunction was visible in a
three-word span. Corrected, both versions left visible.

PENDING-159 AMENDMENT 2 files the jurist's answer to the item's own caveat and the
narrowing it produces: the marker may be NOTED, NEVER COUNTED — an aggregate becomes a
measurement, and a measurement invites accuracy. And PENDING-89 now carries the sentence
saying what it can and cannot expect: individual instances, unaggregated, in unknown
proportion, non-neutral — therefore NO correlation statistic. If its falsifier needs a
rate, it needs another instrument or an honest admission that it has none.

125 controls across five scripts.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J6hZXNYSxEfZseBGTni4sf

scripts/tarbuckle-mumble.py

@@ -90,6 +90,44 @@ def muted() -> str:
         return ""
 
 
+def log_rejection(why: str, line: str, surface: str = "") -> None:
+    """The rejection log. ⚠ STRUCTURALLY UNABLE TO RECORD AN ACCEPTED LINE.
+
+    Jurist ruling, 2026-08-25, on whether this log breaches §9's "filed nowhere":
+
+        "The rejection log is a log of my instruction, not of Tarbuckle... The rejected
+         lines were never uttered: he was silent, and the log holds what silence cost.
+         Nothing there entered the room... the fool cannot be cited from it because
+         there is nothing to cite — only material the net suppressed.
+         THE CONDITION: the log holds rejections only. If it ever holds an accepted
+         line, that is filing, straightforwardly, and §9 is breached."
+
+    Made structural rather than intentional, as the ruling asked. `why` is acceptable()'s
+    violation reason, and it is EMPTY EXACTLY WHEN THE LINE PASSED. Refusing an empty
+    `why` means no call site exists from which an accepted line could be written: to log
+    one you would have to invent a violation it does not have. Same guarantee render()
+    takes from its signature — a function that cannot be handed the thing it must not
+    see.
+
+    ⚠ TEMPORARY. Deleted on 2026-09-08 with the fortnight's report, per the same ruling:
+    "a permanent store of rejected lines is a corpus, and a corpus of his suppressed
+    speech is exactly what would let someone reconstruct a register." Tracked as a
+    DEFERRED-DECISION so it cannot be quietly retained.
+
+    ⚠ NOT READ FOR CONTENT BEFORE THEN. Reading it as it accumulates is reading Tarbuckle
+    by the back door and would shape the net toward lines the reader happens to like.
+    """
+    if not why:
+        return                      # an accepted line has no reason; there is no path
+    try:
+        with open(REJECTS, "a") as fh:
+            fh.write(json.dumps({"t": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
+                                 "kind": surface, "why": why,
+                                 "line": line[:200]}) + "\n")
+    except Exception:
+        pass
+
+
 def _grams(text: str, n: int) -> set:
     w = re.findall(r"[a-z']+", text.lower())
     return {" ".join(w[i:i + n]) for i in range(len(w) - n + 1)}
@@ -260,12 +298,7 @@ def main() -> int:
         if echo:
             ok, why = False, f"recited the soul: {echo!r}"
     if not ok:
-        try:
-            with open(REJECTS, "a") as fh:
-                fh.write(json.dumps({"t": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
-                                     "kind": kind, "why": why, "line": line[:200]}) + "\n")
-        except Exception:
-            pass
+        log_rejection(why, line, kind)
         log_event(kind, "rejected")
         return 1                      # silence. The draw was already consumed.
     try:
@@ -279,6 +312,8 @@ def main() -> int:
 
 
 def selftest() -> int:
+    global MUTE, REJECTS
+    import tempfile
     checks, failed = [], []
 
     def ck(name, cond):
@@ -333,8 +368,6 @@ def selftest() -> int:
     ck("A4 material paths are session/soul only",
        not any(("PENDING" in q or "REVIEWED" in q) for q in paths))
     # A5 — the mute switch, and that every surface must be able to see it.
-    import tempfile
-    global MUTE
     _m = MUTE
     MUTE = os.path.join(tempfile.mkdtemp(), "mute")
     try:
@@ -361,6 +394,22 @@ def selftest() -> int:
        not echoes_soul("Second surface you've found for the same voice.", _soul))
     ck("A7n passes an ordinary short observation",
        not echoes_soul("Third one that's held together with a name.", _soul))
+    # A8 — THE JURIST'S CONDITION, structural. An accepted line has no `why`, so there
+    # is no call from which it could be written.
+    _r = REJECTS
+    REJECTS = os.path.join(tempfile.mkdtemp(), "rej.jsonl")
+    try:
+        log_rejection("", "an accepted line, offered to the log", "test")
+        ck("A8 an accepted line CANNOT be logged", not os.path.exists(REJECTS))
+        log_rejection("12 words", "a rejected line", "test")
+        ck("A8n a rejected line IS logged", os.path.exists(REJECTS))
+        ck("A8n the predicate can fail",
+           "a rejected line" in open(REJECTS).read())
+        log_rejection("", "a second accepted line", "test")
+        ck("A8 accepted lines never appear",
+           "second accepted" not in open(REJECTS).read())
+    finally:
+        REJECTS = _r
     ck("A6n it cannot be handed a line",
        "line" not in log_event.__code__.co_varnames)
     ck("A4n the predicate can fail",