"""Phase 6.3 acceptance tests for ARS v3.6.7 §3.7 invariant lint.

Every row in spec §3.7 families A-F gets at least one positive (valid
fixture passes) and one negative (deliberately-broken fixture fails)
test. The aggregator (run_checks) is also smoke-tested on a fully-
valid synthetic proposal + persisted bundle.

Per the user's iron law: positive + negative tests for every rule.
"""
from __future__ import annotations

import copy
import json
import re
import subprocess
import sys
from pathlib import Path
from typing import Any

import pytest

from scripts.check_audit_artifact_consistency import (
    LintContext,
    LintError,
    check_a1,
    check_a2,
    check_a3,
    check_a4,
    check_a5,
    check_a6,
    check_a7,
    check_b1,
    check_b2,
    check_b3,
    check_b4,
    check_b5,
    check_b6,
    check_b7,
    check_b8,
    check_b9,
    check_b10,
    check_c1,
    check_c2,
    check_c3,
    check_c4,
    check_d1,
    check_d2,
    check_d3,
    check_d4,
    check_e1_e2_e6,
    check_e3_e4,
    check_e5,
    check_e7,
    check_f1,
    check_f2,
    check_f3,
    compute_bundle_manifest,
    main,
    run_checks,
    run_example_harness,
)

REPO = Path(__file__).resolve().parent.parent


# ---------------------------------------------------------------------------
# Synthetic fixtures (kept in-memory; written to tmp_path when files needed)
# ---------------------------------------------------------------------------

VALID_RUN_ID = "2026-04-30T15-22-04Z-d8f3"
VALID_THREAD_ID = "019de371-4c13-7521-8af7-fccf6bd23279"


def make_valid_verdict_file_minor() -> dict[str, Any]:
    return {
        "run_id": VALID_RUN_ID,
        "verdict_status": "MINOR",
        "round": 2,
        "target_rounds": 3,
        "finding_counts": {"p1": 0, "p2": 0, "p3": 1},
        "findings": [
            {"id": "F-007", "severity": "P3", "dimension": "3.7",
             "file": "chapter_4/synthesis.md", "line": 482,
             "description": "deictic temporal phrase",
             "suggested_fix": "replace with explicit date"},
        ],
        "generated_at": "2026-04-30T15:22:58.471Z",
        "generated_by": "scripts/run_codex_audit.sh",
        "generator_version": "1.0.0",
    }


def make_valid_verdict_file_pass() -> dict[str, Any]:
    return {
        "run_id": VALID_RUN_ID,
        "verdict_status": "PASS",
        "round": 1,
        "target_rounds": 3,
        "finding_counts": {"p1": 0, "p2": 0, "p3": 0},
        "findings": [],
        "generated_at": "2026-04-30T15:22:58.471Z",
        "generated_by": "scripts/run_codex_audit.sh",
        "generator_version": "1.0.0",
    }


def make_valid_verdict_file_audit_failed() -> dict[str, Any]:
    return {
        "run_id": VALID_RUN_ID,
        "verdict_status": "AUDIT_FAILED",
        "round": 1,
        "target_rounds": 3,
        "finding_counts": {"p1": 0, "p2": 0, "p3": 0},
        "findings": [],
        "failure_reason": "codex exit 70: network timeout",
        "generated_at": "2026-04-30T15:22:58.471Z",
        "generated_by": "scripts/run_codex_audit.sh",
        "generator_version": "1.0.0",
    }


def make_valid_persisted_entry_minor() -> dict[str, Any]:
    return {
        "stage": 2,
        "agent": "synthesis_agent",
        "deliverable_path": "chapter_4/synthesis.md",
        "deliverable_sha": "a" * 64,
        "run_id": VALID_RUN_ID,
        "bundle_id": "phase2-chapter4-2026-04-30",
        "bundle_manifest_sha": "9" * 64,
        "artifact_paths": {
            "jsonl": f"{VALID_RUN_ID}.jsonl",
            "sidecar": f"{VALID_RUN_ID}.meta.json",
            "verdict": f"{VALID_RUN_ID}.verdict.yaml",
        },
        "verdict": {
            "status": "MINOR",
            "round": 2,
            "target_rounds": 3,
            "finding_counts": {"p1": 0, "p2": 0, "p3": 1},
            "verified_at": "2026-04-30T15:23:11.847Z",
            "verified_by": "pipeline_orchestrator_agent",
        },
    }


def make_valid_proposal_entry_pass() -> dict[str, Any]:
    return {
        "stage": 2,
        "agent": "synthesis_agent",
        "deliverable_path": "chapter_4/synthesis.md",
        "deliverable_sha": "a" * 64,
        "run_id": VALID_RUN_ID,
        "bundle_id": "phase2-chapter4-2026-04-30",
        "bundle_manifest_sha": "9" * 64,
        "artifact_paths": {
            "jsonl": f"{VALID_RUN_ID}.jsonl",
            "sidecar": f"{VALID_RUN_ID}.meta.json",
            "verdict": f"{VALID_RUN_ID}.verdict.yaml",
        },
        "verdict": {
            "status": "PASS",
            "round": 1,
            "target_rounds": 3,
            "finding_counts": {"p1": 0, "p2": 0, "p3": 0},
        },
    }


def make_valid_sidecar(template_sha: str = "1" * 64) -> dict[str, Any]:
    primary = [{"path": "chapter_4/synthesis.md", "sha": "a" * 64}]
    supporting = [{"path": "chapter_4/bibliography.json", "sha": "b" * 64}]
    _, manifest_sha = compute_bundle_manifest(
        primary, supporting, "shared/templates/codex_audit_multifile_template.md", template_sha
    )
    return {
        "run_id": VALID_RUN_ID,
        "codex_cli_version": "0.128.0",
        "runner": {
            "hostname": "runner.example.local",
            "cwd": "/path/to/academic-research-skills",
            "git_sha": "b4fbffd",
            "git_dirty": False,
        },
        "timing": {
            "started_at": "2026-04-30T15:22:04.123Z",
            "ended_at": "2026-04-30T15:22:58.471Z",
            "duration_seconds": 54.348,
        },
        "process": {
            "exit_code": 0,
            "stdout_path": f"audit_artifacts/{VALID_RUN_ID}.stdout",
            "stderr_path": f"audit_artifacts/{VALID_RUN_ID}.stderr",
        },
        "stream": {"jsonl_thread_id": VALID_THREAD_ID},
        "prompt": {
            "audit_template_path": "shared/templates/codex_audit_multifile_template.md",
            "audit_template_sha": template_sha,
            "bundle": {
                "bundle_id": "phase2-chapter4-2026-04-30",
                "bundle_manifest_sha": manifest_sha,
                "primary_deliverables": primary,
                "supporting_context": supporting,
            },
        },
    }


def make_valid_jsonl_events_no_tool() -> list[dict[str, Any]]:
    return [
        {"type": "thread.started", "thread_id": VALID_THREAD_ID},
        {"type": "turn.started"},
        {"type": "item.completed",
         "item": {"id": "item_0", "type": "agent_message",
                  "text": "## Section 6 — Verdict\n\nRound 1: 0 findings of any severity. Convergence reached.\n"}},
        {"type": "turn.completed",
         "usage": {"input_tokens": 100, "cached_input_tokens": 0,
                   "output_tokens": 50, "reasoning_output_tokens": 25}},
    ]


def make_valid_jsonl_events_tool_using() -> list[dict[str, Any]]:
    return [
        {"type": "thread.started", "thread_id": VALID_THREAD_ID},
        {"type": "turn.started"},
        {"type": "item.started", "item": {"id": "item_1", "type": "command_execution"}},
        {"type": "item.completed", "item": {"id": "item_1", "type": "command_execution"}},
        {"type": "item.completed",
         "item": {"id": "item_2", "type": "agent_message",
                  "text": "## Section 6 — Verdict\n\nRound 1: 0 findings of any severity. Convergence reached.\n"}},
        {"type": "turn.completed",
         "usage": {"input_tokens": 100, "cached_input_tokens": 0,
                   "output_tokens": 50, "reasoning_output_tokens": 25}},
    ]


# ---------------------------------------------------------------------------
# Family A
# ---------------------------------------------------------------------------


class TestA1:
    """A1 — verdict.status agrees with finding_counts and failure_reason."""

    def test_pass_with_zero_counts_passes(self):
        v = make_valid_verdict_file_pass()
        assert check_a1(None, v) == []

    def test_pass_with_nonzero_p1_fails(self):
        v = make_valid_verdict_file_pass()
        v["finding_counts"]["p1"] = 1
        findings = check_a1(None, v)
        assert any(f.rule_id == "A1" and "PASS" in f.message for f in findings)

    def test_minor_with_p3_le_3_passes(self):
        v = make_valid_verdict_file_minor()
        assert check_a1(None, v) == []

    def test_minor_with_p3_4_fails(self):
        v = make_valid_verdict_file_minor()
        v["finding_counts"]["p3"] = 4
        findings = check_a1(None, v)
        assert any("MINOR" in f.message for f in findings)

    def test_minor_with_zero_counts_fails(self):
        # Codex round 10 P2: MINOR with p1=p2=p3=0 is malformed because the
        # wrapper classifies zero findings as PASS, not MINOR. A hand-edited
        # verdict file claiming zero-count MINOR would otherwise pass A1
        # and send the orchestrator down the MINOR escalation path with
        # no findings to act on.
        v = make_valid_verdict_file_minor()
        v["finding_counts"] = {"p1": 0, "p2": 0, "p3": 0}
        findings = check_a1(None, v)
        assert any(f.rule_id == "A1" and "MINOR" in f.message for f in findings), [
            f.render() for f in findings
        ]

    def test_material_with_p1_gt_0_passes(self):
        v = {**make_valid_verdict_file_pass(),
             "verdict_status": "MATERIAL",
             "finding_counts": {"p1": 1, "p2": 0, "p3": 0}}
        assert check_a1(None, v) == []

    def test_material_all_zero_fails(self):
        v = {**make_valid_verdict_file_pass(), "verdict_status": "MATERIAL"}
        findings = check_a1(None, v)
        assert any("MATERIAL" in f.message for f in findings)

    def test_audit_failed_with_failure_reason_passes(self):
        v = make_valid_verdict_file_audit_failed()
        assert check_a1(None, v) == []

    def test_audit_failed_missing_failure_reason_fails(self):
        v = make_valid_verdict_file_audit_failed()
        del v["failure_reason"]
        findings = check_a1(None, v)
        assert any("AUDIT_FAILED" in f.message for f in findings)

    def test_pass_with_failure_reason_fails(self):
        v = make_valid_verdict_file_pass()
        v["failure_reason"] = "should not be here"
        findings = check_a1(None, v)
        assert any("PASS forbids failure_reason" in f.message for f in findings)


