@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/unit/engine/test_batch_processor.py

@@ -1,3608 +0,0 @@
-import asyncio
-import json
-from dataclasses import dataclass
-from datetime import UTC, datetime
-from typing import Any
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-from vds_agent_core.llm.budget import (
-    BudgetExceededError,
-    BudgetScope,
-    BudgetStatus,
-    BudgetUsage,
-)
-from vds_audit_orchestrator.engine import batch_processor as batch_processor_module
-from vds_audit_orchestrator.engine.batch_processor import (
-    BatchBudgetExceededError,
-    BatchCheckpoint,
-    BatchConfig,
-    BatchResult,
-    BatchRowProcessor,
-)
-from vds_audit_orchestrator.engine.row_evaluator import RowEvaluator
-from vds_audit_orchestrator.engine.row_evaluator_types import RowEvaluationResult
-from vds_audit_orchestrator.engine.target_selector import TargetSelection, TargetType
-from vds_audit_orchestrator.errors import AUDIT_ERROR_CODES
-from vds_audit_orchestrator.evidence.matcher import EvidenceMatcher, RowEvidenceContext
-from vds_audit_orchestrator.models.checklist import (
-    VERIFICATION_REASON_EXCERPT_VERIFIED_IN_CONTEXT,
-    VERIFICATION_REASON_FALLBACK_REF_INHERITED,
-    EvidenceAnchor,
-    RowProvenance,
-    RowStatus,
-    ScoreBreakdown,
-)
-from vds_audit_orchestrator.models.template import AuditCheck, AuditSection, AuditTemplate
-
-
-@dataclass
-class _DeterministicEvidenceContext:
-    row_id: str
-    requirement_text: str
-    evidence_refs: list[str]
-    retrieval_trace: dict[str, Any] | None = None
-    total_chars: int = 0
-    truncated: bool = False
-    matched_docs: list[Any] | None = None
-    matched_code: list[Any] | None = None
-
-    def format_for_llm(self) -> str:
-        return f"context::{self.requirement_text}"
-
-
-# -----------------------------------------------------------------------------
-# Fixtures
-# -----------------------------------------------------------------------------
-
-
-@pytest.fixture
-def mock_template():
-    """Create a mock AuditTemplate with 10 checks."""
-    checks = []
-    for i in range(10):
-        checks.append(AuditCheck(id=f"CHK-{i}", name=f"Check {i}", description=f"Description {i}", section_id="SEC-1"))
-
-    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(spec=RowEvaluator)
-    evaluator.template_hash = "hash_123"
-    evaluator.evidence_hash = "ev_hash_456"
-    evaluator.aevaluate_row = AsyncMock()
-    evaluator.config = MagicMock()
-    evaluator.config.mode.value = "test_mode"
-    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 = "Evidence Content"
-    context.evidence_refs = ["ref1", "ref2"]
-    context.retrieval_trace = {"mode": "lexical", "docs": [{"source_path": "docs/a.md", "score": 0.9}]}
-    matcher.match_row.return_value = context
-    return matcher
-
-
-@pytest.fixture
-def default_result():
-    """Create a default RowEvaluationResult."""
-    return RowEvaluationResult(
-        row_id="test_row",
-        check_id="test_check",
-        status=RowStatus.PASS,
-        score=100.0,
-        score_breakdown=ScoreBreakdown.compute(100.0),
-        reason="Test reason",
-        finding="Test finding",
-        evidence_anchors=[],
-        provenance=RowProvenance(
-            row_llm_mode="test",
-            protocol=None,
-            model=None,
-            template_hash="hash",
-            rubric_version="1",
-            evidence_hash="hash",
-            evaluated_at=datetime.now(UTC),
-        ),
-    )
-
-
-# -----------------------------------------------------------------------------
-# Tests
-# -----------------------------------------------------------------------------
-
-
-def test_repo_row_distribution_helper_resolves_profiles_and_assignment(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    config = BatchConfig(
-        batch_size=4,
-        row_timeout_ms=1000,
-        run_context={
-            "repo_profile_execution_mode": "distributed",
-            "repo_distribution_profiles": ["profile-a", "profile-b", "profile-a", "profile-c"],
-        },
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    assert processor._repo_row_distribution_profiles() == ["profile-a", "profile-b", "profile-c"]
-    assert processor._repo_row_distribution_enabled() is True
-    assert processor._assigned_repo_profile_for_row(0) == "profile-a"
-    assert processor._assigned_repo_profile_for_row(1) == "profile-b"
-    assert processor._assigned_repo_profile_for_row(2) == "profile-c"
-    assert processor._assigned_repo_profile_for_row(3) == "profile-a"
-
-
-@pytest.mark.asyncio
-async def test_invoke_row_evaluator_distributed_mode_activates_assigned_profile(
-    monkeypatch: pytest.MonkeyPatch,
-    mock_template,
-    mock_evaluator,
-    mock_evidence_matcher,
-) -> None:
-    config = BatchConfig(
-        batch_size=2,
-        row_timeout_ms=1000,
-        run_context={
-            "repo_profile_execution_mode": "distributed",
-            "repo_distribution_profiles": ["profile-a", "profile-b"],
-            "repo_primary_profile": "profile-a",
-            "active_profile": "profile-a",
-        },
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.evidence_bundle = None
-
-    monkeypatch.setattr(
-        batch_processor_module, "RowEvaluator", lambda config, template, evidence_bundle=None: mock_evaluator
-    )
-    monkeypatch.setattr(
-        batch_processor_module,
-        "inherit_runtime_llm_policy",
-        lambda profile_name, source_llm=None: type(
-            "_LLM", (), {"protocol": "openai", "model_standard": f"model-{profile_name}"}
-        )(),
-    )
-
-    expected = RowEvaluationResult(
-        row_id="CHK-1:row_1",
-        check_id="CHK-1",
-        status=RowStatus.PASS,
-        score=90.0,
-        score_breakdown=ScoreBreakdown.compute(90.0),
-        reason="distributed",
-        finding="distributed",
-        evidence_anchors=[],
-        provenance=RowProvenance(
-            row_llm_mode="test",
-            protocol=None,
-            model=None,
-            template_hash="hash",
-            rubric_version="1",
-            evidence_hash="hash",
-            evaluated_at=datetime.now(UTC),
-        ),
-    )
-    mock_evaluator.aevaluate_row.return_value = expected
-
-    result = await processor._invoke_row_evaluator(
-        check=mock_template.sections[0].checks[1],
-        row_id="CHK-1:row_1",
-        row_index=1,
-        evidence_context="ctx",
-        evidence_refs=["ref1"],
-        project_profile=None,
-    )
-
-    assert result is expected
-    assert result.provenance.original_provider == "profile-b"
-    assert result.provenance.final_provider == "profile-b"
-    assert result.provenance.failover_chain == ["profile-b"]
-    assert result.retrieval_trace["row_distribution_profile"] == "profile-b"
-
-
-@pytest.mark.asyncio
-async def test_batch_processing_logic(mock_template, mock_evaluator, mock_evidence_matcher, default_result):
-    """Test that rows are processed in correct batch sizes."""
-    # Config: 10 rows total, batch size 4 -> 3 batches (4, 4, 2)
-    config = BatchConfig(batch_size=4, row_timeout_ms=1000)
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    # Create unique results for each row to avoid deduplication
-    call_count = 0
-
-    async def create_unique_result(*args, **kwargs):
-        nonlocal call_count
-        call_count += 1
-        row_id = kwargs.get("row_id", f"row_{call_count}")
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id="test_check",
-            status=RowStatus.PASS,
-            score=100.0,
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason="Test reason",
-            finding="Test finding",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = create_unique_result
-
-    results = await processor.process_all(thread_id="test-thread")
-
-    assert len(results) == 10
-    assert mock_evaluator.aevaluate_row.call_count == 10
-
-
-@pytest.mark.asyncio
-async def test_row_retrieval_trace_merges_matcher_context(mock_template, mock_evaluator, mock_evidence_matcher):
-    """Row retrieval trace should preserve matcher context and row evaluator fields."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(batch_size=1, row_timeout_ms=1_000)
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.return_value = RowEvaluationResult(
-        row_id="CHK-0:row_0",
-        check_id="CHK-0",
-        status=RowStatus.PASS,
-        score=90.0,
-        score_breakdown=ScoreBreakdown.compute(90.0),
-        reason="merged trace",
-        finding="merged trace",
-        evidence_anchors=[],
-        retrieval_trace={
-            "selected_backend": "prompt_evaluator",
-            "mode": None,
-            "docs": None,
-            "tool_first_loop": {"steps_executed": 5},
-        },
-        provenance=RowProvenance(
-            row_llm_mode="test",
-            protocol=None,
-            model=None,
-            template_hash="hash",
-            rubric_version="1",
-            evidence_hash="hash",
-            evaluated_at=datetime.now(UTC),
-        ),
-    )
-
-    results = await processor.process_all(thread_id="test-row-trace-merge")
-
-    assert len(results) == 1
-    trace = results[0].retrieval_trace
-    assert isinstance(trace, dict)
-    assert trace.get("mode") == "lexical"
-    assert trace.get("selected_backend") == "prompt_evaluator"
-    assert trace.get("tool_first_loop", {}).get("steps_executed") == 5
-    assert trace.get("docs", [{}])[0].get("source_path") == "docs/a.md"
-
-
-@pytest.mark.asyncio
-async def test_batch_progress_callback_emits_incremental_updates(mock_template, mock_evaluator, mock_evidence_matcher):
-    """Processed batches should emit incremental progress snapshots."""
-    config = BatchConfig(batch_size=4, row_timeout_ms=1000)
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    async def create_unique_result(*args, **kwargs):
-        row_id = kwargs.get("row_id", "missing-row-id")
-        check_id = kwargs.get("check").id
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id=check_id,
-            status=RowStatus.PASS,
-            score=100.0,
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason="ok",
-            finding="ok",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = create_unique_result
-
-    progress_events: list[tuple[str, int, int, int]] = []
-
-    async def on_progress(progress, current_results):
-        progress_events.append(
-            (progress.emission_kind, progress.batch_index, progress.batch_count, len(current_results))
-        )
-
-    results = await processor.process_all(thread_id="test-progress", progress_callback=on_progress)
-
-    assert len(results) == 10
-    row_events = [event for event in progress_events if event[0] == "row"]
-    batch_events = [event for event in progress_events if event[0] == "batch"]
-    # Row events include both "started" and "success" emissions per row:
-    # 10 rows × 2 events = 20 total row events
-    assert len(row_events) == 20
-    assert len(batch_events) == 3  # 10 rows with batch size 4 => 3 completed batches
-    # First row event is "started" (completed_rows=0), second is "success" (completed_rows=1)
-    assert row_events[0] == ("row", 0, 3, 0)  # row started
-    assert row_events[1] == ("row", 0, 3, 0)  # row started (concurrent)
-    assert row_events[4] == ("row", 0, 3, 1)  # first row completed
-    assert batch_events[0] == ("batch", 0, 3, 4)
-    assert batch_events[1] == ("batch", 1, 3, 8)
-    assert batch_events[2] == ("batch", 2, 3, 10)
-
-
-@pytest.mark.asyncio
-async def test_parallel_batch_deduplicates_shared_matcher_work(monkeypatch, mock_template, mock_evaluator):
-    """Parallel rows with identical retrieval inputs should share one matcher call per batch."""
-    mock_template.sections[0].checks = [
-        AuditCheck(id="CHK-A", name="Check A", description="same requirement", section_id="SEC-1"),
-        AuditCheck(id="CHK-B", name="Check B", description="same requirement", section_id="SEC-1"),
-    ]
-
-    class _Matcher:
-        retrieval_mode = "lexical"
-
-        def __init__(self) -> None:
-            self.calls: list[tuple[str, str, str | None]] = []
-
-        def match_row(
-            self, *, row_id: str, requirement_text: str, section_id: str | None, log_retrieval_trace_event: bool = True
-        ):  # type: ignore[no-untyped-def]
-            _ = log_retrieval_trace_event
-            self.calls.append((row_id, requirement_text, section_id))
-            return _DeterministicEvidenceContext(
-                row_id=row_id,
-                requirement_text=requirement_text,
-                evidence_refs=[f"ref::{requirement_text}"],
-                retrieval_trace={"mode": "lexical", "row_id": row_id},
-            )
-
-    matcher = _Matcher()
-
-    async def _result(*args, **kwargs):
-        row_id = kwargs["row_id"]
-        check = kwargs["check"]
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id=check.id,
-            status=RowStatus.PASS,
-            score=100.0,
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason="ok",
-            finding="ok",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = _result
-
-    config = BatchConfig(batch_size=2, row_timeout_ms=1000, row_concurrency=2)
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=matcher,
-        config=config,
-    )
-
-    results = await processor.process_all(thread_id="test-parallel-dedup")
-
-    assert len(results) == 2
-    assert len(matcher.calls) == 1
-    assert matcher.calls[0] == ("CHK-A:row_0", "same requirement", "SEC-1")
-    assert all(
-        result.retrieval_trace.get("mode") == "lexical"
-        for result in results
-        if isinstance(result.retrieval_trace, dict)
-    )
-
-
-@pytest.mark.asyncio
-async def test_targeted_execution_complete_log_includes_run_context(
-    monkeypatch, mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Targeted completion logs should include thread/repo/project identity."""
-    target_selection = TargetSelection(
-        target_type=TargetType.ROW_IDS,
-        raw_value="1",
-        row_indices=frozenset({0}),
-    )
-    config = BatchConfig(
-        batch_size=4,
-        row_timeout_ms=1000,
-        target_selection=target_selection,
-        run_context={"repo_key": "demo-repo", "project_key": "demo-project"},
-    )
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    async def create_unique_result(*args, **kwargs):
-        row_id = kwargs.get("row_id", "missing-row-id")
-        check_id = kwargs.get("check").id
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id=check_id,
-            status=RowStatus.PASS,
-            score=100.0,
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason="ok",
-            finding="ok",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = create_unique_result
-
-    captured: list[tuple[str, dict[str, object]]] = []
-
-    def fake_info(event, **kwargs):
-        captured.append((event, kwargs))
-
-    monkeypatch.setattr(batch_processor_module.logger, "info", fake_info)
-
-    await processor.process_all(thread_id="test-targeted-log-context")
-
-    targeted_event = next(kwargs for event, kwargs in captured if event == "targeted_execution_complete")
-    assert targeted_event["repo_key"] == "demo-repo"
-    assert targeted_event["project_key"] == "demo-project"
-    assert targeted_event["thread_id"] == "test-targeted-log-context"
-    assert targeted_event["completion_scope"] == "targeted"
-    assert targeted_event["targeted_total_rows"] == 1
-    assert targeted_event["targeted_completed_rows"] == 1
-    assert targeted_event["targeted_completion_pct"] == 100.0
-
-    batch_progress_event = next(kwargs for event, kwargs in captured if event == "batch_progress")
-    assert batch_progress_event["completion_scope"] == "targeted"
-    assert batch_progress_event["targeted_total_rows"] == 1
-    assert batch_progress_event["targeted_completed_rows"] == 1
-    assert batch_progress_event["targeted_completion_pct"] == 100.0
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("row_concurrency", [1, 3])
-async def test_targeted_row_progress_omits_null_identity_skipped_events(
-    mock_template, mock_evaluator, mock_evidence_matcher, row_concurrency
-):
-    """Targeted runs should not emit row progress entries without row/check identifiers."""
-    target_selection = TargetSelection(
-        target_type=TargetType.ROW_IDS,
-        raw_value="1,3,6",
-        row_indices=frozenset({0, 2, 5}),
-    )
-    config = BatchConfig(
-        batch_size=10,
-        row_timeout_ms=1000,
-        target_selection=target_selection,
-        force_refresh_targets=True,
-        row_concurrency=row_concurrency,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    async def create_unique_result(*args, **kwargs):
-        row_id = kwargs.get("row_id", "missing-row-id")
-        check_id = kwargs.get("check").id
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id=check_id,
-            status=RowStatus.PASS,
-            score=100.0,
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason="ok",
-            finding="ok",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = create_unique_result
-    progress_events: list[tuple[str, str | None, str | None, int]] = []
-
-    async def on_progress(progress, current_results):
-        progress_events.append(
-            (
-                progress.emission_kind,
-                getattr(progress, "current_row_id", None),
-                getattr(progress, "current_check_id", None),
-                len(current_results),
-            )
-        )
-
-    results = await processor.process_all(
-        thread_id=f"test-targeted-no-null-row-progress-{row_concurrency}",
-        progress_callback=on_progress,
-    )
-
-    row_events = [event for event in progress_events if event[0] == "row"]
-    assert len(results) == 3
-    assert len(row_events) >= 3
-    assert all(event[1] is not None and event[2] is not None for event in row_events)
-    assert {event[3] for event in row_events}.issuperset({0, 1, 2, 3})
-
-
-@pytest.mark.asyncio
-async def test_targeted_row_progress_emits_started_identity_before_result(
-    mock_template,
-    mock_evaluator,
-    mock_evidence_matcher,
-):
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=1000,
-        target_selection=TargetSelection(
-            target_type=TargetType.CHECK_IDS,
-            raw_value="CHK-0",
-            check_ids=frozenset({"CHK-0"}),
-            row_indices=frozenset({0}),
-        ),
-    )
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    async def create_result(*args, **kwargs):
-        return RowEvaluationResult(
-            row_id=kwargs.get("row_id", "CHK-0:row_0"),
-            check_id=kwargs.get("check").id,
-            status=RowStatus.PASS,
-            score=100.0,
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason="ok",
-            finding="ok",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = create_result
-
-    progress_events: list[tuple[str, str | None, str | None, int]] = []
-
-    async def on_progress(progress, current_results):
-        progress_events.append(
-            (
-                progress.emission_kind,
-                getattr(progress, "current_row_id", None),
-                getattr(progress, "current_check_id", None),
-                len(current_results),
-            )
-        )
-
-    await processor.process_all(thread_id="test-targeted-started-row-progress", progress_callback=on_progress)
-
-    row_events = [event for event in progress_events if event[0] == "row"]
-    assert row_events
-    first_row_event = row_events[0]
-    assert first_row_event[1] == "CHK-0:row_0"
-    assert first_row_event[2] == "CHK-0"
-    assert first_row_event[3] == 0
-
-
-@pytest.mark.asyncio
-async def test_row_progress_uses_assigned_profile_from_result_provenance(
-    monkeypatch: pytest.MonkeyPatch,
-    mock_template,
-    mock_evaluator,
-    mock_evidence_matcher,
-):
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=1000,
-        target_selection=TargetSelection(
-            target_type=TargetType.CHECK_IDS,
-            raw_value="CHK-1",
-            check_ids=frozenset({"CHK-1"}),
-            row_indices=frozenset({0}),
-        ),
-        run_context={
-            "active_profile": "zai-openai",
-            "repo_primary_profile": "zai-openai",
-            "repo_profile_execution_mode": "distributed",
-            "repo_distribution_profiles": ["zai-openai", "alibaba-openai"],
-            "executed_profile": "zai-openai",
-        },
-    )
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-    mock_evaluator.evidence_bundle = None
-    monkeypatch.setattr(processor, "_build_row_assigned_evaluator", lambda assigned_profile: mock_evaluator)
-
-    async def create_result(*args, **kwargs):
-        return RowEvaluationResult(
-            row_id=kwargs.get("row_id", "CHK-1:row_0"),
-            check_id=kwargs.get("check").id,
-            status=RowStatus.PASS,
-            score=100.0,
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason="ok",
-            finding="ok",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                original_provider="alibaba-openai",
-                final_provider="alibaba-openai",
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-            retrieval_trace={"row_distribution_profile": "alibaba-openai"},
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = create_result
-
-    captured: list[tuple[str, dict[str, object]]] = []
-
-    def fake_info(event, **kwargs):
-        captured.append((event, kwargs))
-
-    monkeypatch.setattr(batch_processor_module.logger, "info", fake_info)
-
-    await processor.process_all(thread_id="test-row-progress-assigned-profile")
-
-    started_event = next(kwargs for event, kwargs in captured if event == "row_progress" and kwargs.get("row_outcome") == "started")
-    success_event = next(kwargs for event, kwargs in captured if event == "row_progress" and kwargs.get("row_outcome") == "success")
-    assert started_event["executed_profile"] == "zai-openai"
-    assert started_event["active_profile"] == "zai-openai"
-    assert success_event["origin_profile"] == "alibaba-openai"
-    assert success_event["row_distribution_profile"] == "alibaba-openai"
-
-
-@pytest.mark.asyncio
-async def test_timeout_handling(mock_template, mock_evaluator, mock_evidence_matcher):
-    """Test handling of row timeout (FR-3.2)."""
-    # Only 1 check for simplicity
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(batch_size=1, row_timeout_ms=100)
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    # Simulate timeout
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-
-    results = await processor.process_all(thread_id="test-thread")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.ERROR
-    assert "timeout" in results[0].error_message.lower()
-
-
-@pytest.mark.asyncio
-async def test_batch_timeout_fallback_preserves_progress_snapshot_and_prompt_summary(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Batch timeout fallback should retain progress snapshot + prompt telemetry summary."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(batch_size=1, row_timeout_ms=60_000, batch_timeout_ms=100)
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    async def _slow_eval(*args, **kwargs):
-        await asyncio.sleep(1.0)
-        return RowEvaluationResult(
-            row_id=str(kwargs.get("row_id") or "CHK-0:row_0"),
-            check_id=str(kwargs.get("check").id if kwargs.get("check") else "CHK-0"),
-            status=RowStatus.PASS,
-            score=85.0,
-            score_breakdown=ScoreBreakdown.compute(85.0),
-            reason="slow result",
-            finding="slow",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = _slow_eval
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": False,
-        "termination_reason": "timeout",
-        "steps_executed": 2,
-        "steps_unique_tools": 2,
-        "step_repetition_rate": 0.5,
-        "evidence_refs_count": 1,
-        "prompt_tool_telemetry": {
-            "event_tool_calls_completed": 2,
-            "event_skill_tool_calls": 1,
-            "event_skill_execution_tool_calls": 0,
-        },
-        "prompt_tool_telemetry_summary": {
-            "tool_calls": 2,
-            "skill_calls": 1,
-            "skill_execution_calls": 0,
-            "skill_effective_calls": 0,
-        },
-        "requirement_interpretation": {
-            "skills_needed": True,
-            "skills_needed_reason": "requirement_keyword:script",
-            "skill_objectives": ["analyze_tooling_automation_guidance"],
-        },
-        "skill_policy_preview": {
-            "source": "timeout_progress_snapshot",
-            "required": True,
-            "policy_mode": "advisory",
-            "strict_require_effective_skill": False,
-            "enforcement_enabled": False,
-            "skills_toolset_enabled": True,
-            "available_skill_count": 2,
-            "observed_skill_calls": 0,
-            "observed_skill_execution_calls": 0,
-            "observed_skill_effective_calls": 0,
-        },
-    }
-
-    results = await processor.process_all(thread_id="test-batch-timeout-fallback")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.ERROR
-    assert isinstance(results[0].retrieval_trace, dict)
-    assert results[0].retrieval_trace.get("batch_timeout_exceeded") is True
-    assert results[0].retrieval_trace.get("timeout_kind") == "timeout_absolute_cap"
-    assert results[0].retrieval_trace.get("timeout_terminal_status") == RowStatus.ERROR.value
-    assert results[0].retrieval_trace.get("prompt_tool_telemetry", {}).get("event_skill_tool_calls") == 1
-    assert results[0].retrieval_trace.get("prompt_tool_telemetry_summary", {}).get("tool_calls") == 2
-    assert (
-        results[0]
-        .retrieval_trace.get("timeout_progress_snapshot", {})
-        .get("prompt_tool_telemetry_summary", {})
-        .get("skill_calls")
-        == 1
-    )
-    assert results[0].retrieval_trace.get("requirement_interpretation", {}).get("skills_needed") is True
-    assert results[0].retrieval_trace.get("skill_policy_retry", {}).get("incomplete_due_to_timeout") is True
-    assert results[0].retrieval_trace.get("skill_policy_retry", {}).get("observed_skill_calls") == 1
-    assert results[0].retrieval_trace.get("skill_policy_retry", {}).get("observed_skill_execution_calls") == 0
-    assert results[0].retrieval_trace.get("skill_policy_retry", {}).get("observed_skill_effective_calls") == 0
-
-
-def test_effective_batch_timeout_includes_progress_extension_headroom(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Derived batch timeout should account for cumulative row retry timeout envelope."""
-    config = BatchConfig(
-        batch_size=5,
-        row_timeout_ms=45_000,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=1,
-        row_timeout_progress_extension_ms=30_000,
-        row_timeout_progress_max_ms=120_000,
-        batch_timeout_ms=None,
-        batch_overhead_ms=15_000,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    assert processor.effective_row_timeout_ceiling_ms() == 120_000
-    assert processor.effective_row_timeout_envelope_ms() == 345_000
-    assert processor.effective_batch_timeout_ms() == 1_740_000
-
-
-def test_effective_batch_timeout_uses_explicit_override(mock_template, mock_evaluator, mock_evidence_matcher):
-    """Explicit batch timeout should override derived timeout calculations."""
-    config = BatchConfig(
-        batch_size=5,
-        row_timeout_ms=45_000,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=3,
-        row_timeout_progress_extension_ms=30_000,
-        row_timeout_progress_max_ms=180_000,
-        batch_timeout_ms=240_000,
-        batch_overhead_ms=15_000,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    assert processor.effective_row_timeout_ceiling_ms() == 180_000
-    assert processor.effective_row_timeout_envelope_ms() == 705_000
-    assert processor.effective_batch_timeout_ms() == 240_000
-
-
-def test_adaptive_row_concurrency_increases_on_healthy_batch(mock_template, mock_evaluator, mock_evidence_matcher):
-    config = BatchConfig(
-        batch_size=2,
-        row_concurrency=2,
-        adaptive_row_concurrency=True,
-        adaptive_row_concurrency_min=1,
-        adaptive_row_concurrency_max=4,
-        adaptive_row_concurrency_increase_threshold_ms=1000,
-        adaptive_row_concurrency_decrease_threshold_ms=5000,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    assert processor._effective_row_concurrency() == 2
-    processor._update_adaptive_row_concurrency(
-        BatchResult(
-            batch_index=0,
-            start_row=0,
-            end_row=2,
-            results=[],
-            duration_ms=400,
-            success_count=2,
-            error_count=0,
-            skipped_count=0,
-            timed_out=False,
-        )
-    )
-    assert processor._effective_row_concurrency() == 3
-
-
-def test_adaptive_row_concurrency_decreases_on_batch_pressure(mock_template, mock_evaluator, mock_evidence_matcher):
-    config = BatchConfig(
-        batch_size=2,
-        row_concurrency=3,
-        adaptive_row_concurrency=True,
-        adaptive_row_concurrency_min=1,
-        adaptive_row_concurrency_max=4,
-        adaptive_row_concurrency_increase_threshold_ms=1000,
-        adaptive_row_concurrency_decrease_threshold_ms=5000,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    assert processor._effective_row_concurrency() == 3
-    processor._update_adaptive_row_concurrency(
-        BatchResult(
-            batch_index=0,
-            start_row=0,
-            end_row=2,
-            results=[],
-            duration_ms=6000,
-            success_count=1,
-            error_count=1,
-            skipped_count=0,
-            timed_out=False,
-        )
-    )
-    assert processor._effective_row_concurrency() == 2
-
-
-def test_adaptive_row_concurrency_respects_bounds(mock_template, mock_evaluator, mock_evidence_matcher):
-    config = BatchConfig(
-        batch_size=2,
-        row_concurrency=2,
-        adaptive_row_concurrency=True,
-        adaptive_row_concurrency_min=2,
-        adaptive_row_concurrency_max=3,
-        adaptive_row_concurrency_increase_threshold_ms=1000,
-        adaptive_row_concurrency_decrease_threshold_ms=5000,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    processor._update_adaptive_row_concurrency(
-        BatchResult(
-            batch_index=0,
-            start_row=0,
-            end_row=2,
-            results=[],
-            duration_ms=300,
-            success_count=2,
-            error_count=0,
-            skipped_count=0,
-            timed_out=False,
-        )
-    )
-    assert processor._effective_row_concurrency() == 3
-
-    processor._update_adaptive_row_concurrency(
-        BatchResult(
-            batch_index=1,
-            start_row=0,
-            end_row=2,
-            results=[],
-            duration_ms=200,
-            success_count=2,
-            error_count=0,
-            skipped_count=0,
-            timed_out=False,
-        )
-    )
-    assert processor._effective_row_concurrency() == 3
-
-    processor._update_adaptive_row_concurrency(
-        BatchResult(
-            batch_index=2,
-            start_row=0,
-            end_row=2,
-            results=[],
-            duration_ms=7000,
-            success_count=0,
-            error_count=1,
-            skipped_count=0,
-            timed_out=True,
-        )
-    )
-    assert processor._effective_row_concurrency() == 2
-
-
-def test_effective_batch_timeout_uses_absolute_cap_when_lease_mode_enabled(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Lease mode should budget rows against the configured absolute timeout cap."""
-    config = BatchConfig(
-        batch_size=3,
-        row_timeout_ms=45_000,
-        row_progress_lease_seconds=60,
-        row_stall_detection_seconds=30,
-        row_absolute_timeout_ms=600_000,
-        batch_timeout_ms=None,
-        batch_overhead_ms=15_000,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    assert processor.effective_row_timeout_ceiling_ms() == 600_000
-    assert processor.effective_row_timeout_envelope_ms() == 600_000
-    assert processor.effective_batch_timeout_ms() == 1_815_000
-
-
-@pytest.mark.asyncio
-async def test_timeout_retries_once_when_effective_timeout_progress_detected(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Row timeout should retry once with extended budget on timeout-based progress snapshot."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=1,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=300,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    call_count = 0
-
-    async def _side_effect(*args, **kwargs):
-        nonlocal call_count
-        call_count += 1
-        if call_count == 1:
-            raise TimeoutError("Simulated timeout")
-        row_id = kwargs.get("row_id", "CHK-0:row_0")
-        check = kwargs.get("check")
-        check_id = check.id if check else "CHK-0"
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id=check_id,
-            status=RowStatus.PASS,
-            score=85.0,
-            score_breakdown=ScoreBreakdown.compute(85.0),
-            reason="Recovered after timeout extension",
-            finding="Recovered",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = _side_effect
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "termination_reason": "timeout",
-        "steps_executed": 4,
-        "steps_unique_tools": 3,
-        "step_repetition_rate": 0.25,
-        "evidence_refs_count": 5,
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-retry")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.PASS
-    assert call_count == 2
-    assert mock_evaluator.get_row_runtime_progress.call_count == 1
-    assert mock_evaluator.clear_row_runtime_progress.call_count == 1
-
-
-@pytest.mark.asyncio
-async def test_timeout_does_not_retry_when_effective_progress_snapshot_is_completed(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Completed fallback-only progress must not degrade into a grounded FAIL."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=1,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=300,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "termination_reason": "completed",
-        "steps_executed": 4,
-        "steps_unique_tools": 3,
-        "step_repetition_rate": 0.25,
-        "evidence_refs_count": 5,
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-completed-no-retry")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.ERROR
-    assert mock_evaluator.aevaluate_row.call_count == 1
-    assert isinstance(results[0].retrieval_trace, dict)
-    assert results[0].retrieval_trace.get("timeout_extended") is False
-    assert results[0].retrieval_trace.get("timeout_extension_denial_reason") == "termination_reason_not_timeout"
-    assert results[0].retrieval_trace.get("timeout_degraded_finalize") is False
-    assert results[0].retrieval_trace.get("timeout_kind") == "timeout_no_progress"
-    assert results[0].retrieval_trace.get("timeout_terminal_status") == RowStatus.ERROR.value
-    assert mock_evaluator.get_row_runtime_progress.call_count == 1
-    assert mock_evaluator.clear_row_runtime_progress.call_count == 1
-
-
-@pytest.mark.asyncio
-async def test_timeout_completed_snapshot_can_still_degrade_when_verified_grounding_exists(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Completed snapshots may degrade only when recorded/verified grounding is present."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=1,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=300,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "termination_reason": "completed",
-        "steps_executed": 4,
-        "steps_unique_tools": 3,
-        "step_repetition_rate": 0.25,
-        "evidence_refs_count": 1,
-        "evidence_refs": ["src/main/security.py"],
-        "evidence_ref_verifications": [
-            {
-                "ref_value": "src/main/security.py",
-                "verified": True,
-                "excerpt": "def validate_token(token: str) -> bool:",
-                "verification_reason": VERIFICATION_REASON_EXCERPT_VERIFIED_IN_CONTEXT,
-            }
-        ],
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-completed-verified-grounding")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.FAIL
-    assert isinstance(results[0].retrieval_trace, dict)
-    assert results[0].retrieval_trace.get("timeout_degraded_finalize") is True
-    assert results[0].retrieval_trace.get("timeout_kind") == "timeout_with_grounding"
-    assert results[0].retrieval_trace.get("timeout_terminal_status") == RowStatus.FAIL.value
-
-
-@pytest.mark.asyncio
-async def test_timeout_app_config_snapshot_with_decisive_trace_recovers_to_pass(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """App-config timeout rows should recover to PASS when trace-backed pool evidence is already complete."""
-    mock_template.sections[0].checks = [
-        AuditCheck(
-            id="CL-006",
-            name="Connection pooling riêng biệt",
-            description=(
-                "Kiểm tra repo app-config theo đúng tên service và môi trường production. "
-                "Mở file application.properties hoặc application.yml của service để xác nhận datasource.url, "
-                "minimum-idle, maximum-pool-size, max-lifetime."
-            ),
-            section_id="1. Decoupling",
-        )
-    ]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=1,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=300,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "termination_reason": "completed",
-        "steps_executed": 4,
-        "steps_unique_tools": 3,
-        "step_repetition_rate": 0.25,
-        "evidence_refs_count": 2,
-        "evidence_refs": ["production/application.properties", "production/bootstrap.properties"],
-        "requirement_interpretation": {
-            "intent": "2. Sử dụng Connection Pooling riêng biệt và có giới hạn (Limit).",
-            "detailed_guidance": (
-                "Kiểm tra repo app-config theo đúng tên service và môi trường production. "
-                "Mở file application.properties hoặc application.yml của service để xác nhận datasource.url, "
-                "minimum-idle, maximum-pool-size, max-lifetime."
-            ),
-            "app_config_only": True,
-            "required_config_environments": ["production"],
-        },
-        "config_repo_companion_refs": [
-            {
-                "ref_value": "production/application.properties",
-                "ref": "production/application.properties",
-                "source_repo": "app-config",
-                "metadata": {
-                    "env": "production",
-                    "source_repo_slug": "app-config",
-                    "config_root": "app-config",
-                },
-            }
-        ],
-        "tool_first_loop": {
-            "trace_steps": [
-                {
-                    "step": 5,
-                    "tool": "read_code_file",
-                    "budget_cost": 1,
-                    "budget_remaining": 95,
-                    "output": {
-                        "path": "production/application.properties",
-                        "file_path": "production/application.properties",
-                        "content": (
-                            "spring.datasource.url=jdbc:postgresql://merchant-transaction\n"
-                            "spring.datasource.hikari.minimum-idle=10\n"
-                            "spring.datasource.hikari.maximum-pool-size=50\n"
-                            "spring.datasource.hikari.max-lifetime=1800000\n"
-                        ),
-                        "start_line": 1,
-                        "end_line": 220,
-                    },
-                },
-                {
-                    "step": 6,
-                    "tool": "record_evidence_refs",
-                    "budget_cost": 1,
-                    "budget_remaining": 94,
-                    "output": {
-                        "row_id": "CL-006:row_0",
-                        "refs": [
-                            {
-                                "ref_type": "code_path",
-                                "ref_value": "production/application.properties",
-                                "verified": True,
-                                "line_range": [1, 220],
-                            }
-                        ],
-                    },
-                },
-            ]
-        },
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-app-config-pass-recovery")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.PASS
-    assert results[0].score == 80.0
-    assert [anchor.ref_value for anchor in results[0].evidence_anchors] == ["production/application.properties"]
-    assert "minimum-idle" in results[0].evidence_anchors[0].excerpt
-    assert "maximum-pool-size" in results[0].evidence_anchors[0].excerpt
-    assert "max-lifetime" in results[0].evidence_anchors[0].excerpt
-    assert isinstance(results[0].retrieval_trace, dict)
-    assert results[0].retrieval_trace.get("timeout_kind") == "timeout_no_progress"
-    assert (
-        results[0].retrieval_trace.get("app_config_complete_pool_guard", {}).get("trigger")
-        == "timeout_trace_decisive_pool_anchor"
-    )
-
-
-@pytest.mark.asyncio
-async def test_timeout_does_not_retry_when_progress_not_effective(mock_template, mock_evaluator, mock_evidence_matcher):
-    """Row timeout should not extend when progress snapshot is not effective."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=1,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=300,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": False,
-        "termination_reason": "max_steps",
-        "steps_executed": 1,
-        "steps_unique_tools": 1,
-        "step_repetition_rate": 1.0,
-        "evidence_refs_count": 2,
-        "prompt_tool_telemetry_summary": {
-            "tool_calls": 3,
-            "skill_calls": 2,
-            "skill_execution_calls": 0,
-            "skill_effective_calls": 0,
-        },
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-no-retry")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.ERROR
-    assert mock_evaluator.aevaluate_row.call_count == 1
-    assert isinstance(results[0].retrieval_trace, dict)
-    assert results[0].retrieval_trace.get("timeout_extended") is False
-    assert results[0].retrieval_trace.get("timeout_degraded_finalize") is False
-    assert results[0].retrieval_trace.get("timeout_kind") == "timeout_no_progress"
-    assert results[0].retrieval_trace.get("timeout_terminal_status") == RowStatus.ERROR.value
-    assert results[0].retrieval_trace.get("timeout_progress_snapshot", {}).get("effective_progress") is False
-    assert results[0].retrieval_trace.get("prompt_tool_telemetry_summary", {}).get("tool_calls") == 3
-    assert results[0].retrieval_trace.get("mode") == "lexical"
-
-
-@pytest.mark.asyncio
-async def test_timeout_trace_reconciles_stale_prompt_telemetry_with_progress_snapshot(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Timeout trace should merge stale prompt telemetry with observed skill/tool progress."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=0,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=300,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "termination_reason": "completed",
-        "steps_executed": 5,
-        "steps_unique_tools": 4,
-        "step_repetition_rate": 0.1,
-        "evidence_refs_count": 3,
-        "prompt_tool_telemetry": {
-            "event_tool_calls_completed": 0,
-            "event_skill_tool_calls": 0,
-            "event_skill_execution_tool_calls": 0,
-            "event_skill_effective_tool_calls": 0,
-            "event_skill_execution_effective_tool_calls": 0,
-        },
-        "prompt_tool_telemetry_summary": {
-            "tool_calls": 0,
-            "skill_calls": 0,
-            "skill_execution_calls": 0,
-            "skill_effective_calls": 0,
-        },
-        "skill_policy_preview": {
-            "source": "timeout_progress_snapshot",
-            "required": True,
-            "policy_mode": "advisory",
-            "strict_require_effective_skill": False,
-            "enforcement_enabled": False,
-            "skills_toolset_enabled": True,
-            "available_skill_count": 2,
-            "observed_skill_calls": 2,
-            "observed_skill_execution_calls": 1,
-            "observed_skill_effective_calls": 1,
-        },
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-reconcile-progress")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.FAIL
-    assert mock_evaluator.aevaluate_row.call_count == 1
-    assert isinstance(results[0].retrieval_trace, dict)
-    assert results[0].retrieval_trace.get("prompt_tool_telemetry_summary", {}).get("tool_calls") == 5
-    assert results[0].retrieval_trace.get("prompt_tool_telemetry_summary", {}).get("skill_calls") == 2
-    assert results[0].retrieval_trace.get("prompt_tool_telemetry", {}).get("event_tool_calls_completed") == 5
-    assert results[0].retrieval_trace.get("prompt_tool_telemetry", {}).get("event_skill_tool_calls") == 2
-    assert results[0].retrieval_trace.get("prompt_tool_telemetry", {}).get("event_skill_execution_tool_calls") == 1
-    assert results[0].retrieval_trace.get("prompt_tool_telemetry", {}).get("event_skill_effective_tool_calls") == 1
-    assert (
-        results[0].retrieval_trace.get("prompt_tool_telemetry", {}).get("event_skill_execution_effective_tool_calls")
-        == 1
-    )
-    assert results[0].retrieval_trace.get("skill_policy_retry", {}).get("observed_skill_calls") == 2
-    assert results[0].retrieval_trace.get("skill_policy_retry", {}).get("observed_skill_execution_calls") == 1
-    assert results[0].retrieval_trace.get("skill_policy_retry", {}).get("observed_skill_effective_calls") == 1
-
-
-@pytest.mark.asyncio
-async def test_timeout_retry_exhausted_with_effective_progress_degrades_to_fail(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Timeout retry exhaustion should degrade to FAIL when progress is effective and grounded."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=1,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=300,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "termination_reason": "timeout",
-        "steps_executed": 4,
-        "steps_unique_tools": 3,
-        "step_repetition_rate": 0.25,
-        "evidence_refs_count": 2,
-        "evidence_refs": ["confluence://doc-a", "src/vds_hooks/core/framework.py"],
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-degraded-finalize")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.FAIL
-    assert results[0].status != RowStatus.ERROR
-    assert mock_evaluator.aevaluate_row.call_count == 3
-    assert isinstance(results[0].retrieval_trace, dict)
-    assert results[0].retrieval_trace.get("timeout_retry_attempts") == 2
-    assert results[0].retrieval_trace.get("timeout_extended") is True
-    assert results[0].retrieval_trace.get("timeout_extension_denial_reason") == "max_timeout_reached"
-    assert results[0].retrieval_trace.get("timeout_degraded_finalize") is True
-    assert results[0].retrieval_trace.get("timeout_kind") == "timeout_with_grounding"
-    assert results[0].retrieval_trace.get("timeout_terminal_status") == RowStatus.FAIL.value
-    assert results[0].retrieval_trace.get("timeout_progress_snapshot", {}).get("evidence_refs_count") == 2
-    assert [anchor.ref_value for anchor in results[0].evidence_anchors] == [
-        "confluence://doc-a",
-        "src/vds_hooks/core/framework.py",
-    ]
-    assert [anchor.verified for anchor in results[0].evidence_anchors] == [False, False]
-    assert [anchor.verification_reason for anchor in results[0].evidence_anchors] == [
-        "fallback_ref_inherited",
-        "fallback_ref_inherited",
-    ]
-    assert results[0].retrieval_trace.get("mode") == "lexical"
-
-
-@pytest.mark.asyncio
-async def test_timeout_degraded_finalize_preserves_phase124_route_and_artifact_diagnostics(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=0,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=300,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "termination_reason": "timeout",
-        "steps_executed": 4,
-        "steps_unique_tools": 3,
-        "step_repetition_rate": 0.25,
-        "evidence_refs_count": 2,
-        "evidence_refs": ["pom.xml", "src/main/java/com/example/config/AppConfig.java"],
-        "route_id": "code_search_read_verify_synthesize",
-        "route_mode": "code_only",
-        "route_reason": "project_scope_required=true",
-        "requirement_interpretation": {
-            "project_scope_required": True,
-            "control_objective": "1. Decoupling",
-        },
-        "project_artifact_readiness": {
-            "readiness_status": "partial",
-            "authoritative_artifact_ready": False,
-            "missing_artifact_types": ["dependency_graph"],
-        },
-        "project_artifact_provenance_summary": [
-            {
-                "artifact_type": "dependency_graph",
-                "source": "knowledge_store",
-            }
-        ],
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-phase124-diagnostics")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.FAIL
-    assert isinstance(results[0].retrieval_trace, dict)
-    assert results[0].retrieval_trace.get("route_mode") == "code_only"
-    assert results[0].retrieval_trace.get("route_id") == "code_search_read_verify_synthesize"
-    assert results[0].retrieval_trace.get("project_artifact_readiness", {}).get("readiness_status") == "partial"
-    assert results[0].retrieval_trace.get("project_artifact_provenance_summary") == [
-        {"artifact_type": "dependency_graph", "source": "knowledge_store"}
-    ]
-    assert results[0].retrieval_trace.get("grounding_validation", {}).get("timeout_incomplete") is True
-    assert results[0].retrieval_trace.get("evidence_gap_diagnostics", {}).get("classification") == "confirmed_gap"
-    assert (
-        results[0].retrieval_trace.get("evidence_gap_diagnostics", {}).get("gap_type")
-        == "authoritative_project_scope_artifact_missing"
-    )
-
-
-@pytest.mark.asyncio
-async def test_timeout_degraded_finalize_promotes_verified_excerpt_only(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Fallback refs remain provisional unless explicit excerpt verification is present."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=0,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=300,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "termination_reason": "timeout",
-        "evidence_refs_count": 2,
-        "evidence_refs": ["confluence://doc-a", "src/main/security.py"],
-        "evidence_ref_verifications": [
-            {
-                "ref_value": "src/main/security.py",
-                "verified": True,
-                "excerpt": "def validate_token(token: str) -> bool:",
-                "verification_reason": VERIFICATION_REASON_EXCERPT_VERIFIED_IN_CONTEXT,
-            }
-        ],
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-fallback-verification-promote")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.FAIL
-    anchors_by_ref = {anchor.ref_value: anchor for anchor in results[0].evidence_anchors}
-    assert anchors_by_ref["confluence://doc-a"].verified is False
-    assert anchors_by_ref["confluence://doc-a"].verification_reason == VERIFICATION_REASON_FALLBACK_REF_INHERITED
-    assert anchors_by_ref["src/main/security.py"].verified is True
-    assert anchors_by_ref["src/main/security.py"].excerpt == "def validate_token(token: str) -> bool:"
-    assert anchors_by_ref["src/main/security.py"].verification_reason == VERIFICATION_REASON_EXCERPT_VERIFIED_IN_CONTEXT
-
-
-@pytest.mark.asyncio
-async def test_timeout_degraded_finalize_rejects_verified_anchor_without_excerpt(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Verified fallback refs with empty excerpts must downgrade to provisional anchors."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=0,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=300,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "termination_reason": "timeout",
-        "evidence_refs_count": 1,
-        "evidence_refs": ["src/main/security.py"],
-        "evidence_ref_verifications": [
-            {
-                "ref_value": "src/main/security.py",
-                "verified": True,
-                "excerpt": "",
-                "verification_reason": VERIFICATION_REASON_EXCERPT_VERIFIED_IN_CONTEXT,
-            }
-        ],
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-fallback-verification-empty-excerpt")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.FAIL
-    assert len(results[0].evidence_anchors) == 1
-    anchor = results[0].evidence_anchors[0]
-    assert anchor.ref_value == "src/main/security.py"
-    assert anchor.verified is False
-    assert anchor.excerpt == ""
-    assert anchor.verification_reason == VERIFICATION_REASON_FALLBACK_REF_INHERITED
-
-
-@pytest.mark.asyncio
-async def test_second_extension_denied_without_progress_delta(mock_template, mock_evaluator, mock_evidence_matcher):
-    """Repeat extension must be denied when telemetry counters do not progress."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=2,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=400,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "step_repetition_rate": 0.1,
-        "evidence_refs_count": 3,
-        "prompt_tool_telemetry_summary": {
-            "tool_calls": 1,
-            "skill_calls": 1,
-            "skill_execution_calls": 0,
-            "skill_effective_calls": 0,
-        },
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-no-delta")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.FAIL
-    assert mock_evaluator.aevaluate_row.call_count == 2
-    assert isinstance(results[0].retrieval_trace, dict)
-    assert results[0].retrieval_trace.get("timeout_retry_attempts") == 1
-    assert results[0].retrieval_trace.get("timeout_extended") is True
-    assert results[0].retrieval_trace.get("timeout_extension_denial_reason") == "no_delta_since_last_timeout"
-    assert results[0].retrieval_trace.get("timeout_extension_progress_delta", {}).get("tool_calls") == 0
-
-
-@pytest.mark.asyncio
-async def test_second_extension_allowed_with_progress_delta(mock_template, mock_evaluator, mock_evidence_matcher):
-    """Repeat extension should proceed when telemetry counters advance between timeouts."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=2,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=500,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    call_count = 0
-
-    async def _side_effect(*args, **kwargs):
-        nonlocal call_count
-        call_count += 1
-        if call_count <= 2:
-            raise TimeoutError("Simulated timeout")
-        row_id = kwargs.get("row_id", "CHK-0:row_0")
-        check = kwargs.get("check")
-        check_id = check.id if check else "CHK-0"
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id=check_id,
-            status=RowStatus.PASS,
-            score=90.0,
-            score_breakdown=ScoreBreakdown.compute(90.0),
-            reason="Recovered after second extension",
-            finding="Recovered",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = _side_effect
-    mock_evaluator.get_row_runtime_progress.side_effect = [
-        {
-            "effective_progress": True,
-            "step_repetition_rate": 0.1,
-            "evidence_refs_count": 2,
-            "prompt_tool_telemetry_summary": {
-                "tool_calls": 1,
-                "skill_calls": 1,
-                "skill_execution_calls": 0,
-                "skill_effective_calls": 0,
-            },
-        },
-        {
-            "effective_progress": True,
-            "step_repetition_rate": 0.1,
-            "evidence_refs_count": 2,
-            "prompt_tool_telemetry_summary": {
-                "tool_calls": 2,
-                "skill_calls": 1,
-                "skill_execution_calls": 0,
-                "skill_effective_calls": 0,
-            },
-        },
-    ]
-
-    results = await processor.process_all(thread_id="test-timeout-with-delta")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.PASS
-    assert call_count == 3
-    assert mock_evaluator.get_row_runtime_progress.call_count == 2
-
-
-@pytest.mark.asyncio
-async def test_repeat_extension_continues_with_stationary_strong_progress_until_timeout_cap(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Strong grounded progress should continue extensions until timeout ceiling."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=2,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=500,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "steps_executed": 5,
-        "steps_unique_tools": 5,
-        "step_repetition_rate": 0.0,
-        "evidence_refs_count": 3,
-        "prompt_tool_telemetry_summary": {
-            "tool_calls": 5,
-            "skill_calls": 1,
-            "skill_execution_calls": 1,
-            "skill_effective_calls": 1,
-        },
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-no-delta-strong-progress")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.FAIL
-    assert mock_evaluator.aevaluate_row.call_count == 5
-    assert isinstance(results[0].retrieval_trace, dict)
-    assert results[0].retrieval_trace.get("timeout_retry_attempts") == 4
-    assert results[0].retrieval_trace.get("timeout_extended") is True
-    assert results[0].retrieval_trace.get("timeout_extension_denial_reason") == "max_timeout_reached"
-
-
-@pytest.mark.asyncio
-async def test_extension_can_continue_beyond_retry_cap_when_progress_continues(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Progressive telemetry should allow extension past retry cap until max timeout."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=1,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=500,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    call_count = 0
-
-    async def _side_effect(*args, **kwargs):
-        nonlocal call_count
-        call_count += 1
-        if call_count <= 2:
-            raise TimeoutError("Simulated timeout")
-        row_id = kwargs.get("row_id", "CHK-0:row_0")
-        check = kwargs.get("check")
-        check_id = check.id if check else "CHK-0"
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id=check_id,
-            status=RowStatus.PASS,
-            score=88.0,
-            score_breakdown=ScoreBreakdown.compute(88.0),
-            reason="Recovered after beyond-cap extension",
-            finding="Recovered",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = _side_effect
-    mock_evaluator.get_row_runtime_progress.side_effect = [
-        {
-            "effective_progress": True,
-            "step_repetition_rate": 0.1,
-            "evidence_refs_count": 2,
-            "prompt_tool_telemetry_summary": {
-                "tool_calls": 1,
-                "skill_calls": 0,
-                "skill_execution_calls": 0,
-                "skill_effective_calls": 0,
-            },
-        },
-        {
-            "effective_progress": True,
-            "step_repetition_rate": 0.1,
-            "evidence_refs_count": 2,
-            "prompt_tool_telemetry_summary": {
-                "tool_calls": 2,
-                "skill_calls": 0,
-                "skill_execution_calls": 0,
-                "skill_effective_calls": 0,
-            },
-        },
-    ]
-
-    results = await processor.process_all(thread_id="test-timeout-beyond-cap")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.PASS
-    assert call_count == 3
-    assert mock_evaluator.get_row_runtime_progress.call_count == 2
-
-
-@pytest.mark.asyncio
-async def test_repeat_extension_denied_when_prompt_summary_missing(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Second extension should be denied when prompt telemetry summary is unavailable."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=2,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=400,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "step_repetition_rate": 0.1,
-        "evidence_refs_count": 3,
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-missing-summary")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.FAIL
-    assert mock_evaluator.aevaluate_row.call_count == 2
-    assert isinstance(results[0].retrieval_trace, dict)
-    assert results[0].retrieval_trace.get("timeout_extension_denial_reason") == (
-        "missing_prompt_telemetry_for_repeat_extension"
-    )
-
-
-@pytest.mark.asyncio
-async def test_repeat_extension_allowed_with_strong_progress_without_prompt_summary_when_tool_loop_timed_out(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Second extension should proceed when strong grounded progress comes from tool-loop timeout."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=2,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=500,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    call_count = 0
-
-    async def _side_effect(*args, **kwargs):
-        nonlocal call_count
-        call_count += 1
-        if call_count <= 2:
-            raise TimeoutError("Simulated timeout")
-        row_id = kwargs.get("row_id", "CHK-0:row_0")
-        check = kwargs.get("check")
-        check_id = check.id if check else "CHK-0"
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id=check_id,
-            status=RowStatus.PASS,
-            score=91.0,
-            score_breakdown=ScoreBreakdown.compute(91.0),
-            reason="Recovered after strong-repeat extension",
-            finding="Recovered",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = _side_effect
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "termination_reason": "timeout",
-        "steps_executed": 4,
-        "steps_unique_tools": 3,
-        "step_repetition_rate": 0.0,
-        "evidence_refs_count": 2,
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-strong-repeat")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.PASS
-    assert call_count == 3
-    assert mock_evaluator.get_row_runtime_progress.call_count == 2
-
-
-@pytest.mark.asyncio
-async def test_extension_denied_with_completed_tool_loop_snapshot_even_with_retry_budget(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Timeout extension should be denied immediately for completed tool-loop snapshots."""
-    mock_template.sections[0].checks = [mock_template.sections[0].checks[0]]
-
-    config = BatchConfig(
-        batch_size=1,
-        row_timeout_ms=100,
-        row_timeout_progress_extension_enabled=True,
-        row_timeout_progress_retry_attempts=2,
-        row_timeout_progress_extension_ms=100,
-        row_timeout_progress_max_ms=500,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    mock_evaluator.aevaluate_row.side_effect = TimeoutError("Simulated timeout")
-    mock_evaluator.get_row_runtime_progress.return_value = {
-        "effective_progress": True,
-        "termination_reason": "completed",
-        "steps_executed": 4,
-        "steps_unique_tools": 3,
-        "step_repetition_rate": 0.0,
-        "evidence_refs_count": 2,
-    }
-
-    results = await processor.process_all(thread_id="test-timeout-completed-snapshot")
-
-    assert len(results) == 1
-    assert results[0].status == RowStatus.FAIL
-    assert mock_evaluator.aevaluate_row.call_count == 1
-    assert isinstance(results[0].retrieval_trace, dict)
-    assert results[0].retrieval_trace.get("timeout_extension_denial_reason") == ("termination_reason_not_timeout")
-
-
-@pytest.mark.asyncio
-async def test_batch_timeout_fallback_handles_remaining_targeted_rows_after_checkpoint_preserve(
-    mock_template, mock_evaluator, mock_evidence_matcher
-):
-    """Batch-timeout fallback must include all remaining targeted rows after skipped checkpoint rows."""
-    mock_template.sections[0].checks = mock_template.sections[0].checks[:5]
-
-    target_selection = TargetSelection(
-        target_type=TargetType.ROW_IDS,
-        raw_value="3-5",
-        row_indices=frozenset({2, 3, 4}),
-    )
-    config = BatchConfig(
-        batch_size=5,
-        row_timeout_ms=60_000,
-        batch_timeout_ms=100,
-        target_selection=target_selection,
-        force_refresh_targets=True,
-    )
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    async def _slow_eval(*args, **kwargs):
-        await asyncio.sleep(1.0)
-        row_id = kwargs.get("row_id", "CHK-2:row_2")
-        check = kwargs.get("check")
-        check_id = check.id if check else "CHK-2"
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id=check_id,
-            status=RowStatus.PASS,
-            score=100.0,
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason="slow",
-            finding="slow",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = _slow_eval
-
-    preserved_results: dict[str, dict[str, Any]] = {}
-    for idx in (0, 1):
-        row_id = f"CHK-{idx}:row_{idx}"
-        preserved_results[row_id] = BatchCheckpoint.serialize_row_result(
-            RowEvaluationResult(
-                row_id=row_id,
-                check_id=f"CHK-{idx}",
-                status=RowStatus.PASS,
-                score=100.0,
-                score_breakdown=ScoreBreakdown.compute(100.0),
-                reason="checkpoint preserved",
-                finding="checkpoint preserved",
-                evidence_anchors=[],
-                provenance=RowProvenance(
-                    row_llm_mode="test",
-                    protocol=None,
-                    model=None,
-                    template_hash="hash",
-                    rubric_version="1",
-                    evidence_hash="hash",
-                    evaluated_at=datetime.now(UTC),
-                ),
-            )
-        )
-
-    checkpoint = BatchCheckpoint(
-        thread_id="batch-timeout-preserve",
-        total_rows=5,
-        template_hash=mock_evaluator.template_hash,
-        evidence_hash=mock_evaluator.evidence_hash,
-        completed_batches=[],
-        results_by_row_id=preserved_results,
-    )
-
-    batch_result = await processor._process_batch(
-        batch_idx=0,
-        start_idx=0,
-        end_idx=5,
-        project_profile=None,
-        checkpoint=checkpoint,
-        thread_id=checkpoint.thread_id,
-    )
-
-    assert batch_result.timed_out is True
-    assert batch_result.skipped_count == 2
-    assert batch_result.error_count == 3
-    assert len(batch_result.results) == 5
-    row_ids = {result.row_id for result in batch_result.results}
-    assert row_ids == {
-        "CHK-0:row_0",
-        "CHK-1:row_1",
-        "CHK-2:row_2",
-        "CHK-3:row_3",
-        "CHK-4:row_4",
-    }
-    timeout_rows = [
-        result for result in batch_result.results if result.row_id in {"CHK-2:row_2", "CHK-3:row_3", "CHK-4:row_4"}
-    ]
-    assert all(result.status == RowStatus.ERROR for result in timeout_rows)
-
-
-@pytest.mark.asyncio
-async def test_checkpoint_save_and_resume(mock_template, mock_evaluator, mock_evidence_matcher, tmp_path):
-    """Test that checkpoints are saved and can be resumed (FR-3.3)."""
-    checkpoint_dir = tmp_path / "checkpoints"
-    config = BatchConfig(batch_size=2, checkpoint_dir=checkpoint_dir, resume_from_checkpoint=True)
-
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    # 1. Simulate failure after first batch (rows 0,1 succeeded)
-    call_count = 0
-
-    async def side_effect(*args, **kwargs):
-        nonlocal call_count
-        call_count += 1
-        if call_count > 2:
-            raise RuntimeError("Simulated Crash")
-        # Create a NEW result object for each call with unique row_id
-        row_id = kwargs.get("row_id", f"unknown_{call_count}")
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id="test_check",
-            status=RowStatus.PASS,
-            score=100.0,
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason="Test reason",
-            finding="Test finding",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = side_effect
-
-    # _guarded_row catches exceptions and returns error results instead of propagating
-    results = await processor.process_all(thread_id="test-thread")
-
-    # Checkpoint should exist (saved after first batch completed before crash)
-    checkpoint_file = processor._get_checkpoint_path("test-thread")
-    assert checkpoint_file.exists()
-
-    # Verify checkpoint content - processor continues all batches even with errors
-    # Result: 2 PASS (rows 0,1 from first batch) + 8 ERROR (crashed rows)
-    data = json.loads(checkpoint_file.read_text())
-    assert 0 in data["completed_batches"]
-    # All 10 rows are in checkpoint (processor doesn't stop on non-BudgetExceededError)
-    assert len(data["results_by_row_id"]) == 10
-    # Verify first batch rows are PASS
-    pass_count = sum(1 for r in data["results_by_row_id"].values() if r["status"] == "PASS")
-    assert pass_count == 2, f"Expected 2 PASS results, got {pass_count}"
-
-    # 2. Resume operation
-    mock_evaluator.aevaluate_row.side_effect = None
-    # Create unique results for resumed calls
-    resume_call_count = 0
-
-    async def create_resume_result(*args, **kwargs):
-        nonlocal resume_call_count
-        resume_call_count += 1
-        row_id = kwargs.get("row_id", f"resumed_row_{resume_call_count}")
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id="test_check",
-            status=RowStatus.PASS,
-            score=100.0,
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason="Test reason",
-            finding="Test finding",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = create_resume_result
-    mock_evaluator.aevaluate_row.reset_mock()
-
-    # Re-init processor
-    processor2 = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    results = await processor2.process_all(thread_id="test-thread")
-
-    # All 10 rows are in checkpoint from first run, so resume skips all
-    # Only checkpoint lookup happens, no new evaluations
-    assert len(results) == 10
-    assert mock_evaluator.aevaluate_row.call_count == 0
-
-
-@pytest.mark.asyncio
-async def test_checkpoint_hash_mismatch(mock_template, mock_evaluator, mock_evidence_matcher, default_result, tmp_path):
-    """Test that checkpoint is ignored if hashes mismatch."""
-    checkpoint_dir = tmp_path / "checkpoints"
-    config = BatchConfig(batch_size=2, checkpoint_dir=checkpoint_dir, resume_from_checkpoint=True)
-
-    # Create a fake checkpoint with different hash
-    checkpoint_file = checkpoint_dir / "batch-checkpoint-test-thread.json"
-    checkpoint_file.parent.mkdir(parents=True, exist_ok=True)
-
-    fake_checkpoint = {
-        "thread_id": "test-thread",
-        "total_rows": 10,
-        "template_hash": "OLD_HASH",  # Mismatch
-        "evidence_hash": "ev_hash_456",
-        "completed_batches": [0],
-        "results_by_row_id": {},
-        "last_updated": "2024-01-01T00:00:00+00:00",
-    }
-    checkpoint_file.write_text(json.dumps(fake_checkpoint))
-
-    processor = BatchRowProcessor(
-        template=mock_template, evaluator=mock_evaluator, evidence_matcher=mock_evidence_matcher, config=config
-    )
-
-    # Create unique results for each row to avoid deduplication
-    call_count = 0
-
-    async def create_unique_result(*args, **kwargs):
-        nonlocal call_count
-        call_count += 1
-        row_id = kwargs.get("row_id", f"row_{call_count}")
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id="test_check",
-            status=RowStatus.PASS,
-            score=100.0,
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason="Test reason",
-            finding="Test finding",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = create_unique_result
-
-    # Should ignore checkpoint and process all 10 rows
-    results = await processor.process_all(thread_id="test-thread")
-
-    assert len(results) == 10
-    assert mock_evaluator.aevaluate_row.call_count == 10
-
-
-def test_checkpoint_serialization(default_result):
-    """Test serialization and deserialization of row results."""
-    default_result.evidence_anchors = [EvidenceAnchor(ref_type="url", ref_value="http://example.com", verified=True)]
-    default_result.retrieval_trace = {"mode": "hybrid", "docs": [{"source_path": "README.md"}]}
-
-    serialized = BatchCheckpoint.serialize_row_result(default_result)
-    assert serialized["row_id"] == default_result.row_id
-    assert serialized["evidence_anchors"][0]["ref_value"] == "http://example.com"
-    assert serialized["retrieval_trace"]["mode"] == "hybrid"
-
-    deserialized = BatchCheckpoint.deserialize_row_result(serialized)
-    assert deserialized.row_id == default_result.row_id
-    assert deserialized.score == default_result.score
-    assert len(deserialized.evidence_anchors) == 1
-    assert deserialized.evidence_anchors[0].ref_value == "http://example.com"
-    assert deserialized.retrieval_trace == default_result.retrieval_trace
-
-
-@pytest.mark.asyncio
-async def test_row_retrieval_trace_persisted_to_checkpoint(
-    mock_template, mock_evaluator, mock_evidence_matcher, default_result, tmp_path
-):
-    """Row retrieval trace should round-trip through checkpoint persistence."""
-    checkpoint_dir = tmp_path / "checkpoints"
-    config = BatchConfig(batch_size=2, checkpoint_dir=checkpoint_dir, resume_from_checkpoint=False)
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    async def create_result(*args, **kwargs):
-        row_id = kwargs.get("row_id", "missing")
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id="test_check",
-            status=default_result.status,
-            score=default_result.score,
-            score_breakdown=default_result.score_breakdown,
-            reason=default_result.reason,
-            finding=default_result.finding,
-            evidence_anchors=default_result.evidence_anchors,
-            provenance=default_result.provenance,
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = create_result
-
-    results = await processor.process_all(thread_id="trace-checkpoint")
-
-    assert results[0].retrieval_trace == mock_evidence_matcher.match_row.return_value.retrieval_trace
-    checkpoint_data = json.loads(processor._get_checkpoint_path("trace-checkpoint").read_text())
-    first_row = checkpoint_data["results_by_row_id"]["CHK-0:row_0"]
-    assert first_row["retrieval_trace"] == mock_evidence_matcher.match_row.return_value.retrieval_trace
-
-
-@pytest.mark.asyncio
-async def test_strict_budget_abort_persists_partial_results(
-    mock_template, mock_evaluator, mock_evidence_matcher, tmp_path
-):
-    """Strict budget abort should persist completed rows before failing."""
-    checkpoint_dir = tmp_path / "checkpoints"
-    config = BatchConfig(batch_size=5, checkpoint_dir=checkpoint_dir, resume_from_checkpoint=False)
-    processor = BatchRowProcessor(
-        template=mock_template,
-        evaluator=mock_evaluator,
-        evidence_matcher=mock_evidence_matcher,
-        config=config,
-    )
-
-    call_count = 0
-
-    async def _side_effect(*args, **kwargs):
-        nonlocal call_count
-        call_count += 1
-        row_id = kwargs.get("row_id", f"row_{call_count}")
-        check = kwargs.get("check")
-        check_id = check.id if check is not None else "unknown"
-        if call_count == 3:
-            raise BudgetExceededError(
-                BudgetUsage(
-                    scope=BudgetScope.AUDIT,
-                    scope_id=row_id,
-                    used_dollars=9.0,
-                    limit_dollars=8.0,
-                    status=BudgetStatus.EXCEEDED,
-                )
-            )
-        return RowEvaluationResult(
-            row_id=row_id,
-            check_id=check_id,
-            status=RowStatus.PASS,
-            score=100.0,
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason=f"Result for {row_id}",
-            finding="ok",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash",
-                rubric_version="1",
-                evidence_hash="hash",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-
-    mock_evaluator.aevaluate_row.side_effect = _side_effect
-
-    with pytest.raises(BatchBudgetExceededError) as exc_info:
-        await processor.process_all(thread_id="strict-budget-thread")
-
-    exc = exc_info.value
-    assert exc.context["kind"] == "strict_budget_exceeded"
-    assert exc.context["audit_error_key"] == "LLM_BUDGET_EXCEEDED"
-    assert exc.context["audit_error_code"] == AUDIT_ERROR_CODES["LLM_BUDGET_EXCEEDED"].code
-    assert exc.context["row_index"] == 3
-    assert exc.context["check_id"] == "CHK-2"
-    assert exc.context["status"] == "exceeded"
-    assert exc.context["completed_rows_persisted"] >= 2
-    assert "checkpoint_path" in exc.context
-    assert len(exc.partial_results) >= 2
-    assert any(result.row_id == "CHK-0:row_0" for result in exc.partial_results)
-    assert any(result.row_id == "CHK-1:row_1" for result in exc.partial_results)
-
-    checkpoint_file = processor._get_checkpoint_path("strict-budget-thread")
-    assert checkpoint_file.exists()
-    data = json.loads(checkpoint_file.read_text())
-    assert len(data["results_by_row_id"]) >= 2
-    assert "CHK-0:row_0" in data["results_by_row_id"]
-    assert "CHK-1:row_1" in data["results_by_row_id"]
-
-
-# -----------------------------------------------------------------------------
-# Tests: Target Filtering (FR-25)
-# -----------------------------------------------------------------------------
-# Tests
-# -----------------------------------------------------------------------------
-
-
-@pytest.fixture
-def target_selection_rows_1_3():
-    """Create a TargetSelection for rows 1 and 3 (0-indexed: 0 and 2)."""
-    return TargetSelection(
-        target_type=TargetType.ROW_IDS,
-        raw_value="1,3",
-        row_indices=frozenset({0, 2}),
-    )
-
-
-@pytest.fixture
-def target_selection_check_ids():
-    """Create a TargetSelection for specific check IDs."""
-    return TargetSelection(
-        target_type=TargetType.CHECK_IDS,
-        raw_value="CHK-0,CHK-5",
-        row_indices=frozenset({0, 5}),
-        check_ids=frozenset({"CHK-0", "CHK-5"}),
-    )
-
-
-class TestTargetFiltering:
-    """Tests for FR-25: Dynamic Analysis Support - Target Filtering."""
-
-    @pytest.mark.asyncio
-    async def test_targeted_rows_only_processed(
-        self, mock_template, mock_evaluator, mock_evidence_matcher, default_result, target_selection_rows_1_3
-    ):
-        """Test that only targeted rows are processed (FR-25.1)."""
-        config = BatchConfig(
-            batch_size=5,
-            row_timeout_ms=1000,
-            target_selection=target_selection_rows_1_3,
-            force_refresh_targets=True,
-        )
-        processor = BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config,
-        )
-
-        mock_evaluator.aevaluate_row.return_value = default_result
-
-        await processor.process_all(thread_id="test-targeted")
-
-        # Only rows 0 and 2 should be evaluated (targeted)
-        assert mock_evaluator.aevaluate_row.call_count == 2
-
-    @pytest.mark.asyncio
-    async def test_skip_batch_with_no_targets(
-        self, mock_template, mock_evaluator, mock_evidence_matcher, default_result
-    ):
-        """Test that batches with no targeted rows are skipped (FR-25.2)."""
-        # Target only row 8 (0-indexed: 7), which is in batch 2 (rows 4-7) or batch 3 (rows 8-9)
-        # With batch_size=4: batch 0 (0-3), batch 1 (4-7), batch 2 (8-9)
-        target_selection = TargetSelection(
-            target_type=TargetType.ROW_IDS,
-            raw_value="9",
-            row_indices=frozenset({8}),  # 0-indexed
-        )
-        config = BatchConfig(
-            batch_size=4,
-            row_timeout_ms=1000,
-            target_selection=target_selection,
-            force_refresh_targets=True,
-        )
-        processor = BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config,
-        )
-
-        mock_evaluator.aevaluate_row.return_value = default_result
-
-        await processor.process_all(thread_id="test-skip-batch")
-
-        # Only 1 row should be evaluated (row 8)
-        assert mock_evaluator.aevaluate_row.call_count == 1
-
-    @pytest.mark.asyncio
-    async def test_mixed_batch_preserves_checkpoint(
-        self, mock_template, mock_evaluator, mock_evidence_matcher, default_result, tmp_path
-    ):
-        """Test that non-targeted rows preserve checkpoint state in mixed batches (FR-25.3)."""
-        checkpoint_dir = tmp_path / "checkpoints"
-
-        # First run: process all rows
-        config_full = BatchConfig(
-            batch_size=5,
-            row_timeout_ms=1000,
-            checkpoint_dir=checkpoint_dir,
-            resume_from_checkpoint=False,
-        )
-        processor_full = BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config_full,
-        )
-
-        # Create unique results for each row
-        call_count = 0
-
-        async def create_unique_result(*args, **kwargs):
-            nonlocal call_count
-            call_count += 1
-            row_id = kwargs.get("row_id", f"row_{call_count}")
-            return RowEvaluationResult(
-                row_id=row_id,
-                check_id="test_check",
-                status=RowStatus.PASS,
-                score=100.0,
-                score_breakdown=ScoreBreakdown.compute(100.0),
-                reason=f"Result for {row_id}",
-                finding="Test finding",
-                evidence_anchors=[],
-                provenance=RowProvenance(
-                    row_llm_mode="test",
-                    protocol=None,
-                    model=None,
-                    template_hash="hash",
-                    rubric_version="1",
-                    evidence_hash="hash",
-                    evaluated_at=datetime.now(UTC),
-                ),
-            )
-
-        mock_evaluator.aevaluate_row.side_effect = create_unique_result
-
-        # Run full processing
-        await processor_full.process_all(thread_id="test-mixed")
-        assert call_count == 10  # All 10 rows processed
-
-        # Second run: target only row 3 (0-indexed: 2)
-        target_selection = TargetSelection(
-            target_type=TargetType.ROW_IDS,
-            raw_value="3",
-            row_indices=frozenset({2}),
-        )
-        config_targeted = BatchConfig(
-            batch_size=5,
-            row_timeout_ms=1000,
-            checkpoint_dir=checkpoint_dir,
-            resume_from_checkpoint=True,
-            target_selection=target_selection,
-            force_refresh_targets=True,
-        )
-        processor_targeted = BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config_targeted,
-        )
-
-        # Reset mock
-        mock_evaluator.aevaluate_row.reset_mock()
-        call_count = 0
-
-        results = await processor_targeted.process_all(thread_id="test-mixed")
-
-        # Only 1 row should be re-evaluated (the targeted one)
-        assert mock_evaluator.aevaluate_row.call_count == 1
-        # But we should still have results for all 10 rows (9 from checkpoint + 1 new)
-        assert len(results) == 10
-
-    @pytest.mark.asyncio
-    async def test_force_refresh_targets_reevaluates(
-        self, mock_template, mock_evaluator, mock_evidence_matcher, default_result, tmp_path
-    ):
-        """Test that force_refresh_targets re-evaluates targeted rows even if checkpointed (FR-25.4)."""
-        checkpoint_dir = tmp_path / "checkpoints"
-
-        # Create a checkpoint with existing results
-        checkpoint_file = checkpoint_dir / "batch-checkpoint-test-force.json"
-        checkpoint_file.parent.mkdir(parents=True, exist_ok=True)
-
-        # Pre-populate checkpoint with results for rows 0-4
-        existing_results = {}
-        for i in range(5):
-            row_id = f"CHK-{i}:row_{i}"
-            existing_results[row_id] = {
-                "row_id": row_id,
-                "check_id": f"CHK-{i}",
-                "status": "PASS",
-                "score": 50.0,  # Old score
-                "score_breakdown": {
-                    "raw_score": 50.0,
-                    "coverage": 1.0,
-                    "confidence": 1.0,
-                    "capped": False,
-                    "final_score": 50.0,
-                },
-                "reason": "Old result",
-                "finding": "Old finding",
-                "evidence_anchors": [],
-                "provenance": {
-                    "row_llm_mode": "test",
-                    "protocol": None,
-                    "model": None,
-                    "template_hash": "hash_123",
-                    "rubric_version": "1",
-                    "evidence_hash": "ev_hash_456",
-                    "evaluated_at": datetime.now(UTC).isoformat(),
-                },
-            }
-
-        checkpoint_data = {
-            "thread_id": "test-force",
-            "total_rows": 10,
-            "template_hash": "hash_123",
-            "evidence_hash": "ev_hash_456",
-            "completed_batches": [0],
-            "results_by_row_id": existing_results,
-            "last_updated": datetime.now(UTC).isoformat(),
-        }
-        checkpoint_file.write_text(json.dumps(checkpoint_data))
-
-        # Target row 1 (0-indexed: 0) with force_refresh
-        target_selection = TargetSelection(
-            target_type=TargetType.ROW_IDS,
-            raw_value="1",
-            row_indices=frozenset({0}),
-        )
-        config = BatchConfig(
-            batch_size=5,
-            row_timeout_ms=1000,
-            checkpoint_dir=checkpoint_dir,
-            resume_from_checkpoint=True,
-            target_selection=target_selection,
-            force_refresh_targets=True,
-        )
-        processor = BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config,
-        )
-
-        # Return a new result with different score
-        new_result = RowEvaluationResult(
-            row_id="CHK-0:row_0",
-            check_id="CHK-0",
-            status=RowStatus.PASS,
-            score=100.0,  # New score
-            score_breakdown=ScoreBreakdown.compute(100.0),
-            reason="New result",
-            finding="New finding",
-            evidence_anchors=[],
-            provenance=RowProvenance(
-                row_llm_mode="test",
-                protocol=None,
-                model=None,
-                template_hash="hash_123",
-                rubric_version="1",
-                evidence_hash="ev_hash_456",
-                evaluated_at=datetime.now(UTC),
-            ),
-        )
-        mock_evaluator.aevaluate_row.return_value = new_result
-
-        results = await processor.process_all(thread_id="test-force")
-
-        # Should have called evaluator for the targeted row
-        assert mock_evaluator.aevaluate_row.call_count == 1
-
-        # Find the result for row 0
-        row_0_result = next((r for r in results if r.row_id == "CHK-0:row_0"), None)
-        assert row_0_result is not None
-        assert row_0_result.score == 100.0  # New score, not old 50.0
-        assert row_0_result.reason == "New result"
-
-    @pytest.mark.asyncio
-    async def test_no_force_refresh_uses_checkpoint(
-        self, mock_template, mock_evaluator, mock_evidence_matcher, default_result, tmp_path
-    ):
-        """Test that without force_refresh, checkpointed targeted rows are not re-evaluated."""
-        checkpoint_dir = tmp_path / "checkpoints"
-
-        # Create a checkpoint with existing results
-        checkpoint_file = checkpoint_dir / "batch-checkpoint-test-no-force.json"
-        checkpoint_file.parent.mkdir(parents=True, exist_ok=True)
-
-        # Pre-populate checkpoint with result for row 0
-        existing_results = {
-            "CHK-0:row_0": {
-                "row_id": "CHK-0:row_0",
-                "check_id": "CHK-0",
-                "status": "PASS",
-                "score": 50.0,
-                "score_breakdown": {
-                    "raw_score": 50.0,
-                    "coverage": 1.0,
-                    "confidence": 1.0,
-                    "capped": False,
-                    "final_score": 50.0,
-                },
-                "reason": "Checkpointed result",
-                "finding": "Checkpointed finding",
-                "evidence_anchors": [],
-                "provenance": {
-                    "row_llm_mode": "test",
-                    "protocol": None,
-                    "model": None,
-                    "template_hash": "hash_123",
-                    "rubric_version": "1",
-                    "evidence_hash": "ev_hash_456",
-                    "evaluated_at": datetime.now(UTC).isoformat(),
-                },
-            }
-        }
-
-        checkpoint_data = {
-            "thread_id": "test-no-force",
-            "total_rows": 10,
-            "template_hash": "hash_123",
-            "evidence_hash": "ev_hash_456",
-            "completed_batches": [],  # Not marked as complete
-            "results_by_row_id": existing_results,
-            "last_updated": datetime.now(UTC).isoformat(),
-        }
-        checkpoint_file.write_text(json.dumps(checkpoint_data))
-
-        # Target row 1 (0-indexed: 0) WITHOUT force_refresh
-        target_selection = TargetSelection(
-            target_type=TargetType.ROW_IDS,
-            raw_value="1",
-            row_indices=frozenset({0}),
-        )
-        config = BatchConfig(
-            batch_size=5,
-            row_timeout_ms=1000,
-            checkpoint_dir=checkpoint_dir,
-            resume_from_checkpoint=True,
-            target_selection=target_selection,
-            force_refresh_targets=False,  # Don't force refresh
-        )
-        processor = BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config,
-        )
-
-        mock_evaluator.aevaluate_row.return_value = default_result
-
-        results = await processor.process_all(thread_id="test-no-force")
-
-        # Should NOT have called evaluator for the targeted row (it's checkpointed)
-        assert mock_evaluator.aevaluate_row.call_count == 0
-
-        # Result should be from checkpoint
-        row_0_result = next((r for r in results if r.row_id == "CHK-0:row_0"), None)
-        assert row_0_result is not None
-        assert row_0_result.score == 50.0  # Checkpointed score
-        assert row_0_result.reason == "Checkpointed result"
-
-    def test_is_row_targeted_no_selection(self, mock_template, mock_evaluator, mock_evidence_matcher):
-        """Test that all rows are targeted when no selection is configured."""
-        config = BatchConfig(batch_size=5, target_selection=None)
-        processor = BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config,
-        )
-
-        # All rows should be targeted
-        for i in range(10):
-            assert processor._is_row_targeted(i, f"CHK-{i}") is True
-
-    def test_is_row_targeted_with_row_ids(
-        self, mock_template, mock_evaluator, mock_evidence_matcher, target_selection_rows_1_3
-    ):
-        """Test row targeting with row ID selection."""
-        config = BatchConfig(batch_size=5, target_selection=target_selection_rows_1_3)
-        processor = BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config,
-        )
-
-        # Only rows 0 and 2 should be targeted
-        assert processor._is_row_targeted(0, "CHK-0") is True
-        assert processor._is_row_targeted(1, "CHK-1") is False
-        assert processor._is_row_targeted(2, "CHK-2") is True
-        assert processor._is_row_targeted(3, "CHK-3") is False
-
-    def test_is_row_targeted_with_check_ids(
-        self, mock_template, mock_evaluator, mock_evidence_matcher, target_selection_check_ids
-    ):
-        """Test row targeting with check ID selection."""
-        config = BatchConfig(batch_size=5, target_selection=target_selection_check_ids)
-        processor = BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config,
-        )
-
-        # CHK-0 and CHK-5 should be targeted
-        assert processor._is_row_targeted(0, "CHK-0") is True
-        assert processor._is_row_targeted(1, "CHK-1") is False
-        assert processor._is_row_targeted(5, "CHK-5") is True
-        assert processor._is_row_targeted(9, "CHK-9") is False
-
-    def test_batch_has_targeted_rows_no_selection(self, mock_template, mock_evaluator, mock_evidence_matcher):
-        """Test that all batches have targets when no selection is configured."""
-        config = BatchConfig(batch_size=5, target_selection=None)
-        processor = BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config,
-        )
-
-        assert processor._batch_has_targeted_rows(0, 5) is True
-        assert processor._batch_has_targeted_rows(5, 10) is True
-
-    def test_batch_has_targeted_rows_with_selection(
-        self, mock_template, mock_evaluator, mock_evidence_matcher, target_selection_rows_1_3
-    ):
-        """Test batch targeting detection with row selection."""
-        config = BatchConfig(batch_size=5, target_selection=target_selection_rows_1_3)
-        processor = BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=config,
-        )
-
-        # Batch 0 (rows 0-4) has targets (rows 0 and 2)
-        assert processor._batch_has_targeted_rows(0, 5) is True
-        # Batch 1 (rows 5-9) has no targets
-        assert processor._batch_has_targeted_rows(5, 10) is False
-
-
-# =============================================================================
-# Phase 145a: Resilience Budget, BatchConfig.batch_error_retry_limit,
-#             and _retry_error_rows tests
-# =============================================================================
-
-
-class TestResilienceBudget:
-    """Tests for ResilienceBudget formula and consume() semantics (FR-145.2)."""
-
-    def test_total_formula_error_driven(self) -> None:
-        """Formula: max(error_count * 3, max(15, ceil(total_rows * 0.35)))."""
-        import math
-
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-
-        b = ResilienceBudget(total_rows=55, error_count=12)
-        expected = max(12 * 3, 15, math.ceil(55 * 0.35))
-        assert b.total == expected == 36
-
-    def test_total_formula_floor_dominates_when_no_errors(self) -> None:
-        """Floor of max(15, ceil(total_rows * 0.35)) when error_count=0."""
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-
-        b = ResilienceBudget(total_rows=4, error_count=0)
-        assert b.total == 15  # floor=15, pct=ceil(4*0.35)=2 → max(0, 15)=15
-
-    def test_total_formula_pct_dominates_for_large_batch(self) -> None:
-        """35% of rows dominates for large batches with few errors."""
-        import math
-
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-
-        b = ResilienceBudget(total_rows=200, error_count=5)
-        assert b.total == max(15, math.ceil(200 * 0.35))  # = 70
-
-    def test_consume_decrements_remaining(self) -> None:
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-
-        b = ResilienceBudget(total_rows=10, error_count=1)
-        initial = b.total
-        assert b.remaining == initial
-        assert b.consume() is True
-        assert b.calls_used == 1
-        assert b.remaining == initial - 1
-
-    def test_consume_returns_false_when_exhausted(self) -> None:
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-
-        b = ResilienceBudget(total_rows=5, error_count=0)
-        assert b.total == 15  # floor=15 with generous formula
-        for _ in range(15):
-            assert b.consume() is True
-        assert b.consume() is False
-        assert b.calls_used == 15
-
-    def test_remaining_never_negative(self) -> None:
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-
-        b = ResilienceBudget(total_rows=2, error_count=0)
-        for _ in range(20):  # exhaust well past limit
-            b.consume()
-        assert b.remaining == 0
-
-
-class TestBatchConfigBatchErrorRetryLimit:
-    """Tests for batch_error_retry_limit field (FR-145.2, TSK-145.6)."""
-
-    def test_default_is_two(self) -> None:
-        """Default batch_error_retry_limit=2 (generous budget)."""
-        cfg = BatchConfig()
-        assert cfg.batch_error_retry_limit == 2
-
-    def test_explicit_override(self) -> None:
-        cfg = BatchConfig(batch_error_retry_limit=3)
-        assert cfg.batch_error_retry_limit == 3
-
-    def test_zero_disables_retry(self) -> None:
-        cfg = BatchConfig(batch_error_retry_limit=0)
-        assert cfg.batch_error_retry_limit == 0
-
-    def test_env_var_override(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        """VDS_AUDIT_BATCH_ERROR_RETRY_LIMIT env var controls default."""
-        import vds_audit_orchestrator.engine.batch_processor as mod
-
-        monkeypatch.setenv("VDS_AUDIT_BATCH_ERROR_RETRY_LIMIT", "5")
-        result = mod._default_batch_error_retry_limit()
-        assert result == 5
-
-    def test_env_var_invalid_falls_back_to_default(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        import vds_audit_orchestrator.engine.batch_processor as mod
-
-        monkeypatch.setenv("VDS_AUDIT_BATCH_ERROR_RETRY_LIMIT", "not_a_number")
-        result = mod._default_batch_error_retry_limit()
-        assert result == 1
-
-    def test_no_max_retries_field(self) -> None:
-        """Old max_retries field is replaced — callers use batch_error_retry_limit."""
-        cfg = BatchConfig()
-        assert hasattr(cfg, "batch_error_retry_limit")
-        # max_retries was removed from BatchConfig
-        assert not hasattr(cfg, "max_retries") or "max_retries" not in BatchConfig.__dataclass_fields__
-
-
-class TestNonFailoverableReasons:
-    """Tests for _NON_FAILOVERABLE_REASONS constant."""
-
-    def test_terminal_auth_is_non_failoverable(self) -> None:
-        from vds_audit_orchestrator.engine.batch_processor import _NON_FAILOVERABLE_REASONS
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderFailureClass
-
-        assert ProviderFailureClass.TERMINAL_AUTH.value in _NON_FAILOVERABLE_REASONS
-
-    def test_non_provider_bug_is_non_failoverable(self) -> None:
-        from vds_audit_orchestrator.engine.batch_processor import _NON_FAILOVERABLE_REASONS
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderFailureClass
-
-        assert ProviderFailureClass.NON_PROVIDER_BUG.value in _NON_FAILOVERABLE_REASONS
-
-    def test_transient_errors_are_not_in_set(self) -> None:
-        from vds_audit_orchestrator.engine.batch_processor import _NON_FAILOVERABLE_REASONS
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderFailureClass
-
-        assert ProviderFailureClass.RETRYABLE_TRANSIENT.value not in _NON_FAILOVERABLE_REASONS
-        assert ProviderFailureClass.QUOTA_OR_CAPACITY.value not in _NON_FAILOVERABLE_REASONS
-
-
-def _make_error_result(
-    row_id: str = "CHK-0:row_0",
-    check_id: str = "CHK-0",
-    reason_code: str = "",
-    original_provider: str = "profile-a",
-) -> RowEvaluationResult:
-    """Helper: create an ERROR RowEvaluationResult for retry sweep tests."""
-    return RowEvaluationResult(
-        row_id=row_id,
-        check_id=check_id,
-        status=RowStatus.ERROR,
-        score=0.0,
-        score_breakdown=ScoreBreakdown.compute(0.0),
-        reason="error",
-        finding="error",
-        evidence_anchors=[],
-        provenance=RowProvenance(
-            row_llm_mode="test",
-            protocol=None,
-            model=None,
-            template_hash="h",
-            rubric_version="1",
-            evidence_hash="h",
-            evaluated_at=datetime.now(UTC),
-            original_provider=original_provider,
-            final_provider=original_provider,
-            failover_chain=[original_provider],
-        ),
-        error_message="evaluation failed",
-        retry_metadata={"reason_code": reason_code} if reason_code else {},
-    )
-
-
-def _make_pass_result(
-    row_id: str = "CHK-0:row_0",
-    check_id: str = "CHK-0",
-    provider: str = "profile-b",
-) -> RowEvaluationResult:
-    """Helper: create a PASS RowEvaluationResult."""
-    return RowEvaluationResult(
-        row_id=row_id,
-        check_id=check_id,
-        status=RowStatus.PASS,
-        score=80.0,
-        score_breakdown=ScoreBreakdown.compute(80.0),
-        reason="pass",
-        finding="pass",
-        evidence_anchors=[],
-        provenance=RowProvenance(
-            row_llm_mode="test",
-            protocol=None,
-            model=None,
-            template_hash="h",
-            rubric_version="1",
-            evidence_hash="h",
-            evaluated_at=datetime.now(UTC),
-            original_provider=provider,
-            final_provider=provider,
-            failover_chain=[provider],
-        ),
-        retry_metadata={},
-    )
-
-
-class TestRetryErrorRows:
-    """Tests for _retry_error_rows post-pass sweep (FR-145.2)."""
-
-    def _make_processor(self, mock_template, mock_evaluator, mock_evidence_matcher):
-        cfg = BatchConfig(batch_size=5, row_timeout_ms=5000)
-        return BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=cfg,
-        )
-
-    @pytest.mark.asyncio
-    async def test_no_failover_profiles_returns_unchanged(
-        self, mock_template, mock_evaluator, mock_evidence_matcher
-    ) -> None:
-        """If failover_profiles is empty, skip sweep entirely."""
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-        results = [_make_error_result()]
-        budget = ResilienceBudget(total_rows=1, error_count=1)
-        health_memory = ProviderHealthMemory()
-
-        updated = await processor._retry_error_rows(
-            results=results,
-            health_memory=health_memory,
-            budget=budget,
-            failover_profiles=[],
-            project_profile=None,
-        )
-
-        assert updated == results
-        assert budget.calls_used == 0
-
-    @pytest.mark.asyncio
-    async def test_non_failoverable_reason_skipped(self, mock_template, mock_evaluator, mock_evidence_matcher) -> None:
-        """Rows with non-failoverable reason_code are not retried."""
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-        results = [_make_error_result(reason_code="terminal_auth")]
-        budget = ResilienceBudget(total_rows=1, error_count=1)
-        health_memory = ProviderHealthMemory()
-
-        updated = await processor._retry_error_rows(
-            results=results,
-            health_memory=health_memory,
-            budget=budget,
-            failover_profiles=["profile-b"],
-            project_profile=None,
-        )
-
-        assert updated[0].status == RowStatus.ERROR
-        assert budget.calls_used == 0  # never consumed
-
-    @pytest.mark.asyncio
-    async def test_successful_retry_replaces_result(self, mock_template, mock_evaluator, mock_evidence_matcher) -> None:
-        """When retry succeeds (non-ERROR), the original ERROR is replaced."""
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-        original_error = _make_error_result(row_id="CHK-0:row_0", check_id="CHK-0")
-
-        pass_result = _make_pass_result(row_id="CHK-0:row_0", check_id="CHK-0", provider="profile-b")
-        mock_evaluator.aevaluate_row.return_value = pass_result
-        # Patch _build_retry_evaluator to return mock_evaluator directly
-        processor._build_retry_evaluator = MagicMock(return_value=mock_evaluator)
-
-        budget = ResilienceBudget(total_rows=1, error_count=1)
-        health_memory = ProviderHealthMemory()
-
-        updated = await processor._retry_error_rows(
-            results=[original_error],
-            health_memory=health_memory,
-            budget=budget,
-            failover_profiles=["profile-b"],
-            project_profile=None,
-        )
-
-        assert updated[0].status == RowStatus.PASS
-        assert updated[0].retry_count == 1
-        assert updated[0].retry_metadata.get("resilience_retry_pass") is True
-        assert updated[0].retry_metadata.get("resilience_retry_provider") == "profile-b"
-        assert budget.calls_used == 1
-
-    @pytest.mark.asyncio
-    async def test_retry_still_error_keeps_original(self, mock_template, mock_evaluator, mock_evidence_matcher) -> None:
-        """If retry also returns ERROR, keep the original result."""
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-        original_error = _make_error_result(row_id="CHK-0:row_0", check_id="CHK-0")
-
-        retry_error = _make_error_result(row_id="CHK-0:row_0", check_id="CHK-0", original_provider="profile-b")
-        mock_evaluator.aevaluate_row.return_value = retry_error
-        processor._build_retry_evaluator = MagicMock(return_value=mock_evaluator)
-
-        budget = ResilienceBudget(total_rows=1, error_count=1)
-        health_memory = ProviderHealthMemory()
-
-        updated = await processor._retry_error_rows(
-            results=[original_error],
-            health_memory=health_memory,
-            budget=budget,
-            failover_profiles=["profile-b"],
-            project_profile=None,
-        )
-
-        assert updated[0].status == RowStatus.ERROR
-        assert updated[0].retry_metadata.get("resilience_retry_pass") is not True
-        assert budget.calls_used == 1
-
-    @pytest.mark.asyncio
-    async def test_budget_exhaustion_stops_sweep(self, mock_template, mock_evaluator, mock_evidence_matcher) -> None:
-        """Budget exhaustion prevents retrying remaining ERROR rows."""
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-
-        # Create 5 ERROR rows
-        results = [_make_error_result(row_id=f"CHK-{i}:row_{i}", check_id=f"CHK-{i}") for i in range(5)]
-
-        pass_result = _make_pass_result(provider="profile-b")
-        mock_evaluator.aevaluate_row.return_value = pass_result
-        processor._build_retry_evaluator = MagicMock(return_value=mock_evaluator)
-
-        # Budget only allows 2 retries
-        budget = ResilienceBudget(total_rows=5, error_count=5)
-        budget.calls_used = budget.total - 2  # exhaust all but 2
-
-        health_memory = ProviderHealthMemory()
-
-        updated = await processor._retry_error_rows(
-            results=results,
-            health_memory=health_memory,
-            budget=budget,
-            failover_profiles=["profile-b"],
-            project_profile=None,
-        )
-
-        # Only 2 rows should have been retried
-        recovered = [r for r in updated if r.status == RowStatus.PASS]
-        assert len(recovered) == 2
-        assert budget.calls_used == budget.total
-
-    @pytest.mark.asyncio
-    async def test_retry_exception_keeps_original(self, mock_template, mock_evaluator, mock_evidence_matcher) -> None:
-        """If retry raises, keep the original ERROR result."""
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-        original_error = _make_error_result(row_id="CHK-0:row_0", check_id="CHK-0")
-
-        mock_evaluator.aevaluate_row.side_effect = RuntimeError("provider unavailable")
-        processor._build_retry_evaluator = MagicMock(return_value=mock_evaluator)
-
-        budget = ResilienceBudget(total_rows=1, error_count=1)
-        health_memory = ProviderHealthMemory()
-
-        updated = await processor._retry_error_rows(
-            results=[original_error],
-            health_memory=health_memory,
-            budget=budget,
-            failover_profiles=["profile-b"],
-            project_profile=None,
-        )
-
-        assert updated[0].status == RowStatus.ERROR
-        assert budget.calls_used == 1
-
-    @pytest.mark.asyncio
-    async def test_cooled_down_provider_is_skipped(self, mock_template, mock_evaluator, mock_evidence_matcher) -> None:
-        """Providers with active cooldown are not selected for retry."""
-        import time
-
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-        original_error = _make_error_result(row_id="CHK-0:row_0", check_id="CHK-0", original_provider="profile-a")
-        # _build_retry_evaluator should not be called when provider is cooled down
-        processor._build_retry_evaluator = MagicMock(return_value=mock_evaluator)
-
-        health_memory = ProviderHealthMemory()
-        health_memory.cooldown_until["profile-b"] = time.monotonic() + 9999.0  # far future
-
-        budget = ResilienceBudget(total_rows=1, error_count=1)
-
-        updated = await processor._retry_error_rows(
-            results=[original_error],
-            health_memory=health_memory,
-            budget=budget,
-            failover_profiles=["profile-b"],  # only candidate but cooled down
-            project_profile=None,
-        )
-
-        assert updated[0].status == RowStatus.ERROR
-        # Budget consumed (we tried to find a provider) but no provider was healthy
-        assert budget.calls_used == 1
-
-    def test_select_healthy_provider_skips_excluded(self, mock_template, mock_evaluator, mock_evidence_matcher) -> None:
-        """_select_healthy_provider excludes explicitly blocked providers."""
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-        health_memory = ProviderHealthMemory()
-
-        result = processor._select_healthy_provider(
-            failover_profiles=["profile-a", "profile-b", "profile-c"],
-            health_memory=health_memory,
-            exclude={"profile-a", "profile-b"},
-        )
-        assert result == "profile-c"
-
-    def test_select_healthy_provider_returns_none_when_all_blocked(
-        self, mock_template, mock_evaluator, mock_evidence_matcher
-    ) -> None:
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-        health_memory = ProviderHealthMemory()
-
-        result = processor._select_healthy_provider(
-            failover_profiles=["profile-a"],
-            health_memory=health_memory,
-            exclude={"profile-a"},
-        )
-        assert result is None
-
-
-# ---------------------------------------------------------------------------
-# Tests for _ResilienceRetryStats accumulator and last_resilience_summary
-# (FR-145.7 telemetry)
-# ---------------------------------------------------------------------------
-
-
-class TestResilienceRetryStats:
-    """Unit tests for the _ResilienceRetryStats dataclass."""
-
-    def test_initial_state(self) -> None:
-        from vds_audit_orchestrator.engine.batch_processor import _ResilienceRetryStats
-
-        stats = _ResilienceRetryStats()
-        assert stats.error_rows_before_retry == 0
-        assert stats.retry_attempts == 0
-        assert stats.retry_successes == 0
-        assert stats.budget_used == 0
-        assert stats.budget_total == 0
-        assert stats.failover_hops == 0
-        assert stats.providers_used == []
-
-    def test_stats_accumulate_correctly(self) -> None:
-        from vds_audit_orchestrator.engine.batch_processor import _ResilienceRetryStats
-
-        stats = _ResilienceRetryStats()
-        stats.error_rows_before_retry = 3
-        stats.retry_attempts = 2
-        stats.retry_successes = 1
-        stats.budget_used = 2
-        stats.budget_total = 6
-        stats.failover_hops = 2
-        stats.providers_used = ["profile-b", "profile-c"]
-
-        assert stats.retry_attempts == 2
-        assert stats.retry_successes == 1
-        assert len(stats.providers_used) == 2
-
-
-class TestResilienceRetryStatsPopulation:
-    """Tests verifying _retry_error_rows populates stats correctly."""
-
-    def _make_processor(self, mock_template, mock_evaluator, mock_evidence_matcher):
-        cfg = BatchConfig(batch_size=5, row_timeout_ms=5000)
-        return BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=cfg,
-        )
-
-    @pytest.mark.asyncio
-    async def test_stats_populated_on_successful_retry(
-        self, mock_template, mock_evaluator, mock_evidence_matcher
-    ) -> None:
-        """Stats accumulator should record attempt, success, hop, and provider."""
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget, _ResilienceRetryStats
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-        original_error = _make_error_result(row_id="CHK-0:row_0", check_id="CHK-0")
-        pass_result = _make_pass_result(row_id="CHK-0:row_0", check_id="CHK-0", provider="profile-b")
-
-        mock_evaluator.aevaluate_row.return_value = pass_result
-        processor._build_retry_evaluator = MagicMock(return_value=mock_evaluator)
-
-        budget = ResilienceBudget(total_rows=1, error_count=1)
-        health_memory = ProviderHealthMemory()
-        stats = _ResilienceRetryStats()
-
-        await processor._retry_error_rows(
-            results=[original_error],
-            health_memory=health_memory,
-            budget=budget,
-            failover_profiles=["profile-b"],
-            project_profile=None,
-            stats=stats,
-        )
-
-        assert stats.error_rows_before_retry == 1
-        assert stats.retry_attempts == 1
-        assert stats.retry_successes == 1
-        assert stats.budget_used == 1
-        assert stats.budget_total == budget.total
-        assert stats.failover_hops == 1
-        assert "profile-b" in stats.providers_used
-
-    @pytest.mark.asyncio
-    async def test_stats_retry_fails_no_success(self, mock_template, mock_evaluator, mock_evidence_matcher) -> None:
-        """Stats should record attempt but no success when retry also errors."""
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget, _ResilienceRetryStats
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-        original_error = _make_error_result(row_id="CHK-0:row_0", check_id="CHK-0")
-        retry_error = _make_error_result(row_id="CHK-0:row_0", check_id="CHK-0", original_provider="profile-b")
-
-        mock_evaluator.aevaluate_row.return_value = retry_error
-        processor._build_retry_evaluator = MagicMock(return_value=mock_evaluator)
-
-        budget = ResilienceBudget(total_rows=1, error_count=1)
-        health_memory = ProviderHealthMemory()
-        stats = _ResilienceRetryStats()
-
-        await processor._retry_error_rows(
-            results=[original_error],
-            health_memory=health_memory,
-            budget=budget,
-            failover_profiles=["profile-b"],
-            project_profile=None,
-            stats=stats,
-        )
-
-        assert stats.retry_attempts == 1
-        assert stats.retry_successes == 0
-        assert stats.failover_hops == 1
-
-    @pytest.mark.asyncio
-    async def test_stats_not_populated_when_no_failover_profiles(
-        self, mock_template, mock_evaluator, mock_evidence_matcher
-    ) -> None:
-        """Empty failover list means sweep skips entirely — stats remain zeroed."""
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget, _ResilienceRetryStats
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-        original_error = _make_error_result()
-
-        budget = ResilienceBudget(total_rows=1, error_count=1)
-        health_memory = ProviderHealthMemory()
-        stats = _ResilienceRetryStats()
-
-        await processor._retry_error_rows(
-            results=[original_error],
-            health_memory=health_memory,
-            budget=budget,
-            failover_profiles=[],
-            project_profile=None,
-            stats=stats,
-        )
-
-        assert stats.retry_attempts == 0
-        assert stats.retry_successes == 0
-        assert stats.providers_used == []
-
-    @pytest.mark.asyncio
-    async def test_providers_deduplicated_across_retries(
-        self, mock_template, mock_evaluator, mock_evidence_matcher
-    ) -> None:
-        """The same retry provider should appear only once in stats.providers_used."""
-        from vds_audit_orchestrator.engine.batch_processor import ResilienceBudget, _ResilienceRetryStats
-        from vds_audit_orchestrator.engine.provider_failure_classifier import ProviderHealthMemory
-
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-
-        # Two error rows that both retry to profile-b
-        err1 = _make_error_result(row_id="CHK-0:row_0", check_id="CHK-0")
-        err2 = _make_error_result(row_id="CHK-1:row_1", check_id="CHK-1")
-        pass1 = _make_pass_result(row_id="CHK-0:row_0", check_id="CHK-0", provider="profile-b")
-        pass2 = _make_pass_result(row_id="CHK-1:row_1", check_id="CHK-1", provider="profile-b")
-
-        mock_evaluator.aevaluate_row.side_effect = [pass1, pass2]
-        processor._build_retry_evaluator = MagicMock(return_value=mock_evaluator)
-
-        budget = ResilienceBudget(total_rows=2, error_count=2)
-        health_memory = ProviderHealthMemory()
-        stats = _ResilienceRetryStats()
-
-        await processor._retry_error_rows(
-            results=[err1, err2],
-            health_memory=health_memory,
-            budget=budget,
-            failover_profiles=["profile-b"],
-            project_profile=None,
-            stats=stats,
-        )
-
-        # profile-b should appear exactly once even though it was used twice
-        assert stats.providers_used.count("profile-b") == 1
-        assert stats.retry_successes == 2
-        assert stats.failover_hops == 2
-
-
-class TestLastResilienceSummary:
-    """Tests for last_resilience_summary on BatchRowProcessor (FR-145.7)."""
-
-    def _make_processor(self, mock_template, mock_evaluator, mock_evidence_matcher):
-        cfg = BatchConfig(batch_size=5, row_timeout_ms=5000, batch_error_retry_limit=0)
-        return BatchRowProcessor(
-            template=mock_template,
-            evaluator=mock_evaluator,
-            evidence_matcher=mock_evidence_matcher,
-            config=cfg,
-        )
-
-    def test_last_resilience_summary_initialized_to_none(
-        self, mock_template, mock_evaluator, mock_evidence_matcher
-    ) -> None:
-        """Processor starts with last_resilience_summary as None."""
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-        assert processor.last_resilience_summary is None
-
-    @pytest.mark.asyncio
-    async def test_last_resilience_summary_set_after_process_all(
-        self, mock_template, mock_evaluator, mock_evidence_matcher
-    ) -> None:
-        """process_all always sets last_resilience_summary with correct keys."""
-        mock_evaluator.aevaluate_row.return_value = _make_pass_result()
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-
-        await processor.process_all(thread_id="test-summary-set")
-
-        summary = processor.last_resilience_summary
-        assert summary is not None
-        assert "total_rows" in summary
-        assert "error_rows_before_retry" in summary
-        assert "error_rows_after_retry" in summary
-        assert "retry_attempts" in summary
-        assert "retry_successes" in summary
-        assert "retry_budget_used" in summary
-        assert "retry_budget_total" in summary
-        assert "failover_hops_total" in summary
-        assert "providers_used" in summary
-        assert "provider_health_summary" in summary
-
-    @pytest.mark.asyncio
-    async def test_last_resilience_summary_reset_on_each_process_all(
-        self, mock_template, mock_evaluator, mock_evidence_matcher
-    ) -> None:
-        """Calling process_all twice should reset accumulator between runs."""
-        mock_evaluator.aevaluate_row.return_value = _make_pass_result()
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-
-        await processor.process_all(thread_id="run-1")
-        summary_1 = dict(processor.last_resilience_summary or {})
-
-        await processor.process_all(thread_id="run-2")
-        summary_2 = dict(processor.last_resilience_summary or {})
-
-        # Both runs had 0 retries, counts should be identical and not doubled.
-        assert summary_1["retry_attempts"] == summary_2["retry_attempts"] == 0
-        assert summary_1["retry_successes"] == summary_2["retry_successes"] == 0
-
-    @pytest.mark.asyncio
-    async def test_last_resilience_summary_correct_row_counts(
-        self, mock_template, mock_evaluator, mock_evidence_matcher
-    ) -> None:
-        """total_rows should equal the number of checks in the template."""
-        mock_evaluator.aevaluate_row.return_value = _make_pass_result()
-        processor = self._make_processor(mock_template, mock_evaluator, mock_evidence_matcher)
-
-        await processor.process_all(thread_id="test-row-counts")
-
-        summary = processor.last_resilience_summary
-        assert summary is not None
-        total_checks = sum(len(s.checks) for s in mock_template.sections)
-        assert summary["total_rows"] == total_checks