fix(evidence): enforce active vector generations

harness/tht/adapters/vector/pgvector.py

@@ -85,6 +85,8 @@ class PgVectorStore:
             search=self._reader is not None,
             existing_hashes=writable,
             upsert=writable,
+            metadata_filter=self._reader is not None,
+            delete_generation=writable,
         )
 
     def _probe(
@@ -242,6 +244,7 @@ class PgVectorStore:
         *,
         limit: int,
         kinds: list[str] | None = None,
+        metadata_filter: dict[str, object] | None = None,
     ) -> list[VectorHit]:
         require_positive_limit(limit)
         if self._reader is None:
@@ -262,7 +265,27 @@ class PgVectorStore:
                     )
                     if kinds and not collection_kinds:
                         continue
-                    where = sql.SQL(" WHERE kind = ANY(%s)") if collection_kinds else sql.SQL("")
+                    clauses = []
+                    filter_params = []
+                    if collection_kinds:
+                        clauses.append(sql.SQL("kind = ANY(%s)"))
+                        filter_params.append(collection_kinds)
+                    if metadata_filter is not None:
+                        if collection != "evidence" or set(metadata_filter) != {
+                            "vector_generation", "document_ids"
+                        }:
+                            raise VectorStoreError("Unsupported vector metadata filter")
+                        generation = metadata_filter["vector_generation"]
+                        document_ids = metadata_filter["document_ids"]
+                        if not isinstance(generation, str) or not isinstance(document_ids, list):
+                            raise VectorStoreError("Invalid vector metadata filter")
+                        clauses.append(sql.SQL("metadata->>'vector_generation' = %s"))
+                        clauses.append(sql.SQL("metadata->>'document_id' = ANY(%s)"))
+                        filter_params.extend((generation, document_ids))
+                    where = (
+                        sql.SQL(" WHERE ") + sql.SQL(" AND ").join(clauses)
+                        if clauses else sql.SQL("")
+                    )
                     query = sql.SQL(
                         "SELECT metadata, 1 - (embedding {} %s::{}) AS similarity "
                         "FROM {}{} ORDER BY embedding {} %s::{}, record_key LIMIT %s"
@@ -275,8 +298,7 @@ class PgVectorStore:
                         _vector_type(self._schema),
                     )
                     params = [_vector_literal(embedding)]
-                    if collection_kinds:
-                        params.append(collection_kinds)
+                    params.extend(filter_params)
                     params.extend((_vector_literal(embedding), limit))
                     cursor.execute(query, params)
                     hits.extend(hit_from_metadata(row[1], row[0]) for row in cursor.fetchall())
@@ -381,5 +403,30 @@ class PgVectorStore:
                 raw.close()
         return len(records)
 
+    def delete_generation(self, collection: str, generation: str) -> int:
+        if collection != "evidence" or not generation.startswith("gen:"):
+            raise VectorStoreError("Only exact Evidence generations may be deleted")
+        raw = None
+        try:
+            raw = self._require_writer().raw_connection()
+            with raw.cursor() as cursor:
+                cursor.execute(
+                    sql.SQL(
+                        "DELETE FROM {} WHERE kind = 'evidence' "
+                        "AND metadata->>'vector_generation' = %s"
+                    ).format(_collection(self._schema, collection)),
+                    (generation,),
+                )
+                count = cursor.rowcount
+            raw.commit()
+            return count
+        except Exception as exc:
+            if raw is not None:
+                raw.rollback()
+            raise VectorWriteUnavailable("Vector generation cleanup unavailable") from exc
+        finally:
+            if raw is not None:
+                raw.close()
+
 
 __all__ = ["ALLOWED_COLLECTIONS", "PgVectorStore"]