class TestA2:
    """A2 — failure_reason iff status == AUDIT_FAILED."""

    def test_audit_failed_with_reason_passes(self):
        v = make_valid_verdict_file_audit_failed()
        assert check_a2(None, v) == []

    def test_audit_failed_without_reason_fails(self):
        v = make_valid_verdict_file_audit_failed()
        del v["failure_reason"]
        findings = check_a2(None, v)
        assert any(f.rule_id == "A2" for f in findings)

    def test_minor_with_reason_fails(self):
        v = make_valid_verdict_file_minor()
        v["failure_reason"] = "leftover"
        findings = check_a2(None, v)
        assert any(f.rule_id == "A2" and "forbidden" in f.message for f in findings)


class TestA3:
    """A3 — round <= target_rounds."""

    def test_round_le_target_passes(self):
        v = make_valid_verdict_file_minor()  # round=2 target=3
        assert check_a3(None, v) == []

    def test_round_gt_target_fails(self):
        v = make_valid_verdict_file_minor()
        v["round"] = 5
        findings = check_a3(None, v)
        assert any(f.rule_id == "A3" for f in findings)


class TestA4:
    """A4 — acknowledgement only on persisted MATERIAL."""

    def test_persisted_material_with_ack_passes(self):
        e = make_valid_persisted_entry_minor()
        e["verdict"]["status"] = "MATERIAL"
        e["verdict"]["finding_counts"] = {"p1": 1, "p2": 0, "p3": 0}
        e["acknowledgement"] = {
            "finding_ids": ["F-001"],
            "acknowledged_at": e["verdict"]["verified_at"],
            "acknowledged_by": "user",
        }
        assert check_a4(e, "persisted") == []

    def test_proposal_with_ack_fails(self):
        e = make_valid_proposal_entry_pass()
        e["acknowledgement"] = {"finding_ids": ["F-001"],
                                 "acknowledged_at": "2026-04-30T15:23:11.847Z",
                                 "acknowledged_by": "user"}
        findings = check_a4(e, "proposal")
        assert any(f.rule_id == "A4" for f in findings)

    def test_persisted_pass_with_ack_fails(self):
        e = make_valid_persisted_entry_minor()
        e["verdict"]["status"] = "PASS"
        e["verdict"]["finding_counts"] = {"p1": 0, "p2": 0, "p3": 0}
        e["acknowledgement"] = {"finding_ids": ["F-001"],
                                 "acknowledged_at": e["verdict"]["verified_at"],
                                 "acknowledged_by": "user"}
        findings = check_a4(e, "persisted")
        assert any(f.rule_id == "A4" and "MATERIAL" in f.message for f in findings)


class TestA5:
    """A5 — finding_counts.pN == count(findings[severity==PN])."""

    def test_counts_agree_passes(self):
        v = make_valid_verdict_file_minor()
        assert check_a5(v) == []

    def test_count_disagrees_fails(self):
        v = make_valid_verdict_file_minor()
        v["finding_counts"]["p3"] = 5  # but findings only has 1 P3
        findings = check_a5(v)
        assert any(f.rule_id == "A5" and "p3" in f.message for f in findings)


class TestA6:
    """A6 — AUDIT_FAILED requires findings == []."""

    def test_audit_failed_empty_findings_passes(self):
        v = make_valid_verdict_file_audit_failed()
        assert check_a6(v) == []

    def test_audit_failed_with_findings_fails(self):
        v = make_valid_verdict_file_audit_failed()
        v["findings"] = [{"id": "F-001", "severity": "P3", "dimension": "3.7",
                          "file": "x.md", "line": 1, "description": "x", "suggested_fix": "y"}]
        findings = check_a6(v)
        assert any(f.rule_id == "A6" for f in findings)


class TestA7:
    """A7 — JSONL stream tool-event pairing."""

    def test_no_tool_events_passes(self):
        events = make_valid_jsonl_events_no_tool()
        assert check_a7(events) == []

    def test_tool_using_events_pass(self):
        events = make_valid_jsonl_events_tool_using()
        assert check_a7(events) == []

    def test_orphan_tool_completion_fails(self):
        events = [
            {"type": "thread.started", "thread_id": VALID_THREAD_ID},
            {"type": "turn.started"},
            {"type": "item.completed",
             "item": {"id": "item_orphan", "type": "command_execution"}},
            {"type": "turn.completed",
             "usage": {"input_tokens": 1, "cached_input_tokens": 0,
                       "output_tokens": 1, "reasoning_output_tokens": 0}},
        ]
        findings = check_a7(events)
        assert any(f.rule_id == "A7" and "orphan" in f.message for f in findings)

    def test_unmatched_tool_start_fails(self):
        events = [
            {"type": "thread.started", "thread_id": VALID_THREAD_ID},
            {"type": "item.started", "item": {"id": "item_unmatched", "type": "command_execution"}},
            {"type": "turn.completed",
             "usage": {"input_tokens": 1, "cached_input_tokens": 0,
                       "output_tokens": 1, "reasoning_output_tokens": 0}},
        ]
        findings = check_a7(events)
        assert any(f.rule_id == "A7" and "unmatched" in f.message for f in findings)

    def test_duplicate_started_fails(self):
        events = [
            {"type": "thread.started", "thread_id": VALID_THREAD_ID},
            {"type": "item.started", "item": {"id": "item_x", "type": "command_execution"}},
            {"type": "item.started", "item": {"id": "item_x", "type": "command_execution"}},
            {"type": "item.completed", "item": {"id": "item_x", "type": "command_execution"}},
            {"type": "turn.completed",
             "usage": {"input_tokens": 1, "cached_input_tokens": 0,
                       "output_tokens": 1, "reasoning_output_tokens": 0}},
        ]
        findings = check_a7(events)
        assert any(f.rule_id == "A7" and "duplicate item.started" in f.message for f in findings)

    def test_completed_before_started_fails(self):
        # An item.completed appearing before its item.started would be classified
        # as orphan because we scan top-down. Either error covers the violation.
        events = [
            {"type": "thread.started", "thread_id": VALID_THREAD_ID},
            {"type": "item.completed", "item": {"id": "item_z", "type": "command_execution"}},
            {"type": "item.started", "item": {"id": "item_z", "type": "command_execution"}},
            {"type": "turn.completed",
             "usage": {"input_tokens": 1, "cached_input_tokens": 0,
                       "output_tokens": 1, "reasoning_output_tokens": 0}},
        ]
        findings = check_a7(events)
        # We expect at least one A7 finding (orphan or ordering)
        assert any(f.rule_id == "A7" for f in findings)


# ---------------------------------------------------------------------------
# Family B
# ---------------------------------------------------------------------------


class TestB1:
    """B1 — sidecar.stream.jsonl_thread_id matches JSONL.thread.started.thread_id."""

    def test_matching_thread_id_passes(self):
        s = make_valid_sidecar()
        events = make_valid_jsonl_events_no_tool()
        v = make_valid_verdict_file_minor()
        assert check_b1(s, events, v) == []

    def test_mismatched_thread_id_fails(self):
        s = make_valid_sidecar()
        s["stream"]["jsonl_thread_id"] = "11111111-1111-1111-1111-111111111111"
        events = make_valid_jsonl_events_no_tool()
        v = make_valid_verdict_file_minor()
        findings = check_b1(s, events, v)
        assert any(f.rule_id == "B1" for f in findings)

    def test_audit_failed_suspends_b1(self):
        s = make_valid_sidecar()
        s["stream"]["jsonl_thread_id"] = ""  # AUDIT_FAILED permits empty
        v = make_valid_verdict_file_audit_failed()
        # JSONL may be malformed/missing on AUDIT_FAILED; but B1 is suspended
        assert check_b1(s, [], v) == []


class TestB2:
    """B2 — entry.deliverable_sha == sidecar.primary_sha == disk SHA."""

    def test_matching_shas_passes(self, tmp_path: Path):
        e = make_valid_persisted_entry_minor()
        s = make_valid_sidecar()
        # repo_root is tmp_path with no deliverable file — disk verify skipped
        assert check_b2(e, s, tmp_path) == []

    def test_entry_sidecar_sha_disagree_fails(self):
        e = make_valid_persisted_entry_minor()
        s = make_valid_sidecar()
        s["prompt"]["bundle"]["primary_deliverables"][0]["sha"] = "f" * 64
        findings = check_b2(e, s, REPO)
        assert any(f.rule_id == "B2" for f in findings)

    def test_disk_sha_mismatch_fails(self, tmp_path: Path):
        e = make_valid_persisted_entry_minor()
        e["deliverable_path"] = "deliverable.md"
        s = make_valid_sidecar()
        s["prompt"]["bundle"]["primary_deliverables"] = [
            {"path": "deliverable.md", "sha": "a" * 64}
        ]
        # Write a real file but with content whose SHA is NOT all-a's
        (tmp_path / "deliverable.md").write_text("totally different content\n")
        findings = check_b2(e, s, tmp_path)
        assert any(f.rule_id == "B2" and "current_file" in f.message for f in findings)


