@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/integration/test_phase48_e2e_verification.py

@@ -1,763 +0,0 @@
-"""End-to-end verification tests for Phase 48 Postgres-only retrieval.
-
-These tests verify the complete flow:
-  parse-registry -> extract-docs -> workflow
-
-Key verifications:
-  - parse-registry seeds state correctly
-  - extract-docs automatically triggers retrieval refresh (chunk+embedding)
-  - workflow retrieves evidence from Postgres only (no filesystem fallback)
-  - Rerun with no changes shows no-rework behavior (changed_chunk_count=0)
-
-References:
-  - Phase 48 design: Postgres-only retrieval enforcement
-  - FR-47.3.7: Hybrid code retrieval with RRF fusion metadata
-  - FR-47.2.10: Advisory lock contract
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-from datetime import UTC, datetime
-from pathlib import Path
-
-import pytest
-
-# =============================================================================
-# Mock Fixtures
-# =============================================================================
-
-
-@pytest.fixture
-def mock_state_store():
-    """Create a mock PostgresStateStore for E2E testing."""
-
-    class MockPostgresStateStore:
-        def __init__(self):
-            self.projects = {}
-            self.repos = {}
-            self.project_links = []
-            self.repo_links = []
-            self.project_preparations = {}
-            self.repo_preparations = {}
-            self.retrieval_snapshots = {}
-            self.corpus_documents = {}
-            self.corpus_chunks = {}
-            self.corpus_embeddings = {}
-            self._closed = False
-            self._call_log = []  # Track method calls for assertions
-
-        def close(self):
-            self._closed = True
-
-        def init_schema(self):
-            self._call_log.append(("init_schema", {}))
-
-        def validate_schema(self):
-            self._call_log.append(("validate_schema", {}))
-            return True
-
-        def upsert_project(self, *, project_key, display_name, metadata=None):
-            self._call_log.append(("upsert_project", {"project_key": project_key}))
-            if project_key not in self.projects:
-                self.projects[project_key] = {
-                    "id": len(self.projects) + 1,
-                    "project_key": project_key,
-                    "display_name": display_name,
-                    "metadata": metadata or {},
-                    "state_version": 1,
-                    "created_at": datetime.now(UTC),
-                    "updated_at": datetime.now(UTC),
-                }
-            return self.projects[project_key]
-
-        def upsert_repo(self, *, project_id, repo_key, repo_url, metadata=None):
-            self._call_log.append(("upsert_repo", {"repo_key": repo_key}))
-            if repo_key not in self.repos:
-                self.repos[repo_key] = {
-                    "id": len(self.repos) + 1,
-                    "project_id": project_id,
-                    "repo_key": repo_key,
-                    "repo_url": repo_url,
-                    "default_branch": "main",
-                    "metadata": metadata or {},
-                    "state_version": 1,
-                    "created_at": datetime.now(UTC),
-                    "updated_at": datetime.now(UTC),
-                }
-            return self.repos[repo_key]
-
-        def upsert_project_link(self, **kwargs):
-            self._call_log.append(("upsert_project_link", kwargs))
-            self.project_links.append(kwargs)
-            return {"id": len(self.project_links), **kwargs}
-
-        def upsert_repo_link(self, **kwargs):
-            self._call_log.append(("upsert_repo_link", kwargs))
-            self.repo_links.append(kwargs)
-            return {"id": len(self.repo_links), **kwargs}
-
-        def upsert_project_preparation(self, **kwargs):
-            self._call_log.append(("upsert_project_preparation", kwargs))
-            key = kwargs.get("project_storage_key", "unknown")
-            self.project_preparations[key] = {
-                "id": len(self.project_preparations) + 1,
-                "status": kwargs.get("status", "prepared"),
-                "sync_metadata": kwargs.get("sync_metadata", {}),
-                **kwargs,
-            }
-            return self.project_preparations[key]
-
-        def upsert_repo_preparation(self, **kwargs):
-            self._call_log.append(("upsert_repo_preparation", kwargs))
-            key = kwargs.get("repo_storage_key", "unknown")
-            self.repo_preparations[key] = {
-                "id": len(self.repo_preparations) + 1,
-                "status": kwargs.get("status", "ready"),
-                "readiness": kwargs.get("readiness", "ready"),
-                "local_code_path": kwargs.get("local_code_path"),
-                **kwargs,
-            }
-            return self.repo_preparations[key]
-
-        def list_retrieval_snapshots(self, *, project_key, repo_key=None, limit=None):
-            self._call_log.append(("list_retrieval_snapshots", {"project_key": project_key, "repo_key": repo_key}))
-            snapshots = [s for s in self.retrieval_snapshots.values() if s.get("project_key") == project_key]
-            if repo_key:
-                snapshots = [s for s in snapshots if s.get("repo_key") == repo_key]
-            return snapshots[:limit] if limit else snapshots
-
-        def plan_retrieval_refresh(
-            self,
-            *,
-            project_key,
-            repo_key,
-            snapshot_key,
-            chunks,
-            embedding_model_name,
-            embedding_model_digest,
-            embedding_dimensions,
-        ):
-            self._call_log.append(
-                (
-                    "plan_retrieval_refresh",
-                    {
-                        "project_key": project_key,
-                        "snapshot_key": snapshot_key,
-                        "chunk_count": len(chunks),
-                    },
-                )
-            )
-            # Detect changed chunks by comparing hashes across ALL existing snapshots
-            # for this project (not just the same snapshot)
-            existing_hashes = set()
-            for snap_key, snap_chunks in self.corpus_chunks.items():
-                if snap_key.startswith(f"{project_key}:"):
-                    for c in snap_chunks.values():
-                        existing_hashes.add(c.get("content_hash"))
-
-            changed_chunk_ids = [c["chunk_id"] for c in chunks if c.get("content_hash") not in existing_hashes]
-            return {
-                "embedding_model_changed": False,
-                "force_reason": None,
-                "changed_chunk_ids": changed_chunk_ids,
-                "chunk_count": len(chunks),
-            }
-
-        def apply_retrieval_refresh(
-            self,
-            *,
-            project_key,
-            repo_key,
-            snapshot_key,
-            chunks,
-            embeddings_by_chunk_id,
-            embedding_model_name,
-            embedding_model_digest,
-            embedding_dimensions,
-            index_type="hnsw",
-            embedding_model_changed=False,
-            lexical_only=False,
-            diagnostics=None,
-        ):
-            self._call_log.append(
-                (
-                    "apply_retrieval_refresh",
-                    {
-                        "project_key": project_key,
-                        "snapshot_key": snapshot_key,
-                        "chunk_count": len(chunks),
-                    },
-                )
-            )
-
-            # Store chunks
-            if snapshot_key not in self.corpus_chunks:
-                self.corpus_chunks[snapshot_key] = {}
-            for chunk in chunks:
-                self.corpus_chunks[snapshot_key][chunk["chunk_id"]] = chunk
-
-            # Calculate changed count
-            changed_count = len([c for c in chunks if c["chunk_id"] in embeddings_by_chunk_id])
-
-            # Create/update retrieval snapshot
-            snapshot_id = len(self.retrieval_snapshots) + 1
-            self.retrieval_snapshots[snapshot_key] = {
-                "id": snapshot_id,
-                "snapshot_key": snapshot_key,
-                "project_key": project_key,
-                "repo_key": repo_key,
-                "embedding_model_name": embedding_model_name,
-                "embedding_model_digest": embedding_model_digest,
-                "embedding_dimensions": embedding_dimensions,
-                "index_type": index_type,
-                "lexical_only": lexical_only,
-                "embedding_model_changed": embedding_model_changed,
-                "force_reason": None,
-                "chunk_count": len(chunks),
-                "changed_chunk_count": changed_count,
-                "state_version": 1,
-                "created_at": datetime.now(UTC),
-                "updated_at": datetime.now(UTC),
-            }
-
-            return {
-                "snapshot_id": snapshot_id,
-                "snapshot_key": snapshot_key,
-                "chunk_count": len(chunks),
-                "changed_chunk_count": changed_count,
-                "reused_chunk_count": len(chunks) - changed_count,
-                "embedding_dimensions": embedding_dimensions,
-            }
-
-        def hybrid_search(
-            self,
-            *,
-            project_key,
-            query_text,
-            snapshot_key=None,
-            retrieval_mode="lexical",
-            top_k=10,
-            rrf_k=60,
-        ):
-            self._call_log.append(
-                (
-                    "hybrid_search",
-                    {
-                        "project_key": project_key,
-                        "query_text": query_text,
-                        "retrieval_mode": retrieval_mode,
-                        "snapshot_key": snapshot_key,
-                    },
-                )
-            )
-            # Return mock search results from Postgres
-            results = []
-
-            # Find chunks from specified snapshot, or latest for project
-            chunks = {}
-            if snapshot_key and snapshot_key in self.corpus_chunks:
-                chunks = self.corpus_chunks[snapshot_key]
-            else:
-                # Find latest snapshot for this project
-                project_snapshots = [k for k in self.corpus_chunks if k.startswith(f"{project_key}:")]
-                if project_snapshots:
-                    # Sort by timestamp in key and get latest
-                    project_snapshots.sort(reverse=True)
-                    chunks = self.corpus_chunks[project_snapshots[0]]
-
-            for chunk_id, chunk in chunks.items():
-                # Simple word-based text matching for mock
-                content = chunk.get("content_text", "").lower()
-                query_words = query_text.lower().split()
-                # Match if any query word is found in content
-                if any(word in content for word in query_words):
-                    results.append(
-                        {
-                            "chunk_pk": hash(chunk_id),
-                            "chunk_id": chunk_id,
-                            "content_text": chunk.get("content_text", ""),
-                            "source_uri": chunk.get("source_uri"),
-                            "page_id": chunk.get("page_id"),
-                            "content_hash": chunk.get("content_hash"),
-                            "metadata": chunk.get("metadata", {}),
-                            "lexical_rank": 1,
-                            "vector_rank": None,
-                            "rrf_score": 0.9,
-                        }
-                    )
-            return results[:top_k]
-
-        def vector_index_diagnostics(self):
-            self._call_log.append(("vector_index_diagnostics", {}))
-            return {
-                "lexical_only": False,
-                "phase47": {"phase47_ready": True},
-                "vector_column_ready": True,
-                "hnsw_index_ready": True,
-            }
-
-        def acquire_corpus_lock(self, *, project_storage_key, timeout_ms=5000):
-            self._call_log.append(("acquire_corpus_lock", {"project_storage_key": project_storage_key}))
-            return True  # Always acquire successfully in mock
-
-    return MockPostgresStateStore()
-
-
-@pytest.fixture
-def sample_registry_payload():
-    """Sample registry payload for parse-registry seeding."""
-    return {
-        "registry_url": "https://confluence.example.com/pages/registry",
-        "registry_page_id": "REGISTRY-001",
-        "projects": [
-            {
-                "project_name": "Insurance Service",
-                "project_name_en": "insurance-service",
-                "page_id": "PROJ-001",
-                "page_url": "https://confluence.example.com/pages/PROJ-001",
-                "department": "IT",
-                "confluence_links": [
-                    {
-                        "url": "https://confluence.example.com/pages/DOC-001",
-                        "role": "canonical",
-                    }
-                ],
-                "bitbucket_links": [
-                    {
-                        "url": "https://bitbucket.example.com/projects/INS/repos/insurance-service",
-                        "repo_slug": "insurance-service",
-                    }
-                ],
-                "documents": [
-                    {
-                        "role": "BA",
-                        "doc_number": 1,
-                        "doc_type": "Tai lieu yeu cau",
-                        "doc_type_en": "SRS",
-                        "url": "https://confluence.example.com/pages/SRS-001",
-                        "source": "confluence",
-                        "title": "System Requirements Specification",
-                    }
-                ],
-            }
-        ],
-    }
-
-
-@pytest.fixture
-def sample_chunks_payload(tmp_path: Path):
-    """Create sample chunks payload for extract-docs retrieval refresh."""
-    chunks = [
-        {
-            "chunk_id": "chunk-001",
-            "content_hash": hashlib.sha256(b"content-1").hexdigest(),
-            "content_text": "# System Requirements\n\nThe insurance platform requires user authentication.",
-            "page_id": "SRS-001",
-            "metadata": {"doc_type": "SRS", "language": "en"},
-        },
-        {
-            "chunk_id": "chunk-002",
-            "content_hash": hashlib.sha256(b"content-2").hexdigest(),
-            "content_text": "# Architecture\n\nThe system uses microservices architecture.",
-            "page_id": "ARCH-001",
-            "metadata": {"doc_type": "DESIGN", "language": "en"},
-        },
-    ]
-
-    chunks_path = tmp_path / "chunks.json"
-    chunks_path.write_text(json.dumps(chunks), encoding="utf-8")
-    return chunks_path, chunks
-
-
-# =============================================================================
-# E2E Verification Tests
-# =============================================================================
-
-
-class TestPhase48E2EVerification:
-    """End-to-end tests for Phase 48 Postgres-only retrieval flow."""
-
-    def test_parse_registry_seeds_state_correctly(self, mock_state_store, sample_registry_payload):
-        """Verify parse-registry correctly seeds the Postgres state store."""
-        # Simulate parse-registry flow
-        for project_data in sample_registry_payload["projects"]:
-            project_key = project_data.get("project_name_en", project_data.get("project_name"))
-            project = mock_state_store.upsert_project(
-                project_key=project_key,
-                display_name=project_data.get("project_name"),
-                metadata={"page_id": project_data.get("page_id")},
-            )
-
-            # Seed project links (Confluence)
-            for link in project_data.get("confluence_links", []):
-                mock_state_store.upsert_project_link(
-                    project_id=project["id"],
-                    link_type="confluence",
-                    link_role=link.get("role", "canonical"),
-                    normalized_url=link.get("url"),
-                    raw_url=link.get("url"),
-                    source_page_id=project_data.get("page_id"),
-                )
-
-            # Seed repo links (Bitbucket)
-            for link in project_data.get("bitbucket_links", []):
-                repo = mock_state_store.upsert_repo(
-                    project_id=project["id"],
-                    repo_key=f"{project_key}:{link.get('repo_slug')}",
-                    repo_url=link.get("url"),
-                )
-                mock_state_store.upsert_repo_link(
-                    repo_id=repo["id"],
-                    link_type="repo_url",
-                    link_role="origin",
-                    normalized_url=link.get("url"),
-                    raw_url=link.get("url"),
-                )
-
-        # Verify state was seeded correctly
-        assert "insurance-service" in mock_state_store.projects
-        assert len(mock_state_store.project_links) == 1
-        assert len(mock_state_store.repos) == 1
-        assert len(mock_state_store.repo_links) == 1
-
-        # Verify no filesystem operations were called
-        call_names = [c[0] for c in mock_state_store._call_log]
-        assert "upsert_project" in call_names
-        assert "upsert_repo" in call_names
-
-    def test_extract_docs_triggers_retrieval_refresh(self, mock_state_store, sample_chunks_payload):
-        """Verify extract-docs automatically triggers retrieval refresh."""
-        _chunks_path, chunks = sample_chunks_payload
-        project_key = "insurance-service"
-        snapshot_key = f"{project_key}:2026-02-13T00:00:00"
-
-        # First, seed a project
-        mock_state_store.upsert_project(
-            project_key=project_key,
-            display_name="Insurance Service",
-        )
-
-        # Simulate extract-docs retrieval refresh flow
-        # 1. Plan retrieval refresh
-        mock_state_store.plan_retrieval_refresh(
-            project_key=project_key,
-            repo_key=None,
-            snapshot_key=snapshot_key,
-            chunks=chunks,
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-v1",
-            embedding_dimensions=1024,
-        )
-
-        # 2. Apply retrieval refresh (simulating embedding generation)
-        embeddings = {chunk["chunk_id"]: [0.1] * 1024 for chunk in chunks}
-        result = mock_state_store.apply_retrieval_refresh(
-            project_key=project_key,
-            repo_key=None,
-            snapshot_key=snapshot_key,
-            chunks=chunks,
-            embeddings_by_chunk_id=embeddings,
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-v1",
-            embedding_dimensions=1024,
-        )
-
-        # Verify refresh was triggered
-        assert result["chunk_count"] == 2
-        assert result["changed_chunk_count"] == 2  # All chunks are new
-
-        # Verify snapshot was created
-        assert snapshot_key in mock_state_store.retrieval_snapshots
-        assert mock_state_store.retrieval_snapshots[snapshot_key]["chunk_count"] == 2
-
-    def test_workflow_retrieves_from_postgres_only(self, mock_state_store, sample_chunks_payload):
-        """Verify workflow retrieves evidence from Postgres without filesystem fallback."""
-        _chunks_path, chunks = sample_chunks_payload
-        project_key = "insurance-service"
-        snapshot_key = f"{project_key}:2026-02-13T00:00:00"
-
-        # Seed project and chunks
-        mock_state_store.upsert_project(project_key=project_key, display_name="Insurance Service")
-        embeddings = {chunk["chunk_id"]: [0.1] * 1024 for chunk in chunks}
-        mock_state_store.apply_retrieval_refresh(
-            project_key=project_key,
-            repo_key=None,
-            snapshot_key=snapshot_key,
-            chunks=chunks,
-            embeddings_by_chunk_id=embeddings,
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-v1",
-            embedding_dimensions=1024,
-        )
-
-        # Simulate workflow retrieval (should use Postgres hybrid_search)
-        results = mock_state_store.hybrid_search(
-            project_key=project_key,
-            query_text="requirements authentication",
-            snapshot_key=snapshot_key,
-            retrieval_mode="hybrid",
-            top_k=5,
-        )
-
-        # Verify results came from Postgres (not filesystem)
-        assert len(results) > 0
-        assert all("chunk_id" in r for r in results)
-        assert all("content_text" in r for r in results)
-
-        # Verify no filesystem fallback was invoked
-        call_names = [c[0] for c in mock_state_store._call_log]
-        assert "hybrid_search" in call_names
-        # Ensure no file read operations
-        file_ops = [c for c in call_names if "file" in c.lower() or "read" in c.lower()]
-        assert len(file_ops) == 0, f"Unexpected filesystem operations: {file_ops}"
-
-    def test_rerun_shows_no_rework_behavior(self, mock_state_store, sample_chunks_payload):
-        """Verify rerun with no changes shows changed_chunk_count=0."""
-        _chunks_path, chunks = sample_chunks_payload
-        project_key = "insurance-service"
-        snapshot_key_1 = f"{project_key}:run-1"
-        snapshot_key_2 = f"{project_key}:run-2"
-
-        # Seed project
-        mock_state_store.upsert_project(project_key=project_key, display_name="Insurance Service")
-
-        # First run: apply chunks
-        embeddings = {chunk["chunk_id"]: [0.1] * 1024 for chunk in chunks}
-        result_1 = mock_state_store.apply_retrieval_refresh(
-            project_key=project_key,
-            repo_key=None,
-            snapshot_key=snapshot_key_1,
-            chunks=chunks,
-            embeddings_by_chunk_id=embeddings,
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-v1",
-            embedding_dimensions=1024,
-        )
-
-        # Verify first run processed all chunks
-        assert result_1["chunk_count"] == 2
-        assert result_1["changed_chunk_count"] == 2
-
-        # Second run: same chunks (no changes)
-        # First, plan to detect no changes
-        plan_2 = mock_state_store.plan_retrieval_refresh(
-            project_key=project_key,
-            repo_key=None,
-            snapshot_key=snapshot_key_2,
-            chunks=chunks,  # Same chunks
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-v1",
-            embedding_dimensions=1024,
-        )
-
-        # Since chunks already exist with same hashes, no changes detected
-        assert plan_2["changed_chunk_ids"] == []
-        assert plan_2["embedding_model_changed"] is False
-
-        # Apply second run (simulating no rework)
-        # In real scenario, empty embeddings would mean no re-embedding
-        result_2 = mock_state_store.apply_retrieval_refresh(
-            project_key=project_key,
-            repo_key=None,
-            snapshot_key=snapshot_key_2,
-            chunks=chunks,
-            embeddings_by_chunk_id={},  # No new embeddings needed
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-v1",
-            embedding_dimensions=1024,
-        )
-
-        # Verify no-rework behavior
-        assert result_2["changed_chunk_count"] == 0
-        assert result_2["reused_chunk_count"] == 2
-
-
-class TestPhase48StructuredLogging:
-    """Tests for structured logging assertions during Postgres-only retrieval."""
-
-    def test_postgres_retrieval_logs_no_filesystem_fallback(self, mock_state_store, sample_chunks_payload, caplog):
-        """Verify structured logging indicates Postgres-only retrieval."""
-        import logging
-
-        # Set up logging capture
-        caplog.set_level(logging.DEBUG)
-
-        _chunks_path, chunks = sample_chunks_payload
-        project_key = "insurance-service"
-        snapshot_key = f"{project_key}:log-test"
-
-        # Seed and refresh
-        mock_state_store.upsert_project(project_key=project_key, display_name="Insurance Service")
-        embeddings = {chunk["chunk_id"]: [0.1] * 1024 for chunk in chunks}
-        mock_state_store.apply_retrieval_refresh(
-            project_key=project_key,
-            repo_key=None,
-            snapshot_key=snapshot_key,
-            chunks=chunks,
-            embeddings_by_chunk_id=embeddings,
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-v1",
-            embedding_dimensions=1024,
-        )
-
-        # Perform search
-        results = mock_state_store.hybrid_search(
-            project_key=project_key,
-            query_text="test query",
-            retrieval_mode="hybrid",
-        )
-
-        # Verify search used Postgres
-        assert len(results) >= 0  # May or may not match
-
-        # Verify call log shows Postgres operations
-        call_log = mock_state_store._call_log
-        pg_operations = [c for c in call_log if c[0] in ("hybrid_search", "apply_retrieval_refresh")]
-        assert len(pg_operations) > 0
-
-        # Verify no filesystem operations in call log
-        fs_operations = [c for c in call_log if any(kw in c[0].lower() for kw in ["file", "read", "load", "path"])]
-        assert len(fs_operations) == 0, f"Unexpected filesystem operations: {fs_operations}"
-
-    def test_retrieval_snapshot_lineage_metadata(self, mock_state_store, sample_chunks_payload):
-        """Verify retrieval snapshots maintain proper lineage metadata."""
-        _chunks_path, chunks = sample_chunks_payload
-        project_key = "insurance-service"
-        snapshot_key = f"{project_key}:lineage-test"
-
-        mock_state_store.upsert_project(project_key=project_key, display_name="Insurance Service")
-
-        embeddings = {chunk["chunk_id"]: [0.1] * 1024 for chunk in chunks}
-        result = mock_state_store.apply_retrieval_refresh(
-            project_key=project_key,
-            repo_key=None,
-            snapshot_key=snapshot_key,
-            chunks=chunks,
-            embeddings_by_chunk_id=embeddings,
-            embedding_model_name="bge-m3",
-            embedding_model_digest="sha256:abc123",
-            embedding_dimensions=1024,
-            index_type="hnsw",
-        )
-
-        # Verify lineage metadata
-        assert result["snapshot_key"] == snapshot_key
-        assert result["embedding_dimensions"] == 1024
-
-        # Verify snapshot stored with full metadata
-        snapshot = mock_state_store.retrieval_snapshots[snapshot_key]
-        assert snapshot["embedding_model_name"] == "bge-m3"
-        assert snapshot["embedding_model_digest"] == "sha256:abc123"
-        assert snapshot["index_type"] == "hnsw"
-        assert snapshot["lexical_only"] is False
-
-
-class TestPhase48NoRetrievalRefreshCommand:
-    """Tests verifying no manual retrieval-refresh command is needed."""
-
-    def test_extract_docs_auto_refresh_without_manual_command(self, mock_state_store, sample_chunks_payload):
-        """Verify extract-docs automatically triggers refresh without manual command."""
-        _chunks_path, chunks = sample_chunks_payload
-        project_key = "insurance-service"
-        snapshot_key = f"{project_key}:auto-refresh"
-
-        mock_state_store.upsert_project(project_key=project_key, display_name="Insurance Service")
-
-        # Simulate extract-docs flow with auto-refresh enabled
-        # This is what happens when --refresh-retrieval-snapshot is passed
-
-        # 1. Preflight checks
-        diagnostics = mock_state_store.vector_index_diagnostics()
-        assert diagnostics["lexical_only"] is False
-        assert diagnostics["phase47"]["phase47_ready"] is True
-
-        # 2. Acquire corpus lock
-        lock_acquired = mock_state_store.acquire_corpus_lock(project_storage_key=project_key)
-        assert lock_acquired is True
-
-        # 3. Plan and apply refresh
-        mock_state_store.plan_retrieval_refresh(
-            project_key=project_key,
-            repo_key=None,
-            snapshot_key=snapshot_key,
-            chunks=chunks,
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-v1",
-            embedding_dimensions=1024,
-        )
-
-        embeddings = {chunk["chunk_id"]: [0.1] * 1024 for chunk in chunks}
-        result = mock_state_store.apply_retrieval_refresh(
-            project_key=project_key,
-            repo_key=None,
-            snapshot_key=snapshot_key,
-            chunks=chunks,
-            embeddings_by_chunk_id=embeddings,
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-v1",
-            embedding_dimensions=1024,
-        )
-
-        # Verify automatic refresh completed
-        assert result["chunk_count"] == 2
-
-        # Verify no manual refresh-retrieval-snapshot command was needed
-        # (All operations happened within extract-docs flow)
-        call_names = [c[0] for c in mock_state_store._call_log]
-        assert "plan_retrieval_refresh" in call_names
-        assert "apply_retrieval_refresh" in call_names
-
-    def test_full_e2e_flow_without_manual_refresh(
-        self, mock_state_store, sample_registry_payload, sample_chunks_payload
-    ):
-        """Full E2E test: parse-registry -> extract-docs -> workflow."""
-        _chunks_path, chunks = sample_chunks_payload
-        project_key = "insurance-service"
-        snapshot_key = f"{project_key}:e2e-test"
-
-        # Step 1: parse-registry seeds state
-        for project_data in sample_registry_payload["projects"]:
-            pk = project_data.get("project_name_en", project_data.get("project_name"))
-            mock_state_store.upsert_project(
-                project_key=pk,
-                display_name=project_data.get("project_name"),
-            )
-
-        assert project_key in mock_state_store.projects
-
-        # Step 2: extract-docs auto-triggers retrieval refresh
-        embeddings = {chunk["chunk_id"]: [0.1] * 1024 for chunk in chunks}
-        refresh_result = mock_state_store.apply_retrieval_refresh(
-            project_key=project_key,
-            repo_key=None,
-            snapshot_key=snapshot_key,
-            chunks=chunks,
-            embeddings_by_chunk_id=embeddings,
-            embedding_model_name="bge-m3",
-            embedding_model_digest="digest-v1",
-            embedding_dimensions=1024,
-        )
-
-        assert refresh_result["chunk_count"] == 2
-
-        # Step 3: workflow retrieves from Postgres only
-        search_results = mock_state_store.hybrid_search(
-            project_key=project_key,
-            query_text="requirements",
-            snapshot_key=snapshot_key,
-            retrieval_mode="hybrid",
-        )
-
-        assert len(search_results) > 0
-
-        # Verify complete flow used Postgres-only retrieval
-        call_log = mock_state_store._call_log
-        assert any(c[0] == "upsert_project" for c in call_log)  # parse-registry
-        assert any(c[0] == "apply_retrieval_refresh" for c in call_log)  # extract-docs
-        assert any(c[0] == "hybrid_search" for c in call_log)  # workflow
-
-        # Verify no filesystem operations
-        fs_calls = [c for c in call_log if "file" in c[0].lower() or "read" in c[0].lower()]
-        assert len(fs_calls) == 0