@ngocsangairvds/vsaf 3.2.13 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/tests/unit/state/test_state_run_api.py

@@ -1,2226 +0,0 @@
-from __future__ import annotations
-
-from datetime import UTC, datetime
-from typing import Any
-
-import pytest
-from vds_audit_orchestrator import state
-
-
-class _WarningCaptureLogger:
-    def __init__(self) -> None:
-        self.events: list[dict[str, Any]] = []
-
-    def warning(self, event: str, **kwargs: Any) -> None:
-        self.events.append({"event": event, **kwargs})
-
-    def info(self, event: str, **kwargs: Any) -> None:
-        self.events.append({"event": event, **kwargs})
-
-    def debug(self, event: str, **kwargs: Any) -> None:
-        self.events.append({"event": event, **kwargs})
-
-
-class _FakeRunApiStore:
-    def __init__(self, _dsn: str) -> None:
-        self.closed = False
-        self.append_calls: list[dict[str, Any]] = []
-
-    def append_run_event(
-        self,
-        *,
-        run_id: str,
-        event_type: str,
-        status: str = "info",
-        payload: dict[str, Any] | None = None,
-        created_at: datetime | None = None,
-    ) -> dict[str, Any]:
-        self.append_calls.append(
-            {
-                "run_id": run_id,
-                "event_type": event_type,
-                "status": status,
-                "payload": payload or {},
-                "created_at": created_at,
-            }
-        )
-        return {
-            "id": 1,
-            "run_pk": 10,
-            "event_type": event_type,
-            "status": status,
-            "payload": payload or {},
-            "created_at": created_at or datetime.now(UTC),
-        }
-
-    def list_runs(
-        self,
-        *,
-        project_key: str | None = None,
-        repo_key: str | None = None,
-        run_type: str | None = None,
-        status: str | None = None,
-        limit: int | None = None,
-    ) -> list[dict[str, Any]]:
-        return [
-            {
-                "id": 7,
-                "run_id": "thread-42",
-                "project_key": project_key or "insurance",
-                "repo_key": repo_key,
-                "run_type": run_type or "workflow",
-                "status": status or "running",
-                "payload": {},
-                "started_at": datetime.now(UTC),
-                "finished_at": None,
-                "state_version": 1,
-                "created_at": datetime.now(UTC),
-                "updated_at": datetime.now(UTC),
-            }
-        ]
-
-    def show_run(self, *, run_id: str) -> dict[str, Any]:
-        return {
-            "id": 7,
-            "run_id": run_id,
-            "project_key": "insurance",
-            "repo_key": "insurance:svc-a",
-            "run_type": "workflow",
-            "status": "running",
-            "payload": {},
-            "started_at": datetime.now(UTC),
-            "finished_at": None,
-            "state_version": 1,
-            "created_at": datetime.now(UTC),
-            "updated_at": datetime.now(UTC),
-        }
-
-    def list_run_events(self, *, run_id: str, limit: int | None = None) -> list[dict[str, Any]]:
-        return [
-            {
-                "id": 21,
-                "run_pk": 7,
-                "event_type": "run_started",
-                "status": "info",
-                "payload": {"run_id": run_id, "limit": limit},
-                "created_at": datetime.now(UTC),
-            }
-        ]
-
-    def upsert_evidence_snapshot(
-        self,
-        *,
-        snapshot_key: str,
-        project_key: str,
-        repo_key: str | None = None,
-        content_hash: str,
-        payload: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        return {
-            "id": 88,
-            "snapshot_key": snapshot_key,
-            "project_key": project_key,
-            "repo_key": repo_key,
-            "content_hash": content_hash,
-            "payload": payload or {},
-            "reuse_count": 0,
-            "first_seen_at": datetime.now(UTC),
-            "last_reused_at": None,
-            "created_at": datetime.now(UTC),
-            "updated_at": datetime.now(UTC),
-        }
-
-    def list_evidence_snapshots(self, *, project_key: str, limit: int | None = None) -> list[dict[str, Any]]:
-        return [
-            {
-                "id": 88,
-                "snapshot_key": "insurance:svc-a:sha256-1",
-                "project_key": project_key,
-                "repo_key": "insurance:svc-a",
-                "content_hash": "sha256-1",
-                "payload": {"limit": limit},
-                "reuse_count": 1,
-                "first_seen_at": datetime.now(UTC),
-                "last_reused_at": datetime.now(UTC),
-                "created_at": datetime.now(UTC),
-                "updated_at": datetime.now(UTC),
-            }
-        ]
-
-    def compact_run_events(self, *, retention_days: int, dry_run: bool = True) -> dict[str, Any]:
-        return {
-            "retention_days": retention_days,
-            "dry_run": dry_run,
-            "candidate_count": 3,
-            "deleted_count": 0 if dry_run else 3,
-        }
-
-    def close(self) -> None:
-        self.closed = True
-
-
-@pytest.fixture(autouse=True)
-def _stub_project_document_count(monkeypatch) -> None:
-    class _FailingStateStore:
-        def __init__(self, _dsn: str) -> None:
-            raise ConnectionError("state unavailable in unit test")
-
-    monkeypatch.setattr(state, "PostgresStateStore", _FailingStateStore)
-    monkeypatch.setattr(state, "_resolve_project_document_count", lambda **_kwargs: None)
-
-
-def test_append_run_event_rejects_invalid_event_type_public_api(monkeypatch) -> None:
-    store = _FakeRunApiStore("postgresql://state")
-    monkeypatch.setattr(state, "PostgresStateStore", lambda _dsn: store)
-
-    try:
-        state.append_run_event(
-            state_dsn="postgresql://state",
-            run_id="thread-42",
-            event_type="phase.started",
-            payload={"phase": 42},
-        )
-        raise AssertionError("Expected ValueError for unsupported event_type")
-    except ValueError as exc:
-        assert "Invalid event_type 'phase.started'" in str(exc)
-
-    assert store.append_calls == []
-
-
-def test_append_run_event_accepts_allowed_event_type_public_api(monkeypatch) -> None:
-    store = _FakeRunApiStore("postgresql://state")
-    monkeypatch.setattr(state, "PostgresStateStore", lambda _dsn: store)
-
-    event = state.append_run_event(
-        state_dsn="postgresql://state",
-        run_id="thread-42",
-        event_type="run_started",
-        payload={"phase": 42},
-    )
-
-    assert event["event_type"] == "run_started"
-    assert store.append_calls[0]["event_type"] == "run_started"
-
-
-def test_list_runs_and_show_run_include_events(monkeypatch) -> None:
-    store = _FakeRunApiStore("postgresql://state")
-    monkeypatch.setattr(state, "PostgresStateStore", lambda _dsn: store)
-
-    runs = state.list_runs(
-        state_dsn="postgresql://state",
-        project_key="insurance",
-        status="running",
-        limit=5,
-    )
-    shown = state.show_run(
-        state_dsn="postgresql://state",
-        run_id="thread-42",
-        include_events=True,
-        events_limit=3,
-    )
-
-    assert runs[0]["project_key"] == "insurance"
-    assert shown is not None
-    assert shown["run"]["run_id"] == "thread-42"
-    assert shown["events"][0]["event_type"] == "run_started"
-
-
-def test_upsert_and_list_evidence_snapshots_public_api(monkeypatch) -> None:
-    store = _FakeRunApiStore("postgresql://state")
-    monkeypatch.setattr(state, "PostgresStateStore", lambda _dsn: store)
-
-    row = state.upsert_evidence_snapshot(
-        state_dsn="postgresql://state",
-        snapshot_key="insurance:svc-a:sha256-1",
-        project_key="insurance",
-        repo_key="insurance:svc-a",
-        content_hash="sha256-1",
-        payload={"evidence_dir": "/tmp/evidence"},
-    )
-    rows = state.list_evidence_snapshots(
-        state_dsn="postgresql://state",
-        project_key="insurance",
-        limit=2,
-    )
-
-    assert row["snapshot_key"] == "insurance:svc-a:sha256-1"
-    assert rows[0]["project_key"] == "insurance"
-    assert rows[0]["payload"]["limit"] == 2
-
-
-def test_compact_public_api(monkeypatch) -> None:
-    store = _FakeRunApiStore("postgresql://state")
-    monkeypatch.setattr(state, "PostgresStateStore", lambda _dsn: store)
-
-    preview = state.compact(state_dsn="postgresql://state", retention_days=30, dry_run=True)
-    applied = state.compact(state_dsn="postgresql://state", retention_days=30, dry_run=False)
-
-    assert preview["candidate_count"] == 3
-    assert preview["deleted_count"] == 0
-    assert applied["deleted_count"] == 3
-
-
-def test_readiness_requires_confluence_sync_artifacts(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "checklist_profiles": [
-                        {
-                            "profile_id": "default",
-                            "display_name": "Default Checklist",
-                            "page_ids": ["88722450"],
-                            "priority": 0,
-                        }
-                    ],
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "repo_url": "https://bitbucket.example.com/projects/INS/repos/repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(
-        state,
-        "list_retrieval_snapshots",
-        lambda **kwargs: (
-            [
-                {
-                    "snapshot_key": "insurance-core:project_corpus",
-                    "payload": {
-                        "diagnostics": {
-                            "docs_chunk_ready": True,
-                            "code_chunk_ready": True,
-                            "docs_chunk_count": 7,
-                            "code_chunk_count": 5,
-                        }
-                    },
-                }
-            ]
-            if not kwargs.get("repo_key")
-            else [
-                {
-                    "snapshot_key": "insurance-core:repo-ready:project_corpus",
-                    "payload": {
-                        "diagnostics": {
-                            "docs_chunk_ready": True,
-                            "code_chunk_ready": True,
-                            "docs_chunk_count": 7,
-                            "code_chunk_count": 3,
-                        }
-                    },
-                }
-            ]
-        ),
-    )
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    assert result["summary"]["ready"] is True
-    assert result["ready"] is True
-    assert result["docs_chunk_ready"] is True
-    assert result["code_chunk_ready"] is True
-    assert result["summary"]["docs_chunk_ready"] is True
-    assert result["summary"]["code_chunk_ready"] is True
-    assert result["project"]["checks"]["has_confluence_sync_artifacts"] is True
-    assert result["project"]["checks"]["has_ready_repo_entries"] is True
-    assert result["repo"]["ready"] is True
-    assert result["hierarchy_ready"] is True
-    assert result["department_count"] == 0
-    assert result["project_count"] == 1
-    assert result["bitbucket_project_count"] == 1
-    assert result["repo_count"] == 1
-    assert result["summary"]["hierarchy_ready"] is True
-    assert result["hierarchy"]["anomaly_count"] == 0
-    assert result["hierarchy"]["anomalies"]["repos_missing_bitbucket_project_key"]["count"] == 0
-    assert len(result["hierarchy"]["anomalies"]["repos_missing_bitbucket_project_key"]["samples"]) == 0
-    checklist_diag = result["checklist_profile_diagnostics"]
-    assert checklist_diag["profiles_total"] == 1
-    assert checklist_diag["profiles_ready"] == 1
-    assert checklist_diag["selected_profile"] == "default"
-    assert checklist_diag["selected_profile_details"]["profile_id"] == "default"
-    assert checklist_diag["selected_profile_details"]["page_ids"] == ["88722450"]
-    assert checklist_diag["selected_page_count"] == 1
-    assert checklist_diag["selected_page_ids"] == ["88722450"]
-    assert checklist_diag["failure_reasons"] == []
-
-
-def test_readiness_project_scope_uses_persisted_chunk_counts_not_snapshot_payload(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    class _PersistedCountStore:
-        def __init__(self, _dsn: str) -> None:
-            pass
-
-        def get_snapshot_chunk_counts(self, *, snapshot_id: int) -> dict[str, int]:
-            if snapshot_id == 101:
-                # Project-scope code docs are deduplicated from persisted corpus.
-                return {"docs_chunk_count": 8, "code_chunk_count": 0}
-            return {"docs_chunk_count": 0, "code_chunk_count": 0}
-
-        def get_project_repo_scoped_code_chunk_count(self, *, project_key: str, project_id: int) -> int:
-            assert project_key == "123"
-            assert project_id == 1
-            return 24
-
-        def resolve_project_id(self, _project_key: str) -> int:
-            return 1
-
-        def corpus_status_diagnostics(self, *, project_key: str, project_id: int) -> dict[str, Any]:
-            return {
-                "total_chunks": 8,
-                "artifact_chunks": 0,
-                "contamination_ratio": 0.0,
-                "metadata_completeness_ratio": 1.0,
-                "health_status": "clean",
-            }
-
-        def _snapshot_project_filter(self, *, project_id: int, project_key: str) -> tuple[str, tuple[Any, ...]]:
-            raise ConnectionError("infra diagnostics unavailable in unit test")
-
-        def close(self) -> None:
-            return None
-
-    monkeypatch.setattr(state, "PostgresStateStore", _PersistedCountStore)
-    monkeypatch.setattr(state, "_resolve_project_document_count", lambda **_kwargs: 8)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(
-        state,
-        "list_retrieval_snapshots",
-        lambda **_kwargs: [
-            {
-                "id": 101,
-                "snapshot_key": "insurance-core:project_corpus",
-                "repo_key": None,
-                "state_version": 30,
-                "payload": {
-                    "diagnostics": {
-                        "docs_chunk_ready": True,
-                        "code_chunk_ready": True,
-                        "docs_chunk_count": 8,
-                        "code_chunk_count": 77,
-                    }
-                },
-            }
-        ],
-    )
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-    )
-
-    assert result["docs_chunk_count"] == 8
-    assert result["docs_chunk_ready"] is True
-    assert result["code_chunk_count"] == 24
-    assert result["code_chunk_ready"] is True
-    assert result["ready"] is True
-    assert result["summary"]["ready"] is True
-
-
-def test_readiness_repo_scope_does_not_use_project_aggregate_code_chunks(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    class _Cursor:
-        def __init__(self) -> None:
-            self._query: str = ""
-
-        def __enter__(self) -> _Cursor:
-            return self
-
-        def __exit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
-            return None
-
-        def execute(self, query: str, _params: Any = None) -> None:
-            self._query = query
-
-        def fetchone(self) -> dict[str, Any]:
-            if "FROM audit_state.repos AS repos" in self._query:
-                return {"id": 99}
-            return {}
-
-        def fetchall(self) -> list[dict[str, Any]]:
-            if "SELECT id FROM audit_state.retrieval_snapshots rs" in self._query:
-                return [{"id": 202}]
-            if "SELECT DISTINCT cd.source_uri" in self._query:
-                return []
-            return []
-
-    class _Conn:
-        def cursor(self) -> _Cursor:
-            return _Cursor()
-
-    class _PersistedCountStore:
-        def __init__(self, _dsn: str) -> None:
-            self._conn = _Conn()
-
-        def get_snapshot_chunk_counts(self, *, snapshot_id: int) -> dict[str, int]:
-            if snapshot_id == 101:
-                return {"docs_chunk_count": 8, "code_chunk_count": 0}
-            if snapshot_id == 202:
-                return {"docs_chunk_count": 2, "code_chunk_count": 0}
-            return {"docs_chunk_count": 0, "code_chunk_count": 0}
-
-        def get_project_repo_scoped_code_chunk_count(self, *, project_key: str, project_id: int) -> int:
-            # Should not affect repo-scoped readiness.
-            assert project_key == "123"
-            assert project_id == 1
-            return 24
-
-        def resolve_project_id(self, _project_key: str) -> int:
-            return 1
-
-        def corpus_status_diagnostics(self, *, project_key: str, project_id: int) -> dict[str, Any]:
-            return {
-                "total_chunks": 10,
-                "artifact_chunks": 0,
-                "contamination_ratio": 0.0,
-                "metadata_completeness_ratio": 1.0,
-                "health_status": "clean",
-            }
-
-        def _snapshot_project_filter(self, *, project_id: int, project_key: str) -> tuple[str, tuple[Any, ...]]:
-            raise ConnectionError("infra diagnostics unavailable in unit test")
-
-        def close(self) -> None:
-            return None
-
-    monkeypatch.setattr(state, "PostgresStateStore", _PersistedCountStore)
-    monkeypatch.setattr(state, "_resolve_project_document_count", lambda **_kwargs: 8)
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-
-    def _list_retrieval_snapshots(**kwargs: Any) -> list[dict[str, Any]]:
-        repo_key = kwargs.get("repo_key")
-        if repo_key:
-            return [
-                {
-                    "id": 202,
-                    "snapshot_key": "insurance-core:repo-ready",
-                    "repo_key": "repo-ready",
-                    "state_version": 31,
-                    "payload": {
-                        "diagnostics": {
-                            "docs_chunk_ready": True,
-                            "code_chunk_ready": True,
-                            "docs_chunk_count": 2,
-                            "code_chunk_count": 11,
-                        }
-                    },
-                }
-            ]
-        return [
-            {
-                "id": 101,
-                "snapshot_key": "insurance-core:project_corpus",
-                "repo_key": None,
-                "state_version": 30,
-                "payload": {
-                    "diagnostics": {
-                        "docs_chunk_ready": True,
-                        "code_chunk_ready": True,
-                        "docs_chunk_count": 8,
-                        "code_chunk_count": 77,
-                    }
-                },
-            }
-        ]
-
-    monkeypatch.setattr(state, "list_retrieval_snapshots", _list_retrieval_snapshots)
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    assert result["docs_chunk_count"] == 10
-    assert result["docs_chunk_ready"] is True
-    assert result["code_chunk_count"] == 0
-    assert result["code_chunk_ready"] is False
-    assert result["ready"] is False
-    assert result["summary"]["ready"] is False
-
-
-def test_readiness_hierarchy_diagnostics_reports_anomalies_with_bounded_samples(monkeypatch, tmp_path) -> None:
-    duplicate_repo_a = tmp_path / "repos" / "duplicate-a"
-    duplicate_repo_b = tmp_path / "repos" / "duplicate-b"
-    duplicate_repo_a.mkdir(parents=True)
-    duplicate_repo_b.mkdir(parents=True)
-
-    missing_entries: list[dict[str, Any]] = []
-    for idx in range(7):
-        missing_path = tmp_path / "repos" / f"missing-{idx}"
-        missing_path.mkdir(parents=True)
-        missing_entries.append(
-            {
-                "repo_slug": f"missing-{idx}",
-                "repo_url": f"https://bitbucket.example.com/repos/missing-{idx}",
-                "local_code_path": str(missing_path),
-                "status": "not_modified",
-            }
-        )
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Shared Selector",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "department": "Claims",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "payments-api",
-                            "bitbucket_project_key": "INS",
-                            "local_code_path": str(duplicate_repo_a),
-                            "status": "not_modified",
-                        },
-                        *missing_entries,
-                    ],
-                },
-                {
-                    "project_name": "Shared Selector",
-                    "project_storage_key": "124",
-                    "page_id": "124",
-                    "department": "Fraud",
-                    "documents": [{"page_id": "2", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "2", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "payments-api",
-                            "bitbucket_project_key": "INS",
-                            "local_code_path": str(duplicate_repo_b),
-                            "status": "not_modified",
-                        }
-                    ],
-                },
-            ]
-        },
-    )
-    # Phase 94 (AC-262.4): dual-source gating requires chunk readiness in snapshots
-    _corpus_snapshot = {
-        "snapshot_key": "insurance-core:project_corpus",
-        "payload": {
-            "diagnostics": {
-                "docs_chunk_count": 10,
-                "code_chunk_count": 5,
-                "docs_chunk_ready": True,
-                "code_chunk_ready": True,
-            }
-        },
-        "state_version": 1,
-    }
-    monkeypatch.setattr(state, "list_retrieval_snapshots", lambda **_kwargs: [_corpus_snapshot])
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-    )
-
-    assert result["ready"] is True
-    assert result["hierarchy_ready"] is False
-    assert result["department_count"] == 1
-    assert result["project_count"] == 1
-    assert result["bitbucket_project_count"] == 1
-    assert result["repo_count"] == 8
-
-    anomalies = result["hierarchy"]["anomalies"]
-    assert anomalies["repos_missing_bitbucket_project_key"]["count"] == 7
-    assert len(anomalies["repos_missing_bitbucket_project_key"]["samples"]) == 5
-    assert anomalies["duplicate_repo_identities"]["count"] == 0
-    assert len(anomalies["duplicate_repo_identities"]["samples"]) == 0
-    assert anomalies["project_selector_anomalies"]["count"] == 0
-    assert len(anomalies["project_selector_anomalies"]["samples"]) == 0
-
-
-def test_hierarchy_diagnostics_extracts_repo_identity_from_clone_url() -> None:
-    diagnostics = state._hierarchy_diagnostics(
-        manifest_payload={
-            "projects": [
-                {
-                    "project_storage_key": "2001",
-                    "page_id": "2001",
-                    "bitbucket": [
-                        {
-                            "clone_url": "https://bitbucket.example.com/scm/INS/payments-api.git",
-                        }
-                    ],
-                },
-                {
-                    "project_storage_key": "2002",
-                    "page_id": "2002",
-                    "bitbucket": [
-                        {
-                            "clone_url": "https://bitbucket.example.com/scm/INS/payments-api.git",
-                        }
-                    ],
-                },
-            ]
-        }
-    )
-
-    anomalies = diagnostics["anomalies"]
-    assert anomalies["repos_missing_bitbucket_project_key"]["count"] == 0
-    assert anomalies["duplicate_repo_identities"]["count"] == 1
-
-
-def test_hierarchy_diagnostics_treats_local_bitbucket_placeholder_as_missing() -> None:
-    diagnostics = state._hierarchy_diagnostics(
-        manifest_payload={
-            "projects": [
-                {
-                    "project_storage_key": "88710011",
-                    "page_id": "88710011",
-                    "bitbucket": [
-                        {
-                            "repo_slug": "payments-api",
-                            "repo_url": "https://bitbucket.local/projects/local/repos/payments-api",
-                        }
-                    ],
-                }
-            ]
-        }
-    )
-
-    anomalies = diagnostics["anomalies"]
-    assert anomalies["repos_missing_bitbucket_project_key"]["count"] == 0
-    assert diagnostics["anomaly_count"] == 0
-
-
-def test_hierarchy_diagnostics_ignores_synthetic_project_repo_entries() -> None:
-    diagnostics = state._hierarchy_diagnostics(
-        manifest_payload={
-            "projects": [
-                {
-                    "project_storage_key": "88718940",
-                    "page_id": "88718940",
-                    "bitbucket": [
-                        {
-                            "repo_storage_key": "88718940:project",
-                            "repo_slug": "project",
-                            "repo_url": "https://bitbucket.local/projects/local/repos/project",
-                        },
-                        {
-                            "repo_storage_key": "cpm-campaign-service",
-                            "repo_slug": "campaign-service",
-                            "bitbucket_project_key": "CPM",
-                            "repo_url": "http://bitbucket.digital.vn/scm/cpm/campaign-service.git",
-                        },
-                    ],
-                }
-            ]
-        }
-    )
-
-    assert diagnostics["repo_count"] == 1
-    assert diagnostics["anomaly_count"] == 0
-
-
-def test_build_registry_payload_excludes_synthetic_project_repo_rows() -> None:
-    snapshot = {
-        "projects": [
-            {
-                "id": 1,
-                "project_key": "88718940",
-                "display_name": "CEP",
-                "metadata": {
-                    "page_id": "88718940",
-                    "project_storage_key": "88718940",
-                    "project_name": "CEP",
-                },
-            }
-        ],
-        "repos": [
-            {
-                "id": 10,
-                "project_id": 1,
-                "repo_key": "88718940:project",
-                "repo_url": "",
-                "default_branch": "main",
-                "metadata": {"repo_slug": "project"},
-            },
-            {
-                "id": 11,
-                "project_id": 1,
-                "repo_key": "cpm-campaign-service",
-                "repo_url": "http://bitbucket.digital.vn/scm/cpm/campaign-service.git",
-                "default_branch": "main",
-                "metadata": {"repo_slug": "campaign-service"},
-            },
-        ],
-        "artifacts": [],
-        "project_preparation": [],
-        "repo_preparation": [],
-        "departments": [],
-        "bitbucket_projects": [],
-    }
-
-    payload = state._build_registry_payload_from_snapshot(snapshot)
-    project_payload = payload["projects"][0]
-    repos = project_payload.get("bitbucket") or []
-
-    assert len(repos) == 1
-    assert repos[0]["repo_storage_key"] == "cpm-campaign-service"
-    assert not str(repos[0]["repo_storage_key"]).endswith(":project")
-
-
-def test_repo_storage_key_from_entry_normalizes_redundant_git_suffix() -> None:
-    key = state._repo_storage_key_from_entry(
-        project_key="3-2-1-4-mini-app",
-        entry={
-            "repo_url": "http://bitbucket.digital.vn/scm/webappv2/miniapp-be.git.git",
-            "bitbucket_project_key": "WEBAPPV2",
-        },
-    )
-
-    assert key == "webappv2-miniapp-be"
-
-
-def test_repo_storage_key_from_entry_uses_canonical_name_fallback() -> None:
-    key = state._repo_storage_key_from_entry(
-        project_key="test-project",
-        entry={
-            "name": "Dự Án Quản Lý",
-            "bitbucket_project_key": "PR",
-        },
-    )
-
-    assert key == "pr-du-an-quan-ly"
-
-
-def test_repo_execution_payload_uses_canonical_repo_slug_fallback() -> None:
-    payload = state._repo_execution_payload(
-        project_key="test-project",
-        entry={
-            "name": "Dự Án Quản Lý",
-            "local_code_path": "/tmp/repo",
-        },
-    )
-
-    assert payload["repo_slug"] == "du-an-quan-ly"
-
-
-def test_readiness_prefers_project_corpus_snapshot_over_smoke_probe(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(
-        state,
-        "list_retrieval_snapshots",
-        lambda **kwargs: (
-            [
-                {
-                    "snapshot_key": "insurance-core:smoke_probe",
-                    "state_version": 100,
-                    "payload": {
-                        "diagnostics": {
-                            "docs_chunk_ready": True,
-                            "code_chunk_ready": False,
-                            "docs_chunk_count": 1,
-                            "code_chunk_count": 0,
-                        }
-                    },
-                },
-                {
-                    "snapshot_key": "insurance-core:project_corpus",
-                    "repo_key": None,
-                    "state_version": 10,
-                    "payload": {
-                        "diagnostics": {
-                            "docs_chunk_ready": True,
-                            "code_chunk_ready": True,
-                            "docs_chunk_count": 5044,
-                            "code_chunk_count": 537,
-                        }
-                    },
-                },
-                {
-                    "snapshot_key": "insurance-core:repo-ready:project_corpus",
-                    "repo_key": "insurance-core:repo-ready",
-                    "state_version": 50,
-                    "payload": {
-                        "diagnostics": {
-                            "docs_chunk_ready": True,
-                            "code_chunk_ready": True,
-                            "docs_chunk_count": 6000,
-                            "code_chunk_count": 6000,
-                        }
-                    },
-                },
-            ]
-            if not kwargs.get("repo_key")
-            else []
-        ),
-    )
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-    )
-
-    assert result["docs_chunk_count"] == 5044
-    assert result["code_chunk_count"] == 537
-    assert result["docs_chunk_ready"] is True
-    assert result["code_chunk_ready"] is True
-    assert result["retrieval"]["latest_project_snapshot"]["snapshot_key"] == "insurance-core:project_corpus"
-
-
-def test_readiness_accepts_snapshot_payload_top_level_chunk_diagnostics(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(
-        state,
-        "list_retrieval_snapshots",
-        lambda **kwargs: (
-            []
-            if kwargs.get("repo_key")
-            else [
-                {
-                    "snapshot_key": "insurance-core:project_corpus",
-                    "payload": {
-                        "docs_chunk_ready": True,
-                        "code_chunk_ready": True,
-                        "docs_chunk_count": 11,
-                        "code_chunk_count": 9,
-                    },
-                }
-            ]
-        ),
-    )
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    assert result["ready"] is True
-    assert result["docs_chunk_ready"] is True
-    assert result["code_chunk_ready"] is True
-    assert result["docs_chunk_count"] == 11
-    assert result["code_chunk_count"] == 9
-
-
-def test_readiness_fails_without_confluence_sync_artifacts(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "filesystem"}],
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(state, "list_retrieval_snapshots", lambda **_kwargs: [])
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    assert result["summary"]["ready"] is False
-    assert result["project"]["checks"]["has_confluence_sync_artifacts"] is False
-
-
-def test_readiness_repo_scope_reports_project_level_docs_info_message(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    class _FailingDiagnosticsStore:
-        def __init__(self, _dsn: str) -> None:
-            raise ConnectionError("state diagnostics unavailable")
-
-    monkeypatch.setattr(state, "PostgresStateStore", _FailingDiagnosticsStore)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(
-        state,
-        "list_retrieval_snapshots",
-        lambda **kwargs: (
-            []
-            if kwargs.get("repo_key")
-            else [
-                {
-                    "snapshot_key": "insurance-core:project_corpus",
-                    "repo_key": None,
-                    "state_version": 10,
-                    "payload": {
-                        "diagnostics": {
-                            "docs_chunk_ready": True,
-                            "code_chunk_ready": True,
-                            "docs_chunk_count": 21,
-                            "code_chunk_count": 5,
-                        }
-                    },
-                }
-            ]
-        ),
-    )
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    assert result["ready"] is True
-    assert result["retrieval"]["latest_selected_repo_snapshot"] is None
-    assert result["retrieval"]["latest_project_snapshot"]["snapshot_key"] == "insurance-core:project_corpus"
-    assert result["info_messages"] == [
-        "Project-level docs chunks are available, but selected repo has no repo-scoped docs chunks; retrieval uses project-level docs."
-    ]
-    assert result["summary"]["info_messages"] == result["info_messages"]
-
-
-def test_readiness_repo_scope_uses_shared_project_docs_when_repo_docs_missing(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    class _FailingDiagnosticsStore:
-        def __init__(self, _dsn: str) -> None:
-            raise ConnectionError("state diagnostics unavailable")
-
-    monkeypatch.setattr(state, "PostgresStateStore", _FailingDiagnosticsStore)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-
-    def _list_retrieval_snapshots(**kwargs):
-        if kwargs.get("repo_key"):
-            return [
-                {
-                    "snapshot_key": "insurance-core:repo-ready:project_corpus",
-                    "repo_key": "insurance-core:repo-ready",
-                    "state_version": 20,
-                    "payload": {
-                        "diagnostics": {
-                            "docs_chunk_ready": False,
-                            "code_chunk_ready": True,
-                            "docs_chunk_count": 0,
-                            "code_chunk_count": 12,
-                        }
-                    },
-                }
-            ]
-        return [
-            {
-                "snapshot_key": "insurance-core:project_corpus",
-                "repo_key": None,
-                "state_version": 20,
-                "payload": {
-                    "diagnostics": {
-                        "docs_chunk_ready": True,
-                        "code_chunk_ready": True,
-                        "docs_chunk_count": 25,
-                        "code_chunk_count": 100,
-                    }
-                },
-            }
-        ]
-
-    monkeypatch.setattr(state, "list_retrieval_snapshots", _list_retrieval_snapshots)
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    assert result["ready"] is True
-    assert result["docs_chunk_ready"] is True
-    assert result["docs_chunk_count"] == 25
-    assert result["code_chunk_ready"] is True
-    assert result["code_chunk_count"] == 12
-    assert result["info_messages"] == [
-        "Project-level docs chunks are available, but selected repo has no repo-scoped docs chunks; retrieval uses project-level docs."
-    ]
-
-
-def test_readiness_accepts_repo_preparation_ready_marker(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "missing",
-                            "sync_decision": "failed",
-                            "readiness": "ready",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    # Phase 94 (AC-262.4): dual-source gating requires chunk readiness in snapshots
-    _corpus_snapshot = {
-        "snapshot_key": "insurance-core:project_corpus",
-        "payload": {
-            "diagnostics": {
-                "docs_chunk_count": 10,
-                "code_chunk_count": 5,
-                "docs_chunk_ready": True,
-                "code_chunk_ready": True,
-            }
-        },
-        "state_version": 1,
-    }
-    monkeypatch.setattr(state, "list_retrieval_snapshots", lambda **_kwargs: [_corpus_snapshot])
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    assert result["summary"]["ready"] is True
-    assert result["project"]["checks"]["has_ready_repo_entries"] is True
-    assert result["repo"]["ready"] is True
-
-
-def test_readiness_includes_checklist_profile_diagnostics_with_repo_type_match(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-backend"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "checklist_profiles": [
-                        {
-                            "profile_id": "backend",
-                            "display_name": "Backend Checklist",
-                            "page_ids": ["88722450", "88722451"],
-                            "priority": 10,
-                            "repo_type_filters": ["backend"],
-                        },
-                        {
-                            "profile_id": "default",
-                            "display_name": "Default Checklist",
-                            "page_ids": ["88722450"],
-                            "priority": 20,
-                        },
-                    ],
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-backend",
-                            "repo_type": "backend",
-                            "local_code_path": str(repo_path),
-                            "status": "ready",
-                            "sync_decision": "synced",
-                            "readiness": "ready",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(
-        state,
-        "list_retrieval_snapshots",
-        lambda **_kwargs: [
-            {
-                "snapshot_key": "insurance-core:project_corpus",
-                "repo_key": None,
-                "payload": {
-                    "diagnostics": {
-                        "docs_chunk_count": 10,
-                        "code_chunk_count": 5,
-                        "docs_chunk_ready": True,
-                        "code_chunk_ready": True,
-                    }
-                },
-                "state_version": 1,
-            }
-        ],
-    )
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-backend",
-    )
-
-    diagnostics = result["checklist_profile_diagnostics"]
-    assert diagnostics["profiles_total"] == 2
-    assert diagnostics["profiles_ready"] == 2
-    assert diagnostics["selected_profile"] == "backend"
-    assert diagnostics["selected_profile_details"]["profile_id"] == "backend"
-    assert diagnostics["selected_profile_details"]["page_ids"] == ["88722450", "88722451"]
-    assert diagnostics["selected_profile_details"]["repo_type_filters"] == ["backend"]
-    assert diagnostics["selected_profile_source"] == "repo_type_match"
-    assert diagnostics["selected_page_count"] == 2
-    assert diagnostics["selected_page_ids"] == ["88722450", "88722451"]
-    assert diagnostics["failure_reasons"] == []
-    assert result["summary"]["checklist_profile_diagnostics"]["selected_profile"] == "backend"
-
-
-def test_readiness_project_scope_includes_checklist_topology_report(monkeypatch, tmp_path) -> None:
-    backend_repo = tmp_path / "repo-backend"
-    frontend_repo = tmp_path / "repo-frontend"
-    backend_repo.mkdir(parents=True)
-    frontend_repo.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "checklist_profiles": [
-                        {
-                            "profile_id": "frontend",
-                            "display_name": "Frontend Checklist",
-                            "page_ids": ["88729031"],
-                            "priority": 10,
-                            "repo_type_filters": ["frontend"],
-                        },
-                        {
-                            "profile_id": "default",
-                            "display_name": "Default Checklist",
-                            "page_ids": ["88722450"],
-                            "priority": 20,
-                        },
-                    ],
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-backend",
-                            "repo_type": "backend",
-                            "local_code_path": str(backend_repo),
-                            "status": "ready",
-                            "sync_decision": "synced",
-                            "readiness": "ready",
-                        },
-                        {
-                            "repo_slug": "repo-frontend",
-                            "repo_type": "frontend",
-                            "local_code_path": str(frontend_repo),
-                            "status": "ready",
-                            "sync_decision": "synced",
-                            "readiness": "ready",
-                        },
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(
-        state,
-        "list_retrieval_snapshots",
-        lambda **_kwargs: [
-            {
-                "snapshot_key": "insurance-core:project_corpus",
-                "repo_key": None,
-                "payload": {
-                    "diagnostics": {
-                        "docs_chunk_count": 10,
-                        "code_chunk_count": 5,
-                        "docs_chunk_ready": True,
-                        "code_chunk_ready": True,
-                    }
-                },
-                "state_version": 1,
-            }
-        ],
-    )
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-    )
-
-    topology = result["checklist_topology_report"]
-    assert topology["repo_count"] == 2
-    assert topology["profile_count"] == 2
-    assert topology["mixed_profile_assignment"] is True
-    repo_map = {row["repo_slug"]: row for row in topology["by_repo"]}
-    assert repo_map["repo-frontend"]["checklist_profile_id"] == "frontend"
-    assert repo_map["repo-backend"]["checklist_profile_id"] == "default"
-    assert result["summary"]["checklist_topology_report"]["mixed_profile_assignment"] is True
-
-
-def test_readiness_legacy_page_field_does_not_synthesize_default_profile(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-legacy"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "checklist_page_id": "88722450",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-legacy",
-                            "local_code_path": str(repo_path),
-                            "status": "ready",
-                            "sync_decision": "synced",
-                            "readiness": "ready",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(
-        state,
-        "list_retrieval_snapshots",
-        lambda **_kwargs: [
-            {
-                "snapshot_key": "insurance-core:project_corpus",
-                "repo_key": None,
-                "payload": {
-                    "diagnostics": {
-                        "docs_chunk_count": 10,
-                        "code_chunk_count": 5,
-                        "docs_chunk_ready": True,
-                        "code_chunk_ready": True,
-                    }
-                },
-                "state_version": 1,
-            }
-        ],
-    )
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-legacy",
-    )
-
-    diagnostics = result["checklist_profile_diagnostics"]
-    assert diagnostics["profiles_total"] == 1
-    assert diagnostics["profiles_ready"] == 1
-    assert diagnostics["selected_profile"] == "default"
-    assert diagnostics["selected_profile_details"]["profile_id"] == "default"
-    assert diagnostics["selected_profile_details"]["page_ids"] == ["88722450"]
-    assert diagnostics["selected_page_count"] == 1
-    assert diagnostics["selected_page_ids"] == ["88722450"]
-    assert diagnostics["failure_reasons"] == []
-    assert diagnostics["info_reasons"] == ["fallback_default_synthesized_default_profile"]
-
-
-def test_readiness_synthesizes_canonical_default_profile_when_catalog_missing(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-no-profile"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-no-profile",
-                            "local_code_path": str(repo_path),
-                            "status": "ready",
-                            "sync_decision": "synced",
-                            "readiness": "ready",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(
-        state,
-        "list_retrieval_snapshots",
-        lambda **_kwargs: [
-            {
-                "snapshot_key": "insurance-core:project_corpus",
-                "repo_key": None,
-                "payload": {
-                    "diagnostics": {
-                        "docs_chunk_count": 10,
-                        "code_chunk_count": 5,
-                        "docs_chunk_ready": True,
-                        "code_chunk_ready": True,
-                    }
-                },
-                "state_version": 1,
-            }
-        ],
-    )
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-no-profile",
-    )
-
-    diagnostics = result["checklist_profile_diagnostics"]
-    assert diagnostics["profiles_total"] == 1
-    assert diagnostics["profiles_ready"] == 1
-    assert diagnostics["selected_profile"] == "default"
-    assert diagnostics["selected_profile_details"]["profile_id"] == "default"
-    assert diagnostics["selected_profile_details"]["page_ids"] == ["88722450"]
-    assert diagnostics["selected_profile_source"] == "state_default_profile"
-    assert diagnostics["selected_page_count"] == 1
-    assert diagnostics["selected_page_ids"] == ["88722450"]
-    assert diagnostics["failure_reasons"] == []
-    assert diagnostics["info_reasons"] == ["fallback_default_synthesized_default_profile"]
-
-
-def test_readiness_selects_auxiliary_repo_and_preserves_role(monkeypatch, tmp_path) -> None:
-    config_repo_path = tmp_path / "workspace" / "DOPS-project" / "config-repo"
-    shared_repo_path = tmp_path / "workspace" / "AUXLIB-project" / "shared-lib"
-    config_repo_path.mkdir(parents=True)
-    shared_repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "config-repo",
-                            "local_code_path": str(config_repo_path),
-                            "status": "not_modified",
-                            "role": "auxiliary_config",
-                        },
-                        {
-                            "repo_slug": "shared-lib",
-                            "local_code_path": str(shared_repo_path),
-                            "status": "not_modified",
-                            "role": "auxiliary_lib",
-                        },
-                    ],
-                }
-            ]
-        },
-    )
-    # Phase 94 (AC-262.4): dual-source gating requires chunk readiness in snapshots
-    _corpus_snapshot = {
-        "snapshot_key": "insurance-core:project_corpus",
-        "payload": {
-            "diagnostics": {
-                "docs_chunk_count": 10,
-                "code_chunk_count": 5,
-                "docs_chunk_ready": True,
-                "code_chunk_ready": True,
-            }
-        },
-        "state_version": 1,
-    }
-    monkeypatch.setattr(state, "list_retrieval_snapshots", lambda **_kwargs: [_corpus_snapshot])
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="config-repo",
-    )
-
-    assert result["ready"] is True
-    assert result["project"]["checks"]["ready_repo_count"] == 2
-    assert result["repo"]["ready"] is True
-    assert result["repo"]["repo_slug"] == "config-repo"
-    assert result["repo"]["role"] == "auxiliary_config"
-
-
-def test_readiness_projects_counts_exclude_analysis_excluded_repos(monkeypatch, tmp_path) -> None:
-    repo_ready_path = tmp_path / "repo-ready"
-    repo_excluded_path = tmp_path / "repo-excluded"
-    repo_ready_path.mkdir(parents=True)
-    repo_excluded_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "insurance-core",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_ready_path),
-                            "readiness": "ready",
-                        },
-                        {
-                            "repo_slug": "repo-excluded",
-                            "local_code_path": str(repo_excluded_path),
-                            "readiness": "ready",
-                            "analysis_excluded": True,
-                            "analysis_exclusion_reason": "unsupported branch",
-                        },
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(
-        state,
-        "list_retrieval_snapshots",
-        lambda **_kwargs: [
-            {
-                "snapshot_key": "insurance-core:project_corpus",
-                "payload": {
-                    "diagnostics": {
-                        "docs_chunk_count": 10,
-                        "code_chunk_count": 5,
-                        "docs_chunk_ready": True,
-                        "code_chunk_ready": True,
-                    }
-                },
-                "state_version": 1,
-            }
-        ],
-    )
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="insurance-core",
-    )
-
-    checks = result["project"]["checks"]
-    assert checks["analysis_repo_total"] == 2
-    assert checks["analysis_repo_excluded_count"] == 1
-    assert checks["analysis_repo_eligible_count"] == 1
-    assert checks["repo_count"] == 1
-    assert checks["ready_repo_count"] == 1
-
-
-def test_readiness_selected_repo_reports_analysis_exclusion(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-excluded"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "insurance-core",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-excluded",
-                            "local_code_path": str(repo_path),
-                            "readiness": "ready",
-                            "analysis_excluded": True,
-                            "analysis_exclusion_reason": "sunset repo",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(
-        state,
-        "list_retrieval_snapshots",
-        lambda **_kwargs: [
-            {
-                "snapshot_key": "insurance-core:project_corpus",
-                "payload": {
-                    "diagnostics": {
-                        "docs_chunk_count": 10,
-                        "code_chunk_count": 5,
-                        "docs_chunk_ready": True,
-                        "code_chunk_ready": True,
-                    }
-                },
-                "state_version": 1,
-            }
-        ],
-    )
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="insurance-core",
-        repo_identifier="repo-excluded",
-    )
-
-    assert result["repo"]["ready"] is False
-    assert result["repo"]["checks"]["analysis_excluded"] is True
-    assert result["repo"]["checks"]["analysis_exclusion_reason"] == "sunset repo"
-
-
-def test_resolve_run_input_includes_latest_workflow_run_parameters(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "project_name_en": "insurance-core",
-                    "page_id": "123",
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(state, "list_retrieval_snapshots", lambda **_kwargs: [])
-
-    captured_calls: list[dict[str, Any]] = []
-
-    def _fake_list_runs(**kwargs):
-        captured_calls.append(kwargs)
-        if kwargs.get("repo_key"):
-            return [
-                {
-                    "run_id": "thread-101",
-                    "project_key": "insurance-core",
-                    "repo_key": "insurance-core-repo-ready",
-                    "run_type": "workflow",
-                    "status": "completed",
-                    "payload": {
-                        "kind": "workflow_invocation",
-                        "run_parameters": {
-                            "evidence_project": "Insurance Core",
-                            "retrieval_mode": "hybrid",
-                            "row_timeout_ms": 90000,
-                        },
-                    },
-                    "started_at": datetime.now(UTC),
-                    "finished_at": datetime.now(UTC),
-                }
-            ]
-        return []
-
-    monkeypatch.setattr(state, "list_runs", _fake_list_runs)
-
-    result = state.resolve_run_input(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    execution = result["execution"]
-    assert execution["latest_workflow_run"]["run_id"] == "thread-101"
-    assert execution["latest_run_parameters"]["row_timeout_ms"] == 90000
-    assert captured_calls[0]["repo_key"] == "123-repo-ready"
-
-
-def test_resolve_run_input_latest_run_parameters_fallback_to_project_scope(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "project_name_en": "insurance-core",
-                    "page_id": "123",
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(state, "list_retrieval_snapshots", lambda **_kwargs: [])
-
-    captured_calls: list[dict[str, Any]] = []
-
-    def _fake_list_runs(**kwargs):
-        captured_calls.append(kwargs)
-        if kwargs.get("repo_key"):
-            return []
-        return [
-            {
-                "run_id": "thread-202",
-                "project_key": "insurance-core",
-                "repo_key": None,
-                "run_type": "workflow",
-                "status": "completed",
-                "payload": {
-                    "kind": "workflow_invocation",
-                    "run_parameters": {
-                        "retrieval_mode": "vector",
-                        "row_consistency_retry_mode": "auto",
-                    },
-                },
-                "started_at": datetime.now(UTC),
-                "finished_at": datetime.now(UTC),
-            }
-        ]
-
-    monkeypatch.setattr(state, "list_runs", _fake_list_runs)
-
-    result = state.resolve_run_input(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    assert len(captured_calls) == 2
-    assert captured_calls[0]["repo_key"] == "123-repo-ready"
-    assert captured_calls[1]["repo_key"] is None
-    assert result["execution"]["latest_workflow_run"]["run_id"] == "thread-202"
-    assert result["execution"]["latest_run_parameters"]["retrieval_mode"] == "vector"
-
-
-def test_resolve_workflow_run_parameters_prefers_repo_scope(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "project_name_en": "insurance-core",
-                    "page_id": "123",
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(state, "list_retrieval_snapshots", lambda **_kwargs: [])
-    monkeypatch.setattr(
-        state,
-        "list_runs",
-        lambda **kwargs: [
-            {
-                "run_id": "thread-303",
-                "project_key": "insurance-core",
-                "repo_key": "insurance-core-repo-ready" if kwargs.get("repo_key") else None,
-                "run_type": "workflow",
-                "status": "completed",
-                "payload": {"run_parameters": {"retrieval_mode": "hybrid", "row_timeout_ms": 45000}},
-                "started_at": datetime.now(UTC),
-                "finished_at": datetime.now(UTC),
-            }
-        ],
-    )
-
-    result = state.resolve_workflow_run_parameters(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    assert result["available"] is True
-    assert result["source_scope"] == "repo_other"
-    assert result["latest_workflow_run"]["run_id"] == "thread-303"
-    assert result["latest_run_parameters"]["retrieval_mode"] == "hybrid"
-
-
-def test_resolve_workflow_run_parameters_reports_none_when_missing(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "project_name_en": "insurance-core",
-                    "page_id": "123",
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(state, "list_retrieval_snapshots", lambda **_kwargs: [])
-    monkeypatch.setattr(state, "list_runs", lambda **_kwargs: [])
-
-    result = state.resolve_workflow_run_parameters(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    assert result["available"] is False
-    assert result["source_scope"] == "none"
-    assert result["latest_workflow_run"] is None
-    assert result["latest_run_parameters"] == {}
-
-
-def test_resolve_run_input_defaults_fallback_handles_recoverable_list_runs_errors(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    warning_logger = _WarningCaptureLogger()
-    monkeypatch.setattr(state, "_log", warning_logger)
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "project_name_en": "insurance-core",
-                    "page_id": "123",
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(state, "list_retrieval_snapshots", lambda **_kwargs: [])
-
-    def _raise_timeout(**_kwargs: Any) -> list[dict[str, Any]]:
-        raise TimeoutError("defaults lookup timed out")
-
-    monkeypatch.setattr(state, "list_runs", _raise_timeout)
-
-    result = state.resolve_run_input(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    assert result["execution"]["latest_workflow_run"] is None
-    assert result["execution"]["latest_run_parameters"] == {}
-    assert warning_logger.events
-    warning = warning_logger.events[0]
-    assert warning["error_type"] == "TimeoutError"
-    assert warning["source_module"] == state.__name__
-    assert warning["context"]["function"] == "_latest_workflow_run_defaults"
-    assert warning["recovery_action"] == "continue_to_next_scope_or_run_type"
-
-
-def test_readiness_snapshot_fallback_handles_recoverable_lookup_errors(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-ready"
-    repo_path.mkdir(parents=True)
-
-    warning_logger = _WarningCaptureLogger()
-    monkeypatch.setattr(state, "_log", warning_logger)
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "123",
-                    "page_id": "123",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-ready",
-                            "local_code_path": str(repo_path),
-                            "status": "not_modified",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-
-    def _raise_connection_error(**_kwargs: Any) -> list[dict[str, Any]]:
-        raise ConnectionError("retrieval snapshot table unavailable")
-
-    monkeypatch.setattr(state, "list_retrieval_snapshots", _raise_connection_error)
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="123",
-        repo_identifier="repo-ready",
-    )
-
-    # Phase 94 (AC-262.4): dual-source gating means ready=False when chunk
-    # readiness is unknown (ConnectionError prevents snapshot lookup)
-    assert result["ready"] is False
-    assert result["docs_chunk_ready"] is False
-    assert result["code_chunk_ready"] is False
-    assert result["docs_chunk_count"] == 0
-    assert result["code_chunk_count"] == 0
-    assert result["retrieval"]["latest_project_snapshot"] is None
-    assert result["retrieval"]["latest_selected_repo_snapshot"] is None
-    assert warning_logger.events
-    warning = next(
-        (e for e in warning_logger.events if e.get("error_type") == "ConnectionError"),
-        None,
-    )
-    assert warning is not None, (
-        f"Expected a warning event with error_type='ConnectionError', "
-        f"got events: {[e.get('event') for e in warning_logger.events]}"
-    )
-    assert warning["error_type"] == "ConnectionError"
-    assert warning["source_module"] == state.__name__
-    assert warning["context"]["function"] == "readiness"
-    assert warning["recovery_action"] == "fallback_to_empty_snapshot_diagnostics"
-
-
-def test_readiness_repo_not_ready_reason_includes_sync_markers(monkeypatch, tmp_path) -> None:
-    repo_path = tmp_path / "repo-failed-sync"
-    repo_path.mkdir(parents=True)
-
-    class _FailingDiagnosticsStore:
-        def __init__(self, _dsn: str) -> None:
-            raise ConnectionError("state diagnostics unavailable")
-
-    monkeypatch.setattr(state, "PostgresStateStore", _FailingDiagnosticsStore)
-    monkeypatch.setattr(state, "_resolve_project_document_count", lambda **_kwargs: 1)
-    monkeypatch.setattr(
-        state,
-        "load_manifest_payload",
-        lambda *, state_dsn: {
-            "projects": [
-                {
-                    "project_name": "Insurance Core",
-                    "project_storage_key": "88710001",
-                    "page_id": "88710001",
-                    "documents": [{"page_id": "1", "title": "Overview", "source": "confluence"}],
-                    "sync_metadata": {
-                        "artifacts": [
-                            {"resource_type": "confluence_page", "resource_id": "1", "status": "not_modified"}
-                        ]
-                    },
-                    "bitbucket": [
-                        {
-                            "repo_slug": "repo-failed-sync",
-                            "local_code_path": str(repo_path),
-                            "status": "missing",
-                            "sync_status": "missing",
-                            "sync_decision": "failed",
-                            "readiness": "not_ready",
-                        }
-                    ],
-                }
-            ]
-        },
-    )
-    monkeypatch.setattr(state, "list_retrieval_snapshots", lambda **_kwargs: [])
-
-    result = state.readiness(
-        state_dsn="postgresql://state",
-        project_identifier="88710001",
-        repo_identifier="repo-failed-sync",
-    )
-
-    assert result["repo"]["ready"] is False
-    assert result["repo"]["checks"]["sync_status"] == "missing"
-    assert result["repo"]["checks"]["sync_decision"] == "failed"
-    assert result["repo"]["checks"]["readiness"] == "not_ready"
-    assert result["repo"]["reason"] == (
-        "repo not ready: sync_decision=failed, sync_status=missing, readiness=not_ready"
-    )