@ngocsangairvds/vsaf 3.2.13 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/tests/test_workflow/test_langgraph_workflow.py

@@ -1,2072 +0,0 @@
-"""Tests for LangGraph workflow (TSK-050, TSK-073).
-
-This module tests the LangGraph-based audit workflow including:
-- StateGraph initialization with AuditState
-- Node execution order (profile -> evidence -> seed_tasks -> dispatcher -> execute_tasks -> synthesize)
-- Checkpointing with MemorySaver
-- Human-in-loop interrupt/resume flow
-- State persistence across checkpoints
-- Error handling in nodes
-- Conditional edge routing
-- Workflow export to Mermaid
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-from langgraph.checkpoint.memory import MemorySaver
-from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
-from vds_audit_orchestrator.agents.base import AgentResult
-from vds_audit_orchestrator.agents.langgraph_workflow import (
-    _VALID_CHECKPOINTER_TYPES,
-    _build_agent_operation_log_context,
-    _extract_agent_efficiency_metrics,
-    _extract_critical_findings,
-    _get_checkpointer,
-    _is_row_unified_single_row_no_task_state,
-    analyze_node,
-    build_audit_graph,
-    dispatcher_node,
-    evidence_node,
-    execute_tasks_node,
-    export_workflow_mermaid,
-    get_pending_reviews,
-    human_review_node,
-    profile_node,
-    resume_audit_with_human_input,
-    route_after_evidence,
-    route_after_execute,
-    run_audit_with_langgraph,
-    seed_tasks_node,
-    should_human_review,
-    synthesize_node,
-)
-from vds_audit_orchestrator.evidence.corpus import EvidenceCorpus
-from vds_audit_orchestrator.models.evidence import (
-    Evidence,
-    EvidenceBundle,
-    EvidenceStatus,
-)
-from vds_audit_orchestrator.models.task import AuditTask, TaskStatus
-
-if TYPE_CHECKING:
-    from vds_audit_orchestrator.agents.audit_state import AuditState
-
-# =============================================================================
-# Test Fixtures
-# =============================================================================
-
-
-@pytest.fixture
-def sample_repo_path(tmp_path: Path) -> Path:
-    """Create a sample repository path for testing."""
-    repo = tmp_path / "test-repo"
-    repo.mkdir()
-    (repo / "README.md").write_text("# Test Repository")
-    (repo / "pyproject.toml").write_text("[tool.poetry]\nname = 'test-repo'")
-    return repo
-
-
-@pytest.fixture
-def sample_evidence_bundle(sample_repo_path: Path) -> EvidenceBundle:
-    """Create a sample evidence bundle for testing."""
-    return EvidenceBundle(
-        repository="test-repo",
-        git_evidence=[
-            Evidence(
-                source="git_file",
-                source_id="README.md",
-                title="README",
-                content="# Test Repository",
-                content_hash="hash123",
-                status=EvidenceStatus.FOUND,
-            ),
-        ],
-    )
-
-
-@pytest.fixture
-def sample_audit_state(sample_repo_path: Path) -> AuditState:
-    """Create a sample audit state for testing."""
-    return {
-        "repository": "test-repo",
-        "repo_path": str(sample_repo_path),
-        "project_id": "test-repo",
-        "step": "start",
-        "profile": {},
-        "evidence": None,
-        "evidence_dir": None,
-        "evidence_corpus": None,
-        "agent_results": [],
-        "synthesis": None,
-        "errors": [],
-        "human_approved": None,
-        "human_feedback": None,
-        "tasks": {},
-        "task_queue": [],
-        "active_workers": {},
-        "row_unified_mode": "off",
-        "single_row_targeted": False,
-        "row_state_context": None,
-    }
-
-
-@pytest.fixture
-def mock_agent_results() -> list[dict[str, Any]]:
-    """Create mock agent results for testing."""
-    return [
-        {
-            "agent": "code",
-            "success": True,
-            "findings": [
-                {
-                    "type": "technical_debt",
-                    "severity": "medium",
-                    "description": "TODO found in code",
-                    "location": "src/main.py",
-                }
-            ],
-            "metadata": {"llm_score": 85},
-        },
-        {
-            "agent": "docs",
-            "success": True,
-            "findings": [
-                {
-                    "type": "doc_quality",
-                    "severity": "low",
-                    "description": "README exists but needs improvement",
-                    "location": "README.md",
-                }
-            ],
-            "metadata": {"llm_score": 90},
-        },
-    ]
-
-
-# =============================================================================
-# Efficiency Metric Extraction Tests
-# =============================================================================
-
-
-class TestEfficiencyMetricExtraction:
-    """Tests for workflow-level agent efficiency log payload extraction."""
-
-    def test_extracts_agentic_efficiency_and_skill_executor_usage(self) -> None:
-        metadata = {
-            "agentic_tool_efficiency": {
-                "tool_calls_completed": 6,
-                "tool_repetition_rate": 0.5,
-                "skill_calls_total": 4,
-                "skill_effective_rate": 0.75,
-            },
-            "tool_usage": [
-                {"tool": "load_skill", "success": True},
-                {"tool": "read_skill_resource", "success": False},
-                {"tool": "run_skill_script", "success": True},
-            ],
-        }
-
-        extracted = _extract_agent_efficiency_metrics(metadata)
-        assert extracted["tool_calls_completed"] == 6
-        assert extracted["tool_repetition_rate"] == 0.5
-        assert extracted["skill_calls_total"] == 4
-        assert extracted["skill_effective_rate"] == 0.75
-        assert extracted["skill_executor_calls_total"] == 3
-        assert extracted["skill_executor_success_rate"] == 0.667
-
-    def test_uses_tool_efficiency_fallback_when_agentic_summary_absent(self) -> None:
-        metadata = {
-            "tool_efficiency": {
-                "tool_calls_started": 2,
-                "tool_calls_completed": 2,
-            }
-        }
-
-        extracted = _extract_agent_efficiency_metrics(metadata)
-        assert extracted == {
-            "tool_calls_started": 2,
-            "tool_calls_completed": 2,
-        }
-
-
-class _EventRecorder:
-    """Capture structured logger events with bound context."""
-
-    def __init__(
-        self, events: list[tuple[str, str, dict[str, Any]]] | None = None, bound: dict[str, Any] | None = None
-    ) -> None:
-        self.events = events if events is not None else []
-        self._bound = bound if bound is not None else {}
-
-    def bind(self, **kwargs):  # type: ignore[no-untyped-def]
-        return _EventRecorder(self.events, {**self._bound, **kwargs})
-
-    def _record(self, level: str, event: str, **kwargs: Any) -> None:
-        payload = {**self._bound, **kwargs}
-        self.events.append((level, event, payload))
-
-    def info(self, event: str, **kwargs: Any) -> None:
-        self._record("info", event, **kwargs)
-
-    def warning(self, event: str, **kwargs: Any) -> None:
-        self._record("warning", event, **kwargs)
-
-    def debug(self, event: str, **kwargs: Any) -> None:
-        self._record("debug", event, **kwargs)
-
-
-class TestAgentOperationTelemetry:
-    """Focused telemetry coverage for per-agent operation lifecycle logs."""
-
-    def test_build_agent_operation_log_context_prefers_row_state_page_id(self, sample_audit_state: AuditState) -> None:
-        state = sample_audit_state.copy()
-        state["project_id"] = "legacy-project-alias"
-        state["row_state_context"] = {"page_id": "88718940"}
-
-        context = _build_agent_operation_log_context(
-            state,
-            operation_scope="analyze_node",
-            agent_name="code",
-            task_id="task-123",
-        )
-
-        assert context["operation_scope"] == "analyze_node"
-        assert context["agent"] == "code"
-        assert context["task_id"] == "task-123"
-        assert context["page_id"] == "88718940"
-        assert context["project_page_id"] == "88718940"
-        assert context["project_id"] == "legacy-project-alias"
-        assert isinstance(context["operation_id"], str)
-        assert len(context["operation_id"]) > 10
-
-    @pytest.mark.asyncio
-    async def test_analyze_node_emits_agent_operation_lifecycle_logs_with_page_id(
-        self, sample_audit_state: AuditState, sample_evidence_bundle: EvidenceBundle, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        state_with_evidence = sample_audit_state.copy()
-        state_with_evidence["evidence"] = sample_evidence_bundle
-        state_with_evidence["row_state_context"] = {"page_id": "88718940"}
-
-        recorder = _EventRecorder()
-        monkeypatch.setattr("vds_audit_orchestrator.agents.langgraph_workflow.logger", recorder)
-
-        with (
-            patch("vds_audit_orchestrator.agents.code_agent.CodeAnalysisAgent") as mock_code,
-            patch("vds_audit_orchestrator.agents.docs_agent.DocumentationAgent") as mock_docs,
-            patch("vds_audit_orchestrator.agents.security_agent.SecurityAgent") as mock_security,
-        ):
-            mock_code.return_value.analyze = AsyncMock(
-                return_value=AgentResult(agent_name="CodeAnalysisAgent", success=True, findings=[], metadata={})
-            )
-            mock_docs.return_value.analyze = AsyncMock(
-                return_value=AgentResult(agent_name="DocumentationAgent", success=True, findings=[], metadata={})
-            )
-            mock_security.return_value.analyze = AsyncMock(
-                return_value=AgentResult(agent_name="SecurityAgent", success=True, findings=[], metadata={})
-            )
-
-            await analyze_node(state_with_evidence)
-
-        started = [payload for _, event, payload in recorder.events if event == "agent_operation_started"]
-        completed = [payload for _, event, payload in recorder.events if event == "agent_operation_complete"]
-
-        assert len(started) == 3
-        assert len(completed) == 3
-        assert all(entry.get("operation_scope") == "analyze_node" for entry in started + completed)
-        assert all(entry.get("page_id") == "88718940" for entry in started + completed)
-
-    @pytest.mark.asyncio
-    async def test_execute_tasks_node_emits_agent_operation_failure_logs_with_page_id(
-        self, sample_audit_state: AuditState, sample_evidence_bundle: EvidenceBundle, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        task = AuditTask(
-            id="task-code-telemetry",
-            type="code_analysis",
-            description="Analyze code quality",
-            assignee="code",
-            status=TaskStatus.RUNNING,
-            input_data={"evidence_bundle": sample_evidence_bundle, "profile": {"domain": "insurance"}},
-        )
-        state_with_task = sample_audit_state.copy()
-        state_with_task["tasks"] = {task.id: task.model_dump()}
-        state_with_task["active_workers"] = {"code": task.id}
-        state_with_task["row_state_context"] = {"project_page_id": "88718940"}
-
-        recorder = _EventRecorder()
-        monkeypatch.setattr("vds_audit_orchestrator.agents.langgraph_workflow.logger", recorder)
-
-        with (
-            patch("vds_audit_orchestrator.agents.code_agent.CodeAnalysisAgent") as mock_code,
-            patch("vds_audit_orchestrator.agents.docs_agent.DocumentationAgent") as mock_docs,
-            patch("vds_audit_orchestrator.agents.security_agent.SecurityAgent") as mock_security,
-        ):
-            mock_code.return_value.analyze = AsyncMock(side_effect=RuntimeError("telemetry failure"))
-            mock_docs.return_value.analyze = AsyncMock()
-            mock_security.return_value.analyze = AsyncMock()
-
-            await execute_tasks_node(state_with_task)
-
-        started = [payload for _, event, payload in recorder.events if event == "agent_operation_started"]
-        failed = [payload for _, event, payload in recorder.events if event == "agent_operation_failed"]
-
-        assert len(started) == 1
-        assert len(failed) == 1
-        assert started[0].get("operation_scope") == "execute_tasks_node"
-        assert failed[0].get("operation_scope") == "execute_tasks_node"
-        assert started[0].get("task_id") == task.id
-        assert failed[0].get("task_id") == task.id
-        assert started[0].get("page_id") == "88718940"
-        assert failed[0].get("page_id") == "88718940"
-
-
-@pytest.fixture
-def critical_agent_results() -> list[dict[str, Any]]:
-    """Create agent results with critical findings."""
-    return [
-        {
-            "agent": "security",
-            "success": True,
-            "findings": [
-                {
-                    "type": "security_vulnerability",
-                    "severity": "critical",
-                    "description": "Hardcoded secret detected",
-                    "location": "src/config.py",
-                }
-            ],
-            "metadata": {"llm_score": 30},
-        },
-        {
-            "agent": "code",
-            "success": False,
-            "error": "Analysis failed: timeout",
-            "findings": [],
-            "metadata": {},
-        },
-    ]
-
-
-# =============================================================================
-# StateGraph Initialization Tests
-# =============================================================================
-
-
-class TestStateGraphInitialization:
-    """Tests for StateGraph initialization with AuditState."""
-
-    @pytest.mark.asyncio
-    async def test_build_graph_with_audit_state(self):
-        """Test that StateGraph is initialized with correct AuditState."""
-        graph = await build_audit_graph(checkpointer="memory")
-
-        # Verify graph is compiled
-        assert graph is not None
-        assert hasattr(graph, "nodes")
-
-        # Check that all expected workflow nodes are present
-        nodes = list(graph.nodes.keys())
-        expected_nodes = [
-            "profile",
-            "evidence",
-            "seed_tasks",
-            "dispatcher",
-            "execute_tasks",
-            "human_review",
-            "synthesize",
-        ]
-        for node in expected_nodes:
-            assert node in nodes, f"Node {node} not found in graph"
-
-        # __start__ should be present, __end__ may not be a node
-        assert "__start__" in nodes
-
-    @pytest.mark.asyncio
-    async def test_graph_with_memory_saver(self):
-        """Test that graph is compiled with MemorySaver checkpointer."""
-        graph = await build_audit_graph(checkpointer="memory")
-
-        # Verify checkpointer is configured
-        assert graph.checkpointer is not None
-        assert isinstance(graph.checkpointer, MemorySaver)
-
-    @pytest.mark.asyncio
-    async def test_unknown_checkpointer_type_raises_value_error(self):
-        """Test that unknown checkpointer types raise ValueError instead of silently falling back."""
-        with pytest.raises(ValueError, match="Unknown checkpointer type"):
-            await _get_checkpointer("postgrse", None)  # typo
-
-    @pytest.mark.asyncio
-    async def test_unknown_checkpointer_type_invalid_value(self):
-        """Test that arbitrary strings are rejected as checkpointer types."""
-        with pytest.raises(ValueError, match="Unknown checkpointer type"):
-            await _get_checkpointer("sqlite", None)
-
-    @pytest.mark.asyncio
-    async def test_valid_checkpointer_types_constant(self):
-        """Test that valid checkpointer types are strictly postgres and memory."""
-        assert frozenset({"postgres", "memory"}) == _VALID_CHECKPOINTER_TYPES
-
-    @pytest.mark.asyncio
-    async def test_memory_checkpointer_explicit(self):
-        """Test that explicitly passing 'memory' returns MemorySaver."""
-        saver = await _get_checkpointer("memory", None)
-        assert isinstance(saver, MemorySaver)
-
-    @pytest.mark.asyncio
-    async def test_none_checkpointer_defaults_to_memory(self):
-        """Test that None checkpointer defaults to MemorySaver."""
-        saver = await _get_checkpointer(None, None)
-        assert isinstance(saver, MemorySaver)
-
-    @pytest.mark.asyncio
-    async def test_postgres_checkpointer_requires_dsn(self):
-        """Test that postgres checkpointer raises ValueError without DSN."""
-        with pytest.raises(ValueError, match="postgres checkpointer requires postgres_dsn"):
-            await _get_checkpointer("postgres", None)
-
-    @pytest.mark.asyncio
-    async def test_postgres_checkpointer_configures_msgpack_allowlist(self, monkeypatch: pytest.MonkeyPatch):
-        """Test postgres checkpointer uses explicit serializer allowlist for evidence checkpoint types."""
-
-        captured: dict[str, object] = {}
-
-        class _DummyCM:
-            async def __aenter__(self):
-                class _DummySaver:
-                    async def setup(self):
-                        return None
-
-                return _DummySaver()
-
-        class _DummyPostgresSaver:
-            @staticmethod
-            def from_conn_string(conn_string: str, *, pipeline: bool = False, serde=None):
-                captured["conn_string"] = conn_string
-                captured["pipeline"] = pipeline
-                captured["serde"] = serde
-                return _DummyCM()
-
-        monkeypatch.setattr(
-            "vds_audit_orchestrator.agents.langgraph_workflow.PostgresSaver",
-            _DummyPostgresSaver,
-        )
-        monkeypatch.setattr(
-            "vds_audit_orchestrator.agents.langgraph_workflow._postgres_saver_import_error",
-            None,
-        )
-
-        saver = await _get_checkpointer("postgres", "postgresql://user:pass@localhost:5432/db")
-
-        assert saver is not None
-        serde = captured["serde"]
-        assert isinstance(serde, JsonPlusSerializer)
-        assert getattr(serde, "_allowed_msgpack_modules", None) == {
-            ("vds_audit_orchestrator.models.evidence", "EvidenceStatus"),
-            ("vds_audit_orchestrator.models.evidence", "EvidenceBundle"),
-        }
-
-    @pytest.mark.asyncio
-    async def test_graph_entry_point(self):
-        """Test that graph has correct entry point."""
-        graph = await build_audit_graph(checkpointer="memory")
-
-        # Entry point should be profile node
-        # The builder.set_entry_point("profile") was called
-        assert "profile" in graph.nodes
-
-
-# =============================================================================
-# Node Execution Order Tests
-# =============================================================================
-
-
-class TestNodeExecutionOrder:
-    """Tests for correct node execution order."""
-
-    @pytest.mark.asyncio
-    async def test_profile_node_execution(self, sample_repo_path: Path, sample_audit_state: AuditState):
-        """Test profile node executes correctly."""
-        with patch("vds_audit_orchestrator.profiles.detection.resolve_profile_async") as mock_resolve:
-            # Mock profile resolution
-            mock_resolution = MagicMock()
-            mock_profile = MagicMock()
-            mock_profile.model_dump.return_value = {
-                "domain": "insurance",
-                "criticality": "medium",
-                "tech_stack": "python",
-            }
-            mock_resolution.profile = mock_profile
-            mock_resolution.source = "detection"
-            mock_resolve.return_value = mock_resolution
-
-            result = await profile_node(sample_audit_state)
-
-            assert result["profile"]["domain"] == "insurance"
-            assert result["step"] == "profile_done"
-            assert "errors" not in result or len(result.get("errors", [])) == 0
-
-    @pytest.mark.asyncio
-    async def test_evidence_node_execution(self, sample_repo_path: Path, sample_audit_state: AuditState):
-        """Test evidence node executes correctly."""
-        # Create bundle directly in test instead of calling fixture
-        mock_bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[
-                Evidence(
-                    source="git_file",
-                    source_id="README.md",
-                    title="README",
-                    content="# Test Repository",
-                    content_hash="hash123",
-                    status=EvidenceStatus.FOUND,
-                ),
-            ],
-        )
-
-        def state_manifest_loader(_dsn: str) -> dict[str, object]:
-            return {"project": {"project_name": "test", "pages": [], "documents": []}}
-
-        state_with_dsn = {
-            **sample_audit_state,
-            "state_dsn": "postgresql://state",
-        }
-
-        with (
-            patch("vds_audit_orchestrator.engine.evidence_collector.EvidenceCollector") as mock_collector_cls,
-            patch("vds_audit_orchestrator.evidence.loader.EvidenceManifestLoader") as mock_loader_cls,
-            patch("vds_audit_orchestrator.agents.langgraph_workflow._check_evidence_readiness") as mock_gate,
-        ):
-            # Mock evidence collector
-            mock_collector = AsyncMock()
-            mock_collector.collect_all.return_value = mock_bundle
-            mock_collector_cls.return_value = mock_collector
-
-            # Mock manifest loader
-            mock_loader = MagicMock()
-            mock_loader.load_runtime_corpus.return_value = EvidenceCorpus()
-            mock_loader_cls.return_value = mock_loader
-
-            # Phase 94: bypass evidence readiness gate for unit test
-            mock_gate_result = MagicMock()
-            mock_gate_result.ready = True
-            mock_gate_result.missing = []
-            mock_gate_result.warnings = []
-            mock_gate_result.confluence_docs_count = 1
-            mock_gate_result.code_files_count = 0
-            mock_gate.return_value = mock_gate_result
-
-            result = await evidence_node(state_with_dsn, state_manifest_loader=state_manifest_loader)
-
-            assert result["evidence"] is not None
-            assert result["step"] == "evidence_done"
-            assert "errors" not in result or len(result.get("errors", [])) == 0
-
-    @pytest.mark.asyncio
-    async def test_evidence_node_uses_state_manifest_loader_when_state_dsn_present(
-        self,
-        sample_audit_state: AuditState,
-    ):
-        """Evidence loader should use centralized state args when state_dsn is provided."""
-        mock_bundle = EvidenceBundle(repository="test-repo")
-
-        def state_manifest_loader(_dsn: str) -> dict[str, object]:
-            return {"project": {"project_name": "demo", "pages": [], "documents": []}}
-
-        state_with_dsn = {
-            **sample_audit_state,
-            "evidence_dir": "/tmp/evidence",
-            "state_dsn": "postgresql://state",
-        }
-
-        with (
-            patch("vds_audit_orchestrator.engine.evidence_collector.EvidenceCollector") as mock_collector_cls,
-            patch("vds_audit_orchestrator.evidence.loader.EvidenceManifestLoader") as mock_loader_cls,
-        ):
-            mock_collector = AsyncMock()
-            mock_collector.collect_all.return_value = mock_bundle
-            mock_collector_cls.return_value = mock_collector
-
-            mock_loader = MagicMock()
-            mock_loader.load_runtime_corpus.return_value = EvidenceCorpus()
-            mock_loader_cls.return_value = mock_loader
-
-            await evidence_node(
-                state_with_dsn,
-                state_manifest_loader=state_manifest_loader,
-            )
-
-            mock_loader_cls.assert_called_once()
-            assert mock_loader_cls.call_args.kwargs["state_dsn"] == "postgresql://state"
-            assert mock_loader_cls.call_args.kwargs["state_manifest_loader"] is state_manifest_loader
-            mock_loader.load_runtime_corpus.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_analyze_node_execution(self, sample_audit_state: AuditState, sample_evidence_bundle: EvidenceBundle):
-        """Test analyze node runs agents in parallel."""
-        # Update state with evidence
-        state_with_evidence = sample_audit_state.copy()
-        state_with_evidence["evidence"] = sample_evidence_bundle
-
-        with (
-            patch("vds_audit_orchestrator.agents.code_agent.CodeAnalysisAgent") as mock_code,
-            patch("vds_audit_orchestrator.agents.docs_agent.DocumentationAgent") as mock_docs,
-            patch("vds_audit_orchestrator.agents.security_agent.SecurityAgent") as mock_security,
-        ):
-            # Mock agent analyze methods - use explicit agent names
-            mock_code.return_value.analyze = AsyncMock(
-                return_value=AgentResult(
-                    agent_name="CodeAnalysisAgent",
-                    success=True,
-                    findings=[{"type": "test_finding", "severity": "low"}],
-                    metadata={"llm_score": 90},
-                )
-            )
-            mock_docs.return_value.analyze = AsyncMock(
-                return_value=AgentResult(
-                    agent_name="DocumentationAgent",
-                    success=True,
-                    findings=[{"type": "test_finding", "severity": "low"}],
-                    metadata={"llm_score": 90},
-                )
-            )
-            mock_security.return_value.analyze = AsyncMock(
-                return_value=AgentResult(
-                    agent_name="SecurityAgent",
-                    success=True,
-                    findings=[{"type": "test_finding", "severity": "low"}],
-                    metadata={"llm_score": 90},
-                )
-            )
-
-            result = await analyze_node(state_with_evidence)
-
-            assert "agent_results" in result
-            assert result["step"] == "analyze_done"
-            assert len(result["agent_results"]) == 3
-            assert mock_code.call_count == 1
-            assert mock_code.call_args.kwargs["agentic_mode"] == "auto"
-
-    @pytest.mark.asyncio
-    async def test_analyze_node_propagates_row_state_context(
-        self, sample_audit_state: AuditState, sample_evidence_bundle: EvidenceBundle
-    ) -> None:
-        """Single-row state context should be forwarded into analyze payload state_context."""
-        state_with_evidence = sample_audit_state.copy()
-        state_with_evidence["evidence"] = sample_evidence_bundle
-        state_with_evidence["row_state_context"] = {
-            "requirement_text": "Validate workflow runbook usage",
-            "requirement_interpretation": {"intent": "Validate workflow runbook usage", "evidence_targets": ["docs"]},
-        }
-
-        with (
-            patch("vds_audit_orchestrator.agents.code_agent.CodeAnalysisAgent") as mock_code,
-            patch("vds_audit_orchestrator.agents.docs_agent.DocumentationAgent") as mock_docs,
-            patch("vds_audit_orchestrator.agents.security_agent.SecurityAgent") as mock_security,
-        ):
-            mock_code.return_value.analyze = AsyncMock(
-                return_value=AgentResult(agent_name="CodeAnalysisAgent", success=True, findings=[], metadata={})
-            )
-            mock_docs.return_value.analyze = AsyncMock(
-                return_value=AgentResult(agent_name="DocumentationAgent", success=True, findings=[], metadata={})
-            )
-            mock_security.return_value.analyze = AsyncMock(
-                return_value=AgentResult(agent_name="SecurityAgent", success=True, findings=[], metadata={})
-            )
-
-            await analyze_node(state_with_evidence)
-
-            code_payload = mock_code.return_value.analyze.await_args.args[0]
-            state_context = code_payload.get("state_context")
-            assert isinstance(state_context, dict)
-            assert state_context.get("requirement_text") == "Validate workflow runbook usage"
-            interpretation = state_context.get("requirement_interpretation")
-            assert isinstance(interpretation, dict)
-            assert interpretation.get("intent") == "Validate workflow runbook usage"
-
-    @pytest.mark.asyncio
-    async def test_seed_tasks_node_execution(
-        self, sample_audit_state: AuditState, sample_evidence_bundle: EvidenceBundle
-    ):
-        """Test seed_tasks node creates baseline tasks."""
-        state_with_evidence = sample_audit_state.copy()
-        state_with_evidence["evidence"] = sample_evidence_bundle
-        state_with_evidence["profile"] = {"domain": "insurance"}
-
-        result = await seed_tasks_node(state_with_evidence)
-
-        assert result["step"] == "tasks_seeded"
-        assert "tasks" in result
-        assert len(result["tasks"]) == 3
-
-    @pytest.mark.asyncio
-    async def test_seed_tasks_node_includes_row_state_context(
-        self, sample_audit_state: AuditState, sample_evidence_bundle: EvidenceBundle
-    ) -> None:
-        """Seeded task payload should include single-row state context for requirement routing."""
-        state_with_evidence = sample_audit_state.copy()
-        state_with_evidence["evidence"] = sample_evidence_bundle
-        state_with_evidence["profile"] = {"domain": "insurance"}
-        state_with_evidence["row_state_context"] = {
-            "requirement_text": "Validate workflow runbook usage",
-            "requirement_interpretation": {"intent": "Validate workflow runbook usage", "evidence_targets": ["docs"]},
-        }
-
-        result = await seed_tasks_node(state_with_evidence)
-
-        assert len(result["tasks"]) == 3
-        first_task = next(iter(result["tasks"].values()))
-        payload = first_task.get("input_data", {})
-        state_context = payload.get("state_context")
-        assert isinstance(state_context, dict)
-        assert state_context.get("requirement_text") == "Validate workflow runbook usage"
-
-    @pytest.mark.asyncio
-    async def test_seed_tasks_node_skips_baseline_tasks_for_row_unified_single_row_target(
-        self, sample_audit_state: AuditState, sample_evidence_bundle: EvidenceBundle
-    ):
-        """Guarded rollout: when row_unified_mode=on for a single-row target, do not seed baseline tasks."""
-        state_with_evidence = sample_audit_state.copy()
-        state_with_evidence["evidence"] = sample_evidence_bundle
-        state_with_evidence["profile"] = {"domain": "insurance"}
-        state_with_evidence["row_unified_mode"] = "on"
-        state_with_evidence["single_row_targeted"] = True
-
-        result = await seed_tasks_node(state_with_evidence)
-
-        assert result["step"] == "tasks_seeded"
-        assert "tasks" in result
-        assert len(result["tasks"]) == 0
-
-    @pytest.mark.asyncio
-    async def test_seed_tasks_node_does_not_emit_single_row_legacy_marker_for_multi_row_target(
-        self, sample_audit_state: AuditState, sample_evidence_bundle: EvidenceBundle, capsys: pytest.CaptureFixture[str]
-    ) -> None:
-        """Row-unified multi-row targets should not emit the deprecated single-row telemetry marker."""
-        state_with_evidence = sample_audit_state.copy()
-        state_with_evidence["evidence"] = sample_evidence_bundle
-        state_with_evidence["profile"] = {"domain": "insurance"}
-        state_with_evidence["row_unified_mode"] = "on"
-        state_with_evidence["single_row_targeted"] = False
-
-        result = await seed_tasks_node(state_with_evidence)
-
-        assert result["step"] == "tasks_seeded"
-        assert len(result["tasks"]) == 0
-        output = capsys.readouterr().out
-        assert "task_seed_skipped_for_row_unified_mode" in output
-        assert "task_seed_skipped_for_row_unified_single_row" not in output
-
-    @pytest.mark.asyncio
-    async def test_row_unified_single_row_path_converges_without_baseline_task_fanout(
-        self, sample_audit_state: AuditState, sample_evidence_bundle: EvidenceBundle
-    ):
-        """Row-unified single-row execution should not fan out baseline security/code/docs tasks."""
-        initial_state = sample_audit_state.copy()
-        initial_state["evidence"] = sample_evidence_bundle
-        initial_state["profile"] = {"domain": "insurance"}
-        initial_state["row_unified_mode"] = "on"
-        initial_state["single_row_targeted"] = True
-
-        seeded = await seed_tasks_node(initial_state)
-        assert seeded["step"] == "tasks_seeded"
-        assert seeded["tasks"] == {}
-        assert seeded["task_queue"] == []
-        assert seeded["active_workers"] == {}
-
-        dispatch_state = {**initial_state, **seeded}
-        dispatched = await dispatcher_node(dispatch_state)
-        assert dispatched["step"] == "dispatch_done"
-        assert dispatched["tasks"] == {}
-        assert dispatched["task_queue"] == []
-        assert dispatched["active_workers"] == {}
-
-        execute_state = {**dispatch_state, **dispatched}
-        executed = await execute_tasks_node(execute_state)
-        assert executed["step"] == "tasks_executed"
-        assert executed["tasks"] == {}
-        assert executed["active_workers"] == {}
-        assert executed["errors"] == []
-
-        route = route_after_execute({**execute_state, **executed})
-        assert route == "synthesize"
-
-    @pytest.mark.asyncio
-    async def test_execute_tasks_node_execution(
-        self, sample_audit_state: AuditState, sample_evidence_bundle: EvidenceBundle
-    ):
-        """Test execute_tasks node completes assigned tasks and captures results."""
-        task = AuditTask(
-            id="task-code-001",
-            type="code_analysis",
-            description="Analyze code quality",
-            assignee="code",
-            status=TaskStatus.RUNNING,
-            input_data={"evidence_bundle": sample_evidence_bundle, "profile": {"domain": "insurance"}},
-        )
-
-        state_with_task = sample_audit_state.copy()
-        state_with_task["tasks"] = {task.id: task.model_dump()}
-        state_with_task["active_workers"] = {"code": task.id}
-
-        with (
-            patch("vds_audit_orchestrator.agents.code_agent.CodeAnalysisAgent") as mock_code,
-            patch("vds_audit_orchestrator.agents.docs_agent.DocumentationAgent") as mock_docs,
-            patch("vds_audit_orchestrator.agents.security_agent.SecurityAgent") as mock_security,
-        ):
-            mock_code.return_value.analyze = AsyncMock(
-                return_value=AgentResult(
-                    agent_name="CodeAnalysisAgent",
-                    success=True,
-                    findings=[{"type": "test_finding", "severity": "low"}],
-                    metadata={"llm_score": 90},
-                    spawned_tasks=[
-                        {
-                            "type": "verify_finding",
-                            "description": "Verify code finding",
-                            "assignee": "code",
-                            "input_data": {"evidence_bundle": sample_evidence_bundle},
-                            "priority": 100,
-                        }
-                    ],
-                )
-            )
-            mock_docs.return_value.analyze = AsyncMock()
-            mock_security.return_value.analyze = AsyncMock()
-
-            result = await execute_tasks_node(state_with_task)
-
-            assert result["step"] == "tasks_executed"
-            assert len(result["agent_results"]) == 1
-            assert result["tasks"][task.id]["status"] == TaskStatus.COMPLETED.value
-            assert len(result["tasks"]) == 2
-            assert mock_code.call_count == 1
-            assert mock_code.call_args.kwargs["agentic_mode"] == "auto"
-
-    @pytest.mark.asyncio
-    async def test_synthesize_node_execution(
-        self, sample_audit_state: AuditState, mock_agent_results: list[dict[str, Any]]
-    ):
-        """Test synthesize node aggregates results correctly."""
-        state_with_results = sample_audit_state.copy()
-        state_with_results["agent_results"] = mock_agent_results
-        state_with_results["human_approved"] = None
-
-        result = await synthesize_node(state_with_results)
-
-        assert result["synthesis"]["status"] == "complete"
-        assert result["synthesis"]["total_findings"] == 2
-        # agent_scores contains scores for each successful agent (from SynthesisResult.to_dict)
-        assert len(result["synthesis"]["agent_scores"]) == 2
-        assert result["step"] == "complete"
-
-    @pytest.mark.asyncio
-    async def test_synthesize_node_no_task_branch_for_row_unified_single_row_target(
-        self, sample_audit_state: AuditState, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """FR-127: deterministic no-task synthesis in row-unified single-row mode."""
-        state_with_no_tasks = sample_audit_state.copy()
-        state_with_no_tasks["row_unified_mode"] = "on"
-        state_with_no_tasks["single_row_targeted"] = True
-        state_with_no_tasks["tasks"] = {}
-        state_with_no_tasks["agent_results"] = []
-        state_with_no_tasks["human_approved"] = None
-
-        events: list[str] = []
-
-        class _LogRecorder:
-            def bind(self, **_kwargs):  # type: ignore[no-untyped-def]
-                return self
-
-            def info(self, event: str, **_kwargs) -> None:  # type: ignore[no-untyped-def]
-                events.append(event)
-
-        monkeypatch.setattr("vds_audit_orchestrator.agents.langgraph_workflow.logger", _LogRecorder())
-
-        with patch(
-            "vds_audit_orchestrator.agents.langgraph_workflow.SynthesisAgent.synthesize",
-            new_callable=AsyncMock,
-        ) as mock_synthesize:
-            result = await synthesize_node(state_with_no_tasks)
-
-        mock_synthesize.assert_not_awaited()
-        synthesis = result["synthesis"]
-        assert synthesis["status"] == "complete"
-        assert synthesis["overall_score"] == 0.0
-        assert synthesis["maturity_level"] == "Critical"
-        assert synthesis["total_findings"] == 0
-        assert synthesis["recommendations"] == []
-        assert "no analysis tasks were executed" in synthesis["executive_summary"].lower()
-        assert "cannot provide evidence-based recommendations" in synthesis["executive_summary"].lower()
-        assert synthesis["rows_evaluated"] == 0
-        assert synthesis["rows_with_tool_activity"] == 0
-        assert "workflow_no_task_synthesis_dynamic_only" in events
-        assert "workflow_no_task_synthesis_path" not in events
-        assert "synthesis_row_unified_single_row_no_task" not in events
-        assert result["step"] == "complete"
-
-    @pytest.mark.asyncio
-    async def test_synthesize_node_row_unified_single_row_with_results_uses_standard_path(
-        self, sample_audit_state: AuditState, mock_agent_results: list[dict[str, Any]]
-    ) -> None:
-        """Row-unified single-row mode must still run normal synthesis when results exist."""
-        state_with_results = sample_audit_state.copy()
-        state_with_results["row_unified_mode"] = "on"
-        state_with_results["single_row_targeted"] = True
-        state_with_results["tasks"] = {}
-        state_with_results["agent_results"] = mock_agent_results
-
-        result = await synthesize_node(state_with_results)
-
-        assert result["synthesis"]["status"] == "complete"
-        assert result["synthesis"]["total_findings"] == 2
-        assert len(result["synthesis"]["agent_scores"]) == 2
-        assert "no analysis tasks were executed" not in result["synthesis"]["executive_summary"].lower()
-        assert result["step"] == "complete"
-
-    def test_no_task_state_guard_rejects_row_context_artifacts(self, sample_audit_state: AuditState) -> None:
-        state_with_row_context = sample_audit_state.copy()
-        state_with_row_context["row_unified_mode"] = "on"
-        state_with_row_context["single_row_targeted"] = True
-        state_with_row_context["tasks"] = {}
-        state_with_row_context["agent_results"] = []
-        state_with_row_context["row_state_context"] = {"check_id": "CL-030"}
-
-        assert _is_row_unified_single_row_no_task_state(state_with_row_context) is False
-
-    def test_no_task_state_guard_rejects_row_results_with_evidence_refs(self, sample_audit_state: AuditState) -> None:
-        state_with_row_results = sample_audit_state.copy()
-        state_with_row_results["row_unified_mode"] = "on"
-        state_with_row_results["single_row_targeted"] = True
-        state_with_row_results["tasks"] = {}
-        state_with_row_results["agent_results"] = []
-        state_with_row_results["row_results"] = [
-            {
-                "row_id": "row_1",
-                "check_id": "CL-001",
-                "status": "partial",
-                "evidence_anchors": [{"ref_type": "doc_path", "ref_value": "docs/security.md"}],
-            }
-        ]
-
-        assert _is_row_unified_single_row_no_task_state(state_with_row_results) is False
-
-    def test_no_task_state_guard_rejects_retrieval_trace_activity(self, sample_audit_state: AuditState) -> None:
-        state_with_trace_activity = sample_audit_state.copy()
-        state_with_trace_activity["row_unified_mode"] = "on"
-        state_with_trace_activity["single_row_targeted"] = True
-        state_with_trace_activity["tasks"] = {}
-        state_with_trace_activity["agent_results"] = []
-        state_with_trace_activity["retrieval_trace_rows"] = [
-            {
-                "row_id": "row_1",
-                "retrieval_trace": {
-                    "tool_first_loop": {
-                        "docs_search_count": 1,
-                        "code_search_count": 0,
-                        "docs_read_count": 0,
-                        "code_read_count": 0,
-                    }
-                },
-            }
-        ]
-
-        assert _is_row_unified_single_row_no_task_state(state_with_trace_activity) is False
-
-
-# =============================================================================
-# Checkpointing Tests
-# =============================================================================
-
-
-class TestCheckpointing:
-    """Tests for checkpointing with MemorySaver."""
-
-    @pytest.mark.asyncio
-    async def test_checkpoint_persists_state(self, sample_repo_path: Path):
-        """Test that state is persisted across checkpoints."""
-        thread_id = "test-thread-001"
-
-        with (
-            patch("vds_audit_orchestrator.profiles.detection.resolve_profile_async") as mock_resolve,
-            patch("vds_audit_orchestrator.engine.evidence_collector.EvidenceCollector") as mock_collector,
-        ):
-            # Mock to return quickly and allow partial execution
-            mock_resolution = MagicMock()
-            mock_profile = MagicMock()
-            mock_profile.model_dump.return_value = {"domain": "insurance"}
-            mock_resolution.profile = mock_profile
-            mock_resolution.source = "test"
-            mock_resolve.return_value = mock_resolution
-
-            mock_collector_instance = AsyncMock()
-            mock_collector_instance.collect_all.return_value = EvidenceBundle(repository="test-repo")
-            mock_collector.return_value = mock_collector_instance
-
-            graph = await build_audit_graph(checkpointer="memory")
-            config = {"configurable": {"thread_id": thread_id}}
-
-            initial_state = {
-                "repository": "test-repo",
-                "repo_path": str(sample_repo_path),
-                "project_id": "test-repo",
-                "step": "start",
-                "profile": {},
-                "evidence": None,
-                "agent_results": [],
-                "synthesis": None,
-                "errors": [],
-                "human_approved": None,
-                "human_feedback": None,
-                "tasks": {},
-                "task_queue": [],
-                "active_workers": {},
-            }
-
-            # Run graph to completion
-            async for _ in graph.astream(initial_state, config):
-                pass
-
-            # Check that state was persisted
-            state = await graph.aget_state(config)
-            assert state.values.get("repository") == "test-repo"
-            # "profile" is no longer an AuditState field; verify agent_results persisted instead
-            assert state.values.get("agent_results") is not None
-
-    @pytest.mark.asyncio
-    async def test_multiple_threads_isolated(self, sample_repo_path: Path):
-        """Test that different threads maintain isolated state."""
-        graph = await build_audit_graph(checkpointer="memory")
-
-        config1 = {"configurable": {"thread_id": "thread-1"}}
-        config2 = {"configurable": {"thread_id": "thread-2"}}
-
-        state1 = {
-            "repository": "repo1",
-            "repo_path": str(sample_repo_path),
-            "project_id": "repo1",
-            "step": "custom",
-            "profile": {"domain": "insurance"},
-            "evidence": None,
-            "agent_results": [],
-            "synthesis": None,
-            "errors": [],
-            "human_approved": None,
-            "human_feedback": None,
-            "tasks": {},
-            "task_queue": [],
-            "active_workers": {},
-        }
-
-        state2 = {
-            "repository": "repo2",
-            "repo_path": str(sample_repo_path),
-            "project_id": "repo2",
-            "step": "other",
-            "profile": {"domain": "lending"},
-            "evidence": None,
-            "agent_results": [],
-            "synthesis": None,
-            "errors": [],
-            "human_approved": None,
-            "human_feedback": None,
-        }
-
-        # Set different states for each thread
-        await graph.aupdate_state(config1, state1)
-        await graph.aupdate_state(config2, state2)
-
-        # Verify isolation
-        retrieved1 = await graph.aget_state(config1)
-        retrieved2 = await graph.aget_state(config2)
-
-        assert retrieved1.values.get("repository") == "repo1"
-        assert retrieved2.values.get("repository") == "repo2"
-
-
-# =============================================================================
-# Human-in-Loop Interrupt/Resume Tests
-# =============================================================================
-
-
-class TestHumanInLoop:
-    """Tests for human-in-loop interrupt/resume flow."""
-
-    @pytest.mark.asyncio
-    async def test_human_review_interrupt(
-        self, sample_audit_state: AuditState, critical_agent_results: list[dict[str, Any]]
-    ):
-        """Test that human_review node interrupts workflow."""
-        state_with_critical = sample_audit_state.copy()
-        state_with_critical["agent_results"] = critical_agent_results
-
-        # Call human_review_node - should call interrupt()
-        # In test, we'll catch the interrupt behavior
-        with patch("vds_audit_orchestrator.agents.langgraph_workflow.interrupt") as mock_interrupt:
-            mock_interrupt.return_value = {
-                "question": "Critical findings detected. Approve continuation?",
-                "critical_issues": _extract_critical_findings(state_with_critical),
-            }
-
-            _ = await human_review_node(state_with_critical)
-
-            # Verify interrupt was called with proper payload
-            mock_interrupt.assert_called_once()
-            call_args = mock_interrupt.call_args[0][0]
-            assert "critical_issues" in call_args
-            assert "review_instructions" in call_args
-            assert len(call_args["critical_issues"]) > 0
-
-    @pytest.mark.asyncio
-    async def test_resume_with_approval(self, sample_repo_path: Path):
-        """Test resuming workflow with human approval."""
-        thread_id = "test-resume-approve"
-
-        with (
-            patch("vds_audit_orchestrator.profiles.detection.resolve_profile_async"),
-            patch("vds_audit_orchestrator.engine.evidence_collector.EvidenceCollector"),
-        ):
-            graph = await build_audit_graph(checkpointer="memory")
-            config = {"configurable": {"thread_id": thread_id}}
-
-            # Set up state as if paused at human_review
-            paused_state = {
-                "repository": "test-repo",
-                "repo_path": str(sample_repo_path),
-                "project_id": "test-repo",
-                "step": "awaiting_human",
-                "profile": {},
-                "evidence": EvidenceBundle(repository="test-repo"),
-                "agent_results": [{"agent": "test", "success": True, "findings": [], "metadata": {}}],
-                "synthesis": None,
-                "errors": [],
-                "human_approved": None,
-                "human_feedback": None,
-            }
-
-            await graph.aupdate_state(config, paused_state)
-
-            # Simulate resume with approval
-            # Note: In real scenario, the graph.next would indicate paused state
-            result = await synthesize_node(
-                {
-                    **paused_state,
-                    "human_approved": True,
-                    "human_feedback": "Approved to proceed",
-                }
-            )
-
-            assert result["synthesis"]["status"] == "complete"
-            assert result["synthesis"]["human_approved"] is True
-            assert result["synthesis"]["human_feedback"] == "Approved to proceed"
-
-    @pytest.mark.asyncio
-    async def test_resume_with_rejection(self, sample_repo_path: Path):
-        """Test resuming workflow with human rejection."""
-        state_with_rejection = {
-            "repository": "test-repo",
-            "repo_path": str(sample_repo_path),
-            "project_id": "test-repo",
-            "step": "awaiting_human",
-            "profile": {},
-            "evidence": EvidenceBundle(repository="test-repo"),
-            "agent_results": [{"agent": "test", "success": True, "findings": [], "metadata": {}}],
-            "synthesis": None,
-            "errors": [],
-            "human_approved": False,
-            "human_feedback": "Critical issues must be fixed",
-        }
-
-        result = await synthesize_node(state_with_rejection)
-
-        assert result["synthesis"]["status"] == "rejected"
-        assert result["synthesis"]["human_approved"] is False
-        assert "rejected" in result["synthesis"]["message"].lower()
-        assert result["step"] == "complete"
-
-
-# =============================================================================
-# State Persistence Tests
-# =============================================================================
-
-
-class TestStatePersistence:
-    """Tests for state persistence across checkpoints."""
-
-    @pytest.mark.asyncio
-    async def test_state_preserved_across_nodes(self, sample_repo_path: Path):
-        """Test that state accumulates correctly across node execution."""
-        thread_id = "persistence-test"
-
-        with (
-            patch("vds_audit_orchestrator.profiles.detection.resolve_profile_async") as mock_resolve,
-            patch("vds_audit_orchestrator.engine.evidence_collector.EvidenceCollector") as mock_collector,
-        ):
-            # Mock profile resolution
-            mock_resolution = MagicMock()
-            mock_profile = MagicMock()
-            mock_profile.model_dump.return_value = {
-                "domain": "insurance",
-                "criticality": "high",
-            }
-            mock_resolution.profile = mock_profile
-            mock_resolution.source = "test"
-            mock_resolve.return_value = mock_resolution
-
-            # Mock evidence collection
-            mock_collector_instance = AsyncMock()
-            mock_bundle = EvidenceBundle(
-                repository="test-repo",
-                git_evidence=[
-                    Evidence(
-                        source="git_file",
-                        source_id="test.py",
-                        title="Test",
-                        content="pass",
-                        content_hash="hash",
-                        status=EvidenceStatus.FOUND,
-                    ),
-                ],
-            )
-            mock_collector_instance.collect_all.return_value = mock_bundle
-            mock_collector.return_value = mock_collector_instance
-
-            graph = await build_audit_graph(checkpointer="memory")
-            config = {"configurable": {"thread_id": thread_id}}
-
-            initial_state = {
-                "repository": "test-repo",
-                "repo_path": str(sample_repo_path),
-                "project_id": "test-repo",
-                "step": "start",
-                "profile": {},
-                "evidence": None,
-                "agent_results": [],
-                "synthesis": None,
-                "errors": [],
-                "human_approved": None,
-                "human_feedback": None,
-                "tasks": {},
-                "task_queue": [],
-                "active_workers": {},
-            }
-
-            # Execute partial workflow
-            async for event in graph.astream(initial_state, config):
-                # Stop after profile node
-                if any(
-                    node_output.get("step") == "profile_done"
-                    for node_output in event.values()
-                    if isinstance(node_output, dict)
-                ):
-                    break
-
-            # Check state was persisted (profile is no longer an AuditState field)
-            state = await graph.aget_state(config)
-            assert state.values.get("repository") == "test-repo"
-            assert state.values.get("agent_results") is not None
-
-    @pytest.mark.asyncio
-    async def test_errors_accumulate_in_state(self, sample_audit_state: AuditState):
-        """Test that errors are accumulated in state."""
-        state = sample_audit_state.copy()
-
-        # Simulate errors from multiple nodes
-        state["errors"] = ["Profile detection warning"]
-        state["profile"] = {}
-        state["step"] = "profile_done"
-
-        # Add more errors
-        state["errors"].append("Evidence collection failed")
-
-        assert len(state["errors"]) == 2
-        assert "Profile detection warning" in state["errors"]
-        assert "Evidence collection failed" in state["errors"]
-
-
-# =============================================================================
-# Error Handling Tests
-# =============================================================================
-
-
-class TestErrorHandling:
-    """Tests for error handling in nodes."""
-
-    @pytest.mark.asyncio
-    async def test_profile_node_error_handling(self, sample_audit_state: AuditState):
-        """Test profile node handles errors gracefully."""
-        with patch("vds_audit_orchestrator.profiles.detection.resolve_profile_async") as mock_resolve:
-            mock_resolve.side_effect = Exception("Detection failed")
-
-            result = await profile_node(sample_audit_state)
-
-            assert result["profile"] == {}
-            assert result["step"] == "profile_done"
-            assert len(result.get("errors", [])) > 0
-            assert "Profile detection failed" in result["errors"][0]
-
-    @pytest.mark.asyncio
-    async def test_evidence_node_error_handling(self, sample_audit_state: AuditState):
-        """Test evidence node handles errors gracefully."""
-        with patch("vds_audit_orchestrator.engine.evidence_collector.EvidenceCollector") as mock_collector_cls:
-            mock_collector = AsyncMock()
-            mock_collector.collect_all.side_effect = Exception("Collection failed")
-            mock_collector_cls.return_value = mock_collector
-
-            result = await evidence_node(sample_audit_state)
-
-            assert result["evidence"] is not None
-            assert isinstance(result["evidence"], EvidenceBundle)
-            assert result["step"] == "evidence_done"
-            assert len(result.get("errors", [])) > 0
-
-    @pytest.mark.asyncio
-    async def test_analyze_node_agent_failure(
-        self, sample_audit_state: AuditState, sample_evidence_bundle: EvidenceBundle
-    ):
-        """Test analyze node handles individual agent failures."""
-        state_with_evidence = sample_audit_state.copy()
-        state_with_evidence["evidence"] = sample_evidence_bundle
-
-        with (
-            patch("vds_audit_orchestrator.agents.code_agent.CodeAnalysisAgent") as mock_code,
-            patch("vds_audit_orchestrator.agents.docs_agent.DocumentationAgent") as mock_docs,
-            patch("vds_audit_orchestrator.agents.security_agent.SecurityAgent") as mock_security,
-        ):
-            # Make one agent fail
-            mock_code.return_value.analyze = AsyncMock(side_effect=Exception("Agent crash"))
-            mock_docs.return_value.analyze = AsyncMock(
-                return_value=AgentResult(
-                    agent_name="DocumentationAgent",
-                    success=True,
-                    findings=[],
-                    metadata={},
-                )
-            )
-            mock_security.return_value.analyze = AsyncMock(
-                return_value=AgentResult(
-                    agent_name="SecurityAgent",
-                    success=True,
-                    findings=[],
-                    metadata={},
-                )
-            )
-
-            result = await analyze_node(state_with_evidence)
-
-            # Should have 3 results, one with error
-            assert len(result["agent_results"]) == 3
-            failed_result = next(r for r in result["agent_results"] if r.get("error"))
-            assert "Agent crash" in failed_result["error"]
-            assert len(result.get("errors", [])) > 0
-
-
-# =============================================================================
-# Conditional Edge Routing Tests
-# =============================================================================
-
-
-class TestConditionalEdgeRouting:
-    """Tests for conditional edge routing based on findings."""
-
-    def test_route_after_evidence_terminates_when_readiness_failed(self):
-        """Evidence gating should terminate workflow before task seeding."""
-        state: AuditState = {
-            "repository": "test",
-            "repo_path": "/tmp/test",
-            "project_id": "test",
-            "step": "evidence_failed",
-            "state_dsn": None,
-            "repo_storage_key": None,
-            "evidence": None,
-            "evidence_corpus": None,
-            "agent_results": [],
-            "synthesis": None,
-            "errors": [],
-            "human_approved": None,
-            "human_feedback": None,
-            "tasks": {},
-            "task_queue": [],
-            "active_workers": {},
-            "agentic_mode": "auto",
-            "row_unified_mode": "off",
-            "single_row_targeted": False,
-            "row_state_context": None,
-        }
-
-        assert route_after_evidence(state) == "end"
-
-    @pytest.mark.asyncio
-    async def test_graph_stops_before_seed_tasks_when_evidence_failed(self, sample_repo_path: Path):
-        """Graph should not execute seed_tasks when evidence node sets evidence_failed."""
-        initial_state: AuditState = {
-            "repository": "test-repo",
-            "repo_path": str(sample_repo_path),
-            "project_id": "test-repo",
-            "step": "start",
-            "state_dsn": None,
-            "repo_storage_key": None,
-            "evidence": None,
-            "evidence_corpus": None,
-            "agent_results": [],
-            "synthesis": None,
-            "errors": [],
-            "human_approved": None,
-            "human_feedback": None,
-            "tasks": {},
-            "task_queue": [],
-            "active_workers": {},
-            "agentic_mode": "auto",
-            "row_unified_mode": "off",
-            "single_row_targeted": False,
-            "row_state_context": None,
-        }
-
-        with (
-            patch(
-                "vds_audit_orchestrator.agents.langgraph_workflow.profile_node",
-                new=AsyncMock(return_value={"profile": {}, "step": "profile_done"}),
-            ),
-            patch(
-                "vds_audit_orchestrator.agents.langgraph_workflow.evidence_node",
-                new=AsyncMock(
-                    return_value={
-                        "step": "evidence_failed",
-                        "errors": ["Evidence readiness gate failed"],
-                    }
-                ),
-            ),
-            patch(
-                "vds_audit_orchestrator.agents.langgraph_workflow.seed_tasks_node",
-                new=AsyncMock(return_value={"step": "tasks_seeded"}),
-            ) as mock_seed_tasks,
-        ):
-            graph = await build_audit_graph(checkpointer="memory")
-            config = {"configurable": {"thread_id": "evidence-failed-route"}}
-            async for _ in graph.astream(initial_state, config):
-                pass
-
-            mock_seed_tasks.assert_not_awaited()
-            saved_state = await graph.aget_state(config)
-            assert saved_state.values.get("step") == "evidence_failed"
-
-    def test_should_route_to_human_review_with_critical_findings(self):
-        """Test routing to human_review when critical findings exist."""
-        state: AuditState = {
-            "repository": "test",
-            "repo_path": "/tmp/test",
-            "project_id": "test",
-            "step": "analyze_done",
-            "profile": {},
-            "evidence": None,
-            "agent_results": [
-                {
-                    "agent": "security",
-                    "success": True,
-                    "findings": [{"type": "security_vulnerability", "severity": "critical"}],
-                    "metadata": {"llm_score": 25},
-                }
-            ],
-            "synthesis": None,
-            "errors": [],
-            "human_approved": None,
-            "human_feedback": None,
-        }
-
-        route = should_human_review(state)
-        assert route == "human_review"
-
-    def test_should_route_to_synthesize_with_clean_results(self):
-        """Test routing to synthesize when no critical findings."""
-        state: AuditState = {
-            "repository": "test",
-            "repo_path": "/tmp/test",
-            "project_id": "test",
-            "step": "analyze_done",
-            "profile": {},
-            "evidence": None,
-            "agent_results": [
-                {
-                    "agent": "code",
-                    "success": True,
-                    "findings": [{"type": "technical_debt", "severity": "low"}],
-                    "metadata": {"llm_score": 85},
-                },
-                {
-                    "agent": "docs",
-                    "success": True,
-                    "findings": [],
-                    "metadata": {"llm_score": 90},
-                },
-            ],
-            "synthesis": None,
-            "errors": [],
-            "human_approved": None,
-            "human_feedback": None,
-        }
-
-        route = should_human_review(state)
-        assert route == "synthesize"
-
-    def test_route_after_execute_dispatches_when_tasks_pending(self):
-        """Test route_after_execute returns dispatch when work remains."""
-        state: AuditState = {
-            "repository": "test",
-            "repo_path": "/tmp/test",
-            "project_id": "test",
-            "step": "tasks_executed",
-            "profile": {},
-            "evidence": None,
-            "agent_results": [],
-            "synthesis": None,
-            "errors": [],
-            "human_approved": None,
-            "human_feedback": None,
-            "tasks": {
-                "task-pending": {
-                    "id": "task-pending",
-                    "type": "code_analysis",
-                    "description": "Pending task",
-                    "assignee": "code",
-                    "status": TaskStatus.PENDING.value,
-                    "dependencies": [],
-                    "priority": 100,
-                    "input_data": {},
-                }
-            },
-            "task_queue": [],
-            "active_workers": {},
-        }
-
-        route = route_after_execute(state)
-        assert route == "dispatch"
-
-    def test_route_after_execute_human_review_when_tasks_complete(self):
-        """Test route_after_execute routes to human_review for critical findings."""
-        state: AuditState = {
-            "repository": "test",
-            "repo_path": "/tmp/test",
-            "project_id": "test",
-            "step": "tasks_executed",
-            "profile": {},
-            "evidence": None,
-            "agent_results": [
-                {
-                    "agent": "security",
-                    "success": True,
-                    "findings": [{"type": "security_vulnerability", "severity": "critical"}],
-                    "metadata": {"llm_score": 25},
-                }
-            ],
-            "synthesis": None,
-            "errors": [],
-            "human_approved": None,
-            "human_feedback": None,
-            "tasks": {
-                "task-complete": {
-                    "id": "task-complete",
-                    "type": "security_analysis",
-                    "description": "Complete task",
-                    "assignee": "security",
-                    "status": TaskStatus.COMPLETED.value,
-                    "dependencies": [],
-                    "priority": 100,
-                    "input_data": {},
-                }
-            },
-            "task_queue": [],
-            "active_workers": {},
-        }
-
-        route = route_after_execute(state)
-        assert route == "human_review"
-
-    def test_extract_critical_findings_low_llm_score(self):
-        """Test critical findings extraction for low LLM scores."""
-        state: AuditState = {
-            "repository": "test",
-            "repo_path": "/tmp/test",
-            "project_id": "test",
-            "step": "analyze_done",
-            "profile": {},
-            "evidence": None,
-            "agent_results": [
-                {
-                    "agent": "code",
-                    "success": True,
-                    "findings": [],
-                    "metadata": {"llm_score": 45},
-                }
-            ],
-            "synthesis": None,
-            "errors": [],
-            "human_approved": None,
-            "human_feedback": None,
-            "tasks": {},
-            "task_queue": [],
-            "active_workers": {},
-        }
-
-        critical = _extract_critical_findings(state)
-        assert len(critical) == 1
-        assert critical[0]["reason"] == "low_llm_score"
-        assert critical[0]["llm_score"] == 45
-
-    def test_extract_critical_findings_security_vulnerability(self):
-        """Test critical findings extraction for security vulnerabilities."""
-        state: AuditState = {
-            "repository": "test",
-            "repo_path": "/tmp/test",
-            "project_id": "test",
-            "step": "analyze_done",
-            "profile": {},
-            "evidence": None,
-            "agent_results": [
-                {
-                    "agent": "security",
-                    "success": True,
-                    "findings": [
-                        {"type": "security_vulnerability", "id": "vuln-1", "severity": "critical"},
-                    ],
-                    "metadata": {"llm_score": 80},
-                }
-            ],
-            "synthesis": None,
-            "errors": [],
-            "human_approved": None,
-            "human_feedback": None,
-        }
-
-        critical = _extract_critical_findings(state)
-        assert len(critical) == 1
-        assert critical[0]["reason"] == "security_vulnerability"
-
-    def test_extract_critical_findings_agent_error(self):
-        """Test critical findings extraction for agent errors."""
-        state: AuditState = {
-            "repository": "test",
-            "repo_path": "/tmp/test",
-            "project_id": "test",
-            "step": "analyze_done",
-            "profile": {},
-            "evidence": None,
-            "agent_results": [
-                {
-                    "agent": "code",
-                    "success": False,
-                    "error": "Analysis timeout",
-                    "findings": [],
-                    "metadata": {},
-                }
-            ],
-            "synthesis": None,
-            "errors": [],
-            "human_approved": None,
-            "human_feedback": None,
-        }
-
-        critical = _extract_critical_findings(state)
-        assert len(critical) == 1
-        assert critical[0]["reason"] == "agent_error"
-
-
-# =============================================================================
-# Workflow Export Tests
-# =============================================================================
-
-
-class TestWorkflowExport:
-    """Tests for workflow export to Mermaid."""
-
-    @pytest.mark.asyncio
-    async def test_export_mermaid_success(self, tmp_path: Path):
-        """Test successful Mermaid export."""
-        output_path = tmp_path / "workflow.mmd"
-
-        result_path = await export_workflow_mermaid(output_path, checkpointer="memory")
-
-        assert result_path == output_path
-        assert output_path.exists()
-        content = output_path.read_text()
-        assert "graph TD" in content or "graph LR" in content
-
-    @pytest.mark.asyncio
-    async def test_export_mermaid_unavailable(self, tmp_path: Path):
-        """Test Mermaid export when unavailable."""
-        output_path = tmp_path / "workflow.mmd"
-
-        with patch("vds_audit_orchestrator.agents.langgraph_workflow.build_audit_graph") as mock_build:
-            mock_graph = AsyncMock()
-            mock_compiled = MagicMock()
-            # Mock that draw_mermaid is not available
-            del mock_compiled.draw_mermaid
-            mock_graph.get_graph.return_value = mock_compiled
-            mock_build.return_value = mock_graph
-
-            with pytest.raises(RuntimeError, match="mermaid export not available"):
-                await export_workflow_mermaid(output_path, checkpointer="memory")
-
-
-# =============================================================================
-# Pending Reviews Tests
-# =============================================================================
-
-
-class TestPendingReviews:
-    """Tests for getting pending human reviews."""
-
-    @pytest.mark.asyncio
-    async def test_get_pending_reviews_with_thread(self, sample_repo_path: Path):
-        """Test getting pending reviews for specific thread."""
-        thread_id = "pending-review-test"
-
-        with (
-            patch("vds_audit_orchestrator.profiles.detection.resolve_profile_async"),
-            patch("vds_audit_orchestrator.engine.evidence_collector.EvidenceCollector"),
-        ):
-            graph = await build_audit_graph(checkpointer="memory")
-            config = {"configurable": {"thread_id": thread_id}}
-
-            # Set up paused state - use a step that get_pending_reviews checks for
-            paused_state = {
-                "repository": "test-repo",
-                "repo_path": str(sample_repo_path),
-                "project_id": "test-repo",
-                "step": "human_review",  # Changed from "awaiting_human" to match get_pending_reviews check
-                "profile": {},
-                "evidence": EvidenceBundle(repository="test-repo"),
-                "agent_results": [
-                    {
-                        "agent": "security",
-                        "success": True,
-                        "findings": [{"type": "security_vulnerability"}],
-                        "metadata": {"llm_score": 30},
-                    }
-                ],
-                "synthesis": None,
-                "errors": [],
-                "human_approved": None,
-                "human_feedback": None,
-            }
-
-            # We need to make the graph think it's paused (has next nodes)
-            # For MemorySaver, get_pending_reviews checks if state.next exists
-            # Let's manually verify the logic by setting up state differently
-            await graph.aupdate_state(config, paused_state)
-
-            # The get_pending_reviews function checks state.next to determine if paused
-            # For MemorySaver, we can't easily simulate a paused state without actual interrupt
-            # Let's test the function with a check that it returns empty for non-paused state
-            pending = await get_pending_reviews(thread_id, checkpointer="memory")
-
-            # Since the state is not actually paused (no next nodes), expect empty list
-            # This validates the function correctly identifies non-paused workflows
-            assert isinstance(pending, list)
-
-    @pytest.mark.asyncio
-    async def test_get_pending_reviews_none_completed(self, sample_repo_path: Path):
-        """Test getting pending reviews when workflow is complete."""
-        thread_id = "completed-workflow"
-
-        graph = await build_audit_graph(checkpointer="memory")
-        config = {"configurable": {"thread_id": thread_id}}
-
-        # Set up completed state
-        completed_state = {
-            "repository": "test-repo",
-            "repo_path": str(sample_repo_path),
-            "project_id": "test-repo",
-            "step": "complete",
-            "profile": {},
-            "evidence": None,
-            "agent_results": [],
-            "synthesis": {"status": "complete"},
-            "errors": [],
-            "human_approved": True,
-            "human_feedback": None,
-        }
-
-        await graph.aupdate_state(config, completed_state)
-
-        pending = await get_pending_reviews(thread_id, checkpointer="memory")
-
-        # Should return empty list since workflow is complete
-        assert len(pending) == 0
-
-
-# =============================================================================
-# Full Workflow Integration Tests
-# =============================================================================
-
-
-class TestFullWorkflow:
-    """Tests for complete workflow execution."""
-
-    @pytest.mark.asyncio
-    async def test_run_audit_full_workflow(self, sample_repo_path: Path):
-        """Test running complete audit workflow without human review."""
-        thread_id = "full-workflow-test"
-
-        with (
-            patch("vds_audit_orchestrator.profiles.detection.resolve_profile_async") as mock_resolve,
-            patch("vds_audit_orchestrator.engine.evidence_collector.EvidenceCollector") as mock_collector,
-            patch("vds_audit_orchestrator.agents.code_agent.CodeAnalysisAgent") as mock_code,
-            patch("vds_audit_orchestrator.agents.docs_agent.DocumentationAgent") as mock_docs,
-            patch("vds_audit_orchestrator.agents.security_agent.SecurityAgent") as mock_security,
-            patch("vds_audit_orchestrator.evidence.loader.EvidenceManifestLoader") as mock_loader_cls,
-            patch("vds_audit_orchestrator.agents.langgraph_workflow._check_evidence_readiness") as mock_gate,
-        ):
-            # Mock profile
-            mock_resolution = MagicMock()
-            mock_profile = MagicMock()
-            mock_profile.model_dump.return_value = {"domain": "insurance", "criticality": "medium"}
-            mock_resolution.profile = mock_profile
-            mock_resolution.source = "test"
-            mock_resolve.return_value = mock_resolution
-
-            # Mock evidence
-            mock_collector_instance = AsyncMock()
-            mock_collector_instance.collect_all.return_value = EvidenceBundle(repository="test-repo")
-            mock_collector.return_value = mock_collector_instance
-
-            # Mock manifest loader
-            mock_loader = MagicMock()
-            mock_loader.load.return_value = MagicMock(documents=[])
-            mock_loader_cls.return_value = mock_loader
-
-            # Phase 94: bypass evidence readiness gate for unit test
-            mock_gate_result = MagicMock()
-            mock_gate_result.ready = True
-            mock_gate_result.missing = []
-            mock_gate_result.warnings = []
-            mock_gate_result.confluence_docs_count = 1
-            mock_gate_result.code_files_count = 0
-            mock_gate.return_value = mock_gate_result
-
-            # Mock agents - all pass with no critical findings - use explicit names
-            mock_code.return_value.analyze = AsyncMock(
-                return_value=AgentResult(
-                    agent_name="CodeAnalysisAgent",
-                    success=True,
-                    findings=[{"type": "minor", "severity": "low"}],
-                    metadata={"llm_score": 90},
-                )
-            )
-            mock_docs.return_value.analyze = AsyncMock(
-                return_value=AgentResult(
-                    agent_name="DocumentationAgent",
-                    success=True,
-                    findings=[{"type": "minor", "severity": "low"}],
-                    metadata={"llm_score": 90},
-                )
-            )
-            mock_security.return_value.analyze = AsyncMock(
-                return_value=AgentResult(
-                    agent_name="SecurityAgent",
-                    success=True,
-                    findings=[{"type": "minor", "severity": "low"}],
-                    metadata={"llm_score": 90},
-                )
-            )
-
-            def _mock_state_manifest_loader(_dsn: str) -> dict:
-                return {"project": {"project_name": "test", "pages": [], "documents": []}}
-
-            result = await run_audit_with_langgraph(
-                repo_path=str(sample_repo_path),
-                thread_id=thread_id,
-                checkpointer="memory",
-                state_dsn="postgresql://mock-state",
-                state_manifest_loader=_mock_state_manifest_loader,
-            )
-
-            assert result is not None
-            # Workflow should still complete with synthesis under mocked dependencies.
-            assert result.get("synthesis") is not None
-            assert result["synthesis"]["status"] == "complete"
-
-    @pytest.mark.asyncio
-    async def test_run_audit_requires_thread_id(self, sample_repo_path: Path):
-        """Test that run_audit requires thread_id."""
-        with pytest.raises(ValueError, match="thread_id is required"):
-            await run_audit_with_langgraph(
-                repo_path=str(sample_repo_path),
-                thread_id=None,
-                checkpointer="memory",
-            )
-
-    @pytest.mark.asyncio
-    async def test_run_audit_passes_state_dsn_to_initial_state(self, sample_repo_path: Path):
-        """run_audit_with_langgraph should include state_dsn and default agentic_mode in initial state."""
-        captured_initial_state: dict[str, Any] = {}
-
-        class _FakeGraph:
-            async def astream(self, initial_state: dict[str, Any], _config: dict[str, Any]):
-                captured_initial_state.update(initial_state)
-                yield {"profile": {"step": "profile_done"}}
-
-            async def aget_state(self, _config: dict[str, Any]):
-                return type(
-                    "_State",
-                    (),
-                    {
-                        "values": {"step": "complete"},
-                        "next": (),
-                    },
-                )()
-
-        with patch(
-            "vds_audit_orchestrator.agents.langgraph_workflow.build_audit_graph",
-            new=AsyncMock(return_value=_FakeGraph()),
-        ):
-            await run_audit_with_langgraph(
-                repo_path=str(sample_repo_path),
-                thread_id="state-dsn-test",
-                state_dsn="postgresql://state",
-            )
-
-        assert captured_initial_state["state_dsn"] == "postgresql://state"
-        assert captured_initial_state["agentic_mode"] == "auto"
-        assert captured_initial_state["row_unified_mode"] == "on"
-        assert captured_initial_state["single_row_targeted"] is False
-        assert captured_initial_state["row_state_context"] is None
-
-    @pytest.mark.asyncio
-    async def test_run_audit_passes_explicit_agentic_mode_to_initial_state(self, sample_repo_path: Path):
-        """run_audit_with_langgraph should preserve explicit agentic_mode override."""
-        captured_initial_state: dict[str, Any] = {}
-
-        class _FakeGraph:
-            async def astream(self, initial_state: dict[str, Any], _config: dict[str, Any]):
-                captured_initial_state.update(initial_state)
-                yield {"profile": {"step": "profile_done"}}
-
-            async def aget_state(self, _config: dict[str, Any]):
-                return type(
-                    "_State",
-                    (),
-                    {
-                        "values": {"step": "complete"},
-                        "next": (),
-                    },
-                )()
-
-        with patch(
-            "vds_audit_orchestrator.agents.langgraph_workflow.build_audit_graph",
-            new=AsyncMock(return_value=_FakeGraph()),
-        ):
-            await run_audit_with_langgraph(
-                repo_path=str(sample_repo_path),
-                thread_id="state-agentic-mode-test",
-                agentic_mode="off",
-                row_unified_mode="on",
-                single_row_targeted=True,
-            )
-
-        assert captured_initial_state["agentic_mode"] == "off"
-        assert captured_initial_state["row_unified_mode"] == "on"
-        assert captured_initial_state["single_row_targeted"] is True
-
-    @pytest.mark.asyncio
-    async def test_run_audit_passes_row_state_context_to_initial_state(self, sample_repo_path: Path):
-        """run_audit_with_langgraph should propagate row_state_context payload to initial state."""
-        captured_initial_state: dict[str, Any] = {}
-
-        class _FakeGraph:
-            async def astream(self, initial_state: dict[str, Any], _config: dict[str, Any]):
-                captured_initial_state.update(initial_state)
-                yield {"profile": {"step": "profile_done"}}
-
-            async def aget_state(self, _config: dict[str, Any]):
-                return type(
-                    "_State",
-                    (),
-                    {
-                        "values": {"step": "complete"},
-                        "next": (),
-                    },
-                )()
-
-        with patch(
-            "vds_audit_orchestrator.agents.langgraph_workflow.build_audit_graph",
-            new=AsyncMock(return_value=_FakeGraph()),
-        ):
-            await run_audit_with_langgraph(
-                repo_path=str(sample_repo_path),
-                thread_id="state-row-context-test",
-                row_state_context={
-                    "requirement_text": "Validate workflow runbook usage",
-                    "requirement_interpretation": {"intent": "Validate workflow runbook usage"},
-                },
-            )
-
-        row_state_context = captured_initial_state.get("row_state_context")
-        assert isinstance(row_state_context, dict)
-        assert row_state_context.get("requirement_text") == "Validate workflow runbook usage"
-
-    @pytest.mark.asyncio
-    async def test_run_audit_uses_last_known_values_when_checkpoint_state_read_fails(self, sample_repo_path: Path):
-        """run_audit_with_langgraph should not fail hard when aget_state raises."""
-
-        class _FakeGraph:
-            async def astream(self, _initial_state: dict[str, Any], _config: dict[str, Any]):
-                yield {
-                    "synthesize": {
-                        "step": "complete",
-                        "synthesis": {"status": "complete", "overall_score": 7.5},
-                    }
-                }
-
-            async def aget_state(self, _config: dict[str, Any]):
-                raise RuntimeError("invalid memory alloc request size 1073741824")
-
-        with patch(
-            "vds_audit_orchestrator.agents.langgraph_workflow.build_audit_graph",
-            new=AsyncMock(return_value=_FakeGraph()),
-        ):
-            result = await run_audit_with_langgraph(
-                repo_path=str(sample_repo_path),
-                thread_id="state-read-failure",
-                checkpointer="postgres",
-            )
-
-        assert result["step"] == "complete"
-        assert result["synthesis"]["status"] == "complete"
-        # postgres_checkpoint_payload_guard skips aget_state entirely for
-        # checkpointer="postgres", so checkpoint_state_error is never set.
-
-    @pytest.mark.asyncio
-    async def test_resume_audit_not_paused_raises_error(self, sample_repo_path: Path):
-        """Test that resuming non-paused workflow raises error."""
-        thread_id = "not-paused-thread"
-
-        graph = await build_audit_graph(checkpointer="memory")
-        config = {"configurable": {"thread_id": thread_id}}
-
-        # Set up state that's NOT paused (no next nodes)
-        completed_state = {
-            "repository": "test-repo",
-            "repo_path": str(sample_repo_path),
-            "project_id": "test-repo",
-            "step": "complete",
-            "profile": {},
-            "evidence": None,
-            "agent_results": [],
-            "synthesis": {"status": "complete"},
-            "errors": [],
-            "human_approved": True,
-            "human_feedback": None,
-        }
-
-        await graph.aupdate_state(config, completed_state)
-
-        with pytest.raises(RuntimeError, match="is not paused"):
-            await resume_audit_with_human_input(
-                thread_id=thread_id,
-                human_approved=True,
-                checkpointer="memory",
-            )