class TestB3:
    """B3 — bundle_manifest_sha agrees with recomputed manifest."""

    def test_matching_manifest_passes(self):
        s = make_valid_sidecar()
        # repo_root REPO doesn't have these files; but declared SHAs will recompute
        # consistently because the helper used the same SHAs.
        assert check_b3(s, REPO / "nonexistent_subtree") == []

    def test_mismatched_manifest_fails(self):
        s = make_valid_sidecar()
        s["prompt"]["bundle"]["bundle_manifest_sha"] = "0" * 64
        findings = check_b3(s, REPO / "nonexistent_subtree")
        assert any(f.rule_id == "B3" for f in findings)

    def test_missing_bundle_file_fails(self, tmp_path: Path):
        # Codex round 2 P2: when a bundle file is missing on disk, B3 must
        # NOT fall back to the sidecar-declared SHA — that would let a
        # deleted/moved file silently pass. With a real .git/ marker, B3
        # Step 2 is required to flag the missing file as stale/unverifiable.
        # Synthesize a tmp repo with a real .git marker but missing bundle
        # files; the sidecar's declared paths are intentionally absent.
        (tmp_path / ".git").mkdir()  # marker only; B3 doesn't run git commands
        s = make_valid_sidecar()  # references deliverable.md / bibliography.json / verification.md / template
        findings = check_b3(s, tmp_path)
        assert any(
            f.rule_id == "B3" and "missing on disk" in f.message
            for f in findings
        ), [f.render() for f in findings]


class TestB4:
    """B4 — runner.git_sha resolves to a real commit."""

    def test_real_git_sha_passes(self):
        # Use the actual repo HEAD
        result = subprocess.run(
            ["git", "rev-parse", "HEAD"],
            capture_output=True, text=True, cwd=REPO,
        )
        head = result.stdout.strip()
        s = make_valid_sidecar()
        s["runner"]["git_sha"] = head[:12]
        assert check_b4(s, REPO) == []

    def test_fake_git_sha_fails(self):
        s = make_valid_sidecar()
        s["runner"]["git_sha"] = "deadbeefdeadbeef"
        findings = check_b4(s, REPO)
        assert any(f.rule_id == "B4" for f in findings)

    def test_outside_git_repo_skipped(self, tmp_path: Path):
        # tmp_path has no .git/, so B4 is skipped (no false positive on synthetic fixtures)
        s = make_valid_sidecar()
        s["runner"]["git_sha"] = "deadbeef"
        assert check_b4(s, tmp_path) == []


class TestB5:
    """B5 — ended_at - started_at == duration_seconds (±1s)."""

    def test_consistent_timing_passes(self):
        s = make_valid_sidecar()
        assert check_b5(s) == []

    def test_inconsistent_timing_fails(self):
        s = make_valid_sidecar()
        s["timing"]["duration_seconds"] = 999.0
        findings = check_b5(s)
        assert any(f.rule_id == "B5" for f in findings)


class TestB6:
    """B6 — exit_code == 0 for non-AUDIT_FAILED."""

    def test_zero_exit_minor_passes(self):
        s = make_valid_sidecar()
        v = make_valid_verdict_file_minor()
        assert check_b6(s, v) == []

    def test_nonzero_exit_minor_fails(self):
        s = make_valid_sidecar()
        s["process"]["exit_code"] = 70
        v = make_valid_verdict_file_minor()
        findings = check_b6(s, v)
        assert any(f.rule_id == "B6" for f in findings)

    def test_nonzero_exit_audit_failed_passes(self):
        s = make_valid_sidecar()
        s["process"]["exit_code"] = 70
        v = make_valid_verdict_file_audit_failed()
        assert check_b6(s, v) == []


class TestB7:
    """B7 — entry.run_id == sidecar.run_id == bare basename of every co-located file."""

    def test_matching_run_ids_pass(self, tmp_path: Path):
        e = make_valid_persisted_entry_minor()
        s = make_valid_sidecar()
        sidecar_path = tmp_path / f"{VALID_RUN_ID}.meta.json"
        jsonl_path = tmp_path / f"{VALID_RUN_ID}.jsonl"
        verdict_path = tmp_path / f"{VALID_RUN_ID}.verdict.yaml"
        # Don't actually need to write the files for B7
        assert check_b7(e, s, None, sidecar_path, jsonl_path, verdict_path, "persisted") == []

    def test_entry_sidecar_run_id_mismatch_fails(self, tmp_path: Path):
        e = make_valid_persisted_entry_minor()
        s = make_valid_sidecar()
        s["run_id"] = "2026-04-30T15-22-04Z-aaaa"
        findings = check_b7(e, s, None, tmp_path / f"{VALID_RUN_ID}.meta.json",
                             tmp_path / f"{VALID_RUN_ID}.jsonl",
                             tmp_path / f"{VALID_RUN_ID}.verdict.yaml", "persisted")
        assert any(f.rule_id == "B7" and "entry.run_id" in f.message for f in findings)

    def test_basename_mismatch_fails(self, tmp_path: Path):
        e = make_valid_persisted_entry_minor()
        s = make_valid_sidecar()
        # sidecar path basename doesn't match run_id
        wrong_path = tmp_path / "totally-wrong-stem.meta.json"
        findings = check_b7(e, s, None, wrong_path, None, None, "persisted")
        assert any(f.rule_id == "B7" and "basename" in f.message for f in findings)


class TestB8:
    """B8 — verified_at == acknowledged_at on ack entries."""

    def test_matching_timestamps_pass(self):
        e = make_valid_persisted_entry_minor()
        e["verdict"]["status"] = "MATERIAL"
        e["verdict"]["finding_counts"] = {"p1": 1, "p2": 0, "p3": 0}
        e["acknowledgement"] = {
            "finding_ids": ["F-001"],
            "acknowledged_at": e["verdict"]["verified_at"],
            "acknowledged_by": "user",
        }
        assert check_b8(e, "persisted") == []

    def test_mismatched_timestamps_fail(self):
        e = make_valid_persisted_entry_minor()
        e["verdict"]["status"] = "MATERIAL"
        e["verdict"]["finding_counts"] = {"p1": 1, "p2": 0, "p3": 0}
        e["acknowledgement"] = {
            "finding_ids": ["F-001"],
            "acknowledged_at": "2026-04-30T16:00:00.000Z",
            "acknowledged_by": "user",
        }
        findings = check_b8(e, "persisted")
        assert any(f.rule_id == "B8" for f in findings)


class TestB9:
    """B9 — entry.bundle_id == sidecar.prompt.bundle.bundle_id (when present)."""

    def test_matching_bundle_id_passes(self):
        e = make_valid_persisted_entry_minor()
        s = make_valid_sidecar()
        assert check_b9(e, s) == []

    def test_no_bundle_id_skipped(self):
        e = make_valid_persisted_entry_minor()
        del e["bundle_id"]
        s = make_valid_sidecar()
        assert check_b9(e, s) == []

    def test_mismatched_bundle_id_fails(self):
        e = make_valid_persisted_entry_minor()
        s = make_valid_sidecar()
        s["prompt"]["bundle"]["bundle_id"] = "different-bundle"
        findings = check_b9(e, s)
        assert any(f.rule_id == "B9" for f in findings)


class TestB10:
    """B10 — ack finding_ids: non-empty + all exist + full coverage."""

    def test_full_coverage_passes(self):
        e = make_valid_persisted_entry_minor()
        e["verdict"]["status"] = "MATERIAL"
        e["verdict"]["finding_counts"] = {"p1": 1, "p2": 0, "p3": 0}
        e["acknowledgement"] = {
            "finding_ids": ["F-001"],
            "acknowledged_at": e["verdict"]["verified_at"],
            "acknowledged_by": "user",
        }
        v = make_valid_verdict_file_minor()
        v["verdict_status"] = "MATERIAL"
        v["finding_counts"] = {"p1": 1, "p2": 0, "p3": 0}
        v["findings"] = [{"id": "F-001", "severity": "P1", "dimension": "3.7",
                          "file": "x.md", "line": 1, "description": "x",
                          "suggested_fix": "y"}]
        assert check_b10(e, v, "persisted") == []

    def test_unknown_finding_id_fails(self):
        e = make_valid_persisted_entry_minor()
        e["verdict"]["status"] = "MATERIAL"
        e["verdict"]["finding_counts"] = {"p1": 1, "p2": 0, "p3": 0}
        e["acknowledgement"] = {
            "finding_ids": ["F-999"],
            "acknowledged_at": e["verdict"]["verified_at"],
            "acknowledged_by": "user",
        }
        v = make_valid_verdict_file_minor()
        v["verdict_status"] = "MATERIAL"
        v["finding_counts"] = {"p1": 1, "p2": 0, "p3": 0}
        v["findings"] = [{"id": "F-001", "severity": "P1", "dimension": "3.7",
                          "file": "x.md", "line": 1, "description": "x",
                          "suggested_fix": "y"}]
        findings = check_b10(e, v, "persisted")
        assert any(f.rule_id == "B10" and "unknown" in f.message for f in findings)

    def test_partial_coverage_fails(self):
        e = make_valid_persisted_entry_minor()
        e["verdict"]["status"] = "MATERIAL"
        e["verdict"]["finding_counts"] = {"p1": 2, "p2": 0, "p3": 0}
        e["acknowledgement"] = {
            "finding_ids": ["F-001"],
            "acknowledged_at": e["verdict"]["verified_at"],
            "acknowledged_by": "user",
        }
        v = make_valid_verdict_file_minor()
        v["verdict_status"] = "MATERIAL"
        v["finding_counts"] = {"p1": 2, "p2": 0, "p3": 0}
        v["findings"] = [
            {"id": "F-001", "severity": "P1", "dimension": "3.7",
             "file": "x.md", "line": 1, "description": "x", "suggested_fix": "y"},
            {"id": "F-002", "severity": "P1", "dimension": "3.7",
             "file": "x.md", "line": 2, "description": "y", "suggested_fix": "z"},
        ]
        findings = check_b10(e, v, "persisted")
        assert any(f.rule_id == "B10" and "coverage" in f.message for f in findings)

    def test_empty_finding_ids_fails(self):
        e = make_valid_persisted_entry_minor()
        e["verdict"]["status"] = "MATERIAL"
        e["verdict"]["finding_counts"] = {"p1": 1, "p2": 0, "p3": 0}
        e["acknowledgement"] = {
            "finding_ids": [],
            "acknowledged_at": e["verdict"]["verified_at"],
            "acknowledged_by": "user",
        }
        v = make_valid_verdict_file_minor()
        findings = check_b10(e, v, "persisted")
        assert any(f.rule_id == "B10" and "non-empty" in f.message for f in findings)


