@ngocsangairvds/vsaf 3.2.13 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/tests/test_cli/test_workflow_project_project_scope.py

@@ -1,831 +0,0 @@
-"""Tests for Phase 113 Project-Scope Execution Lane (TSK-113.5, TSK-113.6, TSK-113.8).
-
-Integration tests covering:
-- FR-113.4: Project-scope lane under workflow-project
-- FR-113.5: Project-artifact-grounded row evaluation
-- FR-113.6: Project-level reporting and evidence publication
-- TSK-113.5: Dedicated execution lane for cross_repo_code_required rows
-- TSK-113.6: Project artifact consumption in row evaluation
-- TSK-113.8: Project aggregate/report integration
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from types import SimpleNamespace
-from typing import Any
-
-import pytest
-from vds_audit_orchestrator import cli, workflow_cmds
-from vds_audit_orchestrator.config import reset_config
-from vds_audit_orchestrator.models.readiness import (
-    CrossRepoRowEvidence,
-    ProjectArtifactReference,
-    ProjectScopeExecutionSummary,
-)
-
-# ---------------------------------------------------------------------------
-# Autouse fixtures
-# ---------------------------------------------------------------------------
-
-
-@pytest.fixture(autouse=True)
-def _isolate_cli_runtime(monkeypatch: pytest.MonkeyPatch) -> None:
-    reset_config()
-    cli._cli_state.clear()
-    monkeypatch.setattr(
-        cli,
-        "apply_runtime_profile",
-        lambda *_a, **_k: SimpleNamespace(
-            profile_name="test",
-            source="test",
-            profile_path=Path("/tmp/test-profile.yaml"),
-            applied_env_keys=[],
-        ),
-    )
-    monkeypatch.setattr(cli, "load_shared_env", lambda *_a, **_k: {})
-    monkeypatch.setattr("vds_audit_orchestrator.config.load_shared_env", lambda *_a, **_k: {})
-    monkeypatch.setattr("vds_audit_orchestrator.config.DEFAULT_CONFIG_FILE", Path("/tmp/nonexistent-test.yaml"))
-    monkeypatch.setenv("VDS_AUDIT_BOOTSTRAP_HOME", "false")
-    monkeypatch.setenv("VDS_AUDIT_LANGGRAPH__POSTGRES_DSN", "postgresql://localhost/test")
-    monkeypatch.delenv("VDS_AUDIT_PROFILE", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_ACTIVE_PROFILE", raising=False)
-    yield
-    cli._cli_state.clear()
-    reset_config()
-
-
-# ---------------------------------------------------------------------------
-# Test helpers
-# ---------------------------------------------------------------------------
-
-
-def _make_aggregate_input_with_cross_repo_row(
-    *,
-    repo_name: str = "test-repo",
-    check_id: str = "CL-003",
-    check_title: str = "Circular Dependency Check",
-    execution_scope_class: str = "cross_repo_code_required",
-    status: str = "partial",
-    score: float = 65.0,
-) -> dict[str, Any]:
-    """Build an aggregate input payload with a cross-repo row."""
-    return {
-        "repository": repo_name,
-        "overall_score": 42.0,
-        "rows": [
-            {
-                "check_id": check_id,
-                "check_title": check_title,
-                "description": "Check for circular dependencies between modules",
-                "status": status,
-                "score": score,
-                "retrieval_trace": {
-                    "requirement_analysis": {
-                        "analysis_mode": "code_first",
-                        "execution_scope_class": execution_scope_class,
-                        "project_scope_required": execution_scope_class == "cross_repo_code_required",
-                    }
-                },
-            }
-        ],
-    }
-
-
-def _make_project_artifact(
-    *,
-    artifact_type: str = "dependency_graph",
-    artifact_path: str | None = None,
-) -> dict[str, Any]:
-    """Build a project artifact reference.
-
-    Note: artifact_type uses underscores (e.g., dependency_graph) for consistency.
-    """
-    if artifact_path is None:
-        artifact_path = f"/run/root/project-{artifact_type.replace('_', '-')}.json"
-    return {
-        "artifact_type": artifact_type,
-        "artifact_path": artifact_path,
-        "artifact_url": None,
-        "generated_at": "2026-03-12T10:00:00Z",
-        "provenance": {
-            "thread_id": "test-thread",
-            "project_storage_key": "88730001",
-        },
-        "is_authoritative": True,
-    }
-
-
-# ---------------------------------------------------------------------------
-# Tests: _detect_cross_repo_rows_from_aggregates (TSK-113.5)
-# ---------------------------------------------------------------------------
-
-
-def test_detect_cross_repo_rows_from_aggregates_identifies_cross_repo_rows() -> None:
-    """TSK-113.5: Correctly identify cross_repo_code_required rows from aggregates."""
-    aggregate_inputs = [
-        _make_aggregate_input_with_cross_repo_row(
-            repo_name="service-a",
-            check_id="CL-003",
-            execution_scope_class="cross_repo_code_required",
-        ),
-        _make_aggregate_input_with_cross_repo_row(
-            repo_name="service-b",
-            check_id="CL-003",
-            execution_scope_class="cross_repo_code_required",
-        ),
-        _make_aggregate_input_with_cross_repo_row(
-            repo_name="common-lib",
-            check_id="CL-001",
-            execution_scope_class="repo_local",
-        ),
-    ]
-
-    cross_repo_rows = workflow_cmds._detect_cross_repo_rows_from_aggregates(aggregate_inputs)
-
-    assert len(cross_repo_rows) == 1
-    assert cross_repo_rows[0]["check_id"] == "CL-003"
-    assert cross_repo_rows[0]["check_title"] == "Circular Dependency Check"
-    assert cross_repo_rows[0]["repo_count"] == 2
-    assert len(cross_repo_rows[0]["repos_with_status"]) == 2
-    assert cross_repo_rows[0]["repos_with_status"][0]["repo"] in {"service-a", "service-b"}
-
-
-def test_detect_cross_repo_rows_from_aggregates_empty_when_no_cross_repo() -> None:
-    """TSK-113.5: Return empty list when no project-scope rows exist."""
-    aggregate_inputs = [
-        _make_aggregate_input_with_cross_repo_row(
-            repo_name="service-a",
-            check_id="CL-001",
-            execution_scope_class="repo_local",
-        ),
-        _make_aggregate_input_with_cross_repo_row(
-            repo_name="service-b",
-            check_id="CL-002",
-            execution_scope_class="project_doc_authoritative",
-        ),
-    ]
-    for item in aggregate_inputs:
-        item["rows"][0]["retrieval_trace"]["requirement_analysis"]["project_scope_required"] = False
-
-    cross_repo_rows = workflow_cmds._detect_cross_repo_rows_from_aggregates(aggregate_inputs)
-
-    assert len(cross_repo_rows) == 0
-
-
-def test_detect_cross_repo_rows_from_aggregates_promotes_project_scope_required_rows() -> None:
-    aggregate_inputs = [
-        _make_aggregate_input_with_cross_repo_row(
-            repo_name="service-a",
-            check_id="CL-004",
-            check_title="Circular Dependency Check",
-            execution_scope_class="repo_local",
-            status="partial",
-            score=60.0,
-        )
-    ]
-    aggregate_inputs[0]["rows"][0]["retrieval_trace"]["requirement_analysis"]["project_scope_required"] = True
-
-    cross_repo_rows = workflow_cmds._detect_cross_repo_rows_from_aggregates(aggregate_inputs)
-
-    assert len(cross_repo_rows) == 1
-    assert cross_repo_rows[0]["check_id"] == "CL-004"
-    assert cross_repo_rows[0]["repo_count"] == 1
-    assert cross_repo_rows[0]["requirement_analysis"]["project_scope_required"] is True
-
-
-def test_detect_cross_repo_rows_from_aggregates_handles_missing_retrieval_trace() -> None:
-    """TSK-113.5: Gracefully handle rows without retrieval_trace."""
-    aggregate_inputs = [
-        {
-            "repository": "test-repo",
-            "overall_score": 50.0,
-            "rows": [
-                {
-                    "check_id": "CL-001",
-                    "check_title": "Basic Check",
-                    "status": "pass",
-                    "score": 100.0,
-                }
-            ],
-        }
-    ]
-
-    cross_repo_rows = workflow_cmds._detect_cross_repo_rows_from_aggregates(aggregate_inputs)
-
-    assert len(cross_repo_rows) == 0
-
-
-# ---------------------------------------------------------------------------
-# Tests: _load_project_scope_artifacts (TSK-113.5)
-# ---------------------------------------------------------------------------
-
-
-def test_load_project_scope_artifacts_loads_existing_artifacts(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    """TSK-113.5: Load existing project topology, dependency graph, and cycle report artifacts."""
-    # Create artifact files
-    topology_artifact = {
-        "generated_at": "2026-03-12T10:00:00Z",
-        "timestamp": "2026-03-12T10:00:00Z",
-        "provenance": {"thread_id": "test-thread"},
-        "repos": ["service-a", "service-b"],
-    }
-    (tmp_path / "project-topology.json").write_text(json.dumps(topology_artifact))
-
-    dependency_graph = {
-        "generated_at": "2026-03-12T10:00:00Z",
-        "timestamp": "2026-03-12T10:00:00Z",
-        "nodes": ["service-a", "service-b"],
-        "edges": [],
-    }
-    (tmp_path / "project-dependency-graph.json").write_text(json.dumps(dependency_graph))
-
-    cycle_report = {
-        "generated_at": "2026-03-12T10:00:00Z",
-        "timestamp": "2026-03-12T10:00:00Z",
-        "cycles": [],
-    }
-    (tmp_path / "project-cycle-report.json").write_text(json.dumps(cycle_report))
-
-    artifacts = workflow_cmds._load_project_scope_artifacts(
-        run_root=tmp_path,
-        project_storage_key="88730001",
-    )
-
-    # Artifacts are keyed by artifact_type (topology, dependency_graph, cycle_report)
-    assert artifacts["topology"] is not None
-    assert artifacts["topology"]["artifact_type"] == "topology"
-    assert artifacts["dependency_graph"] is not None
-    assert artifacts["dependency_graph"]["artifact_type"] == "dependency_graph"
-    assert artifacts["cycle_report"] is not None
-    assert artifacts["cycle_report"]["artifact_type"] == "cycle_report"
-    assert len(artifacts["all_artifacts"]) == 3
-
-
-def test_load_project_scope_artifacts_returns_empty_when_missing(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """TSK-113.5: Return empty artifact dict when no artifacts exist."""
-    artifacts = workflow_cmds._load_project_scope_artifacts(
-        run_root=tmp_path,
-        project_storage_key="88730001",
-    )
-
-    assert artifacts["project_topology"] is None
-    assert artifacts["dependency_graph"] is None
-    assert artifacts["cycle_report"] is None
-    assert len(artifacts["all_artifacts"]) == 0
-
-
-# ---------------------------------------------------------------------------
-# Tests: _execute_project_scope_lane (TSK-113.5, TSK-113.6)
-# ---------------------------------------------------------------------------
-
-
-def test_execute_project_scope_lane_with_existing_artifacts(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    """TSK-113.5/113.6: Execute project-scope lane with existing authoritative artifacts."""
-    cross_repo_rows = [
-        {
-            "check_id": "CL-003",
-            "check_title": "Circular Dependency Check",
-            "repo_count": 2,
-            "repos_with_status": [
-                {"repo": "service-a", "status": "partial", "score": 65.0},
-                {"repo": "service-b", "status": "partial", "score": 65.0},
-            ],
-            "requirement_analysis": {
-                "execution_scope_class": "cross_repo_code_required",
-                "project_scope_required": True,
-            },
-        }
-    ]
-
-    topology_path = tmp_path / "project-topology.json"
-    dependency_graph_path = tmp_path / "project-dependency-graph.json"
-    cycle_report_path = tmp_path / "project-cycle-report.json"
-    for artifact_path in (topology_path, dependency_graph_path, cycle_report_path):
-        artifact_path.write_text("{}", encoding="utf-8")
-
-    existing_artifacts = {
-        "project_topology": _make_project_artifact(artifact_type="topology", artifact_path=str(topology_path)),
-        "dependency_graph": _make_project_artifact(
-            artifact_type="dependency_graph", artifact_path=str(dependency_graph_path)
-        ),
-        "cycle_report": _make_project_artifact(artifact_type="cycle_report", artifact_path=str(cycle_report_path)),
-        "all_artifacts": [
-            _make_project_artifact(artifact_type="topology", artifact_path=str(topology_path)),
-            _make_project_artifact(artifact_type="dependency_graph", artifact_path=str(dependency_graph_path)),
-            _make_project_artifact(artifact_type="cycle_report", artifact_path=str(cycle_report_path)),
-        ],
-    }
-
-    def _fake_load_json_object(path: Path) -> dict[str, Any]:
-        if path.name == "project-dependency-graph.json":
-            return {
-                "generated_at": "2026-03-12T10:00:00Z",
-                "nodes": {"service-a": {}, "service-b": {}},
-                "edges": [{"source_repo": "service-a", "target_repo": "service-b"}],
-            }
-        return {"generated_at": "2026-03-12T10:00:00Z"}
-
-    monkeypatch.setattr(workflow_cmds, "_load_json_object", _fake_load_json_object)
-
-    summary = workflow_cmds._execute_project_scope_lane(
-        state_dsn="postgresql://localhost/test",
-        project_storage_key="88730001",
-        repos=[("service-a", Path("/repos/service-a")), ("service-b", Path("/repos/service-b"))],
-        run_root=tmp_path,
-        thread_id="test-thread",
-        cross_repo_rows=cross_repo_rows,
-        existing_artifacts=existing_artifacts,
-    )
-
-    assert summary["execution_lane_active"] is True
-    assert summary["cross_repo_rows_evaluated"] == 1
-    assert summary["cross_repo_rows_authoritatively_closed"] == 1
-    assert len(summary["generated_artifacts"]) == 3
-    assert len(summary["cross_repo_evidence"]) == 1
-    assert summary["cross_repo_evidence"][0]["check_id"] == "CL-003"
-    assert summary["cross_repo_evidence"][0]["status"] == "evaluated"
-    # Check for closure notes about evaluation (word "authoritative" may be present)
-    assert "project" in summary["cross_repo_evidence"][0]["closure_notes"].lower()
-
-
-def test_execute_project_scope_lane_with_empty_artifacts_stays_preliminary(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    cross_repo_rows = [
-        {
-            "check_id": "CL-004",
-            "check_title": "Dependency Graph Check",
-            "repo_count": 2,
-            "repos_with_status": [],
-            "requirement_analysis": {
-                "execution_scope_class": "cross_repo_code_required",
-                "project_scope_required": True,
-            },
-        }
-    ]
-
-    existing_artifacts = {
-        "dependency_graph": _make_project_artifact(artifact_type="dependency_graph"),
-        "all_artifacts": [_make_project_artifact(artifact_type="dependency_graph")],
-    }
-
-    monkeypatch.setattr(
-        workflow_cmds,
-        "_load_json_object",
-        lambda _p: {"generated_at": "2026-03-12T10:00:00Z", "nodes": {}, "edges": []},
-    )
-
-    summary = workflow_cmds._execute_project_scope_lane(
-        state_dsn="postgresql://localhost/test",
-        project_storage_key="88730001",
-        repos=[("service-a", Path("/repos/service-a"))],
-        run_root=tmp_path,
-        thread_id="test-thread",
-        cross_repo_rows=cross_repo_rows,
-        existing_artifacts=existing_artifacts,
-    )
-
-    assert summary["cross_repo_rows_authoritatively_closed"] == 0
-    assert summary["cross_repo_evidence"][0]["status"] == "preliminary"
-    assert "empty" in summary["cross_repo_evidence"][0]["closure_notes"].lower()
-
-
-def test_execute_project_scope_lane_without_artifacts_is_preliminary(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """TSK-113.5/113.6: Results are preliminary when project artifacts don't exist."""
-    cross_repo_rows = [
-        {
-            "check_id": "CL-003",
-            "check_title": "Circular Dependency Check",
-            "repo_count": 2,
-            "repos_with_status": [],
-            "requirement_analysis": {
-                "execution_scope_class": "cross_repo_code_required",
-                "project_scope_required": True,
-            },
-        }
-    ]
-
-    existing_artifacts = {"all_artifacts": []}
-
-    summary = workflow_cmds._execute_project_scope_lane(
-        state_dsn="postgresql://localhost/test",
-        project_storage_key="88730001",
-        repos=[("service-a", Path("/repos/service-a"))],
-        run_root=tmp_path,
-        thread_id="test-thread",
-        cross_repo_rows=cross_repo_rows,
-        existing_artifacts=existing_artifacts,
-    )
-
-    assert summary["execution_lane_active"] is True
-    assert summary["cross_repo_rows_evaluated"] == 1
-    assert summary["cross_repo_rows_authoritatively_closed"] == 0
-    assert len(summary["preliminary_repo_local_warnings"]) > 0
-    assert "preliminary" in summary["cross_repo_evidence"][0]["status"]
-    assert "preliminary" in summary["cross_repo_evidence"][0]["closure_notes"].lower()
-
-
-def test_execute_project_scope_lane_ignores_empty_hydrated_artifacts(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    cross_repo_rows = [
-        {
-            "check_id": "CL-004",
-            "check_title": "Dependency Graph Check",
-            "repo_count": 2,
-            "repos_with_status": [],
-            "requirement_analysis": {
-                "execution_scope_class": "cross_repo_code_required",
-                "project_scope_required": True,
-            },
-        }
-    ]
-    existing_artifacts = {"all_artifacts": []}
-
-    class _HydratingKnowledgeStore:
-        def __init__(self, *, state_store: object) -> None:
-            self.state_store = state_store
-
-        def hydrate_topology_artifacts(self, *, project_key: str, output_dir: Path) -> dict[str, dict[str, Any]]:
-            (output_dir / "project-topology.json").write_text(json.dumps({"repos": []}), encoding="utf-8")
-            (output_dir / "project-dependency-graph.json").write_text(
-                json.dumps({"nodes": {}, "edges": []}), encoding="utf-8"
-            )
-            (output_dir / "project-cycle-report.json").write_text(
-                json.dumps({"total_edges_analyzed": 0, "circular_cycles": []}), encoding="utf-8"
-            )
-            return {
-                "topology": {"knowledge_entry_id": "know-topology", "source_run_id": "prior-run"},
-                "dependency_graph": {"knowledge_entry_id": "know-graph", "source_run_id": "prior-run"},
-                "cycle_report": {"knowledge_entry_id": "know-cycle", "source_run_id": "prior-run"},
-            }
-
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.engine.project_knowledge_store.ProjectKnowledgeStore",
-        _HydratingKnowledgeStore,
-    )
-
-    class _FailingStore:
-        def __init__(self, dsn: str) -> None:
-            raise RuntimeError("db unavailable")
-
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.state.store.PostgresStateStore",
-        _FailingStore,
-    )
-    monkeypatch.setattr(
-        workflow_cmds, "_load_json_object", lambda path: json.loads(Path(path).read_text(encoding="utf-8"))
-    )
-
-    summary = workflow_cmds._execute_project_scope_lane(
-        state_dsn="postgresql://localhost/test",
-        project_storage_key="88730001",
-        repos=[("service-a", Path("/repos/service-a"))],
-        run_root=tmp_path,
-        thread_id="test-thread",
-        cross_repo_rows=cross_repo_rows,
-        existing_artifacts=existing_artifacts,
-    )
-
-    assert summary["cross_repo_rows_authoritatively_closed"] == 0
-    assert summary["cross_repo_evidence"][0]["status"] == "preliminary"
-
-
-def test_execute_project_scope_lane_hydrates_artifacts_from_knowledge_store(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """Phase 124: hydrate authoritative artifacts from project knowledge store before regeneration."""
-    cross_repo_rows = [
-        {
-            "check_id": "CL-004",
-            "check_title": "Dependency Graph Check",
-            "repo_count": 2,
-            "repos_with_status": [],
-            "requirement_analysis": {
-                "execution_scope_class": "cross_repo_code_required",
-                "project_scope_required": True,
-            },
-        }
-    ]
-    existing_artifacts = {"all_artifacts": []}
-
-    class _HydratingKnowledgeStore:
-        def __init__(self, *, state_store: object) -> None:
-            self.state_store = state_store
-
-        def hydrate_topology_artifacts(self, *, project_key: str, output_dir: Path) -> dict[str, dict[str, Any]]:
-            assert project_key == "88730001"
-            (output_dir / "project-topology.json").write_text(
-                json.dumps(
-                    {
-                        "generated_at": "2026-03-12T10:00:00Z",
-                        "provenance": {"source": "knowledge-store"},
-                        "repos": ["service-a", "service-b"],
-                    }
-                ),
-                encoding="utf-8",
-            )
-            (output_dir / "project-dependency-graph.json").write_text(
-                json.dumps(
-                    {
-                        "generated_at": "2026-03-12T10:00:00Z",
-                        "provenance": {"source_run_id": "prior-run"},
-                        "nodes": {"service-a": {}, "service-b": {}},
-                        "edges": [{"source_repo": "service-a", "target_repo": "service-b"}],
-                    }
-                ),
-                encoding="utf-8",
-            )
-            return {
-                "topology": {"knowledge_entry_id": "know-topology", "source_run_id": "prior-run"},
-                "dependency_graph": {"knowledge_entry_id": "know-graph", "source_run_id": "prior-run"},
-            }
-
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.engine.project_knowledge_store.ProjectKnowledgeStore",
-        _HydratingKnowledgeStore,
-    )
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.state.store.PostgresStateStore",
-        lambda dsn: SimpleNamespace(dsn=dsn),
-    )
-
-    summary = workflow_cmds._execute_project_scope_lane(
-        state_dsn="postgresql://localhost/test",
-        project_storage_key="88730001",
-        repos=[("service-a", Path("/repos/service-a"))],
-        run_root=tmp_path,
-        thread_id="test-thread",
-        cross_repo_rows=cross_repo_rows,
-        existing_artifacts=existing_artifacts,
-    )
-
-    assert summary["cross_repo_rows_authoritatively_closed"] == 1
-    assert summary["artifact_readiness"]["artifact_source"] == "knowledge_store"
-    assert summary["artifact_readiness"]["readiness_status"] == "ready"
-    assert sorted(summary["artifact_readiness"]["hydrated_artifact_types"]) == ["dependency_graph", "topology"]
-    assert summary["cross_repo_evidence"][0]["status"] == "evaluated"
-    assert existing_artifacts["dependency_graph"]["provenance"]["node_count"] == 2
-    assert summary["project_storage_key"] == "88730001"
-
-
-# ---------------------------------------------------------------------------
-# Tests: _augment_project_readiness_with_scope_execution (TSK-113.8)
-# ---------------------------------------------------------------------------
-
-
-def test_augment_project_readiness_with_scope_execution_adds_phase_113_fields() -> None:
-    """TSK-113.8: Extend base readiness report with Phase 113 artifact and evidence fields."""
-    base_report = {
-        "project_name": "Test Project",
-        "assessment_date": "2026-03-12",
-        "executive_summary": {
-            "readiness_score_pct": 65.0,
-            "classification": "in_progress",
-            "confidence": "MEDIUM",
-            "confidence_pct": 70.0,
-            "general_assessment": "Test assessment",
-        },
-        "repo_readiness": [],
-        "synthesis_status": "complete",
-    }
-
-    scope_execution_summary = {
-        "execution_lane_active": True,
-        "cross_repo_rows_evaluated": 2,
-        "cross_repo_rows_authoritatively_closed": 1,
-        "generated_artifacts": [],
-        "artifact_readiness": {
-            "readiness_status": "ready",
-            "artifact_source": "knowledge_store",
-        },
-        "artifact_provenance_summary": [{"artifact_type": "dependency_graph", "artifact_source": "knowledge_store"}],
-        "cross_repo_evidence": [
-            {
-                "check_id": "CL-003",
-                "check_title": "Circular Dependency",
-                "status": "evaluated",
-                "authoritative_artifacts": [],
-                "closure_notes": "Evaluated against project graph",
-                "cross_repo_findings": [],
-            }
-        ],
-        "preliminary_repo_local_warnings": [],
-    }
-
-    project_artifacts = {
-        "all_artifacts": [
-            _make_project_artifact(artifact_type="topology"),
-            _make_project_artifact(artifact_type="dependency_graph"),
-        ],
-    }
-
-    extended = workflow_cmds._augment_project_readiness_with_scope_execution(
-        base_report=base_report,
-        scope_execution_summary=scope_execution_summary,
-        project_artifacts=project_artifacts,
-    )
-
-    # Base fields preserved
-    assert extended["project_name"] == "Test Project"
-    assert extended["executive_summary"]["readiness_score_pct"] == 65.0
-
-    # Phase 113 fields added
-    # Models are returned as Pydantic models, convert to dict for assertion
-    topo = extended["project_topology_artifact"]
-    assert topo is not None
-    assert topo.artifact_type == "topology"
-
-    dep = extended["dependency_graph_artifact"]
-    assert dep is not None
-    assert dep.artifact_type == "dependency_graph"
-
-    assert extended["cycle_report_artifact"] is None
-
-    assert extended["project_scope_execution"]["execution_lane_active"] is True
-    assert extended["project_scope_execution"]["cross_repo_rows_evaluated"] == 2
-    assert extended["project_artifact_readiness"]["artifact_source"] == "knowledge_store"
-    assert extended["project_artifact_provenance_summary"][0]["artifact_type"] == "dependency_graph"
-
-    assert len(extended["cross_repo_evidence"]) == 1
-    assert extended["cross_repo_evidence"][0]["check_id"] == "CL-003"
-
-
-def test_augment_project_readiness_with_scope_execution_empty_artifacts() -> None:
-    """TSK-113.8: Handle empty artifacts gracefully."""
-    base_report = {
-        "project_name": "Test Project",
-        "executive_summary": {
-            "readiness_score_pct": 50.0,
-            "classification": "not_ready",
-            "confidence": "LOW",
-            "confidence_pct": 50.0,
-            "general_assessment": "Test",
-        },
-        "repo_readiness": [],
-        "synthesis_status": "partial",
-    }
-
-    scope_execution_summary = {
-        "execution_lane_active": False,
-        "cross_repo_rows_evaluated": 0,
-        "cross_repo_rows_authoritatively_closed": 0,
-        "generated_artifacts": [],
-        "cross_repo_evidence": [],
-        "preliminary_repo_local_warnings": ["No artifacts available"],
-    }
-
-    project_artifacts = {"all_artifacts": []}
-
-    extended = workflow_cmds._augment_project_readiness_with_scope_execution(
-        base_report=base_report,
-        scope_execution_summary=scope_execution_summary,
-        project_artifacts=project_artifacts,
-    )
-
-    assert extended["project_topology_artifact"] is None
-    assert extended["dependency_graph_artifact"] is None
-    assert extended["cycle_report_artifact"] is None
-    assert extended["other_artifacts"] == []
-    assert extended["project_scope_execution"]["execution_lane_active"] is False
-    assert extended["evidence_classification_notes"] == ["No artifacts available"]
-
-
-# ---------------------------------------------------------------------------
-# Tests: Model validation (FR-113.6, TSK-113.8)
-# ---------------------------------------------------------------------------
-
-
-def test_project_artifact_reference_model() -> None:
-    """FR-113.6: ProjectArtifactReference model validates correctly."""
-    artifact = ProjectArtifactReference(
-        artifact_type="dependency_graph",
-        artifact_path="/run/root/project-dependency-graph.json",
-        artifact_url="https://confluence.example/pages/123",
-        generated_at="2026-03-12T10:00:00Z",
-        provenance={"thread_id": "test-thread", "project_storage_key": "88730001"},
-        is_authoritative=True,
-    )
-
-    assert artifact.artifact_type == "dependency_graph"
-    assert artifact.is_authoritative is True
-
-    dump = artifact.model_dump(mode="json")
-    assert dump["artifact_type"] == "dependency_graph"
-    assert dump["is_authoritative"] is True
-
-
-def test_cross_repo_row_evidence_model() -> None:
-    """FR-113.6: CrossRepoRowEvidence model validates correctly."""
-    evidence = CrossRepoRowEvidence(
-        check_id="CL-003",
-        check_title="Circular Dependency Check",
-        status="pass",
-        repo_local_status="partial",
-        authoritative_artifacts=[
-            ProjectArtifactReference(
-                artifact_type="cycle_report",
-                artifact_path="/run/root/project-cycle-report.json",
-                generated_at="2026-03-12T10:00:00Z",
-                provenance={},
-            )
-        ],
-        closure_notes="No cycles found in project dependency graph",
-        cross_repo_findings=["No circular dependencies detected"],
-    )
-
-    assert evidence.check_id == "CL-003"
-    assert evidence.status == "pass"
-    assert len(evidence.authoritative_artifacts) == 1
-    assert evidence.authoritative_artifacts[0].artifact_type == "cycle_report"
-
-
-def test_project_scope_execution_summary_model() -> None:
-    """FR-113.6: ProjectScopeExecutionSummary model validates correctly."""
-    summary = ProjectScopeExecutionSummary(
-        execution_lane_active=True,
-        cross_repo_rows_evaluated=5,
-        cross_repo_rows_authoritatively_closed=4,
-        generated_artifacts=[
-            ProjectArtifactReference(
-                artifact_type="topology",
-                artifact_path="/run/root/project-topology.json",
-                generated_at="2026-03-12T10:00:00Z",
-                provenance={},
-            )
-        ],
-        cross_repo_evidence=[
-            CrossRepoRowEvidence(
-                check_id="CL-003",
-                check_title="Check",
-                status="pass",
-                authoritative_artifacts=[],
-                closure_notes="",
-            )
-        ],
-        preliminary_repo_local_warnings=["1 row pending artifact generation"],
-    )
-
-    assert summary.execution_lane_active is True
-    assert summary.cross_repo_rows_evaluated == 5
-    assert summary.cross_repo_rows_authoritatively_closed == 4
-    assert len(summary.generated_artifacts) == 1
-    assert len(summary.cross_repo_evidence) == 1
-    assert len(summary.preliminary_repo_local_warnings) == 1
-
-
-# ---------------------------------------------------------------------------
-# Tests: Integration with project_topology.py (TSK-113.2/113.3/113.4)
-# ---------------------------------------------------------------------------
-
-
-def test_execute_project_scope_lane_handles_generation_failure_gracefully(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """TSK-113.5: Handle artifact generation failures without crashing."""
-    from vds_audit_orchestrator.engine import project_topology
-
-    cross_repo_rows = [
-        {
-            "check_id": "CL-003",
-            "check_title": "Circular Dependency Check",
-            "repo_count": 2,
-            "repos_with_status": [],
-            "requirement_analysis": {
-                "execution_scope_class": "cross_repo_code_required",
-                "project_scope_required": True,
-            },
-        }
-    ]
-
-    existing_artifacts = {"all_artifacts": []}
-
-    # Mock build_project_topology_artifacts to raise an exception
-    def mock_build_fails(**kwargs):
-        raise ValueError("Simulated artifact generation failure")
-
-    monkeypatch.setattr(project_topology, "build_project_topology_artifacts", mock_build_fails)
-
-    summary = workflow_cmds._execute_project_scope_lane(
-        state_dsn="postgresql://localhost/test",
-        project_storage_key="88730001",
-        repos=[],
-        run_root=tmp_path,
-        thread_id="test-thread",
-        cross_repo_rows=cross_repo_rows,
-        existing_artifacts=existing_artifacts,
-    )
-
-    # Execution should continue with preliminary results
-    assert summary["execution_lane_active"] is True
-    assert summary["cross_repo_rows_evaluated"] == 1
-    assert summary["cross_repo_rows_authoritatively_closed"] == 0
-    assert len(summary["generated_artifacts"]) == 0
-    assert len(summary["preliminary_repo_local_warnings"]) > 0
-    assert "failed" in summary["preliminary_repo_local_warnings"][0].lower()