test(ledgers): enforce unique DISC ids and the expanded negative-evidence outcomes

Harden `scripts/check_ledgers.py` so the two ledger-integrity invariants that
the accompanying doc changes rely on are machine-checked, not just conventions.

check_negative_evidence: the entry regex previously hard-coded
`WIN|NEGATIVE(reverted)` in the outcome group, which silently skipped any row
using a different label. Capture the outcome generically and validate it against
the allowed set {WIN, PROVISIONAL_LOCAL_WIN, NEGATIVE(reverted),
NEGATIVE(retained-for-proof)}, emitting a per-entry `negative-outcome` check and
failing on anything else. This locks in the taxonomy just added to
docs/NEGATIVE_EVIDENCE.md and stops an unrecognized outcome from being counted.

check_discrepancies: capture each `## DISC-<n>:` heading id and add a
`disc-id-unique` check that fails on any duplicate id — the exact regression
(two DISC-004 entries) that was just repaired in docs/DISCREPANCIES.md. Guards
the ledger against a silent id collision recurring.

Both are additive validators over the existing checker structure; no other
behavior changes.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Dicklesworthstone

scripts/check_ledgers.py

@@ -228,13 +228,31 @@ def check_negative_evidence(path: Path, text: str, failures: list[str]) -> None:
     unfenced = strip_fenced_blocks(text)
     entries = list(
         re.finditer(
-            r"^(?P<date>\d{4}-\d{2}-\d{2}) \| (?P<outcome>WIN|NEGATIVE\(reverted\)) \| (?P<lever>.+)$",
+            r"^(?P<date>\d{4}-\d{2}-\d{2}) \| (?P<outcome>[^|]+?) \| (?P<lever>.+)$",
             unfenced,
             flags=re.MULTILINE,
         )
     )
     emit("negative-entry-count", True, count=len(entries))
 
+    allowed_outcomes = {
+        "WIN",
+        "PROVISIONAL_LOCAL_WIN",
+        "NEGATIVE(reverted)",
+        "NEGATIVE(retained-for-proof)",
+    }
+    for entry in entries:
+        outcome = entry.group("outcome")
+        allowed = outcome in allowed_outcomes
+        emit(
+            "negative-outcome",
+            allowed,
+            line=unfenced.count("\n", 0, entry.start()) + 1,
+            outcome=outcome,
+        )
+        if not allowed:
+            failures.append(f"{path}: unsupported negative-evidence outcome {outcome!r}")
+
     required_fields = [
         "claim_id:",
         "evidence_id:",
@@ -289,11 +307,18 @@ def check_negative_evidence(path: Path, text: str, failures: list[str]) -> None:
 
 def check_discrepancies(path: Path, text: str, failures: list[str]) -> None:
     unfenced = strip_fenced_blocks(text)
-    headings = list(re.finditer(r"^## DISC-\d+:", unfenced, flags=re.MULTILINE))
+    headings = list(re.finditer(r"^## (?P<id>DISC-\d+):", unfenced, flags=re.MULTILINE))
     emit("disc-entry-count", True, count=len(headings))
     if not headings:
         return
 
+    ids = [heading.group("id") for heading in headings]
+    duplicates = sorted({identifier for identifier in ids if ids.count(identifier) > 1})
+    unique = not duplicates
+    emit("disc-id-unique", unique, duplicates=duplicates)
+    if not unique:
+        failures.append(f"{path}: duplicate discrepancy IDs: {', '.join(duplicates)}")
+
     required_fields = [
         "- claim_id / evidence_id:",
         "- Provenance (model commit + fixture hash):",