@gmickel/gno 1.45.1 → 2.0.0

package/src/pipeline/hydration.ts

@@ -0,0 +1,161 @@
+/** Immutable raw hydration owned by one retrieval request, never by a model.
+ * Create at the request boundary and release in finally (or on abort). No read
+ * transaction survives a store call. Already-started stages keep their values.
+ */
+import type {
+  ChunkRow,
+  DocumentRow,
+  StorePort,
+  StoreResult,
+} from "../store/types";
+
+import { getContentBatch } from "../store/content-batch";
+import { err, ok } from "../store/types";
+
+type BatchCache<T> = Map<string, Promise<StoreResult<T | undefined>>>;
+type DocumentOptions = Parameters<StorePort["getDocumentsByMirrorHashes"]>[1];
+
+function freezeDeep<T>(value: T): T {
+  if (value && typeof value === "object") {
+    for (const child of Object.values(value)) freezeDeep(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+/** Each caller owns its Map; cached rows are detached, recursively frozen data.
+ * The StorePort-compatible types let existing consumers read these snapshots.
+ * Consumers that need to mutate a row/array must copy it first.
+ */
+async function loadBatch<T>(
+  cache: BatchCache<T>,
+  keys: string[],
+  load: (missing: string[]) => Promise<StoreResult<Map<string, T>>>
+): Promise<StoreResult<Map<string, T>>> {
+  const unique = [...new Set(keys)];
+  const missing = unique.filter((key) => !cache.has(key));
+  if (missing.length > 0) {
+    // Defer the store call until every pending key is published, including when
+    // a lightweight adapter throws synchronously instead of returning a result.
+    const batch = Promise.resolve().then(async () => {
+      const result = await load(missing);
+      if (!result.ok) return result;
+      const snapshots = new Map<string, T>();
+      for (const key of missing) {
+        if (result.value.has(key)) {
+          snapshots.set(
+            key,
+            freezeDeep(structuredClone(result.value.get(key)!))
+          );
+        }
+      }
+      return ok(snapshots);
+    });
+    for (const key of missing) {
+      const pending = batch.then(
+        (result): StoreResult<T | undefined> => {
+          if (!result.ok) {
+            if (cache.get(key) === pending) cache.delete(key);
+            return result;
+          }
+          return ok(result.value.get(key));
+        },
+        (error: unknown) => {
+          if (cache.get(key) === pending) cache.delete(key);
+          throw error;
+        }
+      );
+      cache.set(key, pending);
+    }
+  }
+  // Capture the promises before yielding: release clears ownership, not work.
+  const pending = unique.map((key) => cache.get(key)!);
+  const results = await Promise.all(pending);
+  const values = new Map<string, T>();
+  for (const [index, result] of results.entries()) {
+    if (!result.ok) return result;
+    if (result.value !== undefined) values.set(unique[index]!, result.value);
+  }
+  return ok(values);
+}
+
+export class RequestHydration {
+  private store: StorePort | null;
+  private readonly chunks: BatchCache<ChunkRow[]> = new Map();
+  private readonly content: BatchCache<string> = new Map();
+  private readonly documents: BatchCache<DocumentRow[]> = new Map();
+  private readonly signal?: AbortSignal;
+
+  constructor(store: StorePort, signal?: AbortSignal) {
+    this.store = store;
+    this.signal = signal;
+    if (signal?.aborted) this.release();
+    else signal?.addEventListener("abort", this.release, { once: true });
+  }
+
+  /** Idempotent. Returned snapshots and pending loads remain valid; new loads
+   * fail. Abort does not cancel a store operation another active stage needs.
+   */
+  readonly release = (): void => {
+    this.signal?.removeEventListener("abort", this.release);
+    this.store = null;
+    this.chunks.clear();
+    this.content.clear();
+    this.documents.clear();
+  };
+
+  getChunksBatch(
+    hashes: string[]
+  ): Promise<StoreResult<Map<string, ChunkRow[]>>> {
+    const store = this.store;
+    if (!store)
+      return Promise.resolve(err("QUERY_FAILED", "Hydration request released"));
+    return loadBatch(this.chunks, hashes, (missing) =>
+      store.getChunksBatch(missing)
+    );
+  }
+
+  getContentBatch(hashes: string[]): Promise<StoreResult<Map<string, string>>> {
+    const store = this.store;
+    if (!store)
+      return Promise.resolve(err("QUERY_FAILED", "Hydration request released"));
+    return loadBatch(this.content, hashes, (missing) =>
+      getContentBatch(store, missing)
+    );
+  }
+
+  async getContent(hash: string): Promise<StoreResult<string | null>> {
+    const store = this.store;
+    if (!store) return err("QUERY_FAILED", "Hydration request released");
+    const result = await loadBatch(this.content, [hash], async () => {
+      const content = await store.getContent(hash);
+      if (!content.ok) return content;
+      return ok(new Map(content.value === null ? [] : [[hash, content.value]]));
+    });
+    return result.ok ? ok(result.value.get(hash) ?? null) : result;
+  }
+
+  async getDocumentsByMirrorHashes(
+    hashes: string[],
+    options?: DocumentOptions
+  ): Promise<StoreResult<DocumentRow[]>> {
+    const store = this.store;
+    if (!store) return err("QUERY_FAILED", "Hydration request released");
+    // Capture caller-owned options before any asynchronous read. Collection
+    // and activity are part of the lookup identity; titles never key by hash.
+    const scope = { ...options };
+    // Cache the exact lookup, retaining the adapter's ordering (including SQL
+    // batch boundaries). Regrouping by content hash would reorder documents.
+    const requested = [...hashes];
+    const identity = JSON.stringify([
+      scope.collection ?? null,
+      scope.activeOnly ?? null,
+      requested,
+    ]);
+    const result = await loadBatch(this.documents, [identity], async () => {
+      const rows = await store.getDocumentsByMirrorHashes(requested, scope);
+      return rows.ok ? ok(new Map([[identity, rows.value]])) : rows;
+    });
+    return result.ok ? ok([...(result.value.get(identity) ?? [])]) : result;
+  }
+}

package/src/pipeline/owner-fusion.ts

@@ -0,0 +1,87 @@
+import type { StorePort } from "../store/types";
+import type { RankedInput } from "./fusion";
+import type { RequestHydration } from "./hydration";
+import type { HybridSearchOptions } from "./types";
+
+import { evaluateRetrievalEligibility } from "./filters";
+
+export class OwnerMetadataError extends Error {}
+
+/** Materialize legacy lexical/graph owner domains only when variant retrieval is active. */
+export async function resolveFusionOwners(
+  inputs: RankedInput[],
+  store: StorePort,
+  hydration: RequestHydration,
+  query: string,
+  options: HybridSearchOptions
+): Promise<RankedInput[]> {
+  if (
+    !inputs.some((input) =>
+      input.results.some((result) => result.documentId !== undefined)
+    )
+  )
+    return inputs;
+  const hashes = [
+    ...new Set(
+      inputs.flatMap((input) =>
+        input.results.map((result) => result.mirrorHash)
+      )
+    ),
+  ];
+  const documents = await hydration.getDocumentsByMirrorHashes(hashes, {
+    collection: options.collection,
+    activeOnly: true,
+  });
+  const chunks = await hydration.getChunksBatch(hashes);
+  if (!documents.ok || !chunks.ok)
+    throw new OwnerMetadataError("Vector owner metadata unavailable");
+  let memoryIds: Set<number> | undefined;
+  if (options.memoryFilter) {
+    memoryIds = new Set();
+    for (const collection of new Set(
+      documents.value.map((doc) => doc.collection)
+    )) {
+      const eligible = await store.listMemoryEligibleDocuments({
+        collection,
+        scopes: options.memoryFilter.scopes,
+        excludeSuperseded: options.memoryFilter.excludeSuperseded,
+      });
+      if (!eligible.ok)
+        throw new OwnerMetadataError("Memory owner metadata unavailable");
+      for (const doc of eligible.value) memoryIds.add(doc.id);
+    }
+  }
+  const docids = new Map(documents.value.map((doc) => [doc.id, doc.docid]));
+  const owners = new Map<string, number[]>();
+  for (const doc of documents.value) {
+    if (!doc.mirrorHash || (memoryIds && !memoryIds.has(doc.id))) continue;
+    const eligibility = await evaluateRetrievalEligibility(
+      store,
+      query,
+      doc,
+      chunks.value.get(doc.mirrorHash),
+      options
+    );
+    for (const chunk of eligibility.chunks) {
+      const key = `${doc.mirrorHash}:${chunk.seq}`;
+      const ids = owners.get(key) ?? [];
+      ids.push(doc.id);
+      owners.set(key, ids);
+    }
+  }
+  return inputs.map((input) => ({
+    ...input,
+    results: input.results.flatMap((result) => {
+      const ids = owners.get(`${result.mirrorHash}:${result.seq}`) ?? [];
+      return ids
+        .filter((id) => {
+          if (result.documentId !== undefined) return result.documentId === id;
+          if (result.sourceDocid !== undefined)
+            return result.sourceDocid === docids.get(id);
+          // Older custom stores without provenance cannot lend a rank to ambiguous owners.
+          return ids.length === 1;
+        })
+        .map((documentId) => ({ ...result, documentId }));
+    }),
+  }));
+}

package/src/pipeline/rerank.ts

@@ -1,14 +1,18 @@
+import type { RerankPort } from "../llm/types";
 /**
  * Reranking and position-aware blending.
  * Uses RerankPort to reorder candidates.
  *
  * @module src/pipeline/rerank
  */
-
-import type { RerankPort } from "../llm/types";
 import type { ChunkRow, StorePort } from "../store/types";
+import type { RequestHydration } from "./hydration";
 import type { BlendingTier, FusionCandidate, RerankedCandidate } from "./types";
 
+import {
+  assertInferenceActive,
+  assertInferenceResult,
+} from "../llm/inference-scope";
 import {
   buildIntentAwareRerankQuery,
   selectBestChunkForSteering,
@@ -42,6 +46,8 @@ export interface RerankResult {
 export interface RerankDeps {
   rerankPort: RerankPort | null;
   store: StorePort;
+  /** Shared raw chunks only; model inputs are prepared per invocation. */
+  hydration?: RequestHydration;
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -96,8 +102,12 @@ function isProtectedLexicalTopHit(candidate: FusionCandidate): boolean {
 /**
  * Fetch chunk texts for reranking.
  */
+function rerankOwnerKey(candidate: FusionCandidate): string {
+  return `${candidate.mirrorHash}${candidate.documentId === undefined ? "" : `:${candidate.documentId}`}`;
+}
+
 async function fetchChunkTexts(
-  store: StorePort,
+  store: Pick<StorePort, "getChunksBatch">,
   toRerank: FusionCandidate[],
   query: string,
   intent: string | undefined
@@ -110,13 +120,21 @@ async function fetchChunkTexts(
     ? chunksBatchResult.value
     : new Map();
   const preferredSeqByHash = new Map<string, number>();
+  const ownerHashes = new Map(
+    toRerank.map((candidate) => [
+      rerankOwnerKey(candidate),
+      candidate.mirrorHash,
+    ])
+  );
 
   for (const candidate of toRerank) {
-    const existingSeq = preferredSeqByHash.get(candidate.mirrorHash);
+    assertInferenceActive();
+    const existingSeq = preferredSeqByHash.get(rerankOwnerKey(candidate));
     if (existingSeq !== undefined) {
       const existingCandidate = toRerank.find(
         (entry) =>
-          entry.mirrorHash === candidate.mirrorHash && entry.seq === existingSeq
+          rerankOwnerKey(entry) === rerankOwnerKey(candidate) &&
+          entry.seq === existingSeq
       );
       if (
         existingCandidate &&
@@ -125,12 +143,13 @@ async function fetchChunkTexts(
         continue;
       }
     }
-    preferredSeqByHash.set(candidate.mirrorHash, candidate.seq);
+    preferredSeqByHash.set(rerankOwnerKey(candidate), candidate.seq);
   }
 
   const chunkTexts = new Map<string, string>();
-  for (const hash of uniqueHashes) {
-    const chunks = chunksByHash.get(hash);
+  for (const [hash, mirrorHash] of ownerHashes) {
+    assertInferenceActive();
+    const chunks = chunksByHash.get(mirrorHash);
     const bestChunk = selectBestChunkForSteering(chunks ?? [], query, intent, {
       preferredSeq: preferredSeqByHash.get(hash) ?? null,
       intentWeight: 0.5,
@@ -146,7 +165,8 @@ async function fetchChunkTexts(
 
   const hashToIndex = new Map<string, number>();
   const texts: string[] = [];
-  for (const hash of uniqueHashes) {
+  for (const hash of ownerHashes.keys()) {
+    assertInferenceActive();
     hashToIndex.set(hash, texts.length);
     texts.push(chunkTexts.get(hash) ?? "");
   }
@@ -234,7 +254,7 @@ export async function rerankCandidates(
 
   // Extract best chunk per document for efficient reranking
   const { texts, hashToIndex } = await fetchChunkTexts(
-    store,
+    deps.hydration ?? store,
     toRerank,
     query,
     options.intent
@@ -246,6 +266,7 @@ export async function rerankCandidates(
   const textToUniqueIndex = new Map<string, number>();
 
   for (const [docIndex, text] of texts.entries()) {
+    assertInferenceActive();
     const existingIndex = textToUniqueIndex.get(text);
     if (existingIndex !== undefined) {
       docIndexToUniqueIndex.set(docIndex, existingIndex);
@@ -268,6 +289,7 @@ export async function rerankCandidates(
     uniqueTexts
   );
 
+  assertInferenceResult(rerankResult);
   if (!rerankResult.ok) {
     return {
       candidates: sortAdjustedCandidates(
@@ -285,8 +307,10 @@ export async function rerankCandidates(
   // Normalize rerank scores using min-max
   const scoreByDocIndex = new Map<number, number>();
   for (const score of rerankResult.value) {
+    assertInferenceActive();
     const docIndices = uniqueIndexToDocIndices.get(score.index) ?? [];
     for (const docIndex of docIndices) {
+      assertInferenceActive();
       scoreByDocIndex.set(docIndex, score.score);
     }
   }
@@ -304,7 +328,7 @@ export async function rerankCandidates(
 
   // Build reranked candidates with blended scores
   const rerankedCandidates: RerankedCandidate[] = toRerank.map((c, i) => {
-    const docIndex = hashToIndex.get(c.mirrorHash) ?? -1;
+    const docIndex = hashToIndex.get(rerankOwnerKey(c)) ?? -1;
     const rerankScore = scoreByDocIndex.get(docIndex) ?? null;
     const normalizedRerankScore =
       rerankScore !== null ? normalizeRerankScore(rerankScore) : null;

package/src/pipeline/search.ts

@@ -202,6 +202,8 @@ export async function searchBm25(
   const ftsResult = await store.searchFts(query, {
     limit: retrievalLimit,
     collection: options.collection,
+    allowedMirrorHashes: options.retrievalScope?.allowedMirrorHashes,
+    exclude: options.exclude,
     relPathPrefix: options.retrievalScope?.relPathPrefix,
     language: options.lang,
     snippet: !(options.full || options.lineNumbers),
@@ -244,13 +246,22 @@ export async function searchBm25(
     }
   >();
 
-  // Pre-fetch all chunks in one batch query (eliminates N+1)
+  // Exact sequences suffice unless selection needs whole-document evidence.
   const uniqueHashes = [
     ...new Set(
       ftsResult.value.map((f) => f.mirrorHash).filter((h): h is string => !!h)
     ),
   ];
-  const chunksMapResult = await store.getChunksBatch(uniqueHashes);
+  const chunksMapResult =
+    store.getChunksBySequenceBatch &&
+    !options.intent &&
+    !options.exclude?.length
+      ? await store.getChunksBySequenceBatch(
+          ftsResult.value
+            .filter((row) => !!row.mirrorHash)
+            .map((row) => ({ mirrorHash: row.mirrorHash!, seq: row.seq }))
+        )
+      : await store.getChunksBatch(uniqueHashes);
   const getChunk = chunksMapResult.ok
     ? createChunkLookup(chunksMapResult.value)
     : () => undefined;

package/src/pipeline/types.ts

@@ -1,11 +1,10 @@
+import type { NormalizedContentTypeRule } from "../config/content-types";
 /**
  * Search pipeline types.
  * Defines SearchPipelinePort and related types for search operations.
  *
  * @module src/pipeline/types
  */
-
-import type { NormalizedContentTypeRule } from "../config/content-types";
 import type {
   ContextCapsuleV1,
   ContextCapsuleVerification,
@@ -13,6 +12,7 @@ import type {
 import type { EgressLineage } from "../core/egress-provenance";
 import type { RecordEvidenceMetadata } from "../core/record-metadata";
 import type { RetrievalTraceSession } from "../core/retrieval-trace-session";
+import type { InferenceOptions } from "../llm/types";
 import type { StoreResult } from "../store/types";
 import type { ClaimVerificationResult } from "./claim-verification";
 import type { SemanticVerificationCapability } from "./claim-verifier";
@@ -172,7 +172,7 @@ export interface SearchResults {
 // ─────────────────────────────────────────────────────────────────────────────
 
 /** Common options for all search commands */
-export interface SearchOptions {
+export interface SearchOptions extends InferenceOptions {
   /** Internal receipt seam; never serialized or included in public schemas. */
   traceSession?: RetrievalTraceSession;
   /** Trusted, already-resolved project affinity; never accepts raw roots. */
@@ -332,6 +332,8 @@ export type FusionSource =
 
 /** Fusion candidate with ranks from different sources */
 export interface FusionCandidate {
+  /** Internal exact document owner; canonical public chunk identity is unchanged. */
+  documentId?: number;
   mirrorHash: string;
   seq: number;
   bm25Rank: number | null;

package/src/pipeline/vsearch.ts

@@ -1,11 +1,10 @@
+import type { Config } from "../config/types";
 /**
  * Vector search pipeline.
  * Wraps VectorIndexPort.searchNearest() to produce SearchResults.
  *
  * @module src/pipeline/vsearch
  */
-
-import type { Config } from "../config/types";
 import type { EmbeddingPort } from "../llm/types";
 import type { DocumentRow, StorePort } from "../store/types";
 import type { VectorIndexPort } from "../store/vector/types";
@@ -13,8 +12,14 @@ import type { SearchOptions, SearchResult, SearchResults } from "./types";
 
 import { normalizeContentTypes } from "../config/content-types";
 import { projectRecordEvidenceMetadata } from "../core/record-metadata";
+import {
+  assertInferenceActive,
+  assertInferenceResult,
+  withInferenceScope,
+} from "../llm/inference-scope";
 import { getContentBatch } from "../store/content-batch";
 import { err, ok } from "../store/types";
+import { resolveVectorSearchIdentity } from "../store/vector/variant-search";
 import { createChunkLookup } from "./chunk-lookup";
 import {
   applyContentTypeBoost,
@@ -87,6 +92,17 @@ export async function searchVectorWithEmbedding(
   query: string,
   queryEmbedding: Float32Array,
   options: SearchOptions = {}
+): Promise<ReturnType<typeof ok<SearchResults>>> {
+  return withInferenceScope(options, () =>
+    searchVectorWithEmbeddingOwned(deps, query, queryEmbedding, options)
+  );
+}
+
+async function searchVectorWithEmbeddingOwned(
+  deps: VectorSearchDeps,
+  query: string,
+  queryEmbedding: Float32Array,
+  options: SearchOptions = {}
 ): Promise<ReturnType<typeof ok<SearchResults>>> {
   const traceStartedAt = options.traceSession ? performance.now() : 0;
   const { store, vectorIndex } = deps;
@@ -118,11 +134,37 @@ export async function searchVectorWithEmbedding(
     return err("VEC_SEARCH_UNAVAILABLE", vectorUnavailableMessage(vectorIndex));
   }
 
+  let embeddingIdentity;
+  try {
+    embeddingIdentity = resolveVectorSearchIdentity(deps.embedPort);
+  } catch (cause) {
+    return err(
+      "QUERY_FAILED",
+      cause instanceof Error ? cause.message : String(cause)
+    );
+  }
   // Search nearest neighbors
   const searchResult = await vectorIndex.searchNearest(
     queryEmbedding,
     retrievalLimit,
     {
+      embeddingIdentity,
+      eligibility: {
+        excludeMetadata: true,
+        semanticMetadata: true,
+        collection: options.collection,
+        memoryScopesAny: options.memoryFilter?.scopes,
+        excludeSuperseded: options.memoryFilter?.excludeSuperseded,
+        relPathPrefix: options.retrievalScope?.relPathPrefix,
+        tagsAll: options.tagsAll,
+        tagsAny: options.tagsAny,
+        since: temporalRange.since,
+        until: temporalRange.until,
+        categories: options.categories,
+        author: options.author,
+        exclude: options.exclude,
+        language: options.lang,
+      },
       minScore: projectAffinityActive ? undefined : minScore,
       allowedMirrorHashes: options.retrievalScope?.allowedMirrorHashes,
     }
@@ -140,6 +182,7 @@ export async function searchVectorWithEmbedding(
   const collectionPaths = new Map<string, string>();
   if (collectionsResult.ok) {
     for (const c of collectionsResult.value) {
+      assertInferenceActive();
       collectionPaths.set(c.name, c.path);
     }
   }
@@ -158,8 +201,15 @@ export async function searchVectorWithEmbedding(
       mirrorHashes: uniqueHashes,
     });
 
-  // Pre-fetch all chunks in one batch query (eliminates N+1)
-  const chunksMapResult = await store.getChunksBatch(uniqueHashes);
+  // Exact sequences suffice unless selection needs whole-document evidence.
+  const chunksMapResult =
+    store.getChunksBySequenceBatch &&
+    !options.intent &&
+    !options.exclude?.length
+      ? await store.getChunksBySequenceBatch(
+          vecResults.map(({ mirrorHash, seq }) => ({ mirrorHash, seq }))
+        )
+      : await store.getChunksBatch(uniqueHashes);
   if (!chunksMapResult.ok) {
     return err("QUERY_FAILED", chunksMapResult.error.message);
   }
@@ -182,6 +232,7 @@ export async function searchVectorWithEmbedding(
   >();
 
   for (const vec of vecResults) {
+    assertInferenceActive();
     const baseScore = normalizeVectorScore(vec.distance);
     if (!projectAffinityActive && baseScore < minScore) {
       continue;
@@ -191,7 +242,9 @@ export async function searchVectorWithEmbedding(
     const rawChunk = getChunk(vec.mirrorHash, vec.seq);
     const chunk = options.intent
       ? (selectBestChunkForSteering(
-          chunksMap.get(vec.mirrorHash) ?? [],
+          (chunksMap.get(vec.mirrorHash) ?? []).filter(
+            (chunk) => !options.lang || chunk.language === options.lang
+          ),
           query,
           options.intent,
           {
@@ -210,12 +263,21 @@ export async function searchVectorWithEmbedding(
     }
 
     // Get document (cached)
-    const matchingDocs = docsByMirrorHash.get(vec.mirrorHash);
+    const matchingDocs = docsByMirrorHash
+      .get(vec.mirrorHash)
+      ?.filter(
+        (doc) =>
+          vec.documentIds === undefined || vec.documentIds.includes(doc.id)
+      );
     if (!matchingDocs || matchingDocs.length === 0) {
       continue;
     }
-    const docs = auxiliaryRankingActive ? matchingDocs : [matchingDocs.at(-1)!];
+    const docs =
+      auxiliaryRankingActive || vec.documentIds !== undefined
+        ? matchingDocs
+        : [matchingDocs.at(-1)!];
     for (const doc of docs) {
+      assertInferenceActive();
       const collectionPath = collectionPaths.get(doc.collection);
       const sourceRelPath = doc.recordSourcePath ?? doc.relPath;
       const excluded =
@@ -335,6 +397,7 @@ export async function searchVectorWithEmbedding(
     const fullContentByHash = fullContentResult.value;
 
     for (const { doc, chunk, rawDistance, score } of bestByDocid.values()) {
+      assertInferenceActive();
       const fullContent = doc.mirrorHash
         ? fullContentByHash.get(doc.mirrorHash)
         : undefined;
@@ -430,6 +493,7 @@ export async function searchVectorWithEmbedding(
 
   const finalResults = results.slice(0, limit);
   for (const [index, result] of finalResults.entries()) {
+    assertInferenceActive();
     const metadata = result[SEARCH_RESULT_PLANNER_METADATA];
     if (metadata) metadata.retrievalRank = index + 1;
   }
@@ -487,6 +551,16 @@ export async function searchVector(
   deps: VectorSearchDeps,
   query: string,
   options: SearchOptions = {}
+): Promise<ReturnType<typeof ok<SearchResults>>> {
+  return withInferenceScope(options, () =>
+    searchVectorOwned(deps, query, options)
+  );
+}
+
+async function searchVectorOwned(
+  deps: VectorSearchDeps,
+  query: string,
+  options: SearchOptions = {}
 ): Promise<ReturnType<typeof ok<SearchResults>>> {
   const { vectorIndex, embedPort } = deps;
 
@@ -499,6 +573,7 @@ export async function searchVector(
   const embedResult = await embedPort.embed(
     formatQueryForEmbedding(query, embedPort.modelUri)
   );
+  assertInferenceResult(embedResult);
   if (!embedResult.ok) {
     return err(
       "QUERY_FAILED",
@@ -524,6 +599,7 @@ interface ChunkInfo {
 }
 
 interface DocumentInfo {
+  id: number;
   docid: string;
   uri: string;
   title: string | null;
@@ -625,11 +701,13 @@ async function buildDocumentMap(
     const docIds = activeDocs.map((d) => d.id);
     const tagsResult = await store.getTagsBatch(docIds);
 
+    if (!tagsResult.ok) return { documents, ownershipDocuments };
     if (tagsResult.ok) {
       allowedDocIds = new Set<number>();
       const tagsByDocId = tagsResult.value;
 
       for (const doc of activeDocs) {
+        assertInferenceActive();
         const docTags = new Set(
           (tagsByDocId.get(doc.id) ?? []).map((t) => t.tag)
         );
@@ -652,6 +730,7 @@ async function buildDocumentMap(
   }
 
   for (const doc of activeDocs) {
+    assertInferenceActive();
     const sourceRelPath = doc.recordSourcePath ?? doc.relPath;
     if (
       options.relPathPrefix !== undefined &&
@@ -679,6 +758,7 @@ async function buildDocumentMap(
     }
 
     const documentInfo: DocumentInfo = {
+      id: doc.id,
       docid: doc.docid,
       uri: doc.uri,
       title: doc.title,