# ---------------------------------------------------------------------------
# Family C
# ---------------------------------------------------------------------------


class TestC1:
    """C1 — entry.verdict mirrors verdict file."""

    def test_matching_mirror_passes(self):
        e = make_valid_persisted_entry_minor()
        v = make_valid_verdict_file_minor()
        assert check_c1(e, v) == []

    def test_status_drift_fails(self):
        e = make_valid_persisted_entry_minor()
        v = make_valid_verdict_file_minor()
        v["verdict_status"] = "PASS"
        findings = check_c1(e, v)
        assert any(f.rule_id == "C1" and "status" in f.message for f in findings)

    def test_finding_counts_drift_fails(self):
        e = make_valid_persisted_entry_minor()
        v = make_valid_verdict_file_minor()
        v["finding_counts"] = {"p1": 0, "p2": 0, "p3": 5}
        findings = check_c1(e, v)
        assert any(f.rule_id == "C1" and "finding_counts" in f.message for f in findings)


class TestC2:
    """C2 — entry.bundle_manifest_sha == sidecar.bundle_manifest_sha."""

    def test_matching_sha_passes(self):
        e = make_valid_persisted_entry_minor()
        s = make_valid_sidecar()
        e["bundle_manifest_sha"] = s["prompt"]["bundle"]["bundle_manifest_sha"]
        assert check_c2(e, s) == []

    def test_drift_fails(self):
        e = make_valid_persisted_entry_minor()
        s = make_valid_sidecar()
        e["bundle_manifest_sha"] = "0" * 64
        findings = check_c2(e, s)
        assert any(f.rule_id == "C2" for f in findings)


class TestC3:
    """C3 — ack append copies prior entry byte-for-byte except verified_at/by."""

    def test_byte_for_byte_copy_passes(self):
        prior = make_valid_persisted_entry_minor()
        prior["verdict"]["status"] = "MATERIAL"
        prior["verdict"]["finding_counts"] = {"p1": 1, "p2": 0, "p3": 0}
        new = copy.deepcopy(prior)
        new["verdict"]["verified_at"] = "2026-04-30T15:24:00.000Z"  # bumped
        new["acknowledgement"] = {
            "finding_ids": ["F-001"],
            "acknowledged_at": new["verdict"]["verified_at"],
            "acknowledged_by": "user",
        }
        assert check_c3(new, prior) == []

    def test_drift_in_copied_field_fails(self):
        prior = make_valid_persisted_entry_minor()
        new = copy.deepcopy(prior)
        new["deliverable_sha"] = "f" * 64  # diverged
        new["verdict"]["verified_at"] = "2026-04-30T15:24:00.000Z"
        findings = check_c3(new, prior)
        assert any(f.rule_id == "C3" and "deliverable_sha" in f.message for f in findings)

    def test_same_verified_at_fails(self):
        prior = make_valid_persisted_entry_minor()
        new = copy.deepcopy(prior)  # same verified_at
        findings = check_c3(new, prior)
        assert any(f.rule_id == "C3" and "freshly set" in f.message for f in findings)


class TestC4:
    """C4 — entry.deliverable_sha == sidecar.primary[].sha (entry-side half of B2)."""

    def test_matching_passes(self):
        e = make_valid_persisted_entry_minor()
        s = make_valid_sidecar()
        assert check_c4(e, s) == []

    def test_drift_fails(self):
        e = make_valid_persisted_entry_minor()
        s = make_valid_sidecar()
        s["prompt"]["bundle"]["primary_deliverables"][0]["sha"] = "f" * 64
        findings = check_c4(e, s)
        assert any(f.rule_id == "C4" for f in findings)


# ---------------------------------------------------------------------------
# Family D
# ---------------------------------------------------------------------------


class TestD1:
    """D1 — duplicate verified_at within (stage,agent,sha,run_id) group."""

    def test_unique_verified_at_passes(self):
        e1 = make_valid_persisted_entry_minor()
        e2 = make_valid_persisted_entry_minor()
        e2["verdict"]["verified_at"] = "2026-04-30T15:23:12.847Z"
        e2["run_id"] = "2026-04-30T15-22-04Z-d8f4"  # different run
        assert check_d1([e1, e2]) == []

    def test_duplicate_verified_at_fails(self):
        e1 = make_valid_persisted_entry_minor()
        e2 = copy.deepcopy(e1)
        # same key + same verified_at → duplicate
        findings = check_d1([e1, e2])
        assert any(f.rule_id == "D1" for f in findings)


class TestD2:
    """D2 — proposals sharing started_at."""

    def test_distinct_started_at_passes(self):
        proposals = [
            {"sidecar": {"timing": {"started_at": "2026-04-30T15:22:04.123Z"}},
             "entry": {"run_id": "2026-04-30T15-22-04Z-aaaa"}},
            {"sidecar": {"timing": {"started_at": "2026-04-30T15:22:05.123Z"}},
             "entry": {"run_id": "2026-04-30T15-22-05Z-bbbb"}},
        ]
        assert check_d2(proposals) == []

    def test_shared_started_at_warns(self):
        proposals = [
            {"sidecar": {"timing": {"started_at": "2026-04-30T15:22:04.123Z"}},
             "entry": {"run_id": "2026-04-30T15-22-04Z-aaaa"}},
            {"sidecar": {"timing": {"started_at": "2026-04-30T15:22:04.123Z"}},
             "entry": {"run_id": "2026-04-30T15-22-04Z-bbbb"}},
        ]
        findings = check_d2(proposals)
        assert any(f.rule_id == "D2" for f in findings)


class TestD3:
    """D3 — verified_at strictly monotonic."""

    def test_monotonic_ledger_passes(self):
        e1 = make_valid_persisted_entry_minor()
        e2 = copy.deepcopy(e1)
        e2["verdict"]["verified_at"] = "2026-04-30T15:23:12.847Z"
        e2["run_id"] = "2026-04-30T15-22-04Z-d8f4"
        assert check_d3([e1, e2]) == []

    def test_non_monotonic_fails(self):
        e1 = make_valid_persisted_entry_minor()
        e2 = copy.deepcopy(e1)
        e2["verdict"]["verified_at"] = "2026-04-30T15:00:00.000Z"  # earlier than e1
        e2["run_id"] = "2026-04-30T15-22-04Z-d8f4"
        findings = check_d3([e1, e2])
        assert any(f.rule_id == "D3" for f in findings)


class TestD4:
    """D4 — surface the supersession requirement when proposal round is
    higher than persisted round (spec §3.7 family D + §5.6 A1.5)."""

    def test_higher_round_fires_supersession(self):
        # The lint should SURFACE the supersession (proposal preempts
        # persisted Path A) so the caller sees it before the orchestrator
        # processes the artifacts.
        findings = check_d4(persisted_round=2, proposal_round=3)
        assert any(f.rule_id == "D4" for f in findings)
        assert any("supersedes" in f.message for f in findings)

    def test_equal_round_no_supersession(self):
        # Same round — no supersession required; D4 is silent.
        assert check_d4(persisted_round=3, proposal_round=3) == []

    def test_lower_round_no_supersession(self):
        # Lower-round proposal — D4 silent (orchestrator should reject the
        # proposal at B1a as a stale leftover, but that's not D4's surface).
        assert check_d4(persisted_round=3, proposal_round=1) == []


# ---------------------------------------------------------------------------
# Family E
# ---------------------------------------------------------------------------


class TestE1E2E6:
    """E1/E2/E6 — passport-shape post-hoc detection."""

    def test_orchestrator_emitted_passes(self):
        e = make_valid_persisted_entry_minor()
        assert check_e1_e2_e6([e]) == []

    def test_missing_verified_by_fails(self):
        e = make_valid_persisted_entry_minor()
        del e["verdict"]["verified_by"]
        findings = check_e1_e2_e6([e])
        assert any(f.rule_id == "E1/E2/E6" for f in findings)

    def test_wrong_verified_by_fails(self):
        e = make_valid_persisted_entry_minor()
        e["verdict"]["verified_by"] = "totally_different_agent"
        findings = check_e1_e2_e6([e])
        assert any(f.rule_id == "E1/E2/E6" and "verified_by" in f.message for f in findings)


class TestE3E4:
    """E3/E4 — proposals carrying verified_at/verified_by are rejected."""

    def test_clean_proposal_passes(self):
        e = make_valid_proposal_entry_pass()
        assert check_e3_e4(e, "proposal") == []

    def test_proposal_with_verified_at_fails(self):
        e = make_valid_proposal_entry_pass()
        e["verdict"]["verified_at"] = "2026-04-30T15:23:11.847Z"
        findings = check_e3_e4(e, "proposal")
        assert any(f.rule_id == "E3/E4" and "verified_at" in f.message for f in findings)

    def test_proposal_with_verified_by_fails(self):
        e = make_valid_proposal_entry_pass()
        e["verdict"]["verified_by"] = "pipeline_orchestrator_agent"
        findings = check_e3_e4(e, "proposal")
        assert any(f.rule_id == "E3/E4" and "verified_by" in f.message for f in findings)


