@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/integration/test_checkpoint_merge.py

@@ -1,1371 +0,0 @@
-"""End-to-end regression tests for checkpoint merge and reporting integrity (TSK-253).
-
-This module tests the complete flow:
-1. Full run: Process all rows and create checkpoint
-2. Targeted rerun: Re-evaluate specific rows
-3. Merged report: Verify all rows present with correct values
-
-Requirements validated:
-- FR-25.3: Merge refreshed target-row results into checkpoint by row_id
-- FR-25.4: Force refresh targeted rows even if checkpointed
-- Reporting integrity: audit-checklist.json/xlsx remain complete
-"""
-
-from __future__ import annotations
-
-import json
-from datetime import UTC, datetime
-from pathlib import Path
-from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-import vds_audit_orchestrator.engine.confluence_checklist_contract as checklist_contract
-from structlog import get_logger
-from vds_audit_orchestrator.engine.batch_processor import (
-    BatchCheckpoint,
-    BatchConfig,
-    BatchRowProcessor,
-)
-from vds_audit_orchestrator.engine.row_evaluator_types import RowEvaluationResult
-from vds_audit_orchestrator.engine.target_selector import TargetSelection, TargetType
-from vds_audit_orchestrator.evidence.matcher import EvidenceMatcher, RowEvidenceContext
-from vds_audit_orchestrator.models.checklist import EvidenceAnchor, RowProvenance, RowStatus, ScoreBreakdown
-from vds_audit_orchestrator.models.template import AuditCheck, AuditSection, AuditTemplate
-
-logger = get_logger()
-
-
-# =============================================================================
-# Shared stub: provides no-op classmethods that confluence_checklist_contract
-# calls on RowEvaluator so individual FakeRowEvaluator classes stay minimal.
-# =============================================================================
-
-
-class _RowEvaluatorStub:
-    """Base providing passive stubs for every RowEvaluator classmethod
-    referenced from confluence_checklist_contract.py."""
-
-    def __init__(self, *, config, template, evidence_bundle):
-        self.config = config
-        self.template_hash = "template-hash"
-        self.evidence_hash = "evidence-hash"
-
-    @classmethod
-    def _promote_requirement_analysis_diagnostics(cls, retrieval_trace):
-        return retrieval_trace
-
-    @classmethod
-    def _extract_authoritative_skill_recorded_ref_values(cls, _trace):
-        return []
-
-    @classmethod
-    def _is_generic_code_anchor_ref_value(cls, _ref_value):
-        return False
-
-    @classmethod
-    def _code_anchor_specificity_rank(cls, _anchor):
-        return 0
-
-    @classmethod
-    def _select_anchors_for_modality(cls, anchors, _modality, *, limit=None, substantive_only=False):
-        return list(anchors[:limit]) if limit else list(anchors)
-
-    @classmethod
-    def _is_decisive_explicit_public_interface_anchor(cls, _anchor):
-        return False
-
-    @classmethod
-    def _recover_decisive_explicit_public_interface_excerpt(cls, *, ref_value, trace_contents):
-        return ""
-
-    @classmethod
-    def _recover_anchor_excerpt_from_read_content(cls, *, anchor_ref, ref_type, matched_contents):
-        return ""
-
-    @classmethod
-    def _collect_read_evidence_content(cls, _trace):
-        return {}
-
-    @classmethod
-    def _collect_read_evidence_line_ranges(cls, _trace):
-        return {}
-
-    @classmethod
-    def _resolve_anchor_read_matches(cls, *, anchor_ref, read_content_by_ref):
-        return []
-
-    @classmethod
-    def _normalize_trace_ref(cls, ref_value):
-        return ref_value
-
-
-# =============================================================================
-# Test Fixtures
-# =============================================================================
-
-
-@pytest.fixture(autouse=True)
-def _mock_state_postgres(monkeypatch: pytest.MonkeyPatch) -> None:
-    """Prevent checkpoint-merge tests from opening real Postgres connections.
-
-    ``_persist_incremental_checklist_progress`` lazily imports
-    ``vds_audit_orchestrator.state`` and calls ``update_checklist_run``,
-    ``upsert_checklist_row_result``, and ``upsert_checklist_artifact``.
-    Without this fixture, tests that pass ``state_dsn="postgresql://test"``
-    and reach the batch-progress callback will attempt a real TCP connection,
-    causing 75-second timeouts instead of sub-second test runs.
-    """
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.state.update_checklist_run",
-        lambda **_kw: None,
-    )
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.state.upsert_checklist_row_result",
-        lambda **_kw: {"row_key": _kw.get("row_key", "")},
-    )
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.state.upsert_checklist_artifact",
-        lambda **_kw: {"artifact_type": _kw.get("artifact_type", "")},
-    )
-
-
-@pytest.fixture
-def mock_template_10_rows() -> AuditTemplate:
-    """Create a mock AuditTemplate with 10 checks for testing."""
-    checks = []
-    for i in range(10):
-        checks.append(
-            AuditCheck(
-                id=f"CHK-{i:03d}",
-                name=f"Check {i}",
-                description=f"Description for check {i}",
-                section_id="SEC-1",
-                weight=10.0,
-                max_points=100,
-            )
-        )
-
-    section = AuditSection(
-        id="SEC-1",
-        name="Section 1",
-        weight=100.0,
-        checks=checks,
-    )
-
-    return AuditTemplate(
-        name="Test Template",
-        version="1.0.0",
-        sections=[section],
-    )
-
-
-@pytest.fixture
-def mock_evaluator():
-    """Create a mock RowEvaluator."""
-    evaluator = MagicMock()
-    evaluator.template_hash = "test_template_hash_123"
-    evaluator.evidence_hash = "test_evidence_hash_456"
-    evaluator.config = MagicMock()
-    evaluator.config.mode.value = "per-row"
-    evaluator.aevaluate_row = AsyncMock()
-    return evaluator
-
-
-@pytest.fixture
-def mock_evidence_matcher():
-    """Create a mock EvidenceMatcher."""
-    matcher = MagicMock(spec=EvidenceMatcher)
-    context = MagicMock(spec=RowEvidenceContext)
-    context.format_for_llm.return_value = "Mock evidence context"
-    context.evidence_refs = ["http://confluence/doc1", "src/main.py"]
-    matcher.match_row.return_value = context
-    return matcher
-
-
-def create_row_result(
-    row_id: str,
-    check_id: str,
-    score: float,
-    status: RowStatus = RowStatus.PASS,
-    reason: str = "Test reason",
-    finding: str = "Test finding",
-) -> RowEvaluationResult:
-    """Helper to create a RowEvaluationResult."""
-    return RowEvaluationResult(
-        row_id=row_id,
-        check_id=check_id,
-        status=status,
-        score=score,
-        score_breakdown=ScoreBreakdown.compute(score),
-        reason=reason,
-        finding=finding,
-        evidence_anchors=[],
-        provenance=RowProvenance(
-            row_llm_mode="per-row",
-            protocol="test",
-            model="test-model",
-            template_hash="test_template_hash_123",
-            rubric_version="1.0.0",
-            evidence_hash="test_evidence_hash_456",
-            evaluated_at=datetime.now(UTC),
-        ),
-        score_1_5=int(score / 20) + 1 if score > 0 else 1,
-    )
-
-
-# =============================================================================
-# End-to-End Regression Tests: Full Run -> Targeted Rerun -> Merged Report
-# =============================================================================
-
-
-class TestCheckpointMergeIntegrity:
-    """End-to-end tests for checkpoint merge and reporting integrity (TSK-253)."""
-
-    @pytest.mark.asyncio
-    async def test_full_run_creates_complete_checkpoint(
-        self,
-        mock_template_10_rows: AuditTemplate,
-        mock_evaluator,
-        mock_evidence_matcher,
-        tmp_path: Path,
-    ):
-        """Test that a full run creates a checkpoint with all rows."""
-        checkpoint_dir = tmp_path / "checkpoints"
-        checkpoint_dir.mkdir()
-
-        config = BatchConfig(
-            batch_size=3,
-            row_timeout_ms=5000,
-            checkpoint_dir=checkpoint_dir,
-            resume_from_checkpoint=False,
-        )
-
-        processor = BatchRowProcessor(
-            template=mock_template_10_rows,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config,
-        )
-
-        # Configure evaluator to return unique results for each row
-        call_count = 0
-
-        async def mock_evaluate(*args, **kwargs):
-            nonlocal call_count
-            call_count += 1
-            row_id = str(kwargs.get("row_id", f"unknown_{call_count}"))
-            check = kwargs.get("check")
-            return create_row_result(
-                row_id=row_id,
-                check_id=check.id if check else f"CHK-{call_count}",
-                score=80.0 + call_count,  # Unique scores
-                reason=f"Full run result {call_count}",
-            )
-
-        mock_evaluator.aevaluate_row.side_effect = mock_evaluate
-
-        # Run full processing
-        results = await processor.process_all(thread_id="full-run-test")
-
-        # Verify all 10 rows processed
-        assert len(results) == 10
-        assert call_count == 10
-
-        # Verify checkpoint exists and contains all rows
-        checkpoint_path = checkpoint_dir / "batch-checkpoint-full-run-test.json"
-        assert checkpoint_path.exists()
-
-        checkpoint_data = json.loads(checkpoint_path.read_text())
-        assert checkpoint_data["total_rows"] == 10
-        assert len(checkpoint_data["results_by_row_id"]) == 10
-
-        # Verify each row has unique score
-        scores = [r["score"] for r in checkpoint_data["results_by_row_id"].values()]
-        assert len(set(scores)) == 10  # All unique
-
-    @pytest.mark.asyncio
-    async def test_targeted_rerun_merges_correctly(
-        self,
-        mock_template_10_rows: AuditTemplate,
-        mock_evaluator,
-        mock_evidence_matcher,
-        tmp_path: Path,
-    ):
-        """Test that targeted rerun merges refreshed results with historical data."""
-        checkpoint_dir = tmp_path / "checkpoints"
-        checkpoint_dir.mkdir()
-
-        # Step 1: Create initial checkpoint with all 10 rows
-        initial_results = {}
-        for i in range(10):
-            row_id = f"CHK-{i:03d}:row_{i}"
-            initial_results[row_id] = {
-                "row_id": row_id,
-                "check_id": f"CHK-{i:03d}",
-                "status": "PASS",
-                "score": 70.0 + i,  # Scores: 70, 71, 72, ..., 79
-                "score_breakdown": {
-                    "raw_score": 70.0 + i,
-                    "coverage": 1.0,
-                    "confidence": 1.0,
-                    "capped": False,
-                    "final_score": 70.0 + i,
-                },
-                "reason": f"Initial result for row {i}",
-                "finding": f"Initial finding {i}",
-                "evidence_anchors": [],
-                "provenance": {
-                    "row_llm_mode": "per-row",
-                    "protocol": "test",
-                    "model": "test-model",
-                    "template_hash": "test_template_hash_123",
-                    "rubric_version": "1.0.0",
-                    "evidence_hash": "test_evidence_hash_456",
-                    "evaluated_at": datetime.now(UTC).isoformat(),
-                },
-                "score_1_5": 4,
-            }
-
-        checkpoint_data = {
-            "thread_id": "merge-test",
-            "total_rows": 10,
-            "template_hash": "test_template_hash_123",
-            "evidence_hash": "test_evidence_hash_456",
-            "completed_batches": [0, 1, 2, 3],  # All batches completed
-            "results_by_row_id": initial_results,
-            "last_updated": datetime.now(UTC).isoformat(),
-        }
-
-        checkpoint_path = checkpoint_dir / "batch-checkpoint-merge-test.json"
-        checkpoint_path.write_text(json.dumps(checkpoint_data))
-
-        # Step 2: Run targeted rerun for rows 3 and 7 (0-indexed: 2 and 6)
-        target_selection = TargetSelection(
-            target_type=TargetType.ROW_IDS,
-            raw_value="3,7",
-            row_indices=frozenset({2, 6}),  # 0-indexed
-        )
-
-        config = BatchConfig(
-            batch_size=3,
-            row_timeout_ms=5000,
-            checkpoint_dir=checkpoint_dir,
-            resume_from_checkpoint=True,
-            target_selection=target_selection,
-            force_refresh_targets=True,
-        )
-
-        processor = BatchRowProcessor(
-            template=mock_template_10_rows,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config,
-        )
-
-        # Configure evaluator to return NEW results for targeted rows
-        async def mock_evaluate(*args, **kwargs):
-            row_id = str(kwargs.get("row_id") or "unknown")
-            check = kwargs.get("check")
-            return create_row_result(
-                row_id=row_id,
-                check_id=check.id if check else "unknown",
-                score=95.0,  # New score for refreshed rows
-                reason="Refreshed result",
-                finding="Refreshed finding",
-            )
-
-        mock_evaluator.aevaluate_row.side_effect = mock_evaluate
-
-        # Run targeted processing
-        results = await processor.process_all(thread_id="merge-test")
-
-        # Verify all 10 rows in results
-        assert len(results) == 10
-
-        # Verify only targeted rows were re-evaluated
-        assert mock_evaluator.aevaluate_row.call_count == 2
-
-        # Verify merged results
-        results_by_row_id = {r.row_id: r for r in results}
-
-        # Non-targeted rows should have original scores
-        assert results_by_row_id["CHK-000:row_0"].score == 70.0
-        assert results_by_row_id["CHK-001:row_1"].score == 71.0
-        assert results_by_row_id["CHK-003:row_3"].score == 73.0  # Not targeted
-        assert results_by_row_id["CHK-008:row_8"].score == 78.0
-
-        # Targeted rows should have new scores
-        assert results_by_row_id["CHK-002:row_2"].score == 95.0  # Refreshed
-        assert results_by_row_id["CHK-006:row_6"].score == 95.0  # Refreshed
-
-        # Verify checkpoint was updated
-        updated_checkpoint = json.loads(checkpoint_path.read_text())
-        assert updated_checkpoint["results_by_row_id"]["CHK-002:row_2"]["score"] == 95.0
-        assert updated_checkpoint["results_by_row_id"]["CHK-006:row_6"]["score"] == 95.0
-        # Non-targeted rows unchanged
-        assert updated_checkpoint["results_by_row_id"]["CHK-000:row_0"]["score"] == 70.0
-
-    @pytest.mark.asyncio
-    async def test_merged_report_completeness(
-        self,
-        mock_template_10_rows: AuditTemplate,
-        mock_evaluator,
-        mock_evidence_matcher,
-        tmp_path: Path,
-    ):
-        """Test that merged results produce complete checklist artifacts."""
-        checkpoint_dir = tmp_path / "checkpoints"
-        checkpoint_dir.mkdir()
-        report_dir = tmp_path / "reports"
-        report_dir.mkdir()
-
-        # Step 1: Full run
-        config_full = BatchConfig(
-            batch_size=5,
-            row_timeout_ms=5000,
-            checkpoint_dir=checkpoint_dir,
-            resume_from_checkpoint=False,
-        )
-
-        processor_full = BatchRowProcessor(
-            template=mock_template_10_rows,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config_full,
-        )
-
-        call_count = 0
-
-        async def mock_evaluate_full(*args, **kwargs):
-            nonlocal call_count
-            call_count += 1
-            row_id = str(kwargs.get("row_id") or "unknown")
-            check = kwargs.get("check")
-            return create_row_result(
-                row_id=row_id,
-                check_id=check.id if check else f"CHK-{call_count}",
-                score=60.0,  # Initial score
-                reason="Initial evaluation",
-            )
-
-        mock_evaluator.aevaluate_row.side_effect = mock_evaluate_full
-
-        full_results = await processor_full.process_all(thread_id="report-test")
-        assert len(full_results) == 10
-
-        # Step 2: Targeted rerun for rows 1, 5, 9 (0-indexed: 0, 4, 8)
-        target_selection = TargetSelection(
-            target_type=TargetType.ROW_IDS,
-            raw_value="1,5,9",
-            row_indices=frozenset({0, 4, 8}),
-        )
-
-        config_targeted = BatchConfig(
-            batch_size=5,
-            row_timeout_ms=5000,
-            checkpoint_dir=checkpoint_dir,
-            resume_from_checkpoint=True,
-            target_selection=target_selection,
-            force_refresh_targets=True,
-        )
-
-        processor_targeted = BatchRowProcessor(
-            template=mock_template_10_rows,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config_targeted,
-        )
-
-        mock_evaluator.aevaluate_row.reset_mock()
-
-        async def mock_evaluate_targeted(*args, **kwargs):
-            row_id = str(kwargs.get("row_id") or "unknown")
-            check = kwargs.get("check")
-            return create_row_result(
-                row_id=row_id,
-                check_id=check.id if check else "unknown",
-                score=100.0,  # Perfect score for refreshed rows
-                status=RowStatus.PASS,
-                reason="Refreshed - perfect score",
-            )
-
-        mock_evaluator.aevaluate_row.side_effect = mock_evaluate_targeted
-
-        merged_results = await processor_targeted.process_all(thread_id="report-test")
-
-        # Verify completeness
-        assert len(merged_results) == 10
-
-        # Verify correct mix of historical and refreshed
-        results_by_id = {r.row_id: r for r in merged_results}
-
-        # Refreshed rows (0, 4, 8) should have score 100
-        assert results_by_id["CHK-000:row_0"].score == 100.0
-        assert results_by_id["CHK-004:row_4"].score == 100.0
-        assert results_by_id["CHK-008:row_8"].score == 100.0
-
-        # Historical rows should have score 60
-        assert results_by_id["CHK-001:row_1"].score == 60.0
-        assert results_by_id["CHK-002:row_2"].score == 60.0
-        assert results_by_id["CHK-003:row_3"].score == 60.0
-        assert results_by_id["CHK-005:row_5"].score == 60.0
-        assert results_by_id["CHK-006:row_6"].score == 60.0
-        assert results_by_id["CHK-007:row_7"].score == 60.0
-        assert results_by_id["CHK-009:row_9"].score == 60.0
-
-        # Verify all row IDs are unique
-        row_ids = [r.row_id for r in merged_results]
-        assert len(row_ids) == len(set(row_ids))
-
-        # Verify all check IDs are present
-        check_ids = {r.check_id for r in merged_results}
-        expected_check_ids = {f"CHK-{i:03d}" for i in range(10)}
-        assert check_ids == expected_check_ids
-
-    @pytest.mark.asyncio
-    async def test_multiple_targeted_reruns_accumulate_correctly(
-        self,
-        mock_template_10_rows: AuditTemplate,
-        mock_evaluator,
-        mock_evidence_matcher,
-        tmp_path: Path,
-    ):
-        """Test that multiple targeted reruns accumulate correctly."""
-        checkpoint_dir = tmp_path / "checkpoints"
-        checkpoint_dir.mkdir()
-
-        # Step 1: Full run with initial scores
-        config_full = BatchConfig(
-            batch_size=5,
-            row_timeout_ms=5000,
-            checkpoint_dir=checkpoint_dir,
-            resume_from_checkpoint=False,
-        )
-
-        processor_full = BatchRowProcessor(
-            template=mock_template_10_rows,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config_full,
-        )
-
-        async def mock_evaluate_initial(*args, **kwargs):
-            row_id = str(kwargs.get("row_id") or "unknown")
-            check = kwargs.get("check")
-            return create_row_result(
-                row_id=row_id,
-                check_id=check.id if check else "unknown",
-                score=50.0,  # Initial score
-                reason="Initial",
-            )
-
-        mock_evaluator.aevaluate_row.side_effect = mock_evaluate_initial
-        await processor_full.process_all(thread_id="multi-rerun-test")
-
-        # Step 2: First targeted rerun - rows 1, 2 (0-indexed: 0, 1)
-        target_1 = TargetSelection(
-            target_type=TargetType.ROW_IDS,
-            raw_value="1,2",
-            row_indices=frozenset({0, 1}),
-        )
-
-        config_1 = BatchConfig(
-            batch_size=5,
-            row_timeout_ms=5000,
-            checkpoint_dir=checkpoint_dir,
-            resume_from_checkpoint=True,
-            target_selection=target_1,
-            force_refresh_targets=True,
-        )
-
-        processor_1 = BatchRowProcessor(
-            template=mock_template_10_rows,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config_1,
-        )
-
-        mock_evaluator.aevaluate_row.reset_mock()
-
-        async def mock_evaluate_rerun_1(*args, **kwargs):
-            row_id = str(kwargs.get("row_id") or "unknown")
-            check = kwargs.get("check")
-            return create_row_result(
-                row_id=row_id,
-                check_id=check.id if check else "unknown",
-                score=75.0,  # First rerun score
-                reason="First rerun",
-            )
-
-        mock_evaluator.aevaluate_row.side_effect = mock_evaluate_rerun_1
-        results_1 = await processor_1.process_all(thread_id="multi-rerun-test")
-
-        # Verify first rerun
-        results_by_id_1 = {r.row_id: r for r in results_1}
-        assert results_by_id_1["CHK-000:row_0"].score == 75.0
-        assert results_by_id_1["CHK-001:row_1"].score == 75.0
-        assert results_by_id_1["CHK-002:row_2"].score == 50.0  # Not targeted
-
-        # Step 3: Second targeted rerun - rows 3, 4 (0-indexed: 2, 3)
-        target_2 = TargetSelection(
-            target_type=TargetType.ROW_IDS,
-            raw_value="3,4",
-            row_indices=frozenset({2, 3}),
-        )
-
-        config_2 = BatchConfig(
-            batch_size=5,
-            row_timeout_ms=5000,
-            checkpoint_dir=checkpoint_dir,
-            resume_from_checkpoint=True,
-            target_selection=target_2,
-            force_refresh_targets=True,
-        )
-
-        processor_2 = BatchRowProcessor(
-            template=mock_template_10_rows,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config_2,
-        )
-
-        mock_evaluator.aevaluate_row.reset_mock()
-
-        async def mock_evaluate_rerun_2(*args, **kwargs):
-            row_id = str(kwargs.get("row_id") or "unknown")
-            check = kwargs.get("check")
-            return create_row_result(
-                row_id=row_id,
-                check_id=check.id if check else "unknown",
-                score=90.0,  # Second rerun score
-                reason="Second rerun",
-            )
-
-        mock_evaluator.aevaluate_row.side_effect = mock_evaluate_rerun_2
-        results_2 = await processor_2.process_all(thread_id="multi-rerun-test")
-
-        # Verify accumulated results
-        results_by_id_2 = {r.row_id: r for r in results_2}
-
-        # First rerun results preserved
-        assert results_by_id_2["CHK-000:row_0"].score == 75.0
-        assert results_by_id_2["CHK-001:row_1"].score == 75.0
-
-        # Second rerun results
-        assert results_by_id_2["CHK-002:row_2"].score == 90.0
-        assert results_by_id_2["CHK-003:row_3"].score == 90.0
-
-        # Original results preserved
-        assert results_by_id_2["CHK-004:row_4"].score == 50.0
-        assert results_by_id_2["CHK-009:row_9"].score == 50.0
-
-        # All 10 rows present
-        assert len(results_2) == 10
-
-    @pytest.mark.asyncio
-    async def test_content_match_targeting_merges_correctly(
-        self,
-        mock_template_10_rows: AuditTemplate,
-        mock_evaluator,
-        mock_evidence_matcher,
-        tmp_path: Path,
-    ):
-        """Test that content-match targeting merges correctly."""
-        checkpoint_dir = tmp_path / "checkpoints"
-        checkpoint_dir.mkdir()
-
-        # Create initial checkpoint
-        initial_results = {}
-        for i in range(10):
-            row_id = f"CHK-{i:03d}:row_{i}"
-            initial_results[row_id] = {
-                "row_id": row_id,
-                "check_id": f"CHK-{i:03d}",
-                "status": "PASS",
-                "score": 65.0,
-                "score_breakdown": {
-                    "raw_score": 65.0,
-                    "coverage": 1.0,
-                    "confidence": 1.0,
-                    "capped": False,
-                    "final_score": 65.0,
-                },
-                "reason": "Initial",
-                "finding": "Initial finding",
-                "evidence_anchors": [],
-                "provenance": {
-                    "row_llm_mode": "per-row",
-                    "protocol": "test",
-                    "model": "test-model",
-                    "template_hash": "test_template_hash_123",
-                    "rubric_version": "1.0.0",
-                    "evidence_hash": "test_evidence_hash_456",
-                    "evaluated_at": datetime.now(UTC).isoformat(),
-                },
-                "score_1_5": 4,
-            }
-
-        checkpoint_data = {
-            "thread_id": "content-match-test",
-            "total_rows": 10,
-            "template_hash": "test_template_hash_123",
-            "evidence_hash": "test_evidence_hash_456",
-            "completed_batches": [0, 1],
-            "results_by_row_id": initial_results,
-            "last_updated": datetime.now(UTC).isoformat(),
-        }
-
-        checkpoint_path = checkpoint_dir / "batch-checkpoint-content-match-test.json"
-        checkpoint_path.write_text(json.dumps(checkpoint_data))
-
-        # Target by check ID (simulating content match resolved to check IDs)
-        target_selection = TargetSelection(
-            target_type=TargetType.CHECK_IDS,
-            raw_value="CHK-003,CHK-007",
-            row_indices=frozenset({3, 7}),  # Resolved indices
-            check_ids=frozenset({"CHK-003", "CHK-007"}),
-        )
-
-        config = BatchConfig(
-            batch_size=5,
-            row_timeout_ms=5000,
-            checkpoint_dir=checkpoint_dir,
-            resume_from_checkpoint=True,
-            target_selection=target_selection,
-            force_refresh_targets=True,
-        )
-
-        processor = BatchRowProcessor(
-            template=mock_template_10_rows,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config,
-        )
-
-        async def mock_evaluate(*args, **kwargs):
-            row_id = str(kwargs.get("row_id") or "unknown")
-            check = kwargs.get("check")
-            return create_row_result(
-                row_id=row_id,
-                check_id=check.id if check else "unknown",
-                score=88.0,
-                reason="Content match refresh",
-            )
-
-        mock_evaluator.aevaluate_row.side_effect = mock_evaluate
-
-        results = await processor.process_all(thread_id="content-match-test")
-
-        # Verify all 10 rows present
-        assert len(results) == 10
-
-        # Verify targeted rows refreshed
-        results_by_id = {r.row_id: r for r in results}
-        assert results_by_id["CHK-003:row_3"].score == 88.0
-        assert results_by_id["CHK-007:row_7"].score == 88.0
-
-        # Verify non-targeted rows preserved
-        assert results_by_id["CHK-000:row_0"].score == 65.0
-        assert results_by_id["CHK-005:row_5"].score == 65.0
-
-
-class TestCheckpointSerializationIntegrity:
-    """Tests for checkpoint serialization/deserialization integrity."""
-
-    def test_row_result_round_trip(self):
-        """Test that RowEvaluationResult survives checkpoint serialization."""
-        original = create_row_result(
-            row_id="CHK-001:row_0",
-            check_id="CHK-001",
-            score=85.5,
-            status=RowStatus.PARTIAL,
-            reason="Test reason with unicode: 测试 🎉",
-            finding="Test finding",
-        )
-
-        # Serialize
-        serialized = BatchCheckpoint.serialize_row_result(original)
-
-        # Deserialize
-        restored = BatchCheckpoint.deserialize_row_result(serialized)
-
-        # Verify key fields
-        assert restored.row_id == original.row_id
-        assert restored.check_id == original.check_id
-        assert restored.score == original.score
-        assert restored.status == original.status
-        assert restored.reason == original.reason
-        assert restored.finding == original.finding
-
-    def test_checkpoint_file_integrity(self, tmp_path: Path):
-        """Test that checkpoint file can be saved and loaded correctly."""
-        checkpoint = BatchCheckpoint(
-            thread_id="integrity-test",
-            total_rows=5,
-            template_hash="hash123",
-            evidence_hash="evhash456",
-            completed_batches=[0, 1],
-            results_by_row_id={
-                "row_0": {"row_id": "row_0", "score": 80.0, "status": "PASS"},
-                "row_1": {"row_id": "row_1", "score": 70.0, "status": "PARTIAL"},
-            },
-        )
-
-        checkpoint_path = tmp_path / "test-checkpoint.json"
-        checkpoint.save(checkpoint_path)
-
-        # Load and verify
-        loaded = BatchCheckpoint.load(checkpoint_path)
-        assert loaded is not None
-        assert loaded.thread_id == checkpoint.thread_id
-        assert loaded.total_rows == checkpoint.total_rows
-        assert loaded.template_hash == checkpoint.template_hash
-        assert loaded.completed_batches == checkpoint.completed_batches
-        assert len(loaded.results_by_row_id) == 2
-
-
-class TestCanonicalArtifactMerge:
-    """Integration tests for canonical artifact merge and delta generation (TSK-342)."""
-
-    @pytest.mark.asyncio
-    async def test_full_run_then_targeted_rerun_updates_canonical_and_delta(self, tmp_path: Path, monkeypatch):
-        report_dir = tmp_path / "reports"
-        checkpoint_dir = tmp_path / "checkpoints"
-        report_dir.mkdir()
-        checkpoint_dir.mkdir()
-
-        rows = [
-            checklist_contract.ConfluenceChecklistRow(
-                rule="Security",
-                main_criterion="Auth",
-                sub_criterion="Use JWT auth",
-                weight=4.0,
-                input_score_1_5="4",
-            ),
-            checklist_contract.ConfluenceChecklistRow(
-                rule="Security",
-                main_criterion="Rate limiting",
-                sub_criterion="Apply API rate limits",
-                weight=3.0,
-                input_score_1_5="3",
-            ),
-            checklist_contract.ConfluenceChecklistRow(
-                rule="Operations",
-                main_criterion="Monitoring",
-                sub_criterion="Expose app metrics",
-                weight=3.0,
-                input_score_1_5="3",
-            ),
-        ]
-
-        async def fake_load_rows(
-            *, confluence, page_id: str, expand: str = "body.view,version", source_profile_id: str | None = None
-        ):
-            return rows, {"page_id": page_id, "version": "1", "title": "Checklist"}
-
-        class FakeConfluenceClient:
-            def __init__(self, server=None, timeout=180):
-                self.server = server
-                self.timeout = timeout
-
-        class FakeEvidenceManifestLoader:
-            def __init__(self, **kwargs):
-                pass
-
-            def load(self):
-                return SimpleNamespace(documents=[], code_files=[])
-
-            def load_runtime_corpus(self, **kwargs):
-                return SimpleNamespace(documents=[], code_files=[])
-
-        class FakeEvidenceContext:
-            evidence_refs: list[str] = []
-            matched_docs: list[object] = []
-            matched_code: list[object] = []
-            retrieval_trace = {"mode": "lexical", "docs": [{"source_path": "docs/security.md", "score": 0.91}]}
-            total_chars = 0
-            truncated = False
-
-            def format_for_llm(self) -> str:
-                return ""
-
-        class FakeEvidenceMatcher:
-            def __init__(self, *args, **kwargs):
-                pass
-
-            def match_row(self, *, row_id: str, requirement_text: str, section_id: str, **kwargs):
-                return FakeEvidenceContext()
-
-        run_scores = {
-            "full": {"CL-001": 61.0, "CL-002": 62.0, "CL-003": 63.0},
-            "targeted": {"CL-002": 95.0},
-        }
-        run_mode = {"name": "full"}
-
-        class FakeRowEvaluator(_RowEvaluatorStub):
-            async def aevaluate_row(
-                self,
-                *,
-                check,
-                evidence,
-                row_id: str,
-                row_index: int,
-                evidence_context: str,
-                evidence_refs: list[str],
-                project_profile,
-                **kwargs,
-            ):
-                score = run_scores[run_mode["name"]][check.id]
-                return RowEvaluationResult(
-                    row_id=row_id,
-                    check_id=check.id,
-                    status=RowStatus.from_score(score),
-                    score=score,
-                    score_breakdown=ScoreBreakdown.compute(score),
-                    reason=f"{run_mode['name']}-{check.id}",
-                    finding=f"finding-{run_mode['name']}-{check.id}",
-                    evidence_anchors=[
-                        EvidenceAnchor(
-                            ref_type="code_path",
-                            ref_value=f"src/{check.id.lower()}.py",
-                            excerpt=f"evidence for {check.id}",
-                        )
-                    ],
-                    provenance=RowProvenance(
-                        row_llm_mode="per-row",
-                        protocol="test",
-                        model="test-model",
-                        template_hash="template-hash",
-                        rubric_version="1.0.0",
-                        evidence_hash="evidence-hash",
-                        evaluated_at=datetime.now(UTC),
-                    ),
-                    score_1_5=int(score / 20) + 1,
-                    retrieval_trace={"mode": "lexical"},
-                )
-
-        monkeypatch.setattr(checklist_contract, "load_confluence_checklist_rows", fake_load_rows)
-        monkeypatch.setattr(checklist_contract, "ConfluenceCliClient", FakeConfluenceClient)
-        monkeypatch.setattr(checklist_contract, "EvidenceManifestLoader", FakeEvidenceManifestLoader)
-        monkeypatch.setattr(checklist_contract, "PostgresEvidenceMatcher", FakeEvidenceMatcher)
-        monkeypatch.setattr(checklist_contract, "RowEvaluator", FakeRowEvaluator)
-        monkeypatch.setattr(checklist_contract, "PostgresStateStore", MagicMock)
-        monkeypatch.setattr(checklist_contract, "ProjectKnowledgeStore", MagicMock)
-        monkeypatch.setattr(checklist_contract, "ProjectEvidenceStore", MagicMock)
-
-        await checklist_contract.write_confluence_checklist_artifacts(
-            report_dir=report_dir,
-            repo_name="test-repo",
-            thread_id="tsk342-full",
-            checklist_page_id="test-page",
-            batch_config=BatchConfig(checkpoint_dir=checkpoint_dir, resume_from_checkpoint=False, batch_size=2),
-            skip_evidence_check=True,
-            readiness_gate=False,
-            state_dsn="postgresql://test",
-            state_manifest_loader=lambda _dsn: {},
-        )
-
-        run_mode["name"] = "targeted"
-        await checklist_contract.write_confluence_checklist_artifacts(
-            report_dir=report_dir,
-            repo_name="test-repo",
-            thread_id="tsk342-targeted",
-            checklist_page_id="test-page",
-            batch_config=BatchConfig(checkpoint_dir=checkpoint_dir, resume_from_checkpoint=False, batch_size=2),
-            target="2",
-            skip_evidence_check=True,
-            readiness_gate=False,
-            state_dsn="postgresql://test",
-            state_manifest_loader=lambda _dsn: {},
-        )
-
-        canonical_payload = json.loads((report_dir / "audit-checklist.json").read_text(encoding="utf-8"))
-        rows_by_id = {row["row_id"]: row for row in canonical_payload["rows"]}
-
-        assert rows_by_id["CL-001:row_0"]["score_breakdown"]["final_score"] == 61.0
-        assert rows_by_id["CL-002:row_1"]["score_breakdown"]["final_score"] == 95.0
-        assert rows_by_id["CL-003:row_2"]["score_breakdown"]["final_score"] == 63.0
-
-        delta_payload = json.loads((report_dir / "audit-checklist.delta.json").read_text(encoding="utf-8"))
-        assert delta_payload["targeted_run"] is True
-        assert delta_payload["changed_row_count"] == 1
-        assert delta_payload["merge_guardrail"]["action"] == "targeted_merge_applied"
-        assert len(delta_payload["changed_rows"]) == 1
-        changed = delta_payload["changed_rows"][0]
-        assert changed["row_id"] == "CL-002:row_1"
-        assert changed["before"]["score_breakdown"]["final_score"] == 62.0
-        assert changed["after"]["score_breakdown"]["final_score"] == 95.0
-
-        meta_payload = json.loads((report_dir / "audit-checklist.meta.json").read_text(encoding="utf-8"))
-        assert meta_payload["schema"] == "audit-checklist.meta.v1"
-        assert meta_payload["profile"] == "confluence_checklist_canonical"
-        assert meta_payload["checklist"]["template_hash"] == canonical_payload["template_hash"]
-        assert meta_payload["checklist"]["evidence_hash"] == canonical_payload["evidence_hash"]
-        assert meta_payload["checklist"]["template_row_count"] == len(rows)
-        assert meta_payload["checklist"]["evaluated_row_count"] == len(canonical_payload["rows"])
-        assert meta_payload["delta"]["changed_row_count"] == 1
-        assert meta_payload["delta"]["merge_guardrail"]["action"] == "targeted_merge_applied"
-        assert meta_payload["paths"]["retrieval_trace_json"].endswith("audit-checklist.retrieval-trace.json")
-        assert meta_payload["paths"]["requirement_mapping_preflight_json"].endswith(
-            "audit-checklist.requirement-mapping.preflight.json"
-        )
-        assert meta_payload["paths"]["security_evidence_preflight_json"].endswith(
-            "audit-checklist.security-evidence.preflight.json"
-        )
-        # Preflight row_count reflects targeted scope (1 row targeted), not total template rows
-        assert meta_payload["preflight"]["requirement_mapping"]["row_count"] == 1
-        # Security row count scoped to targeted rows (row 2 may or may not be security)
-        assert meta_payload["preflight"]["security_evidence"]["security_row_count"] >= 0
-
-        retrieval_trace_payload = json.loads((report_dir / "audit-checklist.retrieval-trace.json").read_text("utf-8"))
-        assert retrieval_trace_payload["schema"] == "audit-checklist.retrieval-trace.v1"
-        assert retrieval_trace_payload["row_count"] >= 1
-        # Find the row that was actually evaluated by FakeRowEvaluator (CL-002),
-        # not rows[0] which may be a placeholder with retrieval_mode='hybrid'.
-        _evaluated_row = next(
-            (r for r in retrieval_trace_payload["rows"] if r.get("check_id") == "CL-002"),
-            None,
-        )
-        assert _evaluated_row is not None, (
-            f"CL-002 row not found in retrieval trace; "
-            f"available check_ids: {[r.get('check_id') for r in retrieval_trace_payload['rows']]}"
-        )
-        _eval_trace = _evaluated_row["retrieval_trace"]
-        assert _eval_trace.get("retrieval_mode") == "lexical" or _eval_trace.get("mode") == "lexical", (
-            f"Expected retrieval_mode or mode='lexical' for CL-002, "
-            f"got keys={sorted(_eval_trace.keys())}, "
-            f"retrieval_mode={_eval_trace.get('retrieval_mode')!r}, "
-            f"mode={_eval_trace.get('mode')!r}"
-        )
-        # Structural assertions on first sidecar row (validates sidecar schema regardless of content).
-        first_row = retrieval_trace_payload["rows"][0]
-        assert "tool_effectiveness" in first_row
-        assert isinstance(first_row["tool_effectiveness"], dict)
-        assert first_row["tool_call_summary"]["total_steps"] >= 0
-        assert "coverage_metrics" in first_row
-        assert set(first_row["coverage_metrics"]).issuperset(
-            {"coverage_requirements", "coverage_code", "coverage_docs", "coverage_confidence"}
-        )
-
-    @pytest.mark.asyncio
-    async def test_targeted_merge_guardrail_rejects_when_hashes_drift(self, tmp_path: Path, monkeypatch):
-        report_dir = tmp_path / "reports"
-        checkpoint_dir = tmp_path / "checkpoints"
-        report_dir.mkdir()
-        checkpoint_dir.mkdir()
-
-        rows = [
-            checklist_contract.ConfluenceChecklistRow(
-                rule="Security",
-                main_criterion="Auth",
-                sub_criterion="Use JWT auth",
-                weight=4.0,
-                input_score_1_5="4",
-            ),
-            checklist_contract.ConfluenceChecklistRow(
-                rule="Security",
-                main_criterion="Rate limiting",
-                sub_criterion="Apply API rate limits",
-                weight=3.0,
-                input_score_1_5="3",
-            ),
-            checklist_contract.ConfluenceChecklistRow(
-                rule="Operations",
-                main_criterion="Monitoring",
-                sub_criterion="Expose app metrics",
-                weight=3.0,
-                input_score_1_5="3",
-            ),
-        ]
-
-        run_mode = {"name": "full"}
-        run_scores = {
-            "full": {"CL-001": 61.0, "CL-002": 62.0, "CL-003": 63.0},
-            "targeted": {"CL-002": 95.0},
-        }
-        page_versions = {"full": "1", "targeted": "2"}
-
-        async def fake_load_rows(
-            *, confluence, page_id: str, expand: str = "body.view,version", source_profile_id: str | None = None
-        ):
-            version = page_versions[run_mode["name"]]
-            return rows, {"page_id": page_id, "version": version, "title": "Checklist"}
-
-        class FakeConfluenceClient:
-            def __init__(self, server=None, timeout=180):
-                self.server = server
-                self.timeout = timeout
-
-        class FakeEvidenceManifestLoader:
-            def __init__(self, **kwargs):
-                pass
-
-            def load(self):
-                return SimpleNamespace(documents=[], code_files=[])
-
-            def load_runtime_corpus(self, **kwargs):
-                return SimpleNamespace(documents=[], code_files=[])
-
-        class FakeEvidenceContext:
-            evidence_refs: list[str] = []
-            matched_docs: list[object] = []
-            matched_code: list[object] = []
-            total_chars = 0
-            truncated = False
-
-            def format_for_llm(self) -> str:
-                return ""
-
-        class FakeEvidenceMatcher:
-            def __init__(self, *args, **kwargs):
-                pass
-
-            def match_row(self, *, row_id: str, requirement_text: str, section_id: str, **kwargs):
-                return FakeEvidenceContext()
-
-        class FakeRowEvaluator(_RowEvaluatorStub):
-            async def aevaluate_row(
-                self,
-                *,
-                check,
-                evidence,
-                row_id: str,
-                row_index: int,
-                evidence_context: str,
-                evidence_refs: list[str],
-                project_profile,
-                **kwargs,
-            ):
-                score = run_scores[run_mode["name"]][check.id]
-                return RowEvaluationResult(
-                    row_id=row_id,
-                    check_id=check.id,
-                    status=RowStatus.from_score(score),
-                    score=score,
-                    score_breakdown=ScoreBreakdown.compute(score),
-                    reason=f"{run_mode['name']}-{check.id}",
-                    finding=f"finding-{run_mode['name']}-{check.id}",
-                    evidence_anchors=[
-                        EvidenceAnchor(
-                            ref_type="code_path",
-                            ref_value=f"src/{check.id.lower()}.py",
-                            excerpt=f"evidence for {check.id}",
-                        )
-                    ],
-                    provenance=RowProvenance(
-                        row_llm_mode="per-row",
-                        protocol="test",
-                        model="test-model",
-                        template_hash="template-hash",
-                        rubric_version="1.0.0",
-                        evidence_hash="evidence-hash",
-                        evaluated_at=datetime.now(UTC),
-                    ),
-                    score_1_5=int(score / 20) + 1,
-                    retrieval_trace={"mode": "lexical"},
-                )
-
-        monkeypatch.setattr(checklist_contract, "load_confluence_checklist_rows", fake_load_rows)
-        monkeypatch.setattr(checklist_contract, "ConfluenceCliClient", FakeConfluenceClient)
-        monkeypatch.setattr(checklist_contract, "EvidenceManifestLoader", FakeEvidenceManifestLoader)
-        monkeypatch.setattr(checklist_contract, "PostgresEvidenceMatcher", FakeEvidenceMatcher)
-        monkeypatch.setattr(checklist_contract, "RowEvaluator", FakeRowEvaluator)
-        monkeypatch.setattr(checklist_contract, "PostgresStateStore", MagicMock)
-        monkeypatch.setattr(checklist_contract, "ProjectKnowledgeStore", MagicMock)
-        monkeypatch.setattr(checklist_contract, "ProjectEvidenceStore", MagicMock)
-
-        await checklist_contract.write_confluence_checklist_artifacts(
-            report_dir=report_dir,
-            repo_name="test-repo",
-            thread_id="tsk342-guardrail-full",
-            checklist_page_id="test-page",
-            batch_config=BatchConfig(checkpoint_dir=checkpoint_dir, resume_from_checkpoint=False, batch_size=2),
-            skip_evidence_check=True,
-            readiness_gate=False,
-            state_dsn="postgresql://test",
-            state_manifest_loader=lambda _dsn: {},
-        )
-
-        run_mode["name"] = "targeted"
-        await checklist_contract.write_confluence_checklist_artifacts(
-            report_dir=report_dir,
-            repo_name="test-repo",
-            thread_id="tsk342-guardrail-targeted",
-            checklist_page_id="test-page",
-            batch_config=BatchConfig(checkpoint_dir=checkpoint_dir, resume_from_checkpoint=False, batch_size=2),
-            target="2",
-            skip_evidence_check=True,
-            readiness_gate=False,
-            state_dsn="postgresql://test",
-            state_manifest_loader=lambda _dsn: {},
-        )
-
-        canonical_payload = json.loads((report_dir / "audit-checklist.json").read_text(encoding="utf-8"))
-        rows_by_id = {row["row_id"]: row for row in canonical_payload["rows"]}
-        assert rows_by_id["CL-001:row_0"]["status"] == "N/A"
-        assert rows_by_id["CL-002:row_1"]["score_breakdown"]["final_score"] == 95.0
-        assert rows_by_id["CL-003:row_2"]["status"] == "N/A"
-
-        delta_payload = json.loads((report_dir / "audit-checklist.delta.json").read_text(encoding="utf-8"))
-        guardrail = delta_payload["merge_guardrail"]
-        assert guardrail["action"] == "targeted_merge_rejected"
-        assert guardrail["reason"] == "template_hash_mismatch"
-        assert guardrail["merge_allowed"] is False
-        assert guardrail["merge_attempted"] is True
-
-        meta_payload = json.loads((report_dir / "audit-checklist.meta.json").read_text(encoding="utf-8"))
-        assert meta_payload["delta"]["merge_guardrail"]["action"] == "targeted_merge_rejected"
-        assert meta_payload["delta"]["merge_guardrail"]["reason"] == "template_hash_mismatch"
-
-    @pytest.mark.asyncio
-    async def test_targeted_run_without_previous_canonical_tracks_only_targeted_delta(
-        self, tmp_path: Path, monkeypatch
-    ):
-        report_dir = tmp_path / "reports"
-        checkpoint_dir = tmp_path / "checkpoints"
-        report_dir.mkdir()
-        checkpoint_dir.mkdir()
-
-        rows = [
-            checklist_contract.ConfluenceChecklistRow(
-                rule="Security",
-                main_criterion="Auth",
-                sub_criterion="Use JWT auth",
-                weight=4.0,
-                input_score_1_5="4",
-            ),
-            checklist_contract.ConfluenceChecklistRow(
-                rule="Security",
-                main_criterion="Rate limiting",
-                sub_criterion="Apply API rate limits",
-                weight=3.0,
-                input_score_1_5="3",
-            ),
-            checklist_contract.ConfluenceChecklistRow(
-                rule="Operations",
-                main_criterion="Monitoring",
-                sub_criterion="Expose app metrics",
-                weight=3.0,
-                input_score_1_5="3",
-            ),
-        ]
-
-        async def fake_load_rows(
-            *, confluence, page_id: str, expand: str = "body.view,version", source_profile_id: str | None = None
-        ):
-            return rows, {"page_id": page_id, "version": "1", "title": "Checklist"}
-
-        class FakeConfluenceClient:
-            def __init__(self, server=None, timeout=180):
-                self.server = server
-                self.timeout = timeout
-
-        class FakeEvidenceManifestLoader:
-            def __init__(self, **kwargs):
-                pass
-
-            def load(self):
-                return SimpleNamespace(documents=[], code_files=[])
-
-            def load_runtime_corpus(self, **kwargs):
-                return SimpleNamespace(documents=[], code_files=[])
-
-        class FakeEvidenceContext:
-            evidence_refs: list[str] = []
-            matched_docs: list[object] = []
-            matched_code: list[object] = []
-            total_chars = 0
-            truncated = False
-
-            def format_for_llm(self) -> str:
-                return ""
-
-        class FakeEvidenceMatcher:
-            def __init__(self, *args, **kwargs):
-                pass
-
-            def match_row(self, *, row_id: str, requirement_text: str, section_id: str, **kwargs):
-                return FakeEvidenceContext()
-
-        run_scores = {"CL-002": 95.0}
-
-        class FakeRowEvaluator(_RowEvaluatorStub):
-            async def aevaluate_row(
-                self,
-                *,
-                check,
-                evidence,
-                row_id: str,
-                row_index: int,
-                evidence_context: str,
-                evidence_refs: list[str],
-                project_profile,
-                **kwargs,
-            ):
-                score = run_scores[check.id]
-                return RowEvaluationResult(
-                    row_id=row_id,
-                    check_id=check.id,
-                    status=RowStatus.from_score(score),
-                    score=score,
-                    score_breakdown=ScoreBreakdown.compute(score),
-                    reason=f"targeted-{check.id}",
-                    finding=f"finding-targeted-{check.id}",
-                    evidence_anchors=[
-                        EvidenceAnchor(
-                            ref_type="code_path",
-                            ref_value=f"src/{check.id.lower()}.py",
-                            excerpt=f"evidence for {check.id}",
-                        )
-                    ],
-                    provenance=RowProvenance(
-                        row_llm_mode="per-row",
-                        protocol="test",
-                        model="test-model",
-                        template_hash="template-hash",
-                        rubric_version="1.0.0",
-                        evidence_hash="evidence-hash",
-                        evaluated_at=datetime.now(UTC),
-                    ),
-                    score_1_5=int(score / 20) + 1,
-                    retrieval_trace={"mode": "lexical"},
-                )
-
-        monkeypatch.setattr(checklist_contract, "load_confluence_checklist_rows", fake_load_rows)
-        monkeypatch.setattr(checklist_contract, "ConfluenceCliClient", FakeConfluenceClient)
-        monkeypatch.setattr(checklist_contract, "EvidenceManifestLoader", FakeEvidenceManifestLoader)
-        monkeypatch.setattr(checklist_contract, "PostgresEvidenceMatcher", FakeEvidenceMatcher)
-        monkeypatch.setattr(checklist_contract, "RowEvaluator", FakeRowEvaluator)
-        monkeypatch.setattr(checklist_contract, "PostgresStateStore", MagicMock)
-        monkeypatch.setattr(checklist_contract, "ProjectKnowledgeStore", MagicMock)
-        monkeypatch.setattr(checklist_contract, "ProjectEvidenceStore", MagicMock)
-
-        await checklist_contract.write_confluence_checklist_artifacts(
-            report_dir=report_dir,
-            repo_name="test-repo",
-            thread_id="tsk342-first-targeted",
-            checklist_page_id="test-page",
-            batch_config=BatchConfig(checkpoint_dir=checkpoint_dir, resume_from_checkpoint=False, batch_size=2),
-            target="2",
-            skip_evidence_check=True,
-            readiness_gate=False,
-            state_dsn="postgresql://test",
-            state_manifest_loader=lambda _dsn: {},
-        )
-
-        canonical_payload = json.loads((report_dir / "audit-checklist.json").read_text(encoding="utf-8"))
-        rows_by_id = {row["row_id"]: row for row in canonical_payload["rows"]}
-        assert rows_by_id["CL-001:row_0"]["status"] == "N/A"
-        assert rows_by_id["CL-002:row_1"]["score_breakdown"]["final_score"] == 95.0
-        assert rows_by_id["CL-003:row_2"]["status"] == "N/A"
-
-        delta_payload = json.loads((report_dir / "audit-checklist.delta.json").read_text(encoding="utf-8"))
-        guardrail = delta_payload["merge_guardrail"]
-        assert guardrail["action"] == "targeted_merge_without_previous_canonical"
-        assert guardrail["merge_attempted"] is False
-        assert guardrail["merge_allowed"] is False
-        assert delta_payload["targeted_run"] is True
-        assert delta_payload["changed_row_count"] == 1
-        assert len(delta_payload["changed_rows"]) == 1
-        assert delta_payload["changed_rows"][0]["row_id"] == "CL-002:row_1"