fix(evidence): retain referenced vector generations

harness/tht/corpus/pipeline.py

@@ -96,33 +96,47 @@ class CorpusPipeline:
         list_vectors = getattr(self.vector_store, "list_evidence_generations", None)
         vector_generations = set(list_vectors("evidence")) if list_vectors else set()
         generations = sorted(set(published) | vector_generations)
-        protected = self._protected_generations(workspace_root)
+        job_protected = self._protected_generations(workspace_root)
         active = self.store.active_generation()
         rollback_count = self.retain_published_generations - 1
         rollback = [generation for generation in published if generation != active]
         keep = ({active} if active else set()) | set(rollback[-rollback_count:] if rollback_count else ())
-        keep |= protected
+        fs_keep = keep | job_protected
+        vector_protected = set(fs_keep)
+        for generation in fs_keep:
+            try:
+                manifest = self.store.manifest(generation)
+            except (OSError, ValueError):
+                continue
+            vector_protected.update(
+                value for value in manifest.metadata.get("document_generations", {}).values()
+                if isinstance(value, str)
+            )
         evicted, failures = [], []
+        filesystem_generations = set(self.store.list_generations())
         for generation in generations:
-            if generation in keep:
+            purge_vector = generation not in vector_protected
+            purge_filesystem = generation in filesystem_generations and generation not in fs_keep
+            if not purge_vector and not purge_filesystem:
                 continue
             if dry_run:
                 evicted.append(generation)
                 continue
+            if purge_vector:
+                try:
+                    self.vector_store.delete_generation("evidence", generation)
+                except Exception:
+                    failures.append({"generation": generation, "error": "vector cleanup failed"})
+                    continue
             try:
-                self.vector_store.delete_generation("evidence", generation)
-            except Exception:
-                failures.append({"generation": generation, "error": "vector cleanup failed"})
-                continue
-            try:
-                if generation in self.store.list_generations():
+                if purge_filesystem:
                     self.store.discard(generation)
                 evicted.append(generation)
             except Exception:
                 failures.append({"generation": generation, "error": "filesystem cleanup failed"})
         return {"status": "partial" if failures else "succeeded", "dry_run": dry_run,
                 "active_generation": self.store.active_generation(), "evicted": evicted,
-                "protected": sorted(protected), "failures": failures}
+                "protected": sorted(vector_protected), "failures": failures}
 
     def _discover(self) -> list[tuple[EvidenceSource, SourceObject]]:
         discovered = []

harness/tht/search/evidence.py

@@ -36,8 +36,6 @@ class ActiveEvidenceSearcher:
 
 def active_searcher(cfg, delegate):
     corpus_root = cfg.paths.artifacts.parent / "corpus"
-    if not corpus_root.exists():
-        return delegate
     return ActiveEvidenceSearcher(CorpusStore(corpus_root), delegate)
 
 
@@ -59,15 +57,18 @@ def active_evidence_hits(store: CorpusStore, vector_store, embedding, *, limit:
 def resolve_evidence_file(
     store: CorpusStore, evidence_id: str, *, materialized_root=None,
 ) -> str:
-    manifest = store.active_manifest()
-    if manifest is None:
-        return ""
-    for document in manifest.documents:
-        frontmatter = document.metadata.get("frontmatter", {})
-        identifiers = {document.document_id, document.source_id, str(frontmatter.get("id", ""))}
-        if evidence_id in identifiers:
-            root = materialized_root or (store.root / "runtime")
-            filename = document.document_id.removeprefix("doc:") + ".md"
-            path = store.materialize_document(document.document_id, root / filename)
-            return str(path) if path else ""
+    with store.writer_lock():
+        manifest = store.active_manifest()
+        if manifest is None:
+            return ""
+        for document in manifest.documents:
+            frontmatter = document.metadata.get("frontmatter", {})
+            identifiers = {document.document_id, document.source_id, str(frontmatter.get("id", ""))}
+            if evidence_id in identifiers:
+                root = materialized_root or (store.root / "runtime")
+                filename = document.document_id.removeprefix("doc:") + ".md"
+                path = store.materialize_document(
+                    document.document_id, root / filename, generation=manifest.manifest_id,
+                )
+                return str(path) if path else ""
     return ""