pi-obsidian-memory 0.0.1 → 0.1.0

package/src/usecases/relevant-memory/loaded.ts

@@ -0,0 +1,31 @@
+import type { ReadObservation } from "#src/services"
+import type { LoadedChanges } from "./types.ts"
+
+export class LoadedMemory {
+  #notes = new Map<string, ReadObservation>()
+
+  all(): ReadObservation[] {
+    return [...this.#notes.values()]
+  }
+
+  apply(changes: LoadedChanges): void {
+    for (const note of changes.forgotten) this.forget(note)
+    for (const note of changes.loaded) this.remember(note)
+  }
+
+  has(note: ReadObservation): boolean {
+    return this.#notes.get(keyOf(note))?.hash === note.hash
+  }
+
+  remember(note: ReadObservation): void {
+    this.#notes.set(keyOf(note), note)
+  }
+
+  forget(note: ReadObservation): void {
+    this.#notes.delete(keyOf(note))
+  }
+}
+
+function keyOf(note: ReadObservation): string {
+  return `${note.vault}:${note.path}`
+}

package/src/usecases/relevant-memory/refresh.ts

@@ -0,0 +1,30 @@
+import { type InvalidReason, invalidatedBlock, type ReadObservation, replacementBlock } from "#src/services"
+import { observeLoadedNote, type UnreadableNote } from "#src/usecases/capture-memory"
+import { type MemoryOperationContext, memoryOperationInterruption } from "#src/usecases/operation-context"
+import type { LoadedStore, Refreshed } from "./types.ts"
+
+export async function refreshLoaded(loaded: LoadedStore, context: MemoryOperationContext): Promise<Refreshed> {
+  const blocks: string[] = []
+  const replaced: ReadObservation[] = []
+  const forgotten: ReadObservation[] = []
+  for (const previous of loaded.all()) {
+    const current = await observeLoadedNote(previous, context)
+    if (memoryOperationInterruption(context)) break
+    if (current.kind === "unreadable") {
+      loaded.forget(previous)
+      forgotten.push(previous)
+      blocks.push(invalidatedBlock(previous, invalidReason(current)))
+    } else if (current.hash !== previous.hash) {
+      loaded.remember(current)
+      replaced.push(current)
+      blocks.push(replacementBlock(previous, current))
+    }
+  }
+  return { blocks, changes: { loaded: replaced, forgotten } }
+}
+
+function invalidReason(unreadable: UnreadableNote): InvalidReason {
+  if (unreadable.existence === "gone") return { kind: "gone" }
+  if (unreadable.existence === "present") return { kind: "unusable", problem: unreadable.detail }
+  return { kind: "unreadable", problem: unreadable.detail }
+}

package/src/usecases/relevant-memory/retrieve-memory.ts

@@ -0,0 +1,62 @@
+import { fitBudget, loadedNoteBlock, shouldRetrieveMemory } from "#src/services"
+import type { MemoryOperationContext } from "#src/usecases/operation-context"
+import { type ResolvedMemory, resolveMemory } from "#src/usecases/resolve-memory"
+import { findNotes } from "./agent.ts"
+import { BLOCK_SEPARATOR, RELEVANT_INTRO } from "./constants.ts"
+import { cutoffsMissingNotice, decidingCutoffs, resolveCutoffs } from "./cutoffs.ts"
+import { decisionContextOf, decisionNotice, needsMemory, rankNotes } from "./decision.ts"
+import { refreshLoaded } from "./refresh.ts"
+import type { RankedNotes, RetrieveDeps, RetrieveMemoryResult, RetrieveRequest } from "./types.ts"
+
+export async function retrieveMemory(
+  request: RetrieveRequest,
+  context: MemoryOperationContext,
+  deps: RetrieveDeps,
+): Promise<RetrieveMemoryResult> {
+  const resolved = await resolveMemory(context)
+  if (!resolved.succeeded) return resolved
+  const refreshed = await refreshLoaded(deps.loaded, context)
+  const blocks = refreshed.blocks
+  let found: RankedNotes = { notes: [], notice: null }
+  if (request.message.trim() !== "") found = await relevantNotes(request.message, resolved.output, context, deps)
+  const fitted = fitBudget(found.notes, resolved.output.config.context.budgetChars)
+  for (const note of fitted) deps.loaded.remember(note)
+  blocks.push(...fitted.map(loadedNoteBlock))
+  let text: string | null = null
+  if (blocks.length > 0) text = [RELEVANT_INTRO, ...blocks].join(BLOCK_SEPARATOR)
+  const notices: string[] = []
+  if (found.notice) notices.push(found.notice)
+  const changes = { loaded: [...refreshed.changes.loaded, ...fitted], forgotten: refreshed.changes.forgotten }
+  return { succeeded: true, output: { text, notices, changes } }
+}
+
+async function relevantNotes(
+  message: string,
+  memory: ResolvedMemory,
+  context: MemoryOperationContext,
+  deps: RetrieveDeps,
+): Promise<RankedNotes> {
+  const report = resolveCutoffs(memory.config.decisionModel)
+  const cutoffs = decidingCutoffs(report)
+  if (!cutoffs) return { notes: [], notice: cutoffsMissingNotice(report) }
+  const decision = await decisionContextOf(memory.config.decisionModel, { signal: context.signal }, deps.jev)
+  if (typeof decision === "string") return { notes: [], notice: decision }
+  let project: string | null = null
+  if (memory.project) project = memory.project.vault.name
+  const folder = context.workingFolder
+  const needed = await needsMemory(decision, message, project, folder)
+  if (!needed.succeeded) return { notes: [], notice: decisionNotice(needed) }
+  if (!shouldRetrieveMemory(needed.output.probability, cutoffs.gate)) return { notes: [], notice: null }
+  const agent = await findNotes(
+    {
+      agent: { project, folder },
+      query: message,
+      model: memory.config.memoryAgent.model,
+    },
+    context,
+    deps.complete,
+  )
+  if (!agent.succeeded) return { notes: [], notice: agent.notice }
+  const fresh = agent.output.filter((note) => !note.dontForget && !deps.loaded.has(note))
+  return rankNotes(decision, message, fresh, cutoffs.relevance)
+}

package/src/usecases/relevant-memory/schemas.ts

@@ -0,0 +1,20 @@
+import Type from "typebox"
+
+import { BLANK_NOTE_TYPES } from "#src/usecases/complete-blank-memory"
+
+export const StoredNoteSchema = Type.Object({
+  kind: Type.Literal("read"),
+  vault: Type.Enum(["global", "project"]),
+  path: Type.String(),
+  id: Type.String(),
+  hash: Type.String(),
+  statement: Type.String(),
+  body: Type.String(),
+  type: Type.Enum(BLANK_NOTE_TYPES),
+  dontForget: Type.Boolean(),
+})
+
+export const LoadedChangesSchema = Type.Object({
+  loaded: Type.Array(StoredNoteSchema),
+  forgotten: Type.Array(StoredNoteSchema),
+})

package/src/usecases/relevant-memory/session-memory.ts

@@ -0,0 +1,53 @@
+import { fitBudget, loadedNoteBlock } from "#src/services"
+import type { MemoryOperationContext } from "#src/usecases/operation-context"
+import { resolveMemory } from "#src/usecases/resolve-memory"
+import { findNotes } from "./agent.ts"
+import {
+  BLOCK_SEPARATOR,
+  NO_CHANGES,
+  NO_PROJECT,
+  SESSION_INTRO,
+  SESSION_LOAD_FAILED,
+  SESSION_QUERY_PREFIX,
+} from "./constants.ts"
+import type { RetrievedMemory, RetrieveMemoryResult, SessionMemoryDeps } from "./types.ts"
+
+export async function loadSessionMemory(
+  context: MemoryOperationContext,
+  deps: SessionMemoryDeps,
+): Promise<RetrieveMemoryResult> {
+  const resolved = await resolveMemory(context)
+  if (!resolved.succeeded) return resolved
+  const { config, project } = resolved.output
+  const { workingFolder } = context
+  let name: string | null = null
+  let label = NO_PROJECT
+  if (project) {
+    name = project.vault.name
+    label = name
+  }
+  const found = await findNotes(
+    {
+      agent: { project: name, folder: workingFolder },
+      query: `${SESSION_QUERY_PREFIX} ${label} in ${workingFolder}`,
+      model: config.memoryAgent.model,
+    },
+    context,
+    deps.complete,
+  )
+  if (!found.succeeded) return { succeeded: true, output: failedLoad(found.notice) }
+  const fitted = fitBudget(
+    found.output.filter((note) => !note.dontForget),
+    config.context.budgetChars,
+  )
+  for (const note of fitted) deps.loaded.remember(note)
+  if (fitted.length === 0) return { succeeded: true, output: { text: null, notices: [], changes: NO_CHANGES } }
+  const text = [SESSION_INTRO, ...fitted.map(loadedNoteBlock)].join(BLOCK_SEPARATOR)
+  return { succeeded: true, output: { text, notices: [], changes: NO_CHANGES } }
+}
+
+function failedLoad(notice: string | null): RetrievedMemory {
+  if (typeof notice !== "string") return { text: null, notices: [], changes: NO_CHANGES }
+  const text = `${SESSION_LOAD_FAILED} ${notice}`
+  return { text, notices: [text], changes: NO_CHANGES }
+}

package/src/usecases/relevant-memory/track-dont-forget.ts

@@ -0,0 +1,13 @@
+import type { LoadDontForgetResult } from "#src/usecases/load-dont-forget"
+import type { LoadedMemory } from "./loaded.ts"
+
+export function trackDontForget(loaded: LoadedMemory, result: LoadDontForgetResult): void {
+  if (!result.succeeded) return
+  for (const vault of result.output.vaults) {
+    for (const note of vault.notes) {
+      if (note.body.length === 0) continue
+      const { vault: scope, path, id, hash, statement, body, type } = note
+      loaded.remember({ kind: "read", vault: scope, path, id, hash, statement, body, type, dontForget: true })
+    }
+  }
+}

package/src/usecases/relevant-memory/types.ts

@@ -0,0 +1,106 @@
+import type { Static } from "typebox"
+
+import type {
+  AgentContext,
+  ChatModelReference,
+  CompletionPort,
+  JevClassifierPort,
+  ReadObservation,
+  RetrievalAction,
+} from "#src/services"
+import type { Succeeded } from "#src/shared"
+import type { MemoryResolutionRefusal } from "#src/usecases/resolve-memory"
+import type { LoadedChangesSchema } from "./schemas.ts"
+
+export type { BoolQuestion, DecisionPrompt } from "#src/services"
+
+export interface JevAccess {
+  available: true
+  classifier: JevClassifierPort
+}
+
+export interface JevRefusal {
+  available: false
+  reason: string
+}
+
+export type JevSource = (model: string) => Promise<JevAccess | JevRefusal>
+
+export interface LoadedStore {
+  all(): ReadObservation[]
+  has(note: ReadObservation): boolean
+  remember(note: ReadObservation): void
+  forget(note: ReadObservation): void
+  apply(changes: LoadedChanges): void
+}
+
+export interface RetrieveDeps {
+  complete: CompletionPort
+  jev: JevSource
+  loaded: LoadedStore
+}
+
+export interface SessionMemoryDeps {
+  complete: CompletionPort
+  loaded: LoadedStore
+}
+
+export interface RetrieveRequest {
+  message: string
+}
+
+export type LoadedChanges = Static<typeof LoadedChangesSchema>
+
+export interface RetrievedMemory {
+  text: string | null
+  notices: string[]
+  changes: LoadedChanges
+}
+
+export type CutoffSource = "config" | "typesafe" | "missing"
+
+export interface CutoffValue {
+  value: number | null
+  source: CutoffSource
+}
+
+export interface CutoffReport {
+  gate: CutoffValue
+  relevance: CutoffValue
+}
+
+export interface Refreshed {
+  blocks: string[]
+  changes: LoadedChanges
+}
+
+export type RetrieveMemoryResult = Succeeded<RetrievedMemory> | MemoryResolutionRefusal
+
+export interface AgentFound {
+  succeeded: true
+  output: ReadObservation[]
+}
+
+export interface AgentFailed {
+  succeeded: false
+  notice: string | null
+}
+
+export type AgentOutcome = AgentFound | AgentFailed
+
+export interface AgentRequest {
+  agent: AgentContext
+  query: string
+  model: ChatModelReference
+}
+
+export interface FinishDiscriminant {
+  action: "finish"
+}
+
+export type ReadStep = Exclude<RetrievalAction, FinishDiscriminant>
+
+export interface RankedNotes {
+  notes: ReadObservation[]
+  notice: string | null
+}

package/src/usecases/resolve-memory/index.ts

@@ -0,0 +1,2 @@
+export * from "./resolve-memory.ts"
+export * from "./types.ts"

package/src/usecases/resolve-memory/leased/index.ts

@@ -0,0 +1,2 @@
+export * from "./resolve.ts"
+export * from "./types.ts"

package/src/usecases/resolve-memory/leased/resolve.ts

@@ -0,0 +1,109 @@
+import {
+  type ConfigRefusal,
+  canonicalizeRegistration,
+  canonicalizeWorkingFolder,
+  type MemoryConfig,
+  type MemoryScope,
+  type PathPlatform,
+  readConfigSnapshot,
+  targetVault,
+} from "#src/services"
+import {
+  type MemoryOperationContext,
+  memoryOperationInterruption,
+  staleMemorySession,
+} from "#src/usecases/operation-context"
+import type { ResolvedMemory, ResolveMemoryResult, SelectMemoryVaultResult } from "./types.ts"
+
+export async function resolveLeasedMemory(context: MemoryOperationContext): Promise<ResolveMemoryResult> {
+  const interrupted = memoryOperationInterruption(context)
+  if (interrupted) return interrupted
+  const snapshot = await readConfigSnapshot({ path: context.configPath, platform: context.platform })
+  const stale = memoryOperationInterruption(context)
+  if (stale) return stale
+  if (!snapshot.succeeded) {
+    context.session.invalidate(context.stamp)
+    return { ...snapshot, reason: "config-unavailable", configPath: context.configPath }
+  }
+  if (snapshot.output.state === "missing") {
+    context.session.invalidate(context.stamp)
+    return {
+      succeeded: false,
+      reason: "not-configured",
+      configPath: context.configPath,
+      problems: ["Memory is not configured; provide a complete config file"],
+    }
+  }
+  if (!context.session.acceptConfiguration(context.stamp, snapshot.output.hash)) return staleMemorySession()
+  const parsed = snapshot.output.lexicalParse
+  if (!parsed.succeeded) return invalidMemoryConfiguration(context, parsed.problems)
+  return validateMemoryLocations(context, parsed.output, snapshot.output.hash)
+}
+
+async function validateMemoryLocations(
+  context: MemoryOperationContext,
+  config: MemoryConfig,
+  hash: string,
+): Promise<ResolveMemoryResult> {
+  const canonical = await canonicalizeRegistration({
+    config,
+    configPath: context.configPath,
+    indexPath: context.indexPath,
+    platform: context.platform,
+  })
+  const interrupted = memoryOperationInterruption(context)
+  if (interrupted) return interrupted
+  if (!canonical.succeeded) return invalidMemoryConfiguration(context, canonical.problems)
+  const workingFolder = await canonicalizeWorkingFolder(context.workingFolder)
+  const stale = memoryOperationInterruption(context)
+  if (stale) return stale
+  if (!workingFolder.succeeded) return invalidMemoryConfiguration(context, workingFolder.problems)
+  return resolvedMemory(
+    canonical.output.config,
+    hash,
+    workingFolder.output,
+    canonical.output.indexPath,
+    context.platform,
+  )
+}
+
+function resolvedMemory(
+  config: MemoryConfig,
+  configHash: string,
+  workingFolder: string,
+  indexPath: string,
+  platform: PathPlatform,
+): ResolveMemoryResult {
+  const global = targetVault(config, "global", workingFolder, platform)
+  if (!global.succeeded) throw new Error("Global target requires no project selection")
+  const projectTarget = targetVault(config, "project", workingFolder, platform)
+  const output: ResolvedMemory = {
+    config,
+    configHash,
+    workingFolder,
+    indexPath,
+    platform,
+    global: { scope: "global", vault: { ...global.output, limits: { ...config.limits } } },
+    project: null,
+    protectedRoots: [config.global.vault, ...config.projects.map((project) => project.vault)],
+  }
+  if (projectTarget.succeeded) {
+    output.project = { scope: "project", vault: { ...projectTarget.output, limits: { ...config.limits } } }
+  }
+  return { succeeded: true, output }
+}
+
+function invalidMemoryConfiguration(context: MemoryOperationContext, problems: string[]): ConfigRefusal {
+  return { succeeded: false, reason: "invalid-config", configPath: context.configPath, problems }
+}
+
+export function selectMemoryVault(memory: ResolvedMemory, scope: MemoryScope): SelectMemoryVaultResult {
+  if (scope === "global") return { succeeded: true, output: memory.global }
+  if (memory.project) return { succeeded: true, output: memory.project }
+  return {
+    succeeded: false,
+    reason: "no-project",
+    workingFolder: memory.workingFolder,
+    problems: ["The current folder has no registered project; use global memory instead"],
+  }
+}

package/src/usecases/resolve-memory/leased/types.ts

@@ -0,0 +1,35 @@
+import type {
+  ConfigRefusal,
+  MemoryConfig,
+  MemoryScope,
+  NamedVaultContext,
+  NoProjectRefusal,
+  PathPlatform,
+} from "#src/services"
+import type { Failed, Succeeded } from "#src/shared"
+import type { MemoryOperationRefusal } from "#src/usecases/operation-context"
+
+export interface ResolvedVault {
+  scope: MemoryScope
+  vault: NamedVaultContext
+}
+
+export interface ResolvedMemory {
+  config: MemoryConfig
+  configHash: string
+  global: ResolvedVault
+  project: ResolvedVault | null
+  protectedRoots: string[]
+  workingFolder: string
+  indexPath: string
+  platform: PathPlatform
+}
+
+export interface MemoryConfigurationUnavailable extends Failed {
+  reason: "config-unavailable"
+  configPath: string
+}
+
+export type MemoryResolutionRefusal = ConfigRefusal | MemoryConfigurationUnavailable | MemoryOperationRefusal
+export type ResolveMemoryResult = Succeeded<ResolvedMemory> | MemoryResolutionRefusal
+export type SelectMemoryVaultResult = Succeeded<ResolvedVault> | NoProjectRefusal

package/src/usecases/resolve-memory/resolve-memory.ts

@@ -0,0 +1,23 @@
+import {
+  captureMemoryOperationContext,
+  type MemoryOperationContext,
+  memoryAdmissionRefusal,
+  memoryOperationInterruption,
+} from "#src/usecases/operation-context"
+import { resolveLeasedMemory } from "#src/usecases/resolve-memory/leased"
+import type { ResolveMemoryResult } from "./types.ts"
+
+export async function resolveMemory(callerContext: MemoryOperationContext): Promise<ResolveMemoryResult> {
+  const context = captureMemoryOperationContext(callerContext)
+  const lease = await context.session.acquire(context.stamp, context.signal)
+  if (!lease) return memoryAdmissionRefusal(context)
+  try {
+    const result = await resolveLeasedMemory(context)
+    if (!result.succeeded) return result
+    const interrupted = memoryOperationInterruption(context)
+    if (interrupted) return interrupted
+    return result
+  } finally {
+    lease.release()
+  }
+}

package/src/usecases/resolve-memory/types.ts

@@ -0,0 +1,7 @@
+export type {
+  MemoryConfigurationUnavailable,
+  MemoryResolutionRefusal,
+  ResolvedMemory,
+  ResolvedVault,
+  ResolveMemoryResult,
+} from "#src/usecases/resolve-memory/leased"

package/src/usecases/search-memory/constants.ts

@@ -0,0 +1 @@
+export const SEMANTIC_PARTIAL_LINE = "notes are not embedded yet, so semantic results may be incomplete"

package/src/usecases/search-memory/index.ts

@@ -0,0 +1,3 @@
+export * from "./constants.ts"
+export * from "./search-memory.ts"
+export * from "./types.ts"

package/src/usecases/search-memory/search-memory.ts

@@ -0,0 +1,132 @@
+import {
+  closeIndex,
+  embeddingFingerprint,
+  type MemoryScope,
+  type OpenedIndex,
+  readVectorCoverage,
+  searchCatalog,
+} from "#src/services"
+import {
+  captureMemoryOperationContext,
+  type MemoryOperationContext,
+  memoryAdmissionRefusal,
+  memoryOperationInterruption,
+} from "#src/usecases/operation-context"
+import {
+  type ResolvedMemory,
+  type ResolvedVault,
+  resolveLeasedMemory,
+  selectMemoryVault,
+} from "#src/usecases/resolve-memory/leased"
+import { fuseSearchHits, prepareSemanticSearch, rankSemantically, semanticPortOf } from "#src/usecases/semantic"
+import { openVaultIndex, synchronizeOpenedMemory } from "#src/usecases/synchronize-memory/leased"
+import { SEMANTIC_PARTIAL_LINE } from "./constants.ts"
+import type {
+  SearchedMemory,
+  SearchMemoryRequest,
+  SearchMemoryResult,
+  VaultSearchFailure,
+  VaultSearchHits,
+  VaultSemantic,
+} from "./types.ts"
+
+export async function searchMemory(
+  input: SearchMemoryRequest,
+  callerContext: MemoryOperationContext,
+): Promise<SearchMemoryResult> {
+  const context = captureMemoryOperationContext(callerContext)
+  const request = { query: input.query, vault: input.vault }
+  const lease = await context.session.acquire(context.stamp, context.signal)
+  if (!lease) return memoryAdmissionRefusal(context)
+  try {
+    const memory = await resolveLeasedMemory(context)
+    if (!memory.succeeded) return memory
+    return await searchResolvedMemory(request, memory.output, context)
+  } finally {
+    lease.release()
+  }
+}
+
+async function searchResolvedMemory(
+  request: SearchMemoryRequest,
+  memory: ResolvedMemory,
+  context: MemoryOperationContext,
+): Promise<SearchMemoryResult> {
+  const port = await semanticPortOf(context, memory)
+  const prepared = await prepareSemanticSearch(port, request.query, context)
+  const semantic: VaultSemantic = { port, query: prepared.query }
+  const problems = [...prepared.problems]
+  const output: SearchedMemory = { vaults: [], projectMissing: false, semantic: { mode: "text-only", problems } }
+  if (prepared.query) output.semantic.mode = "fused"
+  for (const scope of scopesOf(request.vault)) {
+    const interrupted = memoryOperationInterruption(context)
+    if (interrupted) return interrupted
+    const target = selectMemoryVault(memory, scope)
+    if (!target.succeeded) {
+      output.projectMissing = true
+      continue
+    }
+    output.vaults.push(await searchLeasedVault(request.query, memory, target.output, context, semantic, problems))
+  }
+  const stale = memoryOperationInterruption(context)
+  if (stale) return stale
+  return { succeeded: true, output }
+}
+
+function scopesOf(vault: SearchMemoryRequest["vault"]): MemoryScope[] {
+  if (vault === "both") return ["global", "project"]
+  return [vault]
+}
+
+async function searchLeasedVault(
+  query: string,
+  memory: ResolvedMemory,
+  target: ResolvedVault,
+  context: MemoryOperationContext,
+  semantic: VaultSemantic,
+  problems: string[],
+): Promise<VaultSearchHits | VaultSearchFailure> {
+  const opened = openVaultIndex(memory, target)
+  if (!opened.succeeded) return { vault: target.scope, problems: opened.problems }
+  const warnings: string[] = []
+  let result: VaultSearchHits | VaultSearchFailure
+  try {
+    result = await searchSynchronizedVault(query, opened, memory, target, context, semantic, problems)
+  } finally {
+    const closed = closeIndex(opened.output)
+    if (!closed.succeeded) warnings.push(...closed.problems)
+  }
+  if ("hits" in result) result.warnings.push(...warnings)
+  else result.problems.push(...warnings)
+  return result
+}
+
+async function searchSynchronizedVault(
+  query: string,
+  opened: OpenedIndex,
+  memory: ResolvedMemory,
+  target: ResolvedVault,
+  context: MemoryOperationContext,
+  semantic: VaultSemantic,
+  problems: string[],
+): Promise<VaultSearchHits | VaultSearchFailure> {
+  const synchronized = await synchronizeOpenedMemory(opened, memory, target, context, semantic.port)
+  if (!synchronized.succeeded) return { vault: target.scope, problems: synchronized.problems }
+  const found = searchCatalog(opened.output, { query })
+  if (!found.succeeded) return { vault: target.scope, problems: found.problems }
+  const warnings = [...synchronized.output.warnings]
+  if (!semantic.query) return { vault: target.scope, hits: found.output, warnings }
+  const ranked = rankSemantically(opened.output, semantic.query, memory.config.embeddings.provider)
+  warnings.push(...ranked.problems)
+  const missing = missingVectors(opened, memory)
+  if (missing > 0) problems.push(`${target.scope}: ${missing} ${SEMANTIC_PARTIAL_LINE}`)
+  return { vault: target.scope, hits: fuseSearchHits(found.output, ranked), warnings }
+}
+
+function missingVectors(opened: OpenedIndex, memory: ResolvedMemory): number {
+  const coverage = readVectorCoverage(opened.output)
+  if (!coverage.succeeded) return 0
+  const { generation, embedded, current } = coverage.output
+  if (generation?.fingerprint !== embeddingFingerprint(memory.config.embeddings)) return current
+  return Math.max(0, current - embedded)
+}