class TestE5:
    """E5 — persisted mode rejects AUDIT_FAILED."""

    def test_minor_persisted_passes(self):
        e = make_valid_persisted_entry_minor()
        assert check_e5(e, "persisted") == []

    def test_audit_failed_persisted_fails(self):
        e = make_valid_persisted_entry_minor()
        e["verdict"]["status"] = "AUDIT_FAILED"
        findings = check_e5(e, "persisted")
        assert any(f.rule_id == "E5" for f in findings)


class TestE7:
    """E7 — ack entry's status remains MATERIAL."""

    def test_material_with_ack_passes(self):
        e = make_valid_persisted_entry_minor()
        e["verdict"]["status"] = "MATERIAL"
        e["acknowledgement"] = {
            "finding_ids": ["F-001"],
            "acknowledged_at": e["verdict"]["verified_at"],
            "acknowledged_by": "user",
        }
        assert check_e7(e) == []

    def test_synthetic_status_with_ack_fails(self):
        e = make_valid_persisted_entry_minor()
        e["verdict"]["status"] = "MATERIAL_ACKNOWLEDGED"
        e["acknowledgement"] = {
            "finding_ids": ["F-001"],
            "acknowledged_at": e["verdict"]["verified_at"],
            "acknowledged_by": "user",
        }
        findings = check_e7(e)
        assert any(f.rule_id == "E7" for f in findings)


# ---------------------------------------------------------------------------
# Family F
# ---------------------------------------------------------------------------


class TestF1:
    """F1 — run_id format."""

    def test_canonical_run_id_passes(self):
        assert check_f1(VALID_RUN_ID) == []

    def test_wrong_format_fails(self):
        findings = check_f1("not-a-run-id")
        assert any(f.rule_id == "F1" for f in findings)

    def test_missing_run_id_fails(self):
        findings = check_f1(None)
        assert any(f.rule_id == "F1" for f in findings)


class TestF2:
    """F2 — bare-run_id basename + extensions."""

    def test_canonical_filenames_pass(self, tmp_path: Path):
        jsonl = tmp_path / f"{VALID_RUN_ID}.jsonl"
        sidecar = tmp_path / f"{VALID_RUN_ID}.meta.json"
        verdict = tmp_path / f"{VALID_RUN_ID}.verdict.yaml"
        entry = tmp_path / f"{VALID_RUN_ID}.audit_artifact_entry.json"
        assert check_f2(jsonl, sidecar, verdict, entry, "proposal") == []

    def test_stage_prefix_fails(self, tmp_path: Path):
        sidecar = tmp_path / f"stage2-synthesis-{VALID_RUN_ID}.meta.json"
        findings = check_f2(None, sidecar, None, None, "persisted")
        assert any(f.rule_id == "F2" for f in findings)

    def test_wrong_extension_fails(self, tmp_path: Path):
        sidecar = tmp_path / f"{VALID_RUN_ID}.json"  # missing .meta
        findings = check_f2(None, sidecar, None, None, "persisted")
        assert any(f.rule_id == "F2" for f in findings)


class TestF3:
    """F3 — sidecar.run_id == basename stem."""

    def test_matching_passes(self, tmp_path: Path):
        s = make_valid_sidecar()
        sidecar_path = tmp_path / f"{VALID_RUN_ID}.meta.json"
        assert check_f3(s, sidecar_path) == []

    def test_drift_fails(self, tmp_path: Path):
        s = make_valid_sidecar()
        s["run_id"] = "2026-04-30T15-22-04Z-aaaa"
        sidecar_path = tmp_path / f"{VALID_RUN_ID}.meta.json"
        findings = check_f3(s, sidecar_path)
        assert any(f.rule_id == "F3" for f in findings)


# ---------------------------------------------------------------------------
# Schema self-validation (verification gate item #1)
# ---------------------------------------------------------------------------


class TestSchemaSelfValidation:
    """Verification gate: each Phase 6.2 schema validates as Draft 2020-12."""

    @pytest.mark.parametrize("schema_name", [
        "audit_artifact_entry.schema.json",
        "audit_jsonl.schema.json",
        "audit_sidecar.schema.json",
        "audit_verdict.schema.json",
    ])
    def test_schema_meta_valid(self, schema_name):
        from scripts._test_helpers import load_json_schema
        if "audit_jsonl" in schema_name or "audit_sidecar" in schema_name or "audit_verdict" in schema_name:
            path = REPO / "shared/contracts/audit" / schema_name
        else:
            path = REPO / "shared/contracts/passport" / schema_name
        schema = load_json_schema(path)
        assert "$schema" in schema


# ---------------------------------------------------------------------------
# Aggregator + CLI smoke tests
# ---------------------------------------------------------------------------


class TestAggregator:
    """run_checks should emit zero findings on a fully-valid synthetic bundle."""

    def test_clean_persisted_bundle_zero_findings(self, tmp_path: Path):
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        # align entry's bundle_manifest_sha with the sidecar's computed value
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        # Codex round 8 P2 closure: B7 now resolves entry.artifact_paths
        # against repo_root and verifies disk existence + samefile match
        # against CLI-loaded paths. Aggregator test writes placeholder
        # files at the recorded basename so the resolution succeeds.
        for ext in (".jsonl", ".meta.json", ".verdict.yaml",
                    ".audit_artifact_entry.json"):
            (tmp_path / f"{VALID_RUN_ID}{ext}").write_text("placeholder")
        ctx = LintContext(
            mode="persisted",
            entry=entry,
            entry_path=tmp_path / f"{VALID_RUN_ID}.audit_artifact_entry.json",
            sidecar=sidecar,
            sidecar_path=tmp_path / f"{VALID_RUN_ID}.meta.json",
            verdict=make_valid_verdict_file_minor(),
            verdict_path=tmp_path / f"{VALID_RUN_ID}.verdict.yaml",
            jsonl_events=make_valid_jsonl_events_no_tool(),
            jsonl_path=tmp_path / f"{VALID_RUN_ID}.jsonl",
            repo_root=tmp_path,  # no .git, no deliverable file: B4 skipped, B2 disk skipped
        )
        findings = run_checks(ctx)
        assert findings == [], "\n".join(f.render() for f in findings)

    def test_clean_proposal_bundle_zero_findings(self, tmp_path: Path):
        sidecar = make_valid_sidecar()
        entry = make_valid_proposal_entry_pass()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        for ext in (".jsonl", ".meta.json", ".verdict.yaml",
                    ".audit_artifact_entry.json"):
            (tmp_path / f"{VALID_RUN_ID}{ext}").write_text("placeholder")
        ctx = LintContext(
            mode="proposal",
            entry=entry,
            entry_path=tmp_path / f"{VALID_RUN_ID}.audit_artifact_entry.json",
            sidecar=sidecar,
            sidecar_path=tmp_path / f"{VALID_RUN_ID}.meta.json",
            verdict=make_valid_verdict_file_pass(),
            verdict_path=tmp_path / f"{VALID_RUN_ID}.verdict.yaml",
            jsonl_events=make_valid_jsonl_events_no_tool(),
            jsonl_path=tmp_path / f"{VALID_RUN_ID}.jsonl",
            repo_root=tmp_path,
        )
        findings = run_checks(ctx)
        assert findings == [], "\n".join(f.render() for f in findings)

    def test_jsonl_stream_mode_clean(self, tmp_path: Path):
        ctx = LintContext(
            mode="jsonl-stream",
            jsonl_events=make_valid_jsonl_events_tool_using(),
            jsonl_path=tmp_path / f"{VALID_RUN_ID}.jsonl",
            repo_root=tmp_path,
        )
        assert run_checks(ctx) == []

    def test_jsonl_stream_mode_orphan_fails(self, tmp_path: Path):
        events = [
            {"type": "thread.started", "thread_id": VALID_THREAD_ID},
            {"type": "item.completed",
             "item": {"id": "orphan", "type": "command_execution"}},
        ]
        ctx = LintContext(
            mode="jsonl-stream",
            jsonl_events=events,
            jsonl_path=tmp_path / f"{VALID_RUN_ID}.jsonl",
            repo_root=tmp_path,
        )
        findings = run_checks(ctx)
        assert any(f.rule_id == "A7" for f in findings)


