psyclaw 0.27.22 → 0.28.0

package/vendor/ars/scripts/test_claim_audit_schema.py

@@ -0,0 +1,1778 @@
+"""Schema-validation tests for v3.8 claim_ref_alignment_audit_agent (T-S1..T-S8).
+
+Per spec §7.1 in
+docs/design/2026-05-15-issue-103-claim-alignment-audit-spec.md.
+
+The test plan section §7.1 lists T-S1..T-S8 keyed to claim_audit_result
+(§3.1) and claim_intent_manifest (§3.2) and uncited_assertion (§3.3).
+§6 lint coverage is broader: it includes claim_drift D-INV-1..4 (§3.4),
+constraint_violation CV-INV-1..4 (§3.5) and audit_sampling_summary
+S-INV-1..4 (§4 step 3). This file follows §6 because that is the lint
+contract under test — drift / constraint-violation / sampling
+invariants get their own pos/neg fixtures alongside INV / M-INV / U-INV
+so the lint's full 38-invariant surface is covered before the agent
+prompt ships in Step 5.
+
+Spec §7 names the test file `tests/test_claim_audit_schema.py`. This
+repo's CI workflows discover tests under `scripts/test_*.py` and the
+30+ existing test files all live there; we honor the repo convention
+and keep the spec name's stem (`test_claim_audit_schema`) so anyone
+greppping the spec lands at the right file.
+
+Run:
+    python -m unittest scripts.test_claim_audit_schema -v
+"""
+from __future__ import annotations
+
+import copy
+import json
+import unittest
+from pathlib import Path
+from typing import Any
+
+from tests.test_helpers import (
+    build_schema_validator,
+    load_json_schema,
+    run_script,
+)
+
+REPO = Path(__file__).resolve().parent.parent
+PASSPORT = REPO / "shared/contracts/passport"
+LINT = REPO / "scripts/check_claim_audit_consistency.py"
+
+SCHEMA_PATHS: dict[str, Path] = {
+    "claim_audit_result": PASSPORT / "claim_audit_result.schema.json",
+    "claim_intent_manifest": PASSPORT / "claim_intent_manifest.schema.json",
+    "uncited_assertion": PASSPORT / "uncited_assertion.schema.json",
+    "claim_drift": PASSPORT / "claim_drift.schema.json",
+    "constraint_violation": PASSPORT / "constraint_violation.schema.json",
+    "uncited_audit_failure": PASSPORT / "uncited_audit_failure.schema.json",
+}
+
+
+# ---------------------------------------------------------------------------
+# Canonical fixture builders. Each helper returns a fresh dict so individual
+# tests can mutate one field without leaking to siblings.
+# ---------------------------------------------------------------------------
+
+MANIFEST_ID = "M-2026-05-15T10:00:00Z-a1b2"
+MANIFEST_ID_OTHER = "M-2026-05-15T10:05:00Z-c3d4"
+SENTINEL_MANIFEST_ID = "M-0000-00-00T00:00:00Z-0000"
+AUDIT_RUN_ID = "2026-05-15T10:10:00Z-9f8e"
+
+
+def supported_entry() -> dict[str, Any]:
+    """Minimal SUPPORTED row — INV-1 positive baseline."""
+    return {
+        "claim_id": "C-001",
+        "scoped_manifest_id": MANIFEST_ID,
+        "claim_text": "Sample preprints accounted for 67% of corpus.",
+        "ref_slug": "smith2024preprints",
+        "anchor_kind": "page",
+        "anchor_value": "12",
+        "judgment": "SUPPORTED",
+        "audit_status": "completed",
+        "defect_stage": None,
+        "rationale": "The cited page reports the 67% figure verbatim.",
+        "judge_model": "gpt-5.5-xhigh",
+        "judge_run_at": "2026-05-15T10:11:00Z",
+        "ref_retrieval_method": "api",
+        "audit_run_id": AUDIT_RUN_ID,
+    }
+
+
+def manifest_entry(
+    manifest_id: str = MANIFEST_ID,
+    *,
+    emitted_by: str = "synthesis_agent",
+    claims: list[dict[str, Any]] | None = None,
+    mncs: list[dict[str, str]] | None = None,
+) -> dict[str, Any]:
+    """Build a minimal claim_intent_manifest entry."""
+    return {
+        "manifest_version": "1.0",
+        "manifest_id": manifest_id,
+        "emitted_by": emitted_by,
+        "emitted_at": "2026-05-15T09:55:00Z",
+        "claims": claims
+        if claims is not None
+        else [
+            {
+                "claim_id": "C-001",
+                "claim_text": "Sample preprints accounted for 67% of corpus.",
+                "intended_evidence_kind": "empirical",
+                "planned_refs": ["smith2024preprints"],
+            }
+        ],
+        "manifest_negative_constraints": mncs or [],
+    }
+
+
+def uncited_assertion_entry() -> dict[str, Any]:
+    """Minimal U-INV-* positive baseline."""
+    return {
+        "finding_id": "UA-001",
+        "sentence_text": "Half of all submissions showed positive results.",
+        "section_path": "3. Results > 3.1 Overview",
+        "trigger_tokens": ["50%", "showed"],
+        "detected_at": "2026-05-15T10:12:00Z",
+        "rule_version": "D4-c-v1",
+    }
+
+
+def claim_drift_entry(*, drift_kind: str = "EMITTED_NOT_INTENDED") -> dict[str, Any]:
+    """Minimal D-INV-* positive baseline."""
+    base: dict[str, Any] = {
+        "finding_id": "CD-001",
+        "drift_kind": drift_kind,
+        "claim_text": "Drifted prose sentence the writer added without manifesting.",
+        "detected_at": "2026-05-15T10:13:00Z",
+        "rule_version": "D4-a-v1",
+    }
+    if drift_kind == "EMITTED_NOT_INTENDED":
+        base["section_path"] = "4. Discussion > 4.2 Implications"
+        base["manifest_claim_id"] = None
+        base["scoped_manifest_id"] = None
+    else:  # INTENDED_NOT_EMITTED
+        base["manifest_claim_id"] = "C-001"
+        base["scoped_manifest_id"] = MANIFEST_ID
+    return base
+
+
+def constraint_violation_entry(
+    *,
+    constraint_id: str = "MNC-1",
+    manifest_claim_id: str | None = None,
+) -> dict[str, Any]:
+    """Minimal CV-INV-* positive baseline."""
+    return {
+        "finding_id": "CV-001",
+        "claim_text": "We observed causality between A and B.",
+        "section_path": "4. Discussion > 4.3 Limitations",
+        "violated_constraint_id": constraint_id,
+        "scoped_manifest_id": MANIFEST_ID,
+        "manifest_claim_id": manifest_claim_id,
+        "judge_verdict": "VIOLATED",
+        "rationale": "The MNC bars causal language without RCT evidence.",
+        "judge_model": "gpt-5.5-xhigh",
+        "judge_run_at": "2026-05-15T10:14:00Z",
+        "rule_version": "D4-a-v1",
+    }
+
+
+def sampling_summary_entry(
+    *,
+    total: int = 150,
+    cap: int = 100,
+) -> dict[str, Any]:
+    """Minimal S-INV-* positive baseline (sampled run)."""
+    audited = list(range(0, total, max(1, total // cap)))[:cap]
+    return {
+        "audit_run_id": AUDIT_RUN_ID,
+        "max_claims_per_paper": cap,
+        "total_citation_count": total,
+        "audited_count": len(audited),
+        "audited_indices": audited,
+        "sampling_strategy": "stratified_buckets_v1",
+        "emitted_at": "2026-05-15T10:15:00Z",
+    }
+
+
+def uncited_audit_failure_entry(
+    *,
+    finding_id: str = "UAF-001",
+    fault_class: str = "judge_timeout",
+    manifest_claim_id: str | None = None,
+) -> dict[str, Any]:
+    """Minimal UAF-INV-* positive baseline (v3.8.2 / #118)."""
+    return {
+        "finding_id": finding_id,
+        "claim_text": "We observed causality between A and B.",
+        "section_path": "4. Discussion > 4.3 Limitations",
+        "scoped_manifest_id": MANIFEST_ID,
+        "manifest_claim_id": manifest_claim_id,
+        "fault_class": fault_class,
+        "rationale": f"{fault_class}: judge invocation failed after 30s",
+        "judge_model": "gpt-5.5-xhigh",
+        "judge_run_at": "2026-05-15T10:14:00Z",
+        "rule_version": "D4-c-v1-uaf-v1",
+    }
+
+
+def build_passport(
+    *,
+    manifests: list[dict[str, Any]] | None = None,
+    results: list[dict[str, Any]] | None = None,
+    uncited: list[dict[str, Any]] | None = None,
+    drifts: list[dict[str, Any]] | None = None,
+    violations: list[dict[str, Any]] | None = None,
+    samplings: list[dict[str, Any]] | None = None,
+    uaf: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Build a minimal passport JSON wrapping the seven aggregates the lint reads (six pre-v3.8.2 + uncited_audit_failures[])."""
+    return {
+        "claim_intent_manifests": manifests if manifests is not None else [manifest_entry()],
+        "claim_audit_results": results or [],
+        "uncited_assertions": uncited or [],
+        "claim_drifts": drifts or [],
+        "constraint_violations": violations or [],
+        "audit_sampling_summaries": samplings or [],
+        "uncited_audit_failures": uaf or [],
+    }
+
+
+def write_passport(tmp: Path, body: dict[str, Any]) -> Path:
+    path = tmp / "passport.json"
+    path.write_text(json.dumps(body, ensure_ascii=False, indent=2), encoding="utf-8")
+    return path
+
+
+def run_lint(passport: Path) -> tuple[int, str, str]:
+    """Invoke the lint subprocess; returns (exit_code, stdout, stderr)."""
+    proc = run_script(
+        LINT,
+        "--passport",
+        str(passport),
+        extra_env={"PYTHONPATH": str(REPO)},
+    )
+    return proc.returncode, proc.stdout, proc.stderr
+
+
+# ---------------------------------------------------------------------------
+# T-S1: Schema-shape only — minimal SUPPORTED entry validates against the
+# claim_audit_result schema. No lint invocation; pure Draft 2020-12 validate.
+# ---------------------------------------------------------------------------
+
+class TS1ValidMinimalEntry(unittest.TestCase):
+    """T-S1: Valid minimal entry validates (SUPPORTED, all required fields)."""
+
+    def test_supported_entry_validates(self) -> None:
+        schema = load_json_schema(SCHEMA_PATHS["claim_audit_result"])
+        validator = build_schema_validator(schema)
+        errors = list(validator.iter_errors(supported_entry()))
+        self.assertEqual(errors, [], msg=f"unexpected validation errors: {errors}")
+
+    def test_all_five_schemas_parse_as_draft_2020_12(self) -> None:
+        for name, path in SCHEMA_PATHS.items():
+            with self.subTest(schema=name):
+                load_json_schema(path)
+
+    def test_subclaim_breakdown_optional_field_validates(self) -> None:
+        """T-S9 (#213): sub_claim_breakdown is an additive optional field."""
+        schema = load_json_schema(SCHEMA_PATHS["claim_audit_result"])
+        validator = build_schema_validator(schema)
+        entry = supported_entry()
+        entry["judgment"] = "UNSUPPORTED"
+        entry["defect_stage"] = "source_description"
+        entry["sub_claim_breakdown"] = [
+            {
+                "sub_claim_text": "n-values are reported",
+                "sub_verdict": "SUPPORTED",
+                "evidence_pointer": "p.4 Table 1",
+            },
+            {
+                "sub_claim_text": "reporting is consistent across models",
+                "sub_verdict": "UNSUPPORTED",
+                "evidence_pointer": None,
+            },
+        ]
+        errors = list(validator.iter_errors(entry))
+        self.assertEqual(errors, [], msg=f"unexpected validation errors: {errors}")
+
+    def test_subclaim_breakdown_rejects_unknown_subfield(self) -> None:
+        """additionalProperties:false holds inside each breakdown item.
+
+        Two valid items satisfy minItems:2 so the ONLY violation is the bogus
+        subfield — this isolates additionalProperties:false from the array-length
+        constraint (round-2 review #2: a one-item fixture also tripped minItems,
+        so it would still pass even if additionalProperties were removed).
+        """
+        schema = load_json_schema(SCHEMA_PATHS["claim_audit_result"])
+        validator = build_schema_validator(schema)
+        entry = supported_entry()
+        entry["judgment"] = "UNSUPPORTED"
+        entry["defect_stage"] = "source_description"
+        entry["sub_claim_breakdown"] = [
+            {"sub_claim_text": "x", "sub_verdict": "SUPPORTED", "bogus": 1},
+            {"sub_claim_text": "y", "sub_verdict": "UNSUPPORTED"},
+        ]
+        errors = list(validator.iter_errors(entry))
+        self.assertNotEqual(errors, [], msg="expected unknown subfield to be rejected")
+        self.assertTrue(
+            any(e.validator == "additionalProperties" for e in errors),
+            msg=f"expected an additionalProperties error, got: {[e.validator for e in errors]}",
+        )
+
+
+# ---------------------------------------------------------------------------
+# Lint-driven invariant tests share a base that writes a tmp passport,
+# invokes the lint subprocess, and asserts findings.
+# ---------------------------------------------------------------------------
+
+class _LintTestBase(unittest.TestCase):
+    def setUp(self) -> None:
+        # Each test owns its tmpdir so concurrent unittest runners don't collide.
+        import tempfile
+
+        self._tmp_obj = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp_obj.cleanup)
+        self.tmp = Path(self._tmp_obj.name)
+
+    def assertLintFinds(
+        self,
+        passport_body: dict[str, Any],
+        *,
+        invariant: str,
+        msg: str | None = None,
+    ) -> tuple[int, str]:
+        """Assert lint exits non-zero AND stdout contains `invariant` tag."""
+        path = write_passport(self.tmp, passport_body)
+        code, out, err = run_lint(path)
+        full_msg = (
+            f"\nexpected lint to flag {invariant}\n"
+            f"--- exit={code} ---\nstdout:\n{out}\nstderr:\n{err}\n"
+        )
+        self.assertEqual(code, 1, msg=full_msg)
+        self.assertIn(invariant, out, msg=full_msg)
+        return code, out
+
+    def assertLintClean(
+        self,
+        passport_body: dict[str, Any],
+        *,
+        msg: str | None = None,
+    ) -> None:
+        """Assert lint exits 0 (no findings) on a passport that should pass."""
+        path = write_passport(self.tmp, passport_body)
+        code, out, err = run_lint(path)
+        self.assertEqual(
+            code,
+            0,
+            msg=(msg or "")
+            + f"\nexpected lint clean\nexit={code}\nstdout:\n{out}\nstderr:\n{err}\n",
+        )
+
+
+# ---------------------------------------------------------------------------
+# T-S2: INV-1..INV-19 paired positive + negative fixtures (claim_audit_result).
+# Each invariant is one subTest; baseline = SUPPORTED entry, negative cases
+# mutate the field combination the invariant forbids.
+# ---------------------------------------------------------------------------
+
+class TS2ClaimAuditInvariants(_LintTestBase):
+    """T-S2: each INV-N paired positive/negative fixture."""
+
+    # ----- Positive: every INV holds when the canonical SUPPORTED row stands.
+    def test_inv_baseline_positive(self) -> None:
+        self.assertLintClean(build_passport(results=[supported_entry()]))
+
+    # ----- Negative cases per invariant.
+    def test_inv_1_supported_with_non_null_defect(self) -> None:
+        # INV-1: SUPPORTED -> defect_stage=null AND violated_constraint_id=null
+        e = supported_entry()
+        e["defect_stage"] = "source_description"
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-1")
+
+    def test_inv_2_unsupported_with_null_defect(self) -> None:
+        # INV-2: UNSUPPORTED -> defect_stage != null
+        e = supported_entry()
+        e["judgment"] = "UNSUPPORTED"
+        e["defect_stage"] = None
+        e["rationale"] = "Mismatch found in source description."
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-2")
+
+    def test_inv_3_ambiguous_with_disallowed_defect(self) -> None:
+        # INV-3: AMBIGUOUS -> defect_stage NOT in {metadata, negative_constraint_violation}
+        e = supported_entry()
+        e["judgment"] = "AMBIGUOUS"
+        e["defect_stage"] = "metadata"
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-3")
+
+    def test_inv_4_retrieval_failed_inconclusive_wrong_defect(self) -> None:
+        # INV-4: RETRIEVAL_FAILED + inconclusive -> defect_stage=not_applicable
+        e = supported_entry()
+        e["judgment"] = "RETRIEVAL_FAILED"
+        e["audit_status"] = "inconclusive"
+        e["defect_stage"] = "retrieval_existence"
+        e["ref_retrieval_method"] = "failed"
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-4")
+
+    def test_inv_5_retrieval_failed_completed_wrong_defect(self) -> None:
+        # INV-5: RETRIEVAL_FAILED + completed -> defect_stage=retrieval_existence
+        e = supported_entry()
+        e["judgment"] = "RETRIEVAL_FAILED"
+        e["audit_status"] = "completed"
+        e["defect_stage"] = "source_description"
+        e["ref_retrieval_method"] = "not_found"
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-5")
+
+    def test_inv_6_anchor_none_without_rationale_prefix(self) -> None:
+        # INV-6: anchor_kind=none -> rationale starts with the canonical prefix
+        e = supported_entry()
+        e["anchor_kind"] = "none"
+        e["anchor_value"] = ""
+        e["judgment"] = "RETRIEVAL_FAILED"
+        e["audit_status"] = "inconclusive"
+        e["defect_stage"] = "not_applicable"
+        e["ref_retrieval_method"] = "not_attempted"
+        e["rationale"] = "anchor missing for this claim"  # no v3.7.3 prefix
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-6")
+
+    def test_inv_6_anchor_none_with_non_empty_anchor_value(self) -> None:
+        # INV-6: anchor_kind=none MUST carry empty sentinel anchor_value.
+        # A stale residual value (e.g. "123") violates the schema contract.
+        # Step 13 R1 Gemini finding (a832d3f).
+        e = supported_entry()
+        e["anchor_kind"] = "none"
+        e["anchor_value"] = "123"  # stale residual — must be rejected
+        e["judgment"] = "RETRIEVAL_FAILED"
+        e["audit_status"] = "inconclusive"
+        e["defect_stage"] = "not_applicable"
+        e["ref_retrieval_method"] = "not_attempted"
+        e["rationale"] = (
+            "v3.7.3 R-L3-1-A violation: cited claim C-001 carries anchor=none; "
+            "v3.7.3 finalizer should have gate-refused upstream."
+        )
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-6")
+
+    def test_inv_7_constraint_violation_without_violated_id(self) -> None:
+        # INV-7: negative_constraint_violation -> violated_constraint_id != null
+        e = supported_entry()
+        e["judgment"] = "UNSUPPORTED"
+        e["defect_stage"] = "negative_constraint_violation"
+        e["rationale"] = "Violated declared negative constraint."
+        e["violated_constraint_id"] = None
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-7")
+
+    def test_inv_8_constraint_violation_wrong_judgment(self) -> None:
+        # INV-8: negative_constraint_violation -> judgment=UNSUPPORTED
+        e = supported_entry()
+        e["judgment"] = "AMBIGUOUS"
+        e["defect_stage"] = "negative_constraint_violation"
+        e["violated_constraint_id"] = "MNC-1"
+        e["rationale"] = "Ambiguous violation of MNC-1."
+        # INV-3 also fires here; we assert INV-8 specifically.
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-8")
+
+    def test_inv_9_dispute_on_not_applicable(self) -> None:
+        # INV-9: upstream_dispute != null -> defect_stage NOT in {null, not_applicable}
+        e = supported_entry()
+        e["judgment"] = "RETRIEVAL_FAILED"
+        e["audit_status"] = "inconclusive"
+        e["defect_stage"] = "not_applicable"
+        e["ref_retrieval_method"] = "failed"
+        e["rationale"] = "Paywalled."
+        e["upstream_dispute"] = "Author disputes this paywall classification."
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-9")
+
+    def test_inv_10_failed_method_wrong_state(self) -> None:
+        # INV-10: ref_retrieval_method=failed -> RETRIEVAL_FAILED + inconclusive + not_applicable
+        e = supported_entry()
+        e["ref_retrieval_method"] = "failed"
+        # judgment still SUPPORTED -> INV-10 violation
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-10")
+
+    def test_inv_11_not_attempted_without_anchor_none(self) -> None:
+        # INV-11: ref_retrieval_method=not_attempted iff anchor_kind=none
+        e = supported_entry()
+        e["ref_retrieval_method"] = "not_attempted"
+        # anchor_kind still page -> INV-11 violation
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-11")
+
+    def test_inv_12_not_found_wrong_state(self) -> None:
+        # INV-12: ref_retrieval_method=not_found iff fabricated-reference triple
+        e = supported_entry()
+        e["ref_retrieval_method"] = "not_found"
+        # judgment still SUPPORTED -> INV-12 violation
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-12")
+
+    def test_inv_13_metadata_wrong_method(self) -> None:
+        # INV-13: defect_stage=metadata -> ref_retrieval_method in {api, manual_pdf}
+        e = supported_entry()
+        e["judgment"] = "UNSUPPORTED"
+        e["defect_stage"] = "metadata"
+        e["rationale"] = "Author/year mismatch."
+        e["ref_retrieval_method"] = "failed"
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-13")
+
+    def test_inv_14_audit_tool_failure_without_fault_class_prefix(self) -> None:
+        # INV-14: ref_retrieval_method=audit_tool_failure -> rationale begins with fault-class tag
+        e = supported_entry()
+        e["judgment"] = "RETRIEVAL_FAILED"
+        e["audit_status"] = "inconclusive"
+        e["defect_stage"] = "not_applicable"
+        e["ref_retrieval_method"] = "audit_tool_failure"
+        e["rationale"] = "Something went wrong."  # missing tag
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-14")
+
+    def test_inv_15_dangling_scoped_manifest_id(self) -> None:
+        # INV-15: (scoped_manifest_id, claim_id) must resolve in some manifest entry
+        e = supported_entry()
+        e["scoped_manifest_id"] = "M-2099-01-01T00:00:00Z-dead"  # not in manifests
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-15")
+
+    def test_inv_15_sentinel_manifest_permitted(self) -> None:
+        # INV-15 sentinel positive case — MANIFEST-MISSING fallback row.
+        e = supported_entry()
+        e["scoped_manifest_id"] = SENTINEL_MANIFEST_ID
+        passport = build_passport(manifests=[], results=[e])
+        self.assertLintClean(
+            passport,
+            msg="sentinel scoped_manifest_id must be accepted in MANIFEST-MISSING fallback",
+        )
+
+    def test_inv_16_empty_anchor_value_with_non_none_kind(self) -> None:
+        # INV-16: anchor_kind != none -> anchor_value non-empty after strip
+        e = supported_entry()
+        e["anchor_value"] = "   "  # whitespace only
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-16")
+
+    def test_inv_16_url_encoded_whitespace_does_not_bypass(self) -> None:
+        # INV-16: URL-encoded whitespace (%20, %09) must NOT bypass the firm
+        # rule — docstring + schema both require non-empty *after* URL-decode.
+        # Step 13 R1 Gemini finding (a832d3f).
+        e = supported_entry()
+        e["anchor_value"] = "%20%20%09"
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-16")
+
+    def test_inv_16_url_encoded_non_whitespace_passes(self) -> None:
+        # INV-16: URL-encoded printable content must still satisfy the rule.
+        e = supported_entry()
+        e["anchor_kind"] = "quote"
+        e["anchor_value"] = "ten%20cited%20words"  # 'ten cited words' after decode
+        self.assertLintClean(build_passport(results=[e]))
+
+    def test_inv_17_constraint_id_inner_hyphen_form(self) -> None:
+        # INV-17: NC-C{n}-{m} parse rule — NO inner hyphen between C and digits
+        manifest = manifest_entry(
+            claims=[
+                {
+                    "claim_id": "C-001",
+                    "claim_text": "Causal claim.",
+                    "intended_evidence_kind": "empirical",
+                    "planned_refs": [],
+                    "negative_constraints": [
+                        {
+                            # malformed: NC-C-001-1 instead of NC-C001-1
+                            "constraint_id": "NC-C-001-1",
+                            "rule": "Must not claim causality without RCT.",
+                        }
+                    ],
+                }
+            ],
+        )
+        # Schema pattern itself rejects this — lint surfaces INV-17 explicitly.
+        passport = build_passport(manifests=[manifest], results=[])
+        self.assertLintFinds(passport, invariant="INV-17")
+
+    def test_inv_18_inconclusive_not_applicable_wrong_method(self) -> None:
+        # INV-18: (RETRIEVAL_FAILED, inconclusive, not_applicable) -> method in
+        # {not_attempted, failed, audit_tool_failure}. `api` is forbidden.
+        e = supported_entry()
+        e["judgment"] = "RETRIEVAL_FAILED"
+        e["audit_status"] = "inconclusive"
+        e["defect_stage"] = "not_applicable"
+        e["ref_retrieval_method"] = "api"
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-18")
+
+    # ----- INV-19 (#213): sub_claim_breakdown pins the normalized-PARTIAL shape.
+    def _partial_entry(self) -> dict[str, Any]:
+        """True-partial UNSUPPORTED row: the INV-19 positive baseline."""
+        e = supported_entry()
+        e["judgment"] = "UNSUPPORTED"
+        e["audit_status"] = "completed"
+        e["defect_stage"] = "source_description"
+        e["sub_claim_breakdown"] = [
+            {"sub_claim_text": "a", "sub_verdict": "SUPPORTED"},
+            {"sub_claim_text": "b", "sub_verdict": "UNSUPPORTED"},
+        ]
+        return e
+
+    def test_inv_19_valid_partial_breakdown_passes(self) -> None:
+        # INV-19 positive baseline: a true-partial row is clean.
+        self.assertLintClean(build_passport(results=[self._partial_entry()]))
+
+    def test_inv_19_breakdown_on_supported_row_flagged(self) -> None:
+        # INV-19: a sub_claim_breakdown on a non-UNSUPPORTED row is illegal.
+        e = supported_entry()  # judgment=SUPPORTED, defect_stage=None
+        e["sub_claim_breakdown"] = [
+            {"sub_claim_text": "a", "sub_verdict": "SUPPORTED"},
+            {"sub_claim_text": "b", "sub_verdict": "UNSUPPORTED"},
+        ]
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-19")
+
+    def test_inv_19_breakdown_wrong_defect_stage_flagged(self) -> None:
+        # INV-19: breakdown row must carry defect_stage=source_description.
+        e = self._partial_entry()
+        e["defect_stage"] = "synthesis_overclaim"
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-19")
+
+    def test_inv_19_all_unsupported_breakdown_flagged(self) -> None:
+        # INV-19: not true-partial — needs >=1 SUPPORTED (round-1 review #2).
+        e = self._partial_entry()
+        e["sub_claim_breakdown"] = [
+            {"sub_claim_text": "a", "sub_verdict": "UNSUPPORTED"},
+            {"sub_claim_text": "b", "sub_verdict": "UNSUPPORTED"},
+        ]
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-19")
+
+    def test_inv_19_all_supported_breakdown_flagged(self) -> None:
+        # INV-19: not true-partial — needs >=1 non-SUPPORTED.
+        e = self._partial_entry()
+        e["sub_claim_breakdown"] = [
+            {"sub_claim_text": "a", "sub_verdict": "SUPPORTED"},
+            {"sub_claim_text": "b", "sub_verdict": "SUPPORTED"},
+        ]
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-19")
+
+    def test_inv_19_single_item_breakdown_flagged(self) -> None:
+        # INV-19: a decomposition with <2 items is not a true partial.
+        e = self._partial_entry()
+        e["sub_claim_breakdown"] = [
+            {"sub_claim_text": "a", "sub_verdict": "SUPPORTED"},
+        ]
+        # schema minItems:2 also rejects this; lint must independently flag it
+        # so a future schema relaxation can't silently admit a 1-item breakdown.
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-19")
+
+    def test_inv_19_breakdown_on_ambiguous_row_flagged(self) -> None:
+        # INV-19 judgment-pin isolation: AMBIGUOUS + completed + source_description
+        # passes INV-3 AND is in ALLOWED_MATRIX, so the ONLY invariant that can
+        # fire is INV-19's judgment check. This catches a partially-broken guard
+        # that forgets the judgment pin but keeps the defect_stage pin — which the
+        # SUPPORTED-row case can't catch (it also has defect_stage=None).
+        # (round-2 review #3.)
+        e = self._partial_entry()
+        e["judgment"] = "AMBIGUOUS"  # defect_stage stays source_description
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-19")
+
+    def test_inv_19_missing_sub_verdict_not_counted_as_non_supported(self) -> None:
+        # INV-19 must NOT read a missing/out-of-enum sub_verdict as "non-SUPPORTED"
+        # (round-2 review #1). [SUPPORTED, <missing>] is NOT true-partial: it has no
+        # valid non-SUPPORTED verdict. A guard using `v != "SUPPORTED"` would wrongly
+        # accept it. The schema also rejects the missing required key, but INV-19 must
+        # independently flag the not-true-partial shape with its own tag.
+        e = self._partial_entry()
+        e["sub_claim_breakdown"] = [
+            {"sub_claim_text": "a", "sub_verdict": "SUPPORTED"},
+            {"sub_claim_text": "b"},  # sub_verdict missing -> not a valid non-SUPPORTED
+        ]
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-19")
+
+
+# ---------------------------------------------------------------------------
+# T-S3: anchor_kind=none + INV-6 violation paths.
+# ---------------------------------------------------------------------------
+
+class TS3AnchorNoneInv6(_LintTestBase):
+    """T-S3: anchor=none entries that miss rationale prefix or use wrong method."""
+
+    def _none_entry(self) -> dict[str, Any]:
+        e = supported_entry()
+        e["anchor_kind"] = "none"
+        e["anchor_value"] = ""
+        e["judgment"] = "RETRIEVAL_FAILED"
+        e["audit_status"] = "inconclusive"
+        e["defect_stage"] = "not_applicable"
+        e["ref_retrieval_method"] = "not_attempted"
+        e["rationale"] = "v3.7.3 R-L3-1-A violation: no anchor on cited claim."
+        return e
+
+    def test_anchor_none_positive_baseline(self) -> None:
+        # Canonical INV-6 compliant row should pass.
+        self.assertLintClean(build_passport(results=[self._none_entry()]))
+
+    def test_anchor_none_missing_rationale_prefix(self) -> None:
+        e = self._none_entry()
+        e["rationale"] = "anchor missing"  # no prefix
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-6")
+
+    def test_anchor_none_wrong_retrieval_method(self) -> None:
+        e = self._none_entry()
+        e["ref_retrieval_method"] = "failed"  # should be not_attempted
+        # INV-11 ↔ INV-6 mismatch — either fires; spec couples the firm rule via INV-6/11.
+        self.assertLintFinds(build_passport(results=[e]), invariant="INV-6")
+
+
+# ---------------------------------------------------------------------------
+# T-S4: M-INV-1 duplicate claim_id within ONE manifest.
+# ---------------------------------------------------------------------------
+
+class TS4ManifestInv1(_LintTestBase):
+    """T-S4: duplicate claim_id within one manifest is rejected; cross-manifest collision permitted."""
+
+    def test_duplicate_claim_id_within_one_manifest_rejected(self) -> None:
+        manifest = manifest_entry(
+            claims=[
+                {
+                    "claim_id": "C-001",
+                    "claim_text": "First claim.",
+                    "intended_evidence_kind": "empirical",
+                    "planned_refs": [],
+                },
+                {
+                    "claim_id": "C-001",  # duplicate within ONE manifest
+                    "claim_text": "Second collision.",
+                    "intended_evidence_kind": "empirical",
+                    "planned_refs": [],
+                },
+            ],
+        )
+        self.assertLintFinds(
+            build_passport(manifests=[manifest]),
+            invariant="M-INV-1",
+        )
+
+    def test_cross_manifest_claim_id_collision_permitted(self) -> None:
+        manifest_a = manifest_entry(manifest_id=MANIFEST_ID)
+        manifest_b = manifest_entry(
+            manifest_id=MANIFEST_ID_OTHER,
+            emitted_by="draft_writer_agent",
+        )
+        self.assertLintClean(
+            build_passport(manifests=[manifest_a, manifest_b]),
+            msg="cross-manifest C-001 collision MUST be permitted (joinable pair)",
+        )
+
+    def test_m_inv_4_duplicate_manifest_id_across_passport_rejected(self) -> None:
+        manifest_a = manifest_entry(manifest_id=MANIFEST_ID)
+        manifest_b = manifest_entry(
+            manifest_id=MANIFEST_ID,  # collides with manifest_a
+            emitted_by="draft_writer_agent",
+        )
+        self.assertLintFinds(
+            build_passport(manifests=[manifest_a, manifest_b]),
+            invariant="M-INV-4",
+        )
+
+
+# ---------------------------------------------------------------------------
+# T-S5: M-INV-2 dangling NC-C{n}-{m} (no parent claim with C-{n}).
+# ---------------------------------------------------------------------------
+
+class TS5ManifestInv2(_LintTestBase):
+    """T-S5: NC-C{n}-{m} must scope under a claims[] entry with claim_id=C-{n}."""
+
+    def test_dangling_claim_level_nc(self) -> None:
+        manifest = manifest_entry(
+            claims=[
+                {
+                    "claim_id": "C-001",
+                    "claim_text": "First claim.",
+                    "intended_evidence_kind": "empirical",
+                    "planned_refs": [],
+                    "negative_constraints": [
+                        {
+                            # NC scoped to C-002, but no C-002 claim exists.
+                            "constraint_id": "NC-C002-1",
+                            "rule": "Mismatched parent.",
+                        }
+                    ],
+                }
+            ],
+        )
+        self.assertLintFinds(
+            build_passport(manifests=[manifest]),
+            invariant="M-INV-2",
+        )
+
+
+# ---------------------------------------------------------------------------
+# T-S6: M-INV-3 claim-level NC attempting to override MNC.
+# ---------------------------------------------------------------------------
+
+class TS6ManifestInv3(_LintTestBase):
+    """T-S6: claim-level NC cannot DROP a global MNC; ADD is permitted."""
+
+    def test_claim_level_nc_collides_with_mnc_id(self) -> None:
+        # M-INV-3 — claim-level constraint reusing an MNC-* id is the override
+        # signature the lint must reject (claim level can ADD via fresh NC-C{n}-{m}
+        # ids, never via re-using an MNC-* id).
+        manifest = manifest_entry(
+            claims=[
+                {
+                    "claim_id": "C-001",
+                    "claim_text": "Causal claim.",
+                    "intended_evidence_kind": "empirical",
+                    "planned_refs": [],
+                    "negative_constraints": [
+                        {
+                            "constraint_id": "MNC-1",  # disallowed at claim level
+                            "rule": "Trying to override.",
+                        }
+                    ],
+                }
+            ],
+            mncs=[
+                {
+                    "constraint_id": "MNC-1",
+                    "rule": "Must not claim causality.",
+                }
+            ],
+        )
+        self.assertLintFinds(
+            build_passport(manifests=[manifest]),
+            invariant="M-INV-3",
+        )
+
+
+# ---------------------------------------------------------------------------
+# T-S7: U-INV-1..U-INV-4 paired positive/negative.
+# ---------------------------------------------------------------------------
+
+class TS7UncitedAssertionInvariants(_LintTestBase):
+    """T-S7: U-INV-1..U-INV-4 paired pos/neg fixtures."""
+
+    def test_u_baseline_positive(self) -> None:
+        self.assertLintClean(build_passport(uncited=[uncited_assertion_entry()]))
+
+    def test_u_inv_1_duplicate_finding_id(self) -> None:
+        a = uncited_assertion_entry()
+        b = uncited_assertion_entry()  # same UA-001
+        self.assertLintFinds(
+            build_passport(uncited=[a, b]),
+            invariant="U-INV-1",
+        )
+
+    def test_u_inv_2_empty_trigger_tokens(self) -> None:
+        e = uncited_assertion_entry()
+        e["trigger_tokens"] = []
+        # Schema also rejects (minItems=1); lint surfaces U-INV-2 specifically.
+        self.assertLintFinds(
+            build_passport(uncited=[e]),
+            invariant="U-INV-2",
+        )
+
+    def test_u_inv_3_wrong_rule_version(self) -> None:
+        e = uncited_assertion_entry()
+        e["rule_version"] = "D4-c-v0"
+        # Schema const rejects; lint surfaces U-INV-3 specifically.
+        self.assertLintFinds(
+            build_passport(uncited=[e]),
+            invariant="U-INV-3",
+        )
+
+    def test_u_inv_4_orphan_manifest_pointer(self) -> None:
+        # manifest_claim_id set without matching manifest entry -> U-INV-4
+        e = uncited_assertion_entry()
+        e["manifest_claim_id"] = "C-999"
+        e["scoped_manifest_id"] = MANIFEST_ID
+        self.assertLintFinds(
+            build_passport(uncited=[e]),
+            invariant="U-INV-4",
+        )
+
+    def test_u_inv_4_null_manifest_id_with_set_claim_id(self) -> None:
+        # manifest_claim_id != null requires scoped_manifest_id != null.
+        e = uncited_assertion_entry()
+        e["manifest_claim_id"] = "C-001"
+        e["scoped_manifest_id"] = None
+        self.assertLintFinds(
+            build_passport(uncited=[e]),
+            invariant="U-INV-4",
+        )
+
+
+# ---------------------------------------------------------------------------
+# T-S8: (judgment, audit_status, defect_stage) matrix exhaustive coverage.
+# Spec §3.1 table: 9 positive rows, lint rejects every (j, a, d) triple
+# outside the table; ≥5 disallowed combinations exercised explicitly.
+# ---------------------------------------------------------------------------
+
+class TS8AllowedMatrix(_LintTestBase):
+    """T-S8: every allowed triple validates; ≥5 disallowed combinations rejected."""
+
+    # Positive matrix rows — each is a self-contained passport fragment.
+    ALLOWED_ROWS = [
+        # (judgment, audit_status, defect_stage, ref_retrieval_method overrides)
+        ("SUPPORTED", "completed", None, {"ref_retrieval_method": "api"}),
+        ("AMBIGUOUS", "completed", "source_description", {"ref_retrieval_method": "api"}),
+        ("AMBIGUOUS", "completed", "citation_anchor", {"ref_retrieval_method": "api"}),
+        ("AMBIGUOUS", "completed", "synthesis_overclaim", {"ref_retrieval_method": "api"}),
+        ("AMBIGUOUS", "completed", None, {"ref_retrieval_method": "api"}),
+        ("UNSUPPORTED", "completed", "source_description", {"ref_retrieval_method": "api"}),
+        ("UNSUPPORTED", "completed", "metadata", {"ref_retrieval_method": "api"}),
+        ("UNSUPPORTED", "completed", "citation_anchor", {"ref_retrieval_method": "api"}),
+        ("UNSUPPORTED", "completed", "synthesis_overclaim", {"ref_retrieval_method": "api"}),
+        (
+            "UNSUPPORTED",
+            "completed",
+            "negative_constraint_violation",
+            {
+                "ref_retrieval_method": "api",
+                "violated_constraint_id": "MNC-1",
+            },
+        ),
+        (
+            "RETRIEVAL_FAILED",
+            "completed",
+            "retrieval_existence",
+            {"ref_retrieval_method": "not_found"},
+        ),
+        (
+            "RETRIEVAL_FAILED",
+            "inconclusive",
+            "not_applicable",
+            {"ref_retrieval_method": "failed"},
+        ),
+    ]
+
+    # Negative cases — ≥5 representative disallowed combinations.
+    DISALLOWED_ROWS = [
+        # (judgment, audit_status, defect_stage, overrides, expected_invariant)
+        (
+            "SUPPORTED",
+            "completed",
+            "source_description",
+            {"ref_retrieval_method": "api"},
+            "INV-1",
+        ),
+        (
+            "UNSUPPORTED",
+            "completed",
+            None,
+            {"ref_retrieval_method": "api"},
+            "INV-2",
+        ),
+        (
+            "RETRIEVAL_FAILED",
+            "completed",
+            "not_applicable",
+            {"ref_retrieval_method": "api"},
+            "matrix",
+        ),
+        (
+            "SUPPORTED",
+            "inconclusive",
+            None,
+            {"ref_retrieval_method": "api"},
+            "matrix",
+        ),
+        (
+            "AMBIGUOUS",
+            "completed",
+            "metadata",
+            {"ref_retrieval_method": "api"},
+            "INV-3",
+        ),
+        (
+            "AMBIGUOUS",
+            "inconclusive",
+            None,
+            {"ref_retrieval_method": "api"},
+            "matrix",
+        ),
+    ]
+
+    def _build_row(self, j: str, a: str, d: Any, overrides: dict[str, Any]) -> dict[str, Any]:
+        e = supported_entry()
+        e["judgment"] = j
+        e["audit_status"] = a
+        e["defect_stage"] = d
+        if d == "negative_constraint_violation":
+            e["rationale"] = "Violated declared negative constraint."
+        elif d == "retrieval_existence":
+            e["rationale"] = "Reference does not exist."
+        elif d == "not_applicable":
+            e["rationale"] = "Paywall — full text not retrievable."
+        elif d is not None:
+            e["rationale"] = f"Defect at {d}."
+        e.update(overrides)
+        return e
+
+    def test_every_allowed_row_passes(self) -> None:
+        for j, a, d, overrides in self.ALLOWED_ROWS:
+            with self.subTest(judgment=j, audit_status=a, defect_stage=d):
+                e = self._build_row(j, a, d, overrides)
+                self.assertLintClean(
+                    build_passport(results=[e]),
+                    msg=f"row ({j}, {a}, {d}) should pass",
+                )
+
+    def test_disallowed_rows_rejected(self) -> None:
+        for j, a, d, overrides, invariant in self.DISALLOWED_ROWS:
+            with self.subTest(judgment=j, audit_status=a, defect_stage=d):
+                e = self._build_row(j, a, d, overrides)
+                self.assertLintFinds(
+                    build_passport(results=[e]),
+                    invariant=invariant,
+                )
+
+
+# ---------------------------------------------------------------------------
+# Spec §6 lint 4a — D-INV-1..D-INV-4 claim_drift cross-array integrity.
+# Not labelled T-Sx in spec §7.1 but mandatory per §6.4a. Paired pos/neg.
+# ---------------------------------------------------------------------------
+
+class TSDDriftInvariants(_LintTestBase):
+    """Spec §6.4a: claim_drift D-INV-1..D-INV-4."""
+
+    def test_d_baseline_emitted_not_intended(self) -> None:
+        self.assertLintClean(build_passport(drifts=[claim_drift_entry()]))
+
+    def test_d_baseline_intended_not_emitted(self) -> None:
+        drift = claim_drift_entry(drift_kind="INTENDED_NOT_EMITTED")
+        self.assertLintClean(build_passport(drifts=[drift]))
+
+    def test_d_inv_1_duplicate_finding_id(self) -> None:
+        a = claim_drift_entry()
+        b = claim_drift_entry()  # CD-001 collides
+        self.assertLintFinds(build_passport(drifts=[a, b]), invariant="D-INV-1")
+
+    def test_d_inv_2_intended_not_emitted_missing_manifest_pointer(self) -> None:
+        drift = claim_drift_entry(drift_kind="INTENDED_NOT_EMITTED")
+        drift["manifest_claim_id"] = None  # MUST be non-null for INTENDED_NOT_EMITTED
+        drift["scoped_manifest_id"] = None
+        self.assertLintFinds(build_passport(drifts=[drift]), invariant="D-INV-2")
+
+    def test_d_inv_2_emitted_not_intended_with_manifest_pointer(self) -> None:
+        drift = claim_drift_entry(drift_kind="EMITTED_NOT_INTENDED")
+        drift["manifest_claim_id"] = "C-001"  # MUST be null for EMITTED_NOT_INTENDED
+        drift["scoped_manifest_id"] = MANIFEST_ID
+        self.assertLintFinds(build_passport(drifts=[drift]), invariant="D-INV-2")
+
+    def test_d_inv_2_dangling_intended_not_emitted_pair(self) -> None:
+        drift = claim_drift_entry(drift_kind="INTENDED_NOT_EMITTED")
+        drift["manifest_claim_id"] = "C-999"  # no such claim in manifest
+        drift["scoped_manifest_id"] = MANIFEST_ID
+        self.assertLintFinds(build_passport(drifts=[drift]), invariant="D-INV-2")
+
+    def test_d_inv_3_wrong_rule_version(self) -> None:
+        drift = claim_drift_entry()
+        drift["rule_version"] = "D4-a-v0"
+        self.assertLintFinds(build_passport(drifts=[drift]), invariant="D-INV-3")
+
+    def test_d_inv_4_uncited_and_drift_collision(self) -> None:
+        # A single sentence appears in both uncited_assertions[] and claim_drifts[].
+        sentence = "Half of submissions showed positive results."
+        uncited = uncited_assertion_entry()
+        uncited["sentence_text"] = sentence
+        drift = claim_drift_entry()
+        drift["claim_text"] = sentence
+        self.assertLintFinds(
+            build_passport(uncited=[uncited], drifts=[drift]),
+            invariant="D-INV-4",
+        )
+
+
+# ---------------------------------------------------------------------------
+# Spec §6.4b — CV-INV-1..CV-INV-4 constraint_violation cross-array integrity.
+# ---------------------------------------------------------------------------
+
+class TSCVConstraintViolationInvariants(_LintTestBase):
+    """Spec §6.4b: constraint_violation CV-INV-1..CV-INV-4."""
+
+    def _manifest_with_mnc_and_nc(self) -> dict[str, Any]:
+        return manifest_entry(
+            claims=[
+                {
+                    "claim_id": "C-001",
+                    "claim_text": "Causal claim.",
+                    "intended_evidence_kind": "empirical",
+                    "planned_refs": [],
+                    "negative_constraints": [
+                        {
+                            "constraint_id": "NC-C001-1",
+                            "rule": "No causal language without RCT.",
+                        }
+                    ],
+                }
+            ],
+            mncs=[{"constraint_id": "MNC-1", "rule": "Global rule."}],
+        )
+
+    def test_cv_baseline_mnc_violation(self) -> None:
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            violations=[constraint_violation_entry()],
+        )
+        self.assertLintClean(passport)
+
+    def test_cv_baseline_nc_violation(self) -> None:
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            violations=[
+                constraint_violation_entry(
+                    constraint_id="NC-C001-1",
+                    manifest_claim_id="C-001",
+                )
+            ],
+        )
+        self.assertLintClean(passport)
+
+    def test_cv_inv_1_duplicate_finding_id(self) -> None:
+        a = constraint_violation_entry()
+        b = constraint_violation_entry()
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            violations=[a, b],
+        )
+        self.assertLintFinds(passport, invariant="CV-INV-1")
+
+    def test_cv_inv_2_dangling_mnc(self) -> None:
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            violations=[constraint_violation_entry(constraint_id="MNC-99")],
+        )
+        self.assertLintFinds(passport, invariant="CV-INV-2")
+
+    def test_cv_inv_2_dangling_nc(self) -> None:
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            violations=[
+                constraint_violation_entry(
+                    constraint_id="NC-C999-1",
+                    manifest_claim_id="C-999",
+                )
+            ],
+        )
+        self.assertLintFinds(passport, invariant="CV-INV-2")
+
+    def test_cv_inv_3_mnc_with_set_manifest_claim_id(self) -> None:
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            violations=[
+                constraint_violation_entry(
+                    constraint_id="MNC-1",
+                    manifest_claim_id="C-001",  # MUST be null for MNC
+                )
+            ],
+        )
+        self.assertLintFinds(passport, invariant="CV-INV-3")
+
+    def test_cv_inv_3_nc_polarity_mismatch(self) -> None:
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            violations=[
+                constraint_violation_entry(
+                    constraint_id="NC-C001-1",
+                    manifest_claim_id="C-002",  # MUST match the C-001 in NC id
+                )
+            ],
+        )
+        self.assertLintFinds(passport, invariant="CV-INV-3")
+
+    def test_cv_inv_4_duplicate_per_constraint(self) -> None:
+        # Two violations for (same sentence, same constraint) -> dedup rule.
+        a = constraint_violation_entry()
+        b = constraint_violation_entry()
+        b["finding_id"] = "CV-002"  # avoid CV-INV-1 collision
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            violations=[a, b],
+        )
+        self.assertLintFinds(passport, invariant="CV-INV-4")
+
+
+# ---------------------------------------------------------------------------
+# Step 13 R8 codex P2-1 — CV-INV-4 dedupe key extension. Two manifests in
+# the same passport can carry colliding MNC-* / NC-* ids; the same sentence
+# text may legitimately violate both. The pre-fix dedupe key
+# (section_path, claim_text_hash, violated_constraint_id) false-positives
+# these as duplicates. Extend the key to scope by manifest_id as well.
+# ---------------------------------------------------------------------------
+
+
+class TSCVDedupeManifestScope(_LintTestBase):
+    """T-SCV-DEDUPE: CV-INV-4 dedupe must scope by scoped_manifest_id."""
+
+    def _two_manifests_with_colliding_mnc(self) -> list[dict[str, Any]]:
+        # Two manifests each carrying the SAME constraint_id "MNC-1" but
+        # bound to different manifests (M-INV-4 permits — manifest_id is
+        # the joinable scope). Schema requires claims[] non-empty so we
+        # add a minimal claim to each manifest; the claim itself is not
+        # under test.
+        return [
+            manifest_entry(
+                manifest_id=MANIFEST_ID,
+                mncs=[{"constraint_id": "MNC-1", "rule": "No comparative claim."}],
+            ),
+            manifest_entry(
+                manifest_id=MANIFEST_ID_OTHER,
+                mncs=[{"constraint_id": "MNC-1", "rule": "No temporal claim."}],
+            ),
+        ]
+
+    def test_same_constraint_id_across_manifests_not_deduped(self) -> None:
+        # Two CV rows on the same sentence text + same constraint_id (MNC-1)
+        # but DIFFERENT scoped_manifest_id. Legitimate per M-INV-4 +
+        # manifest_negative_constraints scoping — dedupe must keep both.
+        a = constraint_violation_entry(constraint_id="MNC-1")
+        a["scoped_manifest_id"] = MANIFEST_ID
+        b = constraint_violation_entry(constraint_id="MNC-1")
+        b["finding_id"] = "CV-002"
+        b["scoped_manifest_id"] = MANIFEST_ID_OTHER
+        passport = build_passport(
+            manifests=self._two_manifests_with_colliding_mnc(),
+            violations=[a, b],
+        )
+        # Pre-fix: CV-INV-4 false-positives → lint reports CV-INV-4 line.
+        # Post-fix: lint MUST NOT fire CV-INV-4 on cross-manifest collision.
+        self.assertLintClean(passport)
+
+    def test_same_constraint_id_same_manifest_still_deduped(self) -> None:
+        # Negative test: dedupe still catches true within-manifest duplicates.
+        a = constraint_violation_entry(constraint_id="MNC-1")
+        b = constraint_violation_entry(constraint_id="MNC-1")
+        b["finding_id"] = "CV-002"
+        # Both rows reference the same manifest_id (default MANIFEST_ID).
+        passport = build_passport(
+            manifests=[self._two_manifests_with_colliding_mnc()[0]],  # single manifest
+            violations=[a, b],
+        )
+        self.assertLintFinds(passport, invariant="CV-INV-4")
+
+
+# ---------------------------------------------------------------------------
+# Spec §6.4c — S-INV-1..S-INV-4 audit_sampling_summary invariants.
+# ---------------------------------------------------------------------------
+
+class TSSamplingInvariants(_LintTestBase):
+    """Spec §6.4c: audit_sampling_summary S-INV-1..S-INV-4."""
+
+    def test_s_baseline(self) -> None:
+        self.assertLintClean(build_passport(samplings=[sampling_summary_entry()]))
+
+    def test_s_inv_1_count_vs_indices_mismatch(self) -> None:
+        e = sampling_summary_entry()
+        e["audited_count"] = e["audited_count"] - 1  # off-by-one
+        self.assertLintFinds(build_passport(samplings=[e]), invariant="S-INV-1")
+
+    def test_s_inv_2_count_exceeds_cap(self) -> None:
+        e = sampling_summary_entry(total=50, cap=10)
+        e["audited_count"] = 20
+        e["audited_indices"] = list(range(20))
+        self.assertLintFinds(build_passport(samplings=[e]), invariant="S-INV-2")
+
+    def test_s_inv_2_count_exceeds_total(self) -> None:
+        e = sampling_summary_entry(total=10, cap=100)
+        e["audited_count"] = 20
+        e["audited_indices"] = list(range(20))
+        self.assertLintFinds(build_passport(samplings=[e]), invariant="S-INV-2")
+
+    def test_s_inv_4_non_ascending_indices(self) -> None:
+        e = sampling_summary_entry(total=20, cap=10)
+        e["audited_indices"] = [5, 3, 7, 9, 11, 13, 15, 17, 19, 2]
+        e["audited_count"] = 10
+        self.assertLintFinds(build_passport(samplings=[e]), invariant="S-INV-4")
+
+    def test_s_inv_4_duplicate_indices(self) -> None:
+        e = sampling_summary_entry(total=20, cap=10)
+        e["audited_indices"] = [0, 1, 1, 3, 4, 5, 6, 7, 8, 9]
+        e["audited_count"] = 10
+        self.assertLintFinds(build_passport(samplings=[e]), invariant="S-INV-4")
+
+
+# ---------------------------------------------------------------------------
+# Spec §6.4d (v3.8.2 / #118) — UAF-INV-1..UAF-INV-5 uncited_audit_failure
+# cross-array integrity and dedup. Mirrors CV-INV pattern.
+# ---------------------------------------------------------------------------
+
+
+class TSUAFUncitedAuditFailureInvariants(_LintTestBase):
+    """Spec §6.4d: uncited_audit_failure UAF-INV-1..UAF-INV-5 (v3.8.2 / #118)."""
+
+    def _manifest_with_mnc_and_nc(self) -> dict[str, Any]:
+        return manifest_entry(
+            claims=[
+                {
+                    "claim_id": "C-001",
+                    "claim_text": "Causal claim.",
+                    "intended_evidence_kind": "empirical",
+                    "planned_refs": [],
+                    "negative_constraints": [
+                        {
+                            "constraint_id": "NC-C001-1",
+                            "rule": "No causal language without RCT.",
+                        }
+                    ],
+                }
+            ],
+            mncs=[{"constraint_id": "MNC-1", "rule": "Global rule."}],
+        )
+
+    # ----- Schema-shape only.
+    def test_uaf_schema_valid_minimal_entry(self) -> None:
+        schema = load_json_schema(SCHEMA_PATHS["uncited_audit_failure"])
+        validator = build_schema_validator(schema)
+        errors = list(validator.iter_errors(uncited_audit_failure_entry()))
+        self.assertEqual(errors, [], msg=f"unexpected validation errors: {errors}")
+
+    def test_uaf_schema_fault_class_enum_matches_constants(self) -> None:
+        """The schema's fault_class enum MUST match INV14_FAULT_CLASS_TAGS exactly.
+
+        Without this guard, extending INV14_FAULT_CLASS_TAGS in the Python
+        constants module would silently produce UAF rows that fail schema
+        validation (the pipeline maps a new exception class to a new tag,
+        but the schema's closed enum hasn't been bumped). Per Gemini cross-
+        model review R2 P2 (2026-05-17): both surfaces must move together,
+        and a rule_version bump (D4-c-v1-uaf-v2 or later) should accompany
+        any enum extension.
+        """
+        from scripts._claim_audit_constants import INV14_FAULT_CLASS_TAGS
+
+        schema = load_json_schema(SCHEMA_PATHS["uncited_audit_failure"])
+        schema_enum = set(schema["properties"]["fault_class"]["enum"])
+        constants_set = set(INV14_FAULT_CLASS_TAGS)
+        self.assertEqual(
+            schema_enum,
+            constants_set,
+            msg=(
+                "uncited_audit_failure.schema.json `fault_class` enum drifted "
+                "from INV14_FAULT_CLASS_TAGS. Either align the schema with the "
+                "python constant, or if intentionally extending the taxonomy "
+                "bump `rule_version` (e.g., D4-c-v1-uaf-v2) and document the "
+                "ramp in spec §3.6."
+            ),
+        )
+
+    def test_uaf_schema_rejects_missing_fault_class(self) -> None:
+        schema = load_json_schema(SCHEMA_PATHS["uncited_audit_failure"])
+        validator = build_schema_validator(schema)
+        e = uncited_audit_failure_entry()
+        del e["fault_class"]
+        errors = list(validator.iter_errors(e))
+        self.assertNotEqual(errors, [], msg="missing fault_class must fail schema validation")
+
+    def test_uaf_schema_rejects_unknown_fault_class(self) -> None:
+        schema = load_json_schema(SCHEMA_PATHS["uncited_audit_failure"])
+        validator = build_schema_validator(schema)
+        e = uncited_audit_failure_entry()
+        e["fault_class"] = "made_up_class"
+        errors = list(validator.iter_errors(e))
+        self.assertNotEqual(errors, [], msg="unknown fault_class must fail schema validation")
+
+    # ----- Lint baseline: clean passport with one UAF row passes.
+    def test_uaf_baseline_mnc_failure(self) -> None:
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            uaf=[uncited_audit_failure_entry()],
+        )
+        self.assertLintClean(passport)
+
+    def test_uaf_baseline_nc_failure(self) -> None:
+        # NC-C path: judge failed on a claim-level constraint check; manifest_claim_id set.
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            uaf=[uncited_audit_failure_entry(manifest_claim_id="C-001")],
+        )
+        self.assertLintClean(passport)
+
+    # ----- UAF-INV-1: finding_id uniqueness.
+    def test_uaf_inv_1_duplicate_finding_id(self) -> None:
+        a = uncited_audit_failure_entry()
+        b = uncited_audit_failure_entry()  # same finding_id "UAF-001"
+        # Per Gemini cross-model review P2 (2026-05-17): keep this test
+        # isolated to UAF-INV-1 by giving b a different claim_text so the
+        # passport does NOT simultaneously trip UAF-INV-4 (per-(sentence,
+        # manifest) dedup). One test should target one invariant cleanly.
+        b["claim_text"] = "Different text so UAF-INV-4 dedup does not fire."
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            uaf=[a, b],
+        )
+        self.assertLintFinds(passport, invariant="UAF-INV-1")
+
+    # ----- UAF-INV-2: scoped_manifest_id must resolve in claim_intent_manifests[].
+    def test_uaf_inv_2_dangling_manifest_id(self) -> None:
+        e = uncited_audit_failure_entry()
+        e["scoped_manifest_id"] = SENTINEL_MANIFEST_ID  # not in manifests
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            uaf=[e],
+        )
+        self.assertLintFinds(passport, invariant="UAF-INV-2")
+
+    # ----- UAF-INV-3: (scoped_manifest_id, manifest_claim_id) pair integrity.
+    def test_uaf_inv_3_dangling_claim_id(self) -> None:
+        e = uncited_audit_failure_entry(manifest_claim_id="C-999")  # no such claim in manifest
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            uaf=[e],
+        )
+        self.assertLintFinds(passport, invariant="UAF-INV-3")
+
+    def test_uaf_inv_3_null_claim_id_allowed_when_mnc_only(self) -> None:
+        # manifest_claim_id=null is legitimate when the failure was against MNCs only.
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            uaf=[uncited_audit_failure_entry(manifest_claim_id=None)],
+        )
+        self.assertLintClean(passport)
+
+    # ----- UAF-INV-4: per-(sentence, manifest) dedup.
+    def test_uaf_inv_4_same_sentence_same_manifest_dup(self) -> None:
+        a = uncited_audit_failure_entry()
+        b = uncited_audit_failure_entry(finding_id="UAF-002")
+        # b shares (scoped_manifest_id, section_path, claim_text) with a.
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            uaf=[a, b],
+        )
+        self.assertLintFinds(passport, invariant="UAF-INV-4")
+
+    def test_uaf_inv_4_same_sentence_different_manifests_not_deduped(self) -> None:
+        # Two manifests both failing on the same sentence text emit two rows
+        # legitimately (mirrors CV-INV-4 cross-manifest reasoning).
+        other_manifest = manifest_entry(
+            manifest_id=MANIFEST_ID_OTHER,
+            mncs=[{"constraint_id": "MNC-1", "rule": "Different rule."}],
+        )
+        a = uncited_audit_failure_entry()
+        a["scoped_manifest_id"] = MANIFEST_ID
+        b = uncited_audit_failure_entry(finding_id="UAF-002")
+        b["scoped_manifest_id"] = MANIFEST_ID_OTHER
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc(), other_manifest],
+            uaf=[a, b],
+        )
+        self.assertLintClean(passport)
+
+    # ----- UAF-INV-5: rationale fault_class prefix.
+    def test_uaf_inv_5_rationale_missing_fault_prefix(self) -> None:
+        e = uncited_audit_failure_entry()
+        e["rationale"] = "Some narrative without the fault_class prefix"
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            uaf=[e],
+        )
+        self.assertLintFinds(passport, invariant="UAF-INV-5")
+
+    def test_uaf_inv_5_rationale_wrong_fault_prefix(self) -> None:
+        # Rationale starts with "made_up_class:" — schema rejected via fault_class
+        # enum, but UAF-INV-5 also flags rationale prefix mismatch independently.
+        # Here we keep fault_class valid but flip rationale to a different valid
+        # tag — should still trip UAF-INV-5 (prefix must match the row's
+        # fault_class, not just any known tag).
+        e = uncited_audit_failure_entry(fault_class="judge_timeout")
+        e["rationale"] = "judge_api_error: wrong tag for this row"
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            uaf=[e],
+        )
+        self.assertLintFinds(passport, invariant="UAF-INV-5")
+
+    # ----- Cross-aggregate exclusivity: UAF vs constraint_violation.
+    def test_uaf_cross_aggregate_exclusive_with_cv(self) -> None:
+        # Same (sentence, manifest) MUST NOT have both an audit_tool_failure (UAF)
+        # and a VIOLATED row (CV). They are mutually exclusive verdict states.
+        cv = constraint_violation_entry()
+        uaf = uncited_audit_failure_entry()
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            violations=[cv],
+            uaf=[uaf],
+        )
+        self.assertLintFinds(passport, invariant="UAF-INV-6")
+
+    # ----- Malformed-payload hardening (Codex R2 P2-2 + P2-3, 2026-05-17).
+    def test_uaf_malformed_manifest_claim_id_does_not_crash_lint(self) -> None:
+        # Schema validator flags type errors separately; lint walker must
+        # skip cleanly on unhashable values rather than raise TypeError.
+        e = uncited_audit_failure_entry()
+        e["manifest_claim_id"] = ["unhashable", "list", "as", "claim_id"]
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            uaf=[e],
+        )
+        # Lint should report SOMETHING (schema-shape finding), exit 1, NOT crash.
+        path = write_passport(self.tmp, passport)
+        code, _, err = run_lint(path)
+        self.assertEqual(
+            code,
+            1,
+            msg=f"expected clean lint failure on malformed manifest_claim_id, got exit={code}\nstderr:\n{err}",
+        )
+        self.assertNotIn(
+            "Traceback",
+            err,
+            msg="lint MUST NOT crash with a traceback on malformed manifest_claim_id (Codex R2 P2-2)",
+        )
+
+    def test_uaf_malformed_rationale_does_not_crash_lint(self) -> None:
+        e = uncited_audit_failure_entry()
+        e["rationale"] = ["unhashable", "rationale"]
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            uaf=[e],
+        )
+        path = write_passport(self.tmp, passport)
+        code, _, err = run_lint(path)
+        self.assertEqual(
+            code,
+            1,
+            msg=f"expected clean lint failure on malformed rationale, got exit={code}\nstderr:\n{err}",
+        )
+        self.assertNotIn(
+            "Traceback",
+            err,
+            msg="lint MUST NOT crash with a traceback on malformed rationale (Codex R2 P2-3)",
+        )
+
+    # ----- Co-existence with uncited_assertions[] IS permitted.
+    def test_uaf_coexists_with_uncited_assertion(self) -> None:
+        # D4-c detector positive (UA) + judge failure (UAF) on the same sentence
+        # are independent signals; cross-aggregate exclusivity does NOT apply.
+        ua = uncited_assertion_entry()
+        uaf = uncited_audit_failure_entry()
+        passport = build_passport(
+            manifests=[self._manifest_with_mnc_and_nc()],
+            uncited=[ua],
+            uaf=[uaf],
+        )
+        self.assertLintClean(passport)
+
+
+# ---------------------------------------------------------------------------
+# T-S9: Defensive guard against malformed passports.
+# Step 13 R4 codex P2 #4 — malformed aggregates (non-list / non-dict entries)
+# must surface as schema findings rather than crash the lint with an
+# AttributeError traceback.
+# ---------------------------------------------------------------------------
+
+
+class TS9MalformedPassportGuard(_LintTestBase):
+    """T-S9: passport with malformed aggregate yields schema finding, not crash."""
+
+    def test_claim_audit_results_with_non_dict_entry(self) -> None:
+        # Pre-R4: list of non-dict in claim_audit_results raised AttributeError
+        # because dict-only invariant loops ran .get() before noticing the shape.
+        body = build_passport()
+        body["claim_audit_results"] = ["this should be an object, not a string"]
+        path = write_passport(self.tmp, body)
+        code, out, err = run_lint(path)
+        self.assertEqual(
+            code,
+            1,
+            msg=f"expected clean lint failure on malformed aggregate; got exit={code}\nstderr:\n{err}",
+        )
+        self.assertNotIn(
+            "Traceback",
+            err,
+            msg=f"lint must not raise — got traceback:\n{err}",
+        )
+        self.assertIn("schema", out, msg=f"expected schema finding tag in stdout:\n{out}")
+
+    def test_claim_intent_manifests_as_dict_instead_of_list(self) -> None:
+        body = build_passport()
+        body["claim_intent_manifests"] = {"oops": "should be a list"}
+        path = write_passport(self.tmp, body)
+        code, out, err = run_lint(path)
+        self.assertEqual(code, 1, msg=f"expected exit=1; got {code}\nstderr:\n{err}")
+        self.assertNotIn("Traceback", err, msg=f"lint must not raise:\n{err}")
+        self.assertIn("schema", out)
+
+    def test_non_object_passport_body_yields_clean_finding(self) -> None:
+        # Step 13 R7 codex P3: `[]`, `null`, scalar top-level JSON would
+        # previously crash with AttributeError on `.get()`. Validate that
+        # each surfaces as a schema finding without traceback.
+        for malformed_body in ([], None, 42, "passport"):
+            with self.subTest(body=malformed_body):
+                path = self.tmp / f"malformed_{type(malformed_body).__name__}.json"
+                path.write_text(json.dumps(malformed_body), encoding="utf-8")
+                code, out, err = run_lint(path)
+                self.assertEqual(
+                    code,
+                    1,
+                    msg=f"expected exit=1 for body={malformed_body!r}; got {code}\nstderr:\n{err}",
+                )
+                self.assertNotIn(
+                    "Traceback",
+                    err,
+                    msg=f"lint must not raise for body={malformed_body!r}:\n{err}",
+                )
+                self.assertIn("schema", out, msg=f"expected schema finding:\n{out}")
+
+    def test_falsey_malformed_aggregate_does_not_bypass_schema(self) -> None:
+        # Step 13 R5 codex P2 #1: `body.get(k, []) or []` would silently
+        # convert a malformed `{}` / `null` / `0` / `""` value to an empty
+        # list and skip schema validation. Each falsey-but-malformed shape
+        # must surface as a schema finding.
+        for malformed in ({}, None, 0, ""):
+            with self.subTest(malformed=malformed):
+                body = build_passport()
+                body["claim_audit_results"] = malformed
+                path = write_passport(self.tmp, body)
+                code, out, err = run_lint(path)
+                self.assertEqual(
+                    code,
+                    1,
+                    msg=f"expected exit=1 for malformed={malformed!r}; got {code}\nstdout:\n{out}\nstderr:\n{err}",
+                )
+                self.assertIn("schema", out, msg=f"expected schema finding for malformed={malformed!r}:\n{out}")
+                self.assertNotIn("Traceback", err, msg=f"lint must not raise for malformed={malformed!r}:\n{err}")
+
+    # Step 13 R6 codex P2 + R8 P2-2 — nested schema-invalid shapes must not
+    # crash the cross-field invariant walkers. Schema validator records the
+    # finding; the invariant helpers then iterate the malformed nested shape
+    # and previously hit TypeError/AttributeError. Issue #119 + #120 P2-2.
+
+    def test_manifest_claims_as_string_does_not_crash_invariant_walker(self) -> None:
+        # #119 + #120 P2-2: claim_intent_manifests[0].claims is a string,
+        # not a list. Schema validator records the finding; the cross-field
+        # invariant walker (M-INV-1..M-INV-4) must NOT iterate the string
+        # and crash. Expect clean exit=1 with schema finding, no traceback.
+        body = build_passport()
+        body["claim_intent_manifests"][0]["claims"] = "should be a list"
+        path = write_passport(self.tmp, body)
+        code, out, err = run_lint(path)
+        self.assertEqual(code, 1, msg=f"expected exit=1; got {code}\nstderr:\n{err}")
+        self.assertNotIn("Traceback", err, msg=f"lint must not crash on nested string:\n{err}")
+        self.assertIn("schema", out, msg=f"expected schema finding:\n{out}")
+
+    def test_manifest_claim_with_non_string_claim_id_does_not_crash(self) -> None:
+        # #119: manifest.claims[].claim_id is a non-string. Schema records
+        # the type mismatch; invariant walker must skip this manifest's
+        # cross-field checks instead of crashing on .get() / regex match.
+        body = build_passport()
+        body["claim_intent_manifests"][0]["claims"][0]["claim_id"] = 42
+        path = write_passport(self.tmp, body)
+        code, out, err = run_lint(path)
+        self.assertEqual(code, 1, msg=f"expected exit=1; got {code}\nstderr:\n{err}")
+        self.assertNotIn("Traceback", err, msg=f"lint must not crash on non-string claim_id:\n{err}")
+        self.assertIn("schema", out, msg=f"expected schema finding:\n{out}")
+
+    def test_audited_indices_mixed_types_does_not_crash_sampling_walker(self) -> None:
+        # #119: audit_sampling_summaries[].audited_indices contains mixed
+        # str/int types. Schema records the type mismatch; S-INV-4 walker
+        # (indices[i] <= indices[i-1]) must skip instead of raising
+        # TypeError on '<=' between str and int.
+        body = build_passport()
+        body["audit_sampling_summaries"] = [{
+            "audit_run_id": AUDIT_RUN_ID,
+            "max_claims_per_paper": 10,
+            "total_citation_count": 5,
+            "audited_count": 2,
+            "audited_indices": ["a", 1],
+            "sampling_strategy": "stratified_buckets_v1",
+            "emitted_at": "2026-05-15T10:15:00Z",
+        }]
+        path = write_passport(self.tmp, body)
+        code, out, err = run_lint(path)
+        self.assertEqual(code, 1, msg=f"expected exit=1; got {code}\nstderr:\n{err}")
+        self.assertNotIn("Traceback", err, msg=f"lint must not crash on mixed-type indices:\n{err}")
+        self.assertIn("schema", out, msg=f"expected schema finding:\n{out}")
+
+    # v3.8.1 Round 2 codex review P2 + adjacent unhashable-id surfaces.
+    # Schema validator records the type mismatch separately; uniqueness loops
+    # and dedupe key construction must not crash on unhashable nested ids.
+
+    def test_unhashable_claim_id_does_not_crash_m_inv_1(self) -> None:
+        # codex round 2 P2: claim.get("claim_id") returns a list/dict
+        # (unhashable). M-INV-1 uniqueness `cid in claim_ids` crashes with
+        # TypeError. Schema records the type mismatch but the invariant walker
+        # still raises, masking the schema findings.
+        body = build_passport()
+        body["claim_intent_manifests"][0]["claims"][0]["claim_id"] = ["bad", "type"]
+        path = write_passport(self.tmp, body)
+        code, out, err = run_lint(path)
+        self.assertEqual(code, 1, msg=f"expected exit=1; got {code}\nstderr:\n{err}")
+        self.assertNotIn("Traceback", err, msg=f"lint must not crash on unhashable claim_id:\n{err}")
+        self.assertIn("schema", out, msg=f"expected schema finding:\n{out}")
+
+    def test_unhashable_finding_id_does_not_crash_cv_inv_1(self) -> None:
+        # CV-INV-1 finding_id uniqueness `fid in seen` crashes when finding_id
+        # is a list / dict (schema-invalid). Same surface class as the M-INV-1
+        # case codex flagged; included for parity coverage across all four
+        # finding_id uniqueness sites (M-INV-4 / U-INV-1 / D-INV-1 / CV-INV-1).
+        body = build_passport()
+        body["constraint_violations"] = [
+            {
+                "finding_id": ["unhashable"],
+                "claim_text": "x",
+                "section_path": "Results > Findings",
+                "violated_constraint_id": "MNC-1",
+                "scoped_manifest_id": MANIFEST_ID,
+                "manifest_claim_id": None,
+                "judge_verdict": "VIOLATED",
+                "rationale": "rationale",
+                "judge_model": "gpt-5.5-xhigh",
+                "judge_run_at": "2026-05-15T10:14:00Z",
+                "rule_version": "D4-a-v1",
+            }
+        ]
+        path = write_passport(self.tmp, body)
+        code, out, err = run_lint(path)
+        self.assertEqual(code, 1, msg=f"expected exit=1; got {code}\nstderr:\n{err}")
+        self.assertNotIn("Traceback", err, msg=f"lint must not crash on unhashable finding_id:\n{err}")
+        self.assertIn("schema", out, msg=f"expected schema finding:\n{out}")
+
+    def test_unhashable_mnc_constraint_id_does_not_crash_m_inv_3(self) -> None:
+        # codex round 3 P2: manifest_negative_constraints[].constraint_id as
+        # list/dict crashes the `mnc_ids = {nc.get("constraint_id") for ...}`
+        # set comprehension when the implementation builds an (unused) set.
+        # Schema records the type mismatch but the lint still raises.
+        body = build_passport()
+        body["claim_intent_manifests"][0]["manifest_negative_constraints"] = [
+            {"constraint_id": ["unhashable"], "rule": "bad"}
+        ]
+        path = write_passport(self.tmp, body)
+        code, out, err = run_lint(path)
+        self.assertEqual(code, 1, msg=f"expected exit=1; got {code}\nstderr:\n{err}")
+        self.assertNotIn("Traceback", err, msg=f"lint must not crash on unhashable MNC constraint_id:\n{err}")
+        self.assertIn("schema", out, msg=f"expected schema finding:\n{out}")
+
+    def test_non_string_claim_text_does_not_crash_cv_inv_4_dedupe(self) -> None:
+        # CV-INV-4 dedupe key constructs hashlib.sha256((claim_text or "").encode())
+        # — if claim_text is a list / dict / int (schema-invalid), the `or ""`
+        # idiom passes the non-string through and .encode() raises AttributeError.
+        # Codex round 2 adversarial probing surfaced this same class.
+        body = build_passport()
+        body["constraint_violations"] = [
+            {
+                "finding_id": "CV-001",
+                "claim_text": ["not", "a", "string"],
+                "section_path": "Results > Findings",
+                "violated_constraint_id": "MNC-1",
+                "scoped_manifest_id": MANIFEST_ID,
+                "manifest_claim_id": None,
+                "judge_verdict": "VIOLATED",
+                "rationale": "rationale",
+                "judge_model": "gpt-5.5-xhigh",
+                "judge_run_at": "2026-05-15T10:14:00Z",
+                "rule_version": "D4-a-v1",
+            }
+        ]
+        path = write_passport(self.tmp, body)
+        code, out, err = run_lint(path)
+        self.assertEqual(code, 1, msg=f"expected exit=1; got {code}\nstderr:\n{err}")
+        self.assertNotIn("Traceback", err, msg=f"lint must not crash on non-string claim_text:\n{err}")
+        self.assertIn("schema", out, msg=f"expected schema finding:\n{out}")
+
+
+# v3.9.1 / #130 — manifest_id non-string guard in _build_manifest_index +
+# _build_manifest_constraint_index. Schema validator records the type
+# mismatch finding; the index builders must skip non-string IDs cleanly
+# instead of raising TypeError("unhashable type") on setdefault() / [mid]=.
+class TSManifestIdNonStringGuard(_LintTestBase):
+    """Issue #130: manifest_id of type list/dict must not crash index builders."""
+
+    def test_manifest_id_as_list_does_not_crash(self) -> None:
+        body = build_passport()
+        body["claim_intent_manifests"][0]["manifest_id"] = ["oops"]
+        path = write_passport(self.tmp, body)
+        code, out, err = run_lint(path)
+        self.assertEqual(code, 1, msg=f"expected exit=1; got {code}\nstderr:\n{err}")
+        self.assertNotIn(
+            "Traceback",
+            err,
+            msg=f"lint must not crash on list manifest_id (unhashable in setdefault):\n{err}",
+        )
+        self.assertIn("schema", out, msg=f"expected schema finding:\n{out}")
+
+    def test_manifest_id_as_dict_does_not_crash(self) -> None:
+        body = build_passport()
+        body["claim_intent_manifests"][0]["manifest_id"] = {"oops": "dict id"}
+        path = write_passport(self.tmp, body)
+        code, out, err = run_lint(path)
+        self.assertEqual(code, 1, msg=f"expected exit=1; got {code}\nstderr:\n{err}")
+        self.assertNotIn(
+            "Traceback",
+            err,
+            msg=f"lint must not crash on dict manifest_id (unhashable in setdefault):\n{err}",
+        )
+        self.assertIn("schema", out, msg=f"expected schema finding:\n{out}")
+
+
+if __name__ == "__main__":
+    unittest.main()