@ngocsangairvds/vsaf 3.2.13 → 3.2.15

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

@@ -1,1756 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-from contextlib import contextmanager
-from datetime import UTC, datetime
-from unittest.mock import MagicMock, patch
-
-import psycopg
-import pytest
-from vds_audit_orchestrator.state.store import PostgresStateStore, _is_pgvector_version_ok
-
-
-@contextmanager
-def _null_context():
-    yield None
-
-
-@pytest.fixture(autouse=True)
-def _disable_runtime_schema_compatibility_check() -> None:
-    with patch.object(PostgresStateStore, "_ensure_runtime_schema_compatibility", return_value=None):
-        yield
-
-
-def test_bootstrap_vector_index_returns_lexical_fallback_on_extension_error() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        # First 2 calls are HNSW session defaults from __init__, then CREATE EXTENSION fails
-        cur.execute.side_effect = [
-            None,  # SET hnsw.ef_search
-            None,  # SET hnsw.iterative_scan
-            psycopg.errors.InsufficientPrivilege("permission denied to create extension"),  # CREATE EXTENSION
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        with patch.object(PostgresStateStore, "_ensure_runtime_schema_compatibility", return_value=None):
-            store = PostgresStateStore("postgresql://test")
-        with patch.object(
-            store,
-            "_phase47_schema_diagnostics",
-            return_value={
-                "schema_exists": True,
-                "schema_version_ready": True,
-                "phase47_tables_ready": True,
-                "phase47_indexes_ready": True,
-                "phase47_constraints_ready": True,
-                "legacy_chunk_embeddings_absent": True,
-                "phase47_ready": True,
-            },
-        ):
-            result = store.bootstrap_vector_index(index_type="hnsw", dimensions=1024)
-
-    assert result["lexical_only"] is True
-    assert result["extension_available"] is False
-    assert "permission denied" in str(result["fallback_reason"])
-
-
-def test_bootstrap_vector_index_requires_dimensions_for_phase47() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        # Reset mock to clear HNSW session defaults calls from __init__
-        cur.reset_mock()
-        with patch.object(
-            store,
-            "_phase47_schema_diagnostics",
-            return_value={
-                "schema_exists": True,
-                "schema_version_ready": True,
-                "phase47_tables_ready": True,
-                "phase47_indexes_ready": True,
-                "phase47_constraints_ready": True,
-                "legacy_chunk_embeddings_absent": True,
-                "phase47_ready": True,
-            },
-        ):
-            result = store.bootstrap_vector_index(index_type="hnsw", dimensions=None)
-
-    assert result["lexical_only"] is True
-    assert "dimensions are required to pin embedding_vector to vector(N)" in str(result["fallback_reason"])
-    cur.execute.assert_not_called()
-
-
-def test_bootstrap_vector_index_allows_non_vector_phase47_index_drift() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        cur.reset_mock()
-        with patch.object(
-            store,
-            "_phase47_schema_diagnostics",
-            return_value={
-                "schema_exists": True,
-                "schema_version_ready": True,
-                "phase47_tables_ready": True,
-                "phase47_indexes_ready": False,
-                "phase47_constraints_ready": True,
-                "legacy_chunk_embeddings_absent": True,
-                "legacy_corpus_documents_project_key_signature_absent": True,
-                "phase47_ready": False,
-            },
-        ):
-            result = store.bootstrap_vector_index(index_type="hnsw", dimensions=None)
-
-    assert result["lexical_only"] is True
-    assert "dimensions are required to pin embedding_vector to vector(N)" in str(result["fallback_reason"])
-
-
-def test_bootstrap_vector_index_pins_generic_vector_column_when_dimensions_provided() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"extversion": "0.8.1"},
-            {"col_exists": True},
-            {"atttypmod": -1},
-            {"index_exists": 1},
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        with patch.object(PostgresStateStore, "_ensure_runtime_schema_compatibility", return_value=None):
-            store = PostgresStateStore("postgresql://test")
-        with patch.object(
-            store,
-            "_phase47_schema_diagnostics",
-            return_value={
-                "schema_exists": True,
-                "schema_version_ready": True,
-                "phase47_tables_ready": True,
-                "phase47_indexes_ready": True,
-                "phase47_constraints_ready": True,
-                "legacy_chunk_embeddings_absent": True,
-                "phase47_ready": True,
-            },
-        ):
-            result = store.bootstrap_vector_index(index_type="hnsw", dimensions=1024)
-
-    assert result["lexical_only"] is False
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert any("ALTER COLUMN embedding_vector TYPE vector(1024)" in sql for sql in executed_sql)
-
-
-def test_plan_retrieval_refresh_forces_full_when_model_dimensions_change() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.return_value = {
-            "id": 10,
-            "snapshot_key": "insurance:prev",
-            "embedding_model_name": "bge-m3",
-            "embedding_model_digest": "digest-a",
-            "embedding_dimensions": 1024,
-        }
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:new",
-            chunks=[
-                {
-                    "chunk_id": "chunk-1",
-                    "content_hash": "sha-1",
-                    "content_text": "hello",
-                }
-            ],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=768,
-        )
-
-    assert plan["embedding_model_changed"] is True
-    assert plan["force_reason"] == "embedding_dimensions_changed"
-    assert plan["changed_chunk_ids"] == ["chunk-1"]
-
-
-def test_plan_retrieval_refresh_ignores_legacy_non_hash_digest_mismatch() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.return_value = {
-            "id": 10,
-            "snapshot_key": "insurance:prev",
-            "embedding_model_name": "bge-m3",
-            "embedding_model_digest": "FROM /Users/vds-ai/.ollama/models/blobs/sha256-legacy",
-            "embedding_dimensions": 1024,
-        }
-        cur.fetchall.return_value = [{"chunk_id": "chunk-1", "content_hash": "sha-1"}]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:new",
-            chunks=[{"chunk_id": "chunk-1", "content_hash": "sha-1", "content_text": "hello"}],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="sha256:" + ("a" * 64),
-            embedding_dimensions=1024,
-        )
-
-    assert plan["embedding_model_changed"] is False
-    assert plan["force_reason"] is None
-    assert plan["changed_chunk_ids"] == []
-
-
-def test_plan_retrieval_refresh_forces_full_when_hash_digest_changes() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.return_value = {
-            "id": 10,
-            "snapshot_key": "insurance:prev",
-            "embedding_model_name": "bge-m3",
-            "embedding_model_digest": "sha256:" + ("a" * 64),
-            "embedding_dimensions": 1024,
-        }
-        cur.fetchall.return_value = [{"chunk_id": "chunk-1", "content_hash": "sha-1"}]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:new",
-            chunks=[{"chunk_id": "chunk-1", "content_hash": "sha-1", "content_text": "hello"}],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="sha256:" + ("b" * 64),
-            embedding_dimensions=1024,
-        )
-
-    assert plan["embedding_model_changed"] is True
-    assert plan["force_reason"] == "embedding_model_digest_changed"
-    assert plan["changed_chunk_ids"] == ["chunk-1"]
-
-
-def test_plan_retrieval_refresh_previous_hash_lookup_avoids_chunk_embeddings_sql() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.return_value = {
-            "id": 10,
-            "snapshot_key": "insurance:prev",
-            "embedding_model_name": "bge-m3",
-            "embedding_model_digest": "digest-a",
-            "embedding_dimensions": 1024,
-        }
-        cur.fetchall.return_value = [{"chunk_id": "chunk-1", "content_hash": "sha-1"}]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:new",
-            chunks=[{"chunk_id": "chunk-1", "content_hash": "sha-1", "content_text": "hello"}],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-        )
-
-    assert plan["changed_chunk_ids"] == []
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert all("chunk_embeddings" not in sql for sql in executed_sql)
-
-
-def test_plan_retrieval_refresh_returns_early_exit_when_snapshot_content_hash_matches() -> None:
-    expected_hash = hashlib.sha256(b"chunk-1|sha-1\n").hexdigest()
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {
-                "id": 10,
-                "snapshot_key": "insurance:new",
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "content_hash": expected_hash,
-            },
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:new",
-            chunks=[{"chunk_id": "chunk-1", "content_hash": "sha-1", "content_text": "hello"}],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-        )
-
-    assert plan["early_exit"] is True
-    assert plan["content_hash"] == expected_hash
-    assert plan["changed_chunk_ids"] == []
-    assert plan["unchanged_chunk_ids"] == ["chunk-1"]
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert all("FROM audit_state.corpus_chunks" not in sql for sql in executed_sql)
-
-
-def test_plan_retrieval_refresh_preplan_skips_early_exit_when_snapshot_missing_chunk_provenance() -> None:
-    expected_hash = hashlib.sha256(b"chunk-1|sha-1\n").hexdigest()
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {
-                "id": 10,
-                "snapshot_key": "insurance:new",
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "content_hash": expected_hash,
-            },
-            {"id": 1},
-            {
-                "missing_chunk_order": 1,
-                "missing_start_line": 0,
-                "missing_end_line": 0,
-            },
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:new",
-            chunks=[
-                {
-                    "chunk_id": "chunk-1",
-                    "content_hash": "sha-1",
-                    "content_text": "hello",
-                    "metadata": {"chunk_ordinal": "0"},
-                }
-            ],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-            early_exit_only=True,
-        )
-
-    assert plan["early_exit"] is False
-    assert plan["requires_full_plan"] is True
-    assert plan["force_reason"] == "missing_chunk_provenance"
-    diagnostics = plan["diagnostics"]
-    assert diagnostics["missing_chunk_provenance_columns"] == ["chunk_order"]
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert any("missing_chunk_order" in sql for sql in executed_sql)
-
-
-def test_plan_retrieval_refresh_checks_provenance_only_for_chunks_with_incoming_provenance() -> None:
-    expected_hash = hashlib.sha256(b"chunk-1|sha-1\nchunk-2|sha-2\n").hexdigest()
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {
-                "id": 10,
-                "snapshot_key": "insurance:new",
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "content_hash": expected_hash,
-            },
-            {
-                "missing_chunk_order": 0,
-                "missing_start_line": 0,
-                "missing_end_line": 0,
-            },
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:new",
-            chunks=[
-                {
-                    "chunk_id": "chunk-1",
-                    "content_hash": "sha-1",
-                    "content_text": "hello",
-                    "metadata": {"chunk_ordinal": "0"},
-                },
-                {
-                    "chunk_id": "chunk-2",
-                    "content_hash": "sha-2",
-                    "content_text": "world",
-                    "metadata": {},
-                },
-            ],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-        )
-
-    assert plan["early_exit"] is True
-    missing_provenance_call = next(
-        call for call in cur.execute.call_args_list if "missing_chunk_order" in str(call.args[0])
-    )
-    params = missing_provenance_call.args[1]
-    assert params[0] == ["chunk-1"]
-    assert params[1] == []
-    assert params[2] == []
-
-
-def test_plan_retrieval_refresh_preplan_skips_early_exit_when_model_name_changes() -> None:
-    expected_hash = hashlib.sha256(b"chunk-1|sha-1\n").hexdigest()
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {
-                "id": 10,
-                "snapshot_key": "insurance:new",
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "content_hash": expected_hash,
-            },
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:new",
-            chunks=[{"chunk_id": "chunk-1", "content_hash": "sha-1", "content_text": "hello"}],
-            embedding_model_name="nomic-embed-text",
-            embedding_model_digest="",
-            embedding_dimensions=0,
-            early_exit_only=True,
-        )
-
-    assert plan["early_exit"] is False
-    assert plan["requires_full_plan"] is True
-
-
-def test_plan_retrieval_refresh_preplan_requires_lineage_even_with_matching_model_name() -> None:
-    expected_hash = hashlib.sha256(b"chunk-1|sha-1\n").hexdigest()
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {
-                "id": 10,
-                "snapshot_key": "insurance:new",
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "sha256:" + ("a" * 64),
-                "embedding_dimensions": 1024,
-                "content_hash": expected_hash,
-            },
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:new",
-            chunks=[{"chunk_id": "chunk-1", "content_hash": "sha-1", "content_text": "hello"}],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="",
-            embedding_dimensions=0,
-            early_exit_only=True,
-        )
-
-    assert plan["early_exit"] is False
-    assert plan["requires_full_plan"] is True
-
-
-def test_plan_retrieval_refresh_preplan_without_snapshot_skips_scope_resolution() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.return_value = None
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        store._resolve_corpus_scope_ids = MagicMock(side_effect=AssertionError("scope resolution should be skipped"))
-
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:new",
-            chunks=[{"chunk_id": "chunk-1", "content_hash": "sha-1", "content_text": "hello"}],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="",
-            embedding_dimensions=0,
-            early_exit_only=True,
-        )
-
-    assert plan["early_exit"] is False
-    assert plan["requires_full_plan"] is True
-    store._resolve_corpus_scope_ids.assert_not_called()
-
-
-def test_plan_retrieval_refresh_prefers_exact_snapshot_key_over_newer_project_snapshot() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {
-                "id": 50,
-                "snapshot_key": "insurance:project_corpus",
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "content_hash": "older-content-hash",
-            },
-        ]
-        cur.fetchall.return_value = [{"chunk_id": "chunk-1", "content_hash": "sha-1"}]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:project_corpus",
-            chunks=[{"chunk_id": "chunk-1", "content_hash": "sha-1", "content_text": "hello"}],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-        )
-
-    assert plan["latest_snapshot_key"] == "insurance:project_corpus"
-    assert plan["latest_snapshot_scope"] == "snapshot_key"
-    assert plan["changed_chunk_ids"] == []
-    assert plan["unchanged_chunk_ids"] == ["chunk-1"]
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert not any("ORDER BY created_at DESC" in sql for sql in executed_sql)
-
-
-def test_list_retrieval_snapshots_project_scope_uses_repo_key_is_null() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchall.return_value = []
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        cur.reset_mock()
-        _ = store.list_retrieval_snapshots(project_key="insurance", repo_key=None, limit=5)
-
-    execute_call = cur.execute.call_args
-    assert execute_call is not None
-    sql = str(execute_call.args[0])
-    params = execute_call.args[1]
-    assert "repo_key IS NULL" in sql
-    assert "repo_key = %s" not in sql
-    assert params == ("insurance", 5)
-
-
-def test_list_retrieval_snapshots_repo_scope_uses_repo_key_equality() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchall.return_value = []
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        cur.reset_mock()
-        _ = store.list_retrieval_snapshots(project_key="insurance", repo_key="insurance:svc-a", limit=5)
-
-    execute_call = cur.execute.call_args
-    assert execute_call is not None
-    sql = str(execute_call.args[0])
-    params = execute_call.args[1]
-    assert "repo_key = %s" in sql
-    assert "repo_key IS NULL" not in sql
-    assert params == ("insurance", "insurance:svc-a", 5)
-
-
-def test_plan_retrieval_refresh_repo_scope_reuses_project_snapshot_hashes() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {"id": 2},
-            None,
-            None,
-            {
-                "id": 11,
-                "snapshot_key": "insurance:project_corpus",
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-            },
-        ]
-        cur.fetchall.return_value = [{"chunk_id": "chunk-1", "content_hash": "sha-1"}]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key="insurance:svc-a",
-            snapshot_key="insurance:svc-a:project_corpus",
-            chunks=[{"chunk_id": "chunk-renamed", "content_hash": "sha-1", "content_text": "hello"}],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-        )
-
-    assert plan["changed_chunk_ids"] == []
-    assert plan["latest_snapshot_key"] == "insurance:project_corpus"
-    assert plan["latest_snapshot_scope"] == "project_fallback"
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert any("repo_key IS NULL" in sql for sql in executed_sql)
-
-
-def test_plan_retrieval_refresh_repo_scope_reuses_legacy_repo_alias_snapshot() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {"id": 2},
-            None,
-            None,
-            {
-                "id": 15,
-                "snapshot_key": "insurance-insurance-svc-a-project_corpus",
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-            },
-        ]
-        cur.fetchall.return_value = [{"chunk_id": "legacy-chunk", "content_hash": "sha-1"}]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key="local-svc-a",
-            snapshot_key="insurance-local-svc-a-project_corpus",
-            chunks=[{"chunk_id": "chunk-renamed", "content_hash": "sha-1", "content_text": "hello"}],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-        )
-
-    assert plan["changed_chunk_ids"] == []
-    assert plan["latest_snapshot_key"] == "insurance-insurance-svc-a-project_corpus"
-    assert plan["latest_snapshot_scope"] == "repo_alias"
-    executed_call_args = [call.args[1] for call in cur.execute.call_args_list if len(call.args) > 1]
-    assert any(args == ("insurance", "insurance-svc-a") for args in executed_call_args)
-
-
-def test_plan_retrieval_refresh_uses_version_tag_by_source_type_and_source_uri_with_diagnostics() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.return_value = {
-            "id": 10,
-            "snapshot_key": "insurance:prev",
-            "embedding_model_name": "bge-m3",
-            "embedding_model_digest": "digest-a",
-            "embedding_dimensions": 1024,
-        }
-        cur.fetchall.return_value = [
-            {
-                "chunk_id": "chunk-prev-1",
-                "content_hash": "sha-prev-1",
-                "source_type": "confluence_page",
-                "source_uri": "https://confluence.example/pages/viewpage.action?pageId=1001",
-                "version_tag": "7",
-            }
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:new",
-            chunks=[
-                {
-                    "chunk_id": "chunk-new-1",
-                    "content_hash": "sha-new-1",
-                    "content_text": "same document, new chunk id",
-                    "source_type": "confluence_page",
-                    "source_uri": "https://confluence.example/pages/viewpage.action?pageId=1001",
-                    "version_tag": "7",
-                },
-                {
-                    "chunk_id": "chunk-new-2",
-                    "content_hash": "sha-new-2",
-                    "content_text": "version changed",
-                    "source_type": "confluence_page",
-                    "source_uri": "https://confluence.example/pages/viewpage.action?pageId=1002",
-                    "version_tag": "8",
-                },
-                {
-                    "chunk_id": "chunk-new-3",
-                    "content_hash": "sha-new-3",
-                    "content_text": "missing metadata",
-                    "source_type": "confluence_page",
-                    "source_uri": "",
-                    "version_tag": "",
-                },
-            ],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-        )
-
-    assert plan["changed_chunk_ids"] == ["chunk-new-2", "chunk-new-3"]
-    assert plan["unchanged_chunk_ids"] == ["chunk-new-1"]
-    assert plan["docs_skipped_unchanged_count"] == 1
-    assert plan["docs_rechunked_count"] == 1
-    assert plan["docs_missing_version_tag_count"] == 1
-    assert plan["docs_missing_source_uri_count"] == 1
-
-
-def test_plan_retrieval_refresh_project_scope_treats_code_chunks_as_unchanged() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {
-                "id": 10,
-                "snapshot_key": "insurance:project_corpus",
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "content_hash": "not-matching-incoming",
-            },
-        ]
-        cur.fetchall.return_value = [
-            {
-                "chunk_id": "chunk-doc-1",
-                "content_hash": "sha-doc-1",
-                "source_type": "confluence_page",
-                "source_uri": "https://confluence.example/pages/viewpage.action?pageId=1001",
-                "version_tag": "7",
-            }
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.vector_index_diagnostics = MagicMock(return_value={"lexical_only": False})
-        plan = store.plan_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:project_corpus",
-            chunks=[
-                {
-                    "chunk_id": "chunk-code-1",
-                    "content_hash": "sha-code-1",
-                    "content_text": "class Sample {}",
-                    "source_type": "code_file",
-                    "metadata": {"source_type": "code_file"},
-                },
-                {
-                    "chunk_id": "chunk-doc-1",
-                    "content_hash": "sha-doc-1",
-                    "content_text": "Confluence content",
-                    "source_type": "confluence_page",
-                    "source_uri": "https://confluence.example/pages/viewpage.action?pageId=1001",
-                    "version_tag": "7",
-                    "metadata": {"source_type": "confluence_page"},
-                },
-            ],
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-        )
-
-    assert plan["changed_chunk_ids"] == []
-    assert plan["unchanged_chunk_ids"] == ["chunk-code-1", "chunk-doc-1"]
-
-
-def test_apply_retrieval_refresh_returns_lineage_and_counts() -> None:
-    now = datetime.now(UTC)
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {
-                "id": 77,
-                "snapshot_key": "insurance:snap-1",
-                "project_key": "insurance",
-                "repo_key": None,
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "index_type": "hnsw",
-                "lexical_only": False,
-                "embedding_model_changed": False,
-                "force_reason": None,
-                "payload": {},
-                "chunk_count": 2,
-                "changed_chunk_count": 1,
-                "state_version": 1,
-                "created_at": now,
-                "updated_at": now,
-            },
-            {"id": 70, "snapshot_key": "insurance:snap-0"},
-            {"id": 100},
-            {"id": 200},
-            {"id": 101},
-            {"id": 201},
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        result = store.apply_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:snap-1",
-            chunks=[
-                {
-                    "chunk_id": "chunk-1",
-                    "content_hash": "sha-1",
-                    "content_text": "one",
-                    "metadata": {},
-                },
-                {
-                    "chunk_id": "chunk-2",
-                    "content_hash": "sha-2",
-                    "content_text": "two",
-                    "metadata": {},
-                },
-            ],
-            embeddings_by_chunk_id={"chunk-1": [0.1, 0.2]},
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-            index_type="hnsw",
-            lexical_only=False,
-            diagnostics={
-                "vector_column_ready": True,
-                "docs_skipped_unchanged_count": 3,
-                "docs_rechunked_count": 1,
-            },
-        )
-
-    assert result["snapshot_id"] == 77
-    assert result["chunk_count"] == 2
-    assert result["changed_chunk_count"] == 1
-    assert result["reused_chunk_count"] == 1
-    assert result["docs_skipped_unchanged_count"] == 3
-    assert result["docs_rechunked_count"] == 1
-    assert result["embedding_dimensions"] == 1024
-    assert cur.execute.call_count >= 3
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert all("chunk_embeddings" not in sql for sql in executed_sql)
-
-
-def test_apply_retrieval_refresh_project_scope_skips_code_file_chunks_and_logs() -> None:
-    now = datetime.now(UTC)
-    with (
-        patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect,
-        patch("vds_audit_orchestrator.state.store._log.info") as mock_log_info,
-    ):
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {
-                "id": 77,
-                "snapshot_key": "insurance:project_corpus",
-                "project_key": "insurance",
-                "repo_key": None,
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "index_type": "hnsw",
-                "lexical_only": False,
-                "embedding_model_changed": False,
-                "force_reason": None,
-                "payload": {},
-                "chunk_count": 2,
-                "changed_chunk_count": 2,
-                "state_version": 1,
-                "created_at": now,
-                "updated_at": now,
-            },
-            None,
-            {"id": 100},
-            {"id": 200},
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        result = store.apply_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:project_corpus",
-            chunks=[
-                {
-                    "chunk_id": "chunk-code-1",
-                    "document_id": "doc-code-1",
-                    "content_hash": "sha-code-1",
-                    "content_text": "class Sample {}",
-                    "source_type": "code_file",
-                    "metadata": {"source_type": "code_file"},
-                },
-                {
-                    "chunk_id": "chunk-doc-1",
-                    "document_id": "doc-page-1",
-                    "content_hash": "sha-doc-1",
-                    "content_text": "Confluence page body",
-                    "source_type": "confluence_page",
-                    "metadata": {"source_type": "confluence_page"},
-                },
-            ],
-            embeddings_by_chunk_id={
-                "chunk-code-1": [0.11, 0.22],
-                "chunk-doc-1": [0.33, 0.44],
-            },
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-            index_type="hnsw",
-            lexical_only=False,
-            diagnostics={"vector_column_ready": True},
-        )
-
-    assert result["snapshot_id"] == 77
-    doc_insert_calls = [
-        call for call in cur.execute.call_args_list if "INSERT INTO audit_state.corpus_documents" in str(call.args[0])
-    ]
-    assert len(doc_insert_calls) == 1
-    assert doc_insert_calls[0].args[1][5] == "confluence_page"
-
-    dedup_logs = [
-        call for call in mock_log_info.call_args_list if call.args and call.args[0] == "extract_docs_code_dedup_skipped"
-    ]
-    assert len(dedup_logs) == 1
-    assert dedup_logs[0].kwargs["chunk_id"] == "chunk-code-1"
-    assert dedup_logs[0].kwargs["source_type"] == "code_file"
-    assert dedup_logs[0].kwargs["reason"] == "project_scope_code_file"
-
-
-def test_apply_retrieval_refresh_prunes_stale_rows_for_stable_snapshot_key() -> None:
-    now = datetime.now(UTC)
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {
-                "id": 77,
-                "snapshot_key": "insurance:project_corpus",
-                "project_key": "insurance",
-                "repo_key": None,
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "index_type": "hnsw",
-                "lexical_only": False,
-                "embedding_model_changed": False,
-                "force_reason": None,
-                "payload": {},
-                "chunk_count": 1,
-                "changed_chunk_count": 1,
-                "state_version": 1,
-                "created_at": now,
-                "updated_at": now,
-            },
-            None,
-            {"id": 100},
-            {"id": 200},
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        store.apply_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:project_corpus",
-            chunks=[
-                {
-                    "chunk_id": "chunk-1",
-                    "content_hash": "sha-1",
-                    "content_text": "one",
-                    "metadata": {},
-                }
-            ],
-            embeddings_by_chunk_id={"chunk-1": [0.1, 0.2]},
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-            index_type="hnsw",
-            lexical_only=False,
-            diagnostics={"vector_column_ready": True},
-        )
-
-    chunk_prune_call = next(
-        call
-        for call in cur.execute.call_args_list
-        if "DELETE FROM audit_state.corpus_chunks" in str(call.args[0])
-        and "NOT (chunk_id = ANY(%s))" in str(call.args[0])
-    )
-    assert chunk_prune_call.args[1][0] == 100
-    assert chunk_prune_call.args[1][1] == ["chunk-1"]
-
-    document_prune_call = next(
-        call
-        for call in cur.execute.call_args_list
-        if "DELETE FROM audit_state.corpus_documents" in str(call.args[0]) and "snapshot_id = %s" in str(call.args[0])
-    )
-    assert document_prune_call.args[1][0] == 77
-    assert document_prune_call.args[1][1] == [100]
-
-
-def test_apply_retrieval_refresh_prunes_snapshot_rows_when_chunk_set_is_empty() -> None:
-    now = datetime.now(UTC)
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {
-                "id": 77,
-                "snapshot_key": "insurance:project_corpus",
-                "project_key": "insurance",
-                "repo_key": None,
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "index_type": "hnsw",
-                "lexical_only": False,
-                "embedding_model_changed": False,
-                "force_reason": None,
-                "payload": {},
-                "chunk_count": 0,
-                "changed_chunk_count": 0,
-                "state_version": 1,
-                "created_at": now,
-                "updated_at": now,
-            },
-            {"id": 70, "snapshot_key": "insurance:snap-0"},
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        result = store.apply_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:project_corpus",
-            chunks=[],
-            embeddings_by_chunk_id={},
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-            index_type="hnsw",
-            lexical_only=False,
-            diagnostics={"vector_column_ready": True},
-        )
-
-    assert result["chunk_count"] == 0
-    assert result["changed_chunk_count"] == 0
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert any(
-        "DELETE FROM audit_state.corpus_documents" in sql and "WHERE snapshot_id = %s" in sql for sql in executed_sql
-    )
-    assert not any("DELETE FROM audit_state.corpus_chunks" in sql and "document_pk = %s" in sql for sql in executed_sql)
-    document_prune_call = next(
-        call
-        for call in cur.execute.call_args_list
-        if "DELETE FROM audit_state.corpus_documents" in str(call.args[0])
-        and "WHERE snapshot_id = %s" in str(call.args[0])
-    )
-    assert document_prune_call.args[1] == (77,)
-
-
-def test_apply_retrieval_refresh_copy_path_excludes_changed_chunks_to_prevent_churn() -> None:
-    now = datetime.now(UTC)
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {
-                "id": 77,
-                "snapshot_key": "insurance:project_corpus",
-                "project_key": "insurance",
-                "repo_key": None,
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "index_type": "hnsw",
-                "lexical_only": False,
-                "embedding_model_changed": False,
-                "force_reason": None,
-                "payload": {},
-                "chunk_count": 2,
-                "changed_chunk_count": 1,
-                "state_version": 1,
-                "created_at": now,
-                "updated_at": now,
-            },
-            {"id": 70, "snapshot_key": "insurance:snap-0"},
-            {"id": 100},
-            {"id": 200},
-            {"id": 101},
-            {"id": 201},
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        result = store.apply_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:project_corpus",
-            chunks=[
-                {
-                    "chunk_id": "chunk-unchanged",
-                    "document_id": "doc-unchanged",
-                    "content_hash": "sha-1",
-                    "content_text": "one",
-                    "metadata": {},
-                },
-                {
-                    "chunk_id": "chunk-changed",
-                    "document_id": "doc-changed",
-                    "content_hash": "sha-2",
-                    "content_text": "two",
-                    "metadata": {},
-                },
-            ],
-            embeddings_by_chunk_id={"chunk-changed": [0.2, 0.3]},
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-            index_type="hnsw",
-            lexical_only=False,
-            diagnostics={"vector_column_ready": True},
-        )
-
-    assert result["changed_chunk_count"] == 1
-    assert result["reused_chunk_count"] == 1
-
-    copy_calls = [
-        call
-        for call in cur.execute.call_args_list
-        if "FROM audit_state.corpus_embeddings AS source" in str(call.args[0])
-    ]
-    assert len(copy_calls) == 1
-    assert copy_calls[0].args[1][8] == ["chunk-changed"]
-
-    changed_embedding_writes = [
-        call
-        for call in cur.executemany.call_args_list
-        if "VALUES (%s, %s, %s, %s, %s, %s::vector)" in str(call.args[0])
-    ]
-    assert len(changed_embedding_writes) == 1
-    changed_rows = changed_embedding_writes[0].args[1]
-    assert len(changed_rows) == 1
-    assert changed_rows[0][1] == 200
-
-
-def test_apply_retrieval_refresh_repo_scope_reuses_project_scope_embeddings() -> None:
-    now = datetime.now(UTC)
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {"id": 2},
-            {
-                "id": 77,
-                "snapshot_key": "insurance:svc-a:project_corpus",
-                "project_key": "insurance",
-                "repo_key": "insurance:svc-a",
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "index_type": "hnsw",
-                "lexical_only": False,
-                "embedding_model_changed": False,
-                "force_reason": None,
-                "payload": {},
-                "chunk_count": 1,
-                "changed_chunk_count": 0,
-                "state_version": 1,
-                "created_at": now,
-                "updated_at": now,
-            },
-            None,
-            {"id": 70, "snapshot_key": "insurance:project_corpus"},
-            {"id": 100},
-            {"id": 200},
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        result = store.apply_retrieval_refresh(
-            project_key="insurance",
-            repo_key="insurance:svc-a",
-            snapshot_key="insurance:svc-a:project_corpus",
-            chunks=[
-                {
-                    "chunk_id": "chunk-1",
-                    "content_hash": "sha-1",
-                    "content_text": "one",
-                    "metadata": {},
-                }
-            ],
-            embeddings_by_chunk_id={},
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-            index_type="hnsw",
-            lexical_only=False,
-            diagnostics={"vector_column_ready": True},
-        )
-
-    assert result["snapshot_id"] == 77
-    assert result["changed_chunk_count"] == 0
-    assert result["reused_chunk_count"] == 1
-    copy_call = next(
-        call
-        for call in cur.execute.call_args_list
-        if "FROM audit_state.corpus_embeddings AS source" in str(call.args[0])
-    )
-    assert "ROW_NUMBER() OVER" in str(copy_call.args[0])
-    assert "PARTITION BY current_chunks.id" in str(copy_call.args[0])
-    assert "current_chunks.content_hash = previous_chunks.content_hash" in str(copy_call.args[0])
-    assert "NOT (current_chunks.chunk_id = ANY(%s))" in str(copy_call.args[0])
-    copy_args = copy_call.args[1]
-    assert copy_args[2] is None
-    assert copy_args[3] is None
-
-
-def test_apply_retrieval_refresh_repo_scope_reuses_legacy_alias_embeddings() -> None:
-    now = datetime.now(UTC)
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {"id": 2},
-            {
-                "id": 77,
-                "snapshot_key": "insurance:local-svc-a:project_corpus",
-                "project_key": "insurance",
-                "repo_key": "local-svc-a",
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "index_type": "hnsw",
-                "lexical_only": False,
-                "embedding_model_changed": False,
-                "force_reason": None,
-                "payload": {},
-                "chunk_count": 1,
-                "changed_chunk_count": 0,
-                "state_version": 1,
-                "created_at": now,
-                "updated_at": now,
-            },
-            None,
-            {"id": 70, "snapshot_key": "insurance-insurance-svc-a-project_corpus"},
-            {"id": 100},
-            {"id": 200},
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        result = store.apply_retrieval_refresh(
-            project_key="insurance",
-            repo_key="local-svc-a",
-            snapshot_key="insurance:local-svc-a:project_corpus",
-            chunks=[
-                {
-                    "chunk_id": "chunk-1",
-                    "content_hash": "sha-1",
-                    "content_text": "one",
-                    "metadata": {},
-                }
-            ],
-            embeddings_by_chunk_id={},
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-            index_type="hnsw",
-            lexical_only=False,
-            diagnostics={"vector_column_ready": True},
-        )
-
-    assert result["snapshot_id"] == 77
-    copy_call = next(
-        call
-        for call in cur.execute.call_args_list
-        if "FROM audit_state.corpus_embeddings AS source" in str(call.args[0])
-    )
-    copy_args = copy_call.args[1]
-    assert copy_args[2] is None
-    assert copy_args[3] is None
-    executed_call_args = [call.args[1] for call in cur.execute.call_args_list if len(call.args) > 1]
-    assert any(
-        args == ("insurance", "insurance-svc-a", "insurance:local-svc-a:project_corpus") for args in executed_call_args
-    )
-
-
-def test_apply_retrieval_refresh_skips_noop_row_updates_for_unchanged_chunks() -> None:
-    now = datetime.now(UTC)
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"id": 1},
-            {
-                "id": 77,
-                "snapshot_key": "insurance:project_corpus",
-                "project_key": "insurance",
-                "repo_key": None,
-                "embedding_model_name": "bge-m3",
-                "embedding_model_digest": "digest-a",
-                "embedding_dimensions": 1024,
-                "index_type": "hnsw",
-                "lexical_only": False,
-                "embedding_model_changed": False,
-                "force_reason": None,
-                "payload": {},
-                "chunk_count": 1,
-                "changed_chunk_count": 0,
-                "state_version": 1,
-                "created_at": now,
-                "updated_at": now,
-            },
-            None,  # previous snapshot lookup
-            None,  # document upsert conflict with unchanged values
-            {"id": 100},  # existing document id fallback
-            None,  # chunk upsert conflict with unchanged values
-            {"id": 200},  # existing chunk id fallback
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        result = store.apply_retrieval_refresh(
-            project_key="insurance",
-            repo_key=None,
-            snapshot_key="insurance:project_corpus",
-            chunks=[
-                {
-                    "chunk_id": "chunk-1",
-                    "content_hash": "sha-1",
-                    "content_text": "one",
-                    "metadata": {},
-                }
-            ],
-            embeddings_by_chunk_id={},
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-a",
-            embedding_dimensions=1024,
-            index_type="hnsw",
-            lexical_only=False,
-            diagnostics={"vector_column_ready": True},
-        )
-
-    assert result["changed_chunk_count"] == 0
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert any(
-        "audit_state.corpus_documents.source_type IS DISTINCT FROM EXCLUDED.source_type" in sql for sql in executed_sql
-    )
-    assert any(
-        "audit_state.corpus_chunks.chunk_order IS DISTINCT FROM EXCLUDED.chunk_order" in sql for sql in executed_sql
-    )
-    assert any("audit_state.corpus_chunks.page_id IS DISTINCT FROM EXCLUDED.page_id" in sql for sql in executed_sql)
-    assert any(
-        "INSERT INTO audit_state.corpus_chunks" in sql
-        and "chunk_order" in sql
-        and "start_line" in sql
-        and "end_line" in sql
-        for sql in executed_sql
-    )
-    assert any("FROM audit_state.corpus_documents" in sql and "document_id = %s" in sql for sql in executed_sql)
-    assert any("FROM audit_state.corpus_chunks" in sql and "chunk_id = %s" in sql for sql in executed_sql)
-
-
-def test_pgvector_version_readiness_requires_0_8_1_or_higher() -> None:
-    assert _is_pgvector_version_ok("0.8.0") is False
-    assert _is_pgvector_version_ok("0.8.1") is True
-    assert _is_pgvector_version_ok("0.9.0") is True
-
-
-def test_vector_index_diagnostics_reports_phase47_readiness() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"extversion": "0.8.1"},
-            {"atttypmod": 1024},
-        ]
-        cur.fetchall.return_value = [
-            {
-                "index_name": "idx_audit_state_corpus_embeddings_hnsw",
-                "index_method": "hnsw",
-                "is_valid": True,
-                "is_ready": True,
-            },
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        with patch.object(PostgresStateStore, "_ensure_runtime_schema_compatibility", return_value=None):
-            store = PostgresStateStore("postgresql://test")
-        with patch.object(
-            store,
-            "_phase47_schema_diagnostics",
-            return_value={
-                "schema_exists": True,
-                "schema_version_ready": True,
-                "phase47_tables_ready": True,
-                "phase47_indexes_ready": True,
-                "phase47_constraints_ready": True,
-                "legacy_chunk_embeddings_absent": True,
-                "phase47_ready": True,
-            },
-        ):
-            diagnostics = store.vector_index_diagnostics()
-
-    assert diagnostics["phase47"]["phase47_ready"] is True
-    assert diagnostics["phase47"]["legacy_chunk_embeddings_absent"] is True
-    assert diagnostics["hnsw_index_ready"] is True
-    assert diagnostics["vector_column_dimensions"] == 1024
-    assert diagnostics["lexical_only"] is False
-
-
-def test_acquire_corpus_session_lock_returns_true_when_available() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.return_value = {"acquired": True}
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        acquired = store.acquire_corpus_session_lock(project_storage_key="insurance", timeout_ms=5000)
-
-    assert acquired is True
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert any("pg_try_advisory_lock" in sql for sql in executed_sql)
-
-
-def test_acquire_corpus_session_lock_returns_false_on_timeout() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.return_value = {"acquired": False}
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        acquired = store.acquire_corpus_session_lock(project_storage_key="insurance", timeout_ms=0)
-
-    assert acquired is False
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert any("pg_try_advisory_lock" in sql for sql in executed_sql)
-
-
-def test_acquire_corpus_session_lock_timeout_does_not_auto_break_stale_lock() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        with patch.object(store, "_acquire_session_advisory_lock", return_value=False) as acquire_mock:
-            with patch.object(store, "detect_and_break_stale_advisory_lock", return_value=True) as break_mock:
-                acquired = store.acquire_corpus_session_lock(project_storage_key="insurance", timeout_ms=1234)
-
-    assert acquired is False
-    acquire_mock.assert_called_once_with(lock_scope_key="corpus:insurance", timeout_ms=1234)
-    break_mock.assert_not_called()
-
-
-def test_release_corpus_session_lock_returns_true() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.return_value = {"released": True}
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        released = store.release_corpus_session_lock(project_storage_key="insurance")
-
-    assert released is True
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert any("pg_advisory_unlock" in sql for sql in executed_sql)
-
-
-def test_apply_retrieval_refresh_sets_transaction_timeouts() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        conn.cursor.return_value.__enter__.return_value = cur
-        conn.transaction.side_effect = _null_context
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        cur.reset_mock()
-        cur.execute.side_effect = [None, None, RuntimeError("stop_after_timeout_guards")]
-        store._resolve_corpus_scope_ids = MagicMock(return_value=(1, None))
-
-        with pytest.raises(RuntimeError, match="stop_after_timeout_guards"):
-            store.apply_retrieval_refresh(
-                project_key="insurance",
-                repo_key=None,
-                snapshot_key="insurance:project_corpus",
-                chunks=[
-                    {
-                        "chunk_id": "chunk-1",
-                        "content_hash": "sha-1",
-                        "content_text": "hello",
-                        "source_type": "confluence_page",
-                    }
-                ],
-                embeddings_by_chunk_id={},
-                embedding_model_name="bge-m3",
-                embedding_model_digest="sha256:" + ("a" * 64),
-                embedding_dimensions=1024,
-                index_type="hnsw",
-                lexical_only=False,
-                diagnostics={"vector_column_ready": True},
-            )
-
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert executed_sql[0] == "SELECT set_config('lock_timeout', %s, true)"
-    assert executed_sql[1] == "SELECT set_config('statement_timeout', %s, true)"
-    executed_args = [call.args[1] for call in cur.execute.call_args_list[:2]]
-    assert executed_args == [("5000ms",), ("900000ms",)]
-
-
-def test_vector_index_diagnostics_marks_non_operable_ann_index_not_ready() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.side_effect = [
-            {"extversion": "0.8.1"},
-            {"atttypmod": 1024},
-        ]
-        cur.fetchall.return_value = [
-            {
-                "index_name": "idx_audit_state_corpus_embeddings_hnsw",
-                "index_method": "hnsw",
-                "is_valid": False,
-                "is_ready": True,
-            },
-        ]
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        with patch.object(
-            store,
-            "_phase47_schema_diagnostics",
-            return_value={
-                "schema_exists": True,
-                "schema_version_ready": True,
-                "phase47_tables_ready": True,
-                "phase47_indexes_ready": True,
-                "phase47_constraints_ready": True,
-                "legacy_chunk_embeddings_absent": True,
-                "phase47_ready": True,
-            },
-        ):
-            diagnostics = store.vector_index_diagnostics()
-
-    assert diagnostics["hnsw_index_ready"] is False
-    assert diagnostics["ivfflat_index_ready"] is False
-    assert diagnostics["lexical_only"] is True
-    assert diagnostics["fallback_reason"] == "pgvector ANN index exists but is not operable (not valid/ready)"
-
-
-def test_get_chunks_by_project_returns_typed_rows() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        expected_rows = [
-            {
-                "chunk_id": "chunk-1",
-                "content_text": "hello world",
-                "metadata": {"section": "intro"},
-                "source_uri": "http://confluence.local/pages/viewpage.action?pageId=123",
-                "version_tag": "v5",
-                "page_title": "Architecture Overview",
-                "space_key": "TTCN24",
-                "source_type": "confluence_page",
-            }
-        ]
-        cur.fetchall.return_value = expected_rows
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        cur.reset_mock()
-        rows = store.get_chunks_by_project(
-            project_storage_key="merchant-profile-service",
-            source_type="confluence_page",
-            limit=3,
-        )
-
-    assert rows == expected_rows
-    execute_call = cur.execute.call_args
-    assert execute_call is not None
-    sql = str(execute_call.args[0])
-    params = execute_call.args[1]
-    assert "cc.chunk_id" in sql
-    assert "cc.content_text" in sql
-    assert "cc.metadata" in sql
-    assert "FROM audit_state.projects p" in sql
-    assert "JOIN audit_state.retrieval_snapshots rs ON rs.project_key = p.project_key" in sql
-    assert "cd.source_uri" in sql
-    assert "cd.version_tag" in sql
-    assert "cd.page_title" in sql
-    assert "cd.space_key" in sql
-    assert "cd.source_type" in sql
-    assert "cd.source_type = %s" in sql
-    # Priority-based snapshot ordering (project_corpus > default > smoke_probe)
-    assert "WHEN lower(rs2.snapshot_key) LIKE '%%:project_corpus' THEN 3" in sql
-    assert "COALESCE(rs2.chunk_count, 0) DESC" in sql
-    assert params == (
-        "merchant-profile-service",
-        "merchant-profile-service",
-        "confluence_page",
-        3,
-    )
-
-
-def test_detect_and_break_stale_advisory_lock_terminates_stale_backend() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        with patch("vds_audit_orchestrator.state.store.time.sleep") as mock_sleep:
-            conn = MagicMock()
-            cur = MagicMock()
-            cur.fetchone.side_effect = [
-                {
-                    "pid": 4321,
-                    "state": "idle",
-                    "state_change": datetime.now(UTC),
-                    "backend_start": datetime.now(UTC),
-                    "idle_seconds": 1200.0,
-                },
-                {"terminated": True},
-            ]
-            conn.cursor.return_value.__enter__.return_value = cur
-            mock_connect.return_value = conn
-
-            store = PostgresStateStore("postgresql://test")
-            cur.reset_mock()
-            broken = store.detect_and_break_stale_advisory_lock(
-                lock_key="corpus:merchant-profile-service",
-                stale_threshold_minutes=10,
-            )
-
-    assert broken is True
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert any("FROM pg_locks pl" in sql for sql in executed_sql)
-    assert any("pg_terminate_backend" in sql for sql in executed_sql)
-    mock_sleep.assert_called_once_with(2)
-
-
-def test_detect_and_break_stale_advisory_lock_skips_non_stale_backend() -> None:
-    with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-        conn = MagicMock()
-        cur = MagicMock()
-        cur.fetchone.return_value = {
-            "pid": 111,
-            "state": "idle",
-            "state_change": datetime.now(UTC),
-            "backend_start": datetime.now(UTC),
-            "idle_seconds": 45.0,
-        }
-        conn.cursor.return_value.__enter__.return_value = cur
-        mock_connect.return_value = conn
-
-        store = PostgresStateStore("postgresql://test")
-        cur.reset_mock()
-        broken = store.detect_and_break_stale_advisory_lock(
-            lock_key="corpus:merchant-profile-service",
-            stale_threshold_minutes=10,
-        )
-
-    assert broken is False
-    executed_sql = [str(call.args[0]) for call in cur.execute.call_args_list]
-    assert any("FROM pg_locks pl" in sql for sql in executed_sql)
-    assert all("pg_terminate_backend" not in sql for sql in executed_sql)