class TestCLI:
    """End-to-end CLI smoke tests using subprocess-style invocation through main()."""

    def test_jsonl_stream_clean_returns_0(self, tmp_path: Path, capsys):
        jsonl = tmp_path / f"{VALID_RUN_ID}.jsonl"
        events = make_valid_jsonl_events_tool_using()
        jsonl.write_text("\n".join(json.dumps(e) for e in events) + "\n")
        rc = main(["--mode", "jsonl-stream", "--jsonl", str(jsonl)])
        assert rc == 0

    def test_jsonl_stream_orphan_returns_1(self, tmp_path: Path):
        jsonl = tmp_path / f"{VALID_RUN_ID}.jsonl"
        events = [
            {"type": "thread.started", "thread_id": VALID_THREAD_ID},
            {"type": "item.completed",
             "item": {"id": "orphan", "type": "command_execution"}},
        ]
        jsonl.write_text("\n".join(json.dumps(e) for e in events) + "\n")
        rc = main(["--mode", "jsonl-stream", "--jsonl", str(jsonl)])
        assert rc == 1

    def test_persisted_clean_via_files(self, tmp_path: Path):
        # Write all four artifact files
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        verdict = make_valid_verdict_file_minor()
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        # verdict as YAML
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        # zero findings -> rc == 0
        assert rc == 0

    def test_persisted_missing_sidecar_returns_1(self, tmp_path: Path, capsys):
        # Codex round 1 P1: missing companion artifacts must be rejected, not
        # silently ignored. Write entry + verdict + jsonl but NOT sidecar.
        run_id = VALID_RUN_ID
        entry = make_valid_persisted_entry_minor()
        verdict = make_valid_verdict_file_minor()
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "B7" in captured.out
        assert "sidecar" in captured.out

    def test_persisted_mode_rejects_proposal_shape(self, tmp_path: Path, capsys):
        # Codex round 2 P1: --mode persisted must enforce persisted arm. A
        # proposal-shaped entry (no verified_at/verified_by) was silently
        # passing oneOf validation as the proposal arm.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        # Build a proposal-shaped entry (no verified_at, no verified_by)
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        entry["verdict"].pop("verified_at", None)
        entry["verdict"].pop("verified_by", None)
        verdict = make_valid_verdict_file_minor()
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "E3" in captured.out
        assert "verified_at" in captured.out

    def test_persisted_mode_rejects_audit_failed(self, tmp_path: Path, capsys):
        # AUDIT_FAILED is proposal-only per §3.2 lifecycle-conditional table.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        entry["verdict"]["status"] = "AUDIT_FAILED"
        entry["verdict"]["failure_reason"] = "synthetic test"
        entry["verdict"]["finding_counts"] = {"p1": 0, "p2": 0, "p3": 0}
        verdict = make_valid_verdict_file_minor()
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "E5" in captured.out
        assert "AUDIT_FAILED" in captured.out

    def test_persisted_truncated_jsonl_rejected(self, tmp_path: Path, capsys):
        # Codex round 3 P1: JSONL with only thread.started + turn.started
        # has no A7 pairing violation but is incomplete evidence. Phase 6.1's
        # parse_audit_verdict.validate_stream_shape must run before A7 in
        # full mode (non-AUDIT_FAILED bundles).
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        verdict = make_valid_verdict_file_minor()  # MINOR — non-AUDIT_FAILED
        # Truncated stream: opens correctly, never closes
        truncated_events = [
            {"type": "thread.started", "thread_id": VALID_THREAD_ID},
            {"type": "turn.started"},
        ]
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in truncated_events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "L2-3/L2-4" in captured.out or "stream-shape" in captured.out, captured.out

    def test_passport_scan_rejects_audit_failed(self, tmp_path: Path, capsys):
        # Codex round 3 P2: hand-edited passport entry with AUDIT_FAILED status
        # plus valid verified_at + verified_by must be flagged as forbidden.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        verdict = make_valid_verdict_file_minor()
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        # Passport with hand-edited AUDIT_FAILED entry that passes E1/E2/E6
        # presence checks (verified_at + verified_by both set, verified_by
        # is the canonical orchestrator value).
        passport = {
            "audit_artifact": [
                {
                    "stage": 2,
                    "agent": "synthesis_agent",
                    "deliverable_path": "chapter_4/synthesis.md",
                    "deliverable_sha": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2",
                    "run_id": "2026-04-30T15-22-04Z-aaaa",
                    "bundle_manifest_sha": "9a8b7c6d5e4f3b2a1c0d9e8f7a6b5c4d3e2f1a0b9c8d7e6f5a4b3c2d1e0f9876",
                    "artifact_paths": {
                        "jsonl": "audit_artifacts/2026-04-30T15-22-04Z-aaaa.jsonl",
                        "sidecar": "audit_artifacts/2026-04-30T15-22-04Z-aaaa.meta.json",
                        "verdict": "audit_artifacts/2026-04-30T15-22-04Z-aaaa.verdict.yaml",
                    },
                    "verdict": {
                        "status": "AUDIT_FAILED",
                        "round": 1,
                        "target_rounds": 3,
                        "finding_counts": {"p1": 0, "p2": 0, "p3": 0},
                        "failure_reason": "hand-edited forgery",
                        "verified_at": "2026-04-30T15:23:11.847Z",
                        "verified_by": "pipeline_orchestrator_agent",
                    },
                }
            ]
        }
        passport_path = tmp_path / "passport.yaml"
        passport_path.write_text(_yaml.safe_dump(passport))
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--passport-path", str(passport_path),
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "E5" in captured.out
        assert "AUDIT_FAILED" in captured.out

    def test_persisted_forged_artifact_paths_in_entry(self, tmp_path: Path, capsys):
        # Codex round 4 P2: hand-edited entry.artifact_paths pointing at a
        # different run_id must be flagged as forgery seam, even when the
        # CLI is invoked with canonical --output-dir + --run-id and the
        # actual on-disk files have the canonical basename.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        # Forged: artifact_paths point at a DIFFERENT run_id's files
        entry["artifact_paths"] = {
            "jsonl": "audit_artifacts/2026-04-30T15-22-04Z-ffff.jsonl",
            "sidecar": "audit_artifacts/2026-04-30T15-22-04Z-ffff.meta.json",
            "verdict": "audit_artifacts/2026-04-30T15-22-04Z-ffff.verdict.yaml",
        }
        verdict = make_valid_verdict_file_minor()
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "B7" in captured.out
        assert "artifact-paths forgery seam" in captured.out

    def test_argparse_invalid_mode_returns_64(self):
        # Codex round 4 P3: argparse-level failures must exit 64, not 2.
        result = subprocess.run(
            [sys.executable, str(REPO / "scripts/check_audit_artifact_consistency.py"),
             "--mode", "definitely_not_a_mode"],
            capture_output=True, text=True,
        )
        assert result.returncode == 64, (
            f"argparse usage error returned {result.returncode}, expected 64\n"
            f"stderr: {result.stderr}"
        )

    def test_argparse_unknown_flag_returns_64(self):
        result = subprocess.run(
            [sys.executable, str(REPO / "scripts/check_audit_artifact_consistency.py"),
             "--bogus-flag"],
            capture_output=True, text=True,
        )
        assert result.returncode == 64, (
            f"unknown flag returned {result.returncode}, expected 64\n"
            f"stderr: {result.stderr}"
        )

    def test_persisted_ack_without_prior_rejected(self, tmp_path: Path, capsys):
        # Codex round 5 P1: a persisted ack entry whose copied fields don't
        # match any prior MATERIAL entry must be rejected, not silently
        # skipped. Previously `prior is None` skipped check_c3 entirely.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        # Build a MATERIAL ack entry with NO matching prior in the passport.
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        entry["verdict"]["status"] = "MATERIAL"
        entry["verdict"]["finding_counts"] = {"p1": 1, "p2": 0, "p3": 0}
        entry["acknowledgement"] = {
            "finding_ids": ["F-001"],
            "acknowledged_at": entry["verdict"]["verified_at"],
            "acknowledged_by": "user",
        }
        verdict = make_valid_verdict_file_minor()
        verdict["verdict_status"] = "MATERIAL"
        verdict["finding_counts"] = {"p1": 1, "p2": 0, "p3": 0}
        verdict["findings"] = [{
            "id": "F-001", "severity": "P1", "dimension": "3.1",
            "file": "x.md", "line": 1,
            "description": "x", "suggested_fix": "y",
        }]
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        # Empty passport — no prior MATERIAL entry to copy from
        passport_path = tmp_path / "passport.yaml"
        passport_path.write_text(_yaml.safe_dump({"audit_artifact": []}))
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--passport-path", str(passport_path),
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "C3" in captured.out
        assert "no prior MATERIAL entry" in captured.out

    def test_non_dict_entry_returns_2(self, tmp_path: Path, capsys):
        # Codex round 5 traceback closure: a non-object entry payload (e.g., `[]`)
        # must surface as a clean error, not an AttributeError traceback.
        entry_path = tmp_path / "entry.json"
        entry_path.write_text("[]")
        rc = main([
            "--mode", "proposal",
            "--entry", str(entry_path),
            "--sidecar", str(tmp_path / "no.meta.json"),
            "--verdict", str(tmp_path / "no.verdict.yaml"),
            "--jsonl", str(tmp_path / "no.jsonl"),
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 2
        assert "is not a JSON object" in captured.err

    def test_stream_shape_runs_via_importlib(self, tmp_path: Path, capsys):
        # Codex round 5 P2: stream-shape gate must work via importlib, not
        # depend on scripts/ being on sys.path. Import this module under a
        # fresh `scripts` package qualifier and run main from there.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        verdict = make_valid_verdict_file_minor()  # MINOR — non-AUDIT_FAILED
        truncated_events = [
            {"type": "thread.started", "thread_id": VALID_THREAD_ID},
            {"type": "turn.started"},
        ]
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(truncated_events[0]))  # placeholder
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in truncated_events) + "\n")
        # Run via subprocess so we exercise the actual import path the gate
        # uses (importlib loads parse_audit_verdict by file path).
        result = subprocess.run(
            [sys.executable, str(REPO / "scripts/check_audit_artifact_consistency.py"),
             "--mode", "persisted",
             "--output-dir", str(tmp_path),
             "--run-id", run_id,
             "--repo-root", str(tmp_path)],
            capture_output=True, text=True,
        )
        assert result.returncode == 1, result.stdout + result.stderr
        assert "L2-3/L2-4" in result.stdout or "stream-shape" in result.stdout, result.stdout

    def test_audit_failed_skips_a7_pairing(self, tmp_path: Path, capsys):
        # Codex round 6 P2: AUDIT_FAILED bundles legitimately have truncated
        # streams. A7 pairing must be suspended for them, mirroring the
        # round-3 stream-shape suspension and §3.4 Layer 3 suspension.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        # AUDIT_FAILED jsonl_thread_id is allowed to be empty per §3.4
        sidecar["stream"]["jsonl_thread_id"] = ""
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        # Entry needs to be a proposal (AUDIT_FAILED is proposal-only)
        # — switch CLI mode to proposal for this test.
        entry["verdict"].pop("verified_at", None)
        entry["verdict"].pop("verified_by", None)
        entry["verdict"]["status"] = "AUDIT_FAILED"
        entry["verdict"]["finding_counts"] = {"p1": 0, "p2": 0, "p3": 0}
        entry["verdict"]["failure_reason"] = "synthetic — codex killed"
        verdict = make_valid_verdict_file_minor()
        verdict["verdict_status"] = "AUDIT_FAILED"
        verdict["finding_counts"] = {"p1": 0, "p2": 0, "p3": 0}
        verdict["findings"] = []
        verdict["failure_reason"] = "synthetic — codex killed"
        # Truncated stream with unmatched item.started — would fail A7 if
        # pairing weren't suspended for AUDIT_FAILED
        truncated_events = [
            {"type": "thread.started", "thread_id": VALID_THREAD_ID},
            {"type": "turn.started"},
            {"type": "item.started",
             "item": {"id": "killed_tool", "type": "command_execution"}},
        ]
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in truncated_events) + "\n")
        rc = main([
            "--mode", "proposal",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        # No A7 finding should appear — AUDIT_FAILED suspends pairing
        assert "A7" not in captured.out, (
            f"AUDIT_FAILED bundle should not produce A7 findings — got: {captured.out}"
        )

    def test_non_object_sidecar_no_traceback(self, tmp_path: Path, capsys):
        # Codex round 6 P2: a non-object sidecar must surface as SCHEMA
        # finding without crashing cross-field checks.
        run_id = VALID_RUN_ID
        entry = make_valid_persisted_entry_minor()
        verdict = make_valid_verdict_file_minor()
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text("[]")  # non-object
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "SCHEMA" in captured.out, captured.out
        # No traceback in stderr
        assert "AttributeError" not in captured.err
        assert "Traceback" not in captured.err

    def test_non_object_verdict_no_traceback(self, tmp_path: Path, capsys):
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        (tmp_path / f"{run_id}.verdict.yaml").write_text("[]")  # non-object
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "SCHEMA" in captured.out, captured.out
        assert "AttributeError" not in captured.err
        assert "Traceback" not in captured.err

    def test_jsonl_lacks_section6_verdict_text_rejected(self, tmp_path: Path, capsys):
        # Codex round 8 P1: stream-shape passes but verdict text is not a
        # parseable Section 6 → must be rejected as L2-4 finding.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        verdict = make_valid_verdict_file_minor()
        # Stream-shape valid but agent_message has no Section 6 summary
        events = [
            {"type": "thread.started", "thread_id": VALID_THREAD_ID},
            {"type": "turn.started"},
            {"type": "item.completed",
             "item": {"id": "item_0", "type": "agent_message",
                      "text": "I considered the bundle and decided everything looks fine."}},
            {"type": "turn.completed",
             "usage": {"input_tokens": 100, "cached_input_tokens": 0,
                       "output_tokens": 50, "reasoning_output_tokens": 25}},
        ]
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "L2-4" in captured.out, captured.out
        assert "Section 6" in captured.out, captured.out

    def test_artifact_path_resolves_to_missing_file_rejected(self, tmp_path: Path, capsys):
        # Codex round 8 P2: entry.artifact_paths recording a path that
        # resolves under repo_root to a missing file must be flagged.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        # Recorded paths point at a sibling subdir that doesn't exist
        entry["artifact_paths"] = {
            "jsonl": f"missing_subdir/{run_id}.jsonl",
            "sidecar": f"missing_subdir/{run_id}.meta.json",
            "verdict": f"missing_subdir/{run_id}.verdict.yaml",
        }
        verdict = make_valid_verdict_file_minor()
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "B7" in captured.out
        assert "does not exist on disk" in captured.out

    def test_audit_failed_skips_layer_3_b2_b3_b4_b5_b7(self, tmp_path: Path, capsys):
        # Codex round 9 P2: Layer 3 cross-file rules (B2/B3/B4/B5/B7) are
        # suspended for AUDIT_FAILED bundles per §3.4 + §5.6 Path B5. A
        # failed audit caused by bundle mutation legitimately has live
        # deliverable SHA != recorded SHA; treating that as B2 violation
        # would reject the failure-signaling artifact.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        sidecar["stream"]["jsonl_thread_id"] = ""  # AUDIT_FAILED suspension
        # Forensic exit_code per §3.4 rule 6 — non-zero allowed for AUDIT_FAILED
        sidecar["process"]["exit_code"] = 70
        # Drift the bundle SHA in sidecar so live recompute would mismatch (if
        # B3 ran). With AUDIT_FAILED suspension, B3 must NOT fire.
        sidecar["prompt"]["bundle"]["primary_deliverables"][0]["sha"] = "f" * 64
        # Drift git_sha to a bogus hex that fails B4 git cat-file (if it ran).
        sidecar["runner"]["git_sha"] = "deadbee"
        # Drift duration vs end-start by >>1s so B5 would fire (if it ran).
        sidecar["timing"]["duration_seconds"] = 9999.0
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        entry["verdict"].pop("verified_at", None)
        entry["verdict"].pop("verified_by", None)
        entry["verdict"]["status"] = "AUDIT_FAILED"
        entry["verdict"]["finding_counts"] = {"p1": 0, "p2": 0, "p3": 0}
        entry["verdict"]["failure_reason"] = "synthetic — codex killed"
        # Drift entry.deliverable_sha so B2 entry-vs-sidecar would fire (if
        # it ran) — entry side not suspended internally, only Layer 3 is.
        entry["deliverable_sha"] = "c" * 64
        verdict = make_valid_verdict_file_minor()
        verdict["verdict_status"] = "AUDIT_FAILED"
        verdict["finding_counts"] = {"p1": 0, "p2": 0, "p3": 0}
        verdict["findings"] = []
        verdict["failure_reason"] = "synthetic — codex killed"
        # Truncated stream — AUDIT_FAILED expected
        events = [
            {"type": "thread.started", "thread_id": VALID_THREAD_ID},
            {"type": "turn.started"},
            # codex was killed before final agent_message + turn.completed
        ]
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "proposal",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        # B2/B3/B4/B5/B7 must not fire — AUDIT_FAILED suspends Layer 3
        for rule in ("B2", "B3", "B4", "B5", "B7"):
            assert f"[{rule}]" not in captured.out, (
                f"{rule} fired on AUDIT_FAILED bundle but Layer 3 should be "
                f"suspended per §3.4: {captured.out}"
            )

    def test_audit_failed_with_partial_jsonl_no_internal_error(self, tmp_path: Path, capsys):
        # Codex round 11 P2: AUDIT_FAILED bundle with partial/non-JSON last
        # line (codex SIGKILL'd mid-write) must NOT exit 2 internal error.
        # Round 9 suspended schema validation but _load_jsonl() still raised
        # before reaching that suspension.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        sidecar["stream"]["jsonl_thread_id"] = ""
        sidecar["process"]["exit_code"] = 137  # 128 + SIGKILL
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        entry["verdict"].pop("verified_at", None)
        entry["verdict"].pop("verified_by", None)
        entry["verdict"]["status"] = "AUDIT_FAILED"
        entry["verdict"]["finding_counts"] = {"p1": 0, "p2": 0, "p3": 0}
        entry["verdict"]["failure_reason"] = "synthetic — codex SIGKILL"
        verdict = make_valid_verdict_file_minor()
        verdict["verdict_status"] = "AUDIT_FAILED"
        verdict["finding_counts"] = {"p1": 0, "p2": 0, "p3": 0}
        verdict["findings"] = []
        verdict["failure_reason"] = "synthetic — codex SIGKILL"
        # Partial JSON on the last line — would raise ValueError in
        # _load_jsonl and previously caused exit 2.
        partial_jsonl = (
            json.dumps({"type": "thread.started", "thread_id": VALID_THREAD_ID}) + "\n"
            + json.dumps({"type": "turn.started"}) + "\n"
            + '{"type":"item.start'  # truncated mid-write, no closing quote/brace
        )
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(partial_jsonl)
        rc = main([
            "--mode", "proposal",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        # Must NOT be rc=2 (internal error). Forensic-only bundle is allowed.
        assert rc != 2, (
            f"AUDIT_FAILED with partial JSONL returned rc=2 internal error; "
            f"should be handled as forensic-only bundle\nstdout: {captured.out}\n"
            f"stderr: {captured.err}"
        )

    def test_schema_error_short_circuits_no_traceback(self, tmp_path: Path, capsys):
        # Codex round 12 P2: schema-valid-as-dict but with a nested field of
        # the wrong shape (timing: [1] passes top-level isinstance(dict) but
        # timing.get() crashes in check_b5). Short-circuit on SCHEMA error
        # so cross-field rules don't crash on input violating their type
        # presuppositions.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        # Inject malformed nested field that schema rejects but isinstance
        # at the top level still passes:
        sidecar["timing"] = [1, 2, 3]  # list instead of dict
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        verdict = make_valid_verdict_file_minor()
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "SCHEMA" in captured.out, captured.out
        # Critical: no traceback must reach stderr
        assert "Traceback" not in captured.err, captured.err
        assert "AttributeError" not in captured.err, captured.err

    def test_persisted_with_higher_round_proposal_fires_d4(self, tmp_path: Path, capsys):
        # Codex round 13 P2: when --mode persisted runs and --output-dir
        # contains a higher-round unmerged proposal for the same (stage,
        # agent, deliverable_sha) tuple, D4 must fire (the persisted
        # entry's Path A is supposed to be preempted).
        run_id = VALID_RUN_ID
        # Persisted entry at round 1
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        entry["verdict"]["round"] = 1
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        verdict = make_valid_verdict_file_minor()
        verdict["round"] = 1  # match entry round
        events = make_valid_jsonl_events_no_tool()
        # Move persisted into a consumed/ subdir so the scan doesn't see
        # it as an unmerged proposal (matches §4.9 step 9 convention).
        consumed = tmp_path / "consumed"
        consumed.mkdir()
        (consumed / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        # Companion files in output_dir (where the lint expects them)
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")

        # Higher-round proposal in output_dir (round 2 > persisted round 1)
        proposal_run_id = "2026-04-30T15-30-00Z-eeee"
        proposal_entry = make_valid_persisted_entry_minor()
        proposal_entry["verdict"]["round"] = 2  # higher than persisted round=1
        proposal_entry["verdict"]["status"] = "PASS"
        proposal_entry["verdict"]["finding_counts"] = {"p1": 0, "p2": 0, "p3": 0}
        proposal_entry["verdict"].pop("verified_at", None)  # proposal arm
        proposal_entry["verdict"].pop("verified_by", None)
        proposal_entry["run_id"] = proposal_run_id
        proposal_entry["artifact_paths"] = {
            "jsonl": f"{proposal_run_id}.jsonl",
            "sidecar": f"{proposal_run_id}.meta.json",
            "verdict": f"{proposal_run_id}.verdict.yaml",
        }
        (tmp_path / f"{proposal_run_id}.audit_artifact_entry.json").write_text(
            json.dumps(proposal_entry))

        rc = main([
            "--mode", "persisted",
            "--entry", str(consumed / f"{run_id}.audit_artifact_entry.json"),
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "D4" in captured.out, captured.out
        assert "round=2" in captured.out and "round=1" in captured.out, captured.out

    def test_script_is_executable(self):
        # Codex round 14 P1: spec §5.2 L2-5 invokes the lint as
        # `scripts/check_audit_artifact_consistency.py --mode jsonl-stream …`
        # without a `python` prefix. The file must carry the executable
        # bit (100755) like Phase 6.1's audit_snapshot.py / parse_audit_
        # verdict.py / run_codex_audit.sh — direct exec failing with
        # permission denied (exit 126) would block the orchestrator gate.
        import os
        script_path = REPO / "scripts/check_audit_artifact_consistency.py"
        assert os.access(script_path, os.X_OK), (
            f"{script_path} must be executable for orchestrator §5.2 L2-5 "
            f"direct invocation. Run `chmod +x` and `git update-index --chmod=+x`."
        )

    def test_script_runs_via_direct_exec(self):
        # End-to-end smoke: invoke the script directly (no `python` prefix)
        # and confirm it produces the documented harness exit code. Belt
        # and braces against future `chmod 644` regressions.
        script_path = REPO / "scripts/check_audit_artifact_consistency.py"
        result = subprocess.run(
            [str(script_path), "--example-validation-harness"],
            capture_output=True, text=True,
        )
        assert result.returncode == 0, (
            f"direct exec returned {result.returncode} (expected 0)\n"
            f"stdout: {result.stdout}\nstderr: {result.stderr}"
        )

    def test_swap_verdict_file_with_different_run_id_rejected(self, tmp_path: Path, capsys):
        # Codex round 15 P1: swap-one-verdict-file forgery — a verdict.yaml
        # with all valid schema/cross-field but internal run_id pointing at
        # a different run, renamed into the canonical <run_id>.verdict.yaml
        # slot. C1 mirrors only the nested verdict block; B7 (pre-round-15)
        # checked sidecar.run_id but not verdict.run_id.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        verdict = make_valid_verdict_file_minor()
        verdict["run_id"] = "2026-04-30T15-30-00Z-ffff"  # different run!
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "B7" in captured.out
        assert "verdict.run_id" in captured.out
        assert "swap-one-verdict-file forgery" in captured.out

    def test_only_entry_flag_resolves_companions_from_artifact_paths(self, tmp_path: Path, capsys):
        # Codex round 16 P2: caller passes only --entry + --repo-root; the
        # lint must resolve sidecar/verdict/jsonl from
        # entry.artifact_paths instead of demanding redundant flags.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        verdict = make_valid_verdict_file_minor()
        events = make_valid_jsonl_events_no_tool()
        # Companion files in tmp_path; entry.artifact_paths records them
        # as repo-relative basenames (matching the round-7+8 fixture
        # convention).
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        # ONLY --entry + --repo-root, no --output-dir, no --sidecar/verdict/jsonl
        rc = main([
            "--mode", "persisted",
            "--entry", str(tmp_path / f"{run_id}.audit_artifact_entry.json"),
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 0, captured.out

    def test_persisted_schema_invalid_sidecar_returns_1(self, tmp_path: Path, capsys):
        # Codex round 1 P2: schema-invalid sidecar must be rejected even when
        # cross-field rules don't cover the malformed field.
        run_id = VALID_RUN_ID
        sidecar = make_valid_sidecar()
        # Inject a malformed bare extra field (additionalProperties: false on
        # sidecar root → schema rejects unknown top-level key).
        sidecar["definitely_not_in_schema"] = "drift"
        entry = make_valid_persisted_entry_minor()
        entry["bundle_manifest_sha"] = sidecar["prompt"]["bundle"]["bundle_manifest_sha"]
        verdict = make_valid_verdict_file_minor()
        events = make_valid_jsonl_events_no_tool()
        (tmp_path / f"{run_id}.audit_artifact_entry.json").write_text(json.dumps(entry))
        (tmp_path / f"{run_id}.meta.json").write_text(json.dumps(sidecar))
        import yaml as _yaml
        (tmp_path / f"{run_id}.verdict.yaml").write_text(_yaml.safe_dump(verdict))
        (tmp_path / f"{run_id}.jsonl").write_text(
            "\n".join(json.dumps(e) for e in events) + "\n")
        rc = main([
            "--mode", "persisted",
            "--output-dir", str(tmp_path),
            "--run-id", run_id,
            "--repo-root", str(tmp_path),
        ])
        captured = capsys.readouterr()
        assert rc == 1, captured.out
        assert "SCHEMA" in captured.out
        assert "definitely_not_in_schema" in captured.out


# ---------------------------------------------------------------------------
# Example validation harness (F4) — smoke test it runs without crash
# ---------------------------------------------------------------------------


class TestExampleHarness:
    """F4 — example-validation-harness runs end-to-end on the real spec dir."""

    def test_harness_runs(self):
        # Should not raise; may produce findings (known §3.4 hyphen drift)
        findings = run_example_harness(REPO)
        # We don't assert zero findings — the spec is known to have drift the
        # harness should surface. We only assert the harness ran and any
        # findings it produces are well-formed LintErrors.
        assert all(isinstance(f, LintError) for f in findings)
        # And every finding's rule_id is "F4" or "SCHEMA"-prefixed
        for f in findings:
            assert f.rule_id in ("F4", "SCHEMA"), f.render()


# ---------------------------------------------------------------------------
# Fixture smoke tests — codex round 7 P2 closure
# ---------------------------------------------------------------------------


FIXTURE_ROOT = REPO / "scripts/fixtures/audit_artifact_consistency"


class TestFixtureSmoke:
    """Verify scripts/fixtures/audit_artifact_consistency/ README invocation
    examples actually produce the documented exit codes.

    Codex round 7 P2: positive fixtures only pass when --repo-root points
    at the fixture directory itself (so B3's live-disk gate hits the
    synthetic-fixture safe-skip via missing .git/ marker). Without this
    test, README drift could leave positive fixtures silently broken
    against the documented invocation.
    """

    def test_positive_persisted_minor(self):
        bundle = FIXTURE_ROOT / "positive/persisted_minor"
        result = subprocess.run(
            [sys.executable, str(REPO / "scripts/check_audit_artifact_consistency.py"),
             "--mode", "persisted",
             "--output-dir", str(bundle),
             "--run-id", "2026-04-30T15-22-04Z-d8f3",
             "--repo-root", str(bundle)],
            capture_output=True, text=True,
        )
        assert result.returncode == 0, (
            f"positive fixture persisted_minor returned {result.returncode}\n"
            f"stdout: {result.stdout}\nstderr: {result.stderr}"
        )

    def test_positive_proposal_pass(self):
        bundle = FIXTURE_ROOT / "positive/proposal_pass"
        result = subprocess.run(
            [sys.executable, str(REPO / "scripts/check_audit_artifact_consistency.py"),
             "--mode", "proposal",
             "--output-dir", str(bundle),
             "--run-id", "2026-04-30T15-22-04Z-d8f3",
             "--repo-root", str(bundle)],
            capture_output=True, text=True,
        )
        assert result.returncode == 0, (
            f"positive fixture proposal_pass returned {result.returncode}\n"
            f"stdout: {result.stdout}\nstderr: {result.stderr}"
        )

    def test_negative_a1_pass_with_p1(self):
        bundle = FIXTURE_ROOT / "negative/a1_pass_with_p1"
        result = subprocess.run(
            [sys.executable, str(REPO / "scripts/check_audit_artifact_consistency.py"),
             "--mode", "proposal",
             "--output-dir", str(bundle),
             "--run-id", "2026-04-30T15-22-04Z-d8f3",
             "--repo-root", str(bundle)],
            capture_output=True, text=True,
        )
        assert result.returncode == 1, result.stdout
        assert "A1" in result.stdout, result.stdout

    def test_negative_a7_orphan_completion(self):
        jsonl = FIXTURE_ROOT / "negative/a7_orphan_completion/2026-04-30T15-22-04Z-d8f3.jsonl"
        result = subprocess.run(
            [sys.executable, str(REPO / "scripts/check_audit_artifact_consistency.py"),
             "--mode", "jsonl-stream",
             "--jsonl", str(jsonl)],
            capture_output=True, text=True,
        )
        assert result.returncode == 1, result.stdout
        assert "A7" in result.stdout, result.stdout
