@gmickel/gno 1.46.0 → 2.1.0

package/src/serve/resident-runtime.ts

@@ -42,9 +42,13 @@ import {
 } from "../core/findings-run-state";
 import { JobManager } from "../core/job-manager";
 import { recordContentMutation } from "../core/mutation-generations";
+import {
+  shutdownDuration,
+  SHUTDOWN_DRAIN_MS,
+  SHUTDOWN_ABORT_MS,
+} from "../core/shutdown-budget";
 import { defaultSyncService, withContentTypeRules } from "../ingestion";
-import { getModelManager } from "../llm/nodeLlamaCpp/lifecycle";
-import { getModelConfig } from "../llm/registry";
+import { withOwnedInferenceScope } from "../llm/inference-scope";
 import { getActivePreset } from "../llm/registry";
 import { createToolContext, Mutex } from "../mcp/context";
 import { SqliteAdapter } from "../store/sqlite/adapter";
@@ -58,10 +62,13 @@ import { createEmbedScheduler } from "./embed-scheduler";
 import { FindingsScheduler, type FindingsPassResult } from "./findings-pass";
 import { AdmissionController, ReaderGate } from "./resident-admission";
 import { ResidentBackgroundWork } from "./resident-background-work";
-import { buildResidentStatusSnapshot } from "./resident-status";
+import { disposeResidentResources } from "./resident-shutdown";
+import {
+  createStandaloneResidentStatus,
+  buildResidentStatusSnapshot,
+} from "./resident-status";
 import { CollectionWatchService as DefaultCollectionWatchService } from "./watch-service";
 
-const DEFAULT_SHUTDOWN_DEADLINE_MS = 5_000;
 const OWNER_LOCK_TIMEOUT_MS = 0;
 
 export type ResidentMode = "serve" | "daemon";
@@ -110,7 +117,10 @@ export interface ResidentRuntime {
   readonly capsuleReverificationScheduler: SavedCapsuleReverificationScheduler;
   /** Present only when daemon mode runs with `findings.enabled`. */
   readonly findingsScheduler: FindingsScheduler | null;
-  readonly modelManager: ModelManager;
+  readonly modelManager: Pick<
+    ModelManager,
+    "acquireLease" | "getLifecycleStats" | "disposeAll"
+  >;
   readonly mcpContext: ToolContext;
   readonly generations: ResidentGeneration;
   readonly activeRequests: number;
@@ -136,7 +146,7 @@ export interface ResidentRuntime {
     runUpdateCmd?: boolean;
     triggerEmbed?: boolean;
   }): Promise<{ syncResult: SyncResult; embedResult: EmbedResult | null }>;
-  dispose(): Promise<void>;
+  dispose(closeSurface?: () => Promise<unknown>): Promise<void>;
 }
 
 export type ResidentRuntimeResult =
@@ -176,6 +186,8 @@ export async function startResidentRuntime(
   options: ResidentRuntimeOptions = {},
   deps: ResidentRuntimeDeps = {}
 ): Promise<ResidentRuntimeResult> {
+  shutdownDuration(options.shutdownDeadlineMs, SHUTDOWN_DRAIN_MS);
+  shutdownDuration(options.shutdownAbortSettleMs, SHUTDOWN_ABORT_MS);
   if (options.index !== undefined && !isValidIndexName(options.index)) {
     return {
       success: false,
@@ -274,9 +286,16 @@ export async function startResidentRuntime(
     eventBus: options.eventBus ?? null,
     watchService: null,
   };
-  const modelManager =
-    deps.modelManagerFactory?.(initialConfig) ??
-    getModelManager(getModelConfig(initialConfig));
+  const modelManager = deps.modelManagerFactory?.(initialConfig) ?? {
+    acquireLease: () =>
+      ctxHolder.current.llm?.acquireModelLease() ?? { release() {} },
+    getLifecycleStats: () =>
+      ctxHolder.current.llm?.getLifecycleStats() ??
+      createStandaloneResidentStatus("stdio").models,
+    disposeAll: async () => {
+      await ctxHolder.current.llm?.dispose();
+    },
+  };
   const generations: ResidentGeneration = { content: 0, index: 0 };
   ctxHolder.markContentMutation = () => {
     generations.content += 1;
@@ -289,7 +308,6 @@ export async function startResidentRuntime(
     getEmbedPort: () => ctxHolder.current.embedPort,
     getVectorIndex: () => ctxHolder.current.vectorIndex,
     getModelUri: () => getActivePreset(ctxHolder.config).embed,
-    acquireModelLease: () => modelManager.acquireLease(),
     onEmbedded: () => {
       generations.index += 1;
     },
@@ -350,6 +368,7 @@ export async function startResidentRuntime(
   let shutdownState: ResidentStatus["shutdown"]["state"] = "none";
   let admissionState: ResidentStatus["admission"]["state"] = "accepting";
   let disposed = false;
+  let disposal: Promise<void> | undefined;
   const backgroundWork = new ResidentBackgroundWork(
     () => !disposed && admission.accepting
   );
@@ -405,7 +424,8 @@ export async function startResidentRuntime(
     writeLockPath,
     enableWrite: false,
     isShuttingDown: () => disposed || !admission.accepting,
-    acquireModelLease: () => modelManager.acquireLease(),
+    getModelAdapter: (config) =>
+      config === ctxHolder.current.config ? ctxHolder.current.llm : undefined,
     markContentMutation: () => {
       generations.content += 1;
     },
@@ -545,60 +565,76 @@ export async function startResidentRuntime(
       policySessionInvalidator = invalidator;
     },
     async syncAll(syncOptions = {}) {
-      const config = ctxHolder.config;
-      const syncAllService = deps.syncAllService
-        ? (...args: Parameters<typeof defaultSyncService.syncAll>) =>
-            deps.syncAllService!(...args)
-        : defaultSyncService.syncAll.bind(defaultSyncService);
-      const syncResult = await syncAllService(
-        config.collections,
-        store,
-        withContentTypeRules(
-          {
-            gitPull: syncOptions.gitPull,
-            runUpdateCmd: syncOptions.runUpdateCmd,
-          },
-          config
-        )
-      );
-      recordContentMutation(syncResult, () => {
-        generations.content += 1;
-      });
-      const embedResult =
-        syncOptions.triggerEmbed === false
-          ? null
-          : await scheduler.triggerNow();
-      capsuleReverificationScheduler.notifySyncSettled();
-      return { syncResult, embedResult };
+      const request = admission.admit();
+      if (!request) throw new Error("Resident runtime is shutting down");
+      try {
+        return await withOwnedInferenceScope(
+          { signal: request.signal },
+          async () => {
+            const config = ctxHolder.config;
+            const syncAllService = deps.syncAllService
+              ? (...args: Parameters<typeof defaultSyncService.syncAll>) =>
+                  deps.syncAllService!(...args)
+              : defaultSyncService.syncAll.bind(defaultSyncService);
+            const syncResult = await syncAllService(
+              config.collections,
+              store,
+              withContentTypeRules(
+                {
+                  gitPull: syncOptions.gitPull,
+                  runUpdateCmd: syncOptions.runUpdateCmd,
+                },
+                config
+              )
+            );
+            recordContentMutation(syncResult, () => {
+              generations.content += 1;
+            });
+            const embedResult =
+              syncOptions.triggerEmbed === false
+                ? null
+                : await scheduler.triggerNow();
+            capsuleReverificationScheduler.notifySyncSettled();
+            return { syncResult, embedResult };
+          }
+        );
+      } finally {
+        request.finish();
+      }
     },
-    async dispose() {
-      if (disposed) return;
+    dispose(closeSurface) {
+      if (disposal) return disposal;
       disposed = true;
+      admission.stop();
+      jobManager.stop();
       admissionState = "draining";
       shutdownState = "graceful";
-      const deadlineReached = await admission.closeAndDrain(
-        options.shutdownDeadlineMs ?? DEFAULT_SHUTDOWN_DEADLINE_MS,
-        options.shutdownAbortSettleMs ?? DEFAULT_SHUTDOWN_DEADLINE_MS
-      );
-      if (deadlineReached) shutdownState = "deadline";
-      findingsScheduler?.dispose();
-      await backgroundWork.cancelAndDrain();
-      await capsuleReverificationScheduler.dispose();
-      await jobManager.shutdown().catch(() => undefined);
-      await Promise.allSettled([
-        Promise.resolve().then(() => watchService.dispose()),
-        Promise.resolve().then(() => options.eventBus?.close()),
-      ]);
-      await Promise.allSettled([scheduler.dispose()]);
-      await Promise.allSettled([
-        (deps.disposeServerContext ?? disposeServerContext)(ctxHolder.current),
-      ]);
-      await Promise.allSettled([modelManager.disposeAll()]);
-      await Promise.allSettled([store.close()]);
-      await Promise.allSettled([ownerLock.release()]);
-      admissionState = "closed";
-      transportStatusProvider = null;
-      listenerPort = null;
+      disposal = disposeResidentResources({
+        options,
+        admission,
+        backgroundWork,
+        jobManager,
+        scheduler,
+        store,
+        watchService,
+        context: ctxHolder.current,
+        mcpContext,
+        modelManager,
+        ownerLock,
+        stopFindings: () => findingsScheduler?.dispose(),
+        stopCapsules: () => capsuleReverificationScheduler.dispose(),
+        closeEvents: () => options.eventBus?.close(),
+        disposeContext: deps.disposeServerContext ?? disposeServerContext,
+        closeSurface,
+        onDeadline: () => {
+          shutdownState = "deadline";
+        },
+      }).then(() => {
+        admissionState = "closed";
+        transportStatusProvider = null;
+        listenerPort = null;
+      });
+      return disposal;
     },
   };
   ctxHolder.startBackgroundWork = (operation) =>

package/src/serve/resident-shutdown.ts

@@ -0,0 +1,153 @@
+import type { WriteLockHandle } from "../core/file-lock";
+/** One finite shutdown clock for the resources owned by a resident runtime. */
+import type { JobManager } from "../core/job-manager";
+import type { ToolContext } from "../mcp/context";
+import type { SqliteAdapter } from "../store/sqlite/adapter";
+import type { ServerContext } from "./context";
+import type { EmbedScheduler } from "./embed-scheduler";
+import type { AdmissionController } from "./resident-admission";
+import type { ResidentBackgroundWork } from "./resident-background-work";
+import type { ResidentRuntimeOptions } from "./resident-runtime";
+
+import {
+  settlesBy,
+  shutdownDuration,
+  SHUTDOWN_DRAIN_MS,
+  SHUTDOWN_ABORT_MS,
+  SHUTDOWN_EXIT_MS,
+} from "../core/shutdown-budget";
+
+interface ResidentShutdownResources {
+  options: ResidentRuntimeOptions;
+  admission: AdmissionController;
+  backgroundWork: ResidentBackgroundWork;
+  jobManager: JobManager;
+  scheduler: EmbedScheduler;
+  store: SqliteAdapter;
+  watchService: { dispose(): void | Promise<void> };
+  context: ServerContext;
+  mcpContext: ToolContext;
+  modelManager: { disposeAll(): Promise<void> };
+  ownerLock: WriteLockHandle;
+  stopFindings: () => void;
+  stopCapsules: () => Promise<void>;
+  closeEvents: () => void | Promise<void>;
+  disposeContext: (context: ServerContext) => Promise<void>;
+  closeSurface?: () => Promise<unknown>;
+  onDeadline: () => void;
+}
+
+export async function disposeResidentResources(
+  resources: ResidentShutdownResources
+): Promise<void> {
+  const {
+    options,
+    admission,
+    backgroundWork,
+    jobManager,
+    scheduler,
+    store,
+    watchService,
+    context,
+    mcpContext,
+    modelManager,
+    ownerLock,
+    stopFindings,
+    stopCapsules,
+    closeEvents,
+    disposeContext,
+    closeSurface,
+    onDeadline,
+  } = resources;
+  let deadlineReached = false;
+  const drainDeadline =
+    performance.now() +
+    shutdownDuration(options.shutdownDeadlineMs, SHUTDOWN_DRAIN_MS);
+  const abortDeadline =
+    drainDeadline +
+    shutdownDuration(options.shutdownAbortSettleMs, SHUTDOWN_ABORT_MS);
+  const exitDeadline = abortDeadline + SHUTDOWN_EXIT_MS;
+  let unfinishedJobs: Promise<void> = Promise.resolve();
+  let writeFailure: unknown;
+  store.beginShutdown?.(abortDeadline);
+  const observe = (operation: () => unknown): Promise<void> =>
+    Promise.resolve()
+      .then(operation)
+      .then(
+        () => {},
+        (error: unknown) => console.error("Resident cleanup failed:", error)
+      );
+  stopFindings();
+  const schedulerDrain = observe(() =>
+    scheduler.stop ? scheduler.stop() : scheduler.dispose()
+  );
+  const work = Promise.all([
+    observe(() => closeSurface?.()),
+    admission.drain(),
+    backgroundWork.drain(),
+    jobManager.shutdown(),
+    schedulerDrain,
+    observe(() => stopCapsules()),
+    observe(() => watchService.dispose()),
+    observe(() => closeEvents()),
+  ]);
+  if (!(await settlesBy(work, drainDeadline))) {
+    deadlineReached = true;
+    onDeadline();
+    admission.cancel();
+    backgroundWork.cancel();
+    jobManager.cancel();
+    const canceledScheduler = observe(() => scheduler.dispose());
+    if (
+      !(await settlesBy(Promise.all([work, canceledScheduler]), abortDeadline))
+    ) {
+      // Revoke/rollback suspended parent writers before closing their DB.
+      // The ordinary store API also fences any late noncooperative callback.
+      try {
+        store.fenceForShutdown?.();
+        // Calling close synchronously closes cached raw handles before
+        // any late callback can resume in the native-exit wait.
+        const closing = store.close();
+        unfinishedJobs = jobManager.failUnfinished();
+        if (!(await settlesBy(closing, exitDeadline)))
+          throw new Error("Store close exceeded shutdown deadline");
+      } catch (error) {
+        writeFailure = error;
+      }
+    }
+  }
+  // Reach the single native owner directly; port disposal may itself wait
+  // for that owner. Never let such a wait hide the forced-exit deadline.
+  const nativeOptions = {
+    deadline: exitDeadline,
+    force: deadlineReached,
+  };
+  const native = Promise.all([
+    context.llm?.dispose(nativeOptions),
+    mcpContext.disposeModels?.(nativeOptions),
+  ]);
+  let nativeFailure: unknown;
+  try {
+    if (!(await settlesBy(native, exitDeadline)))
+      throw new Error(
+        "Native shutdown did not settle before owned-child exit deadline"
+      );
+  } catch (error) {
+    nativeFailure = error;
+    console.error("Resident native shutdown failed:", error);
+  }
+  const cleanup = Promise.all([
+    unfinishedJobs,
+    observe(() => disposeContext(context)),
+    observe(() => modelManager.disposeAll()),
+  ]);
+  if (!(await settlesBy(cleanup, exitDeadline)))
+    console.error("Resident resource cleanup exceeded shutdown deadline");
+  // close performs synchronous rollback/revocation before disconnecting.
+  if (writeFailure) throw writeFailure;
+  if (!(await settlesBy(store.close(), exitDeadline)))
+    throw new Error("Store close exceeded shutdown deadline");
+  if (!(await settlesBy(ownerLock.release(), exitDeadline)))
+    throw new Error("Resident owner lock release exceeded shutdown deadline");
+  if (nativeFailure) throw nativeFailure;
+}

package/src/serve/routes/api.ts

@@ -4244,7 +4244,9 @@ export async function handleSearch(
       req,
       trace.session,
       "failed",
-      errorResponse("RUNTIME", result.error.message, 500)
+      result.error.code === "INVALID_INPUT"
+        ? errorResponse("VALIDATION", result.error.message, 400)
+        : errorResponse("RUNTIME", result.error.message, 500)
     );
   }
 

package/src/serve/server.ts

@@ -472,8 +472,8 @@ export async function startServer(
     }
   } catch (error) {
     removeShutdownHandlers();
-    await Promise.allSettled([gateway.close()]);
-    await Promise.allSettled([runtime.dispose()]);
+    const surfaceClose = Promise.resolve().then(() => gateway.close());
+    await runtime.dispose(() => surfaceClose);
     return {
       success: false,
       error: error instanceof Error ? error.message : String(error),
@@ -1134,8 +1134,11 @@ export async function startServer(
               return withSecurityHeaders(forbiddenResponse(), isDev);
             }
             return withSecurityHeaders(
-              await handleResidentRead(runtime as ResidentRuntime, req, () =>
-                handleQuery(ctxHolder.current, req)
+              await handleResidentRead(
+                runtime as ResidentRuntime,
+                req,
+                (signal) =>
+                  handleQuery(ctxHolder.current, new Request(req, { signal }))
               ),
               isDev
             );
@@ -1147,8 +1150,14 @@ export async function startServer(
               return withSecurityHeaders(forbiddenResponse(), isDev);
             }
             return withSecurityHeaders(
-              await handleResidentRead(runtime as ResidentRuntime, req, () =>
-                handleContextBuild(ctxHolder.current, req)
+              await handleResidentRead(
+                runtime as ResidentRuntime,
+                req,
+                (signal) =>
+                  handleContextBuild(
+                    ctxHolder.current,
+                    new Request(req, { signal })
+                  )
               ),
               isDev
             );
@@ -1160,8 +1169,14 @@ export async function startServer(
               return withSecurityHeaders(forbiddenResponse(), isDev);
             }
             return withSecurityHeaders(
-              await handleResidentRead(runtime as ResidentRuntime, req, () =>
-                handleContextVerify(ctxHolder.current, req)
+              await handleResidentRead(
+                runtime as ResidentRuntime,
+                req,
+                (signal) =>
+                  handleContextVerify(
+                    ctxHolder.current,
+                    new Request(req, { signal })
+                  )
               ),
               isDev
             );
@@ -1173,8 +1188,14 @@ export async function startServer(
               return withSecurityHeaders(forbiddenResponse(), isDev);
             }
             return withSecurityHeaders(
-              await handleResidentRead(runtime as ResidentRuntime, req, () =>
-                handleQueryDiagnose(ctxHolder.current, req)
+              await handleResidentRead(
+                runtime as ResidentRuntime,
+                req,
+                (signal) =>
+                  handleQueryDiagnose(
+                    ctxHolder.current,
+                    new Request(req, { signal })
+                  )
               ),
               isDev
             );
@@ -1186,8 +1207,11 @@ export async function startServer(
               return withSecurityHeaders(forbiddenResponse(), isDev);
             }
             return withSecurityHeaders(
-              await handleResidentRead(runtime as ResidentRuntime, req, () =>
-                handleAsk(ctxHolder.current, req)
+              await handleResidentRead(
+                runtime as ResidentRuntime,
+                req,
+                (signal) =>
+                  handleAsk(ctxHolder.current, new Request(req, { signal }))
               ),
               isDev
             );
@@ -1481,11 +1505,11 @@ export async function startServer(
     });
   } catch (e) {
     removeShutdownHandlers();
-    if (spaBundleSource) {
-      await Promise.allSettled([spaBundleSource.close()]);
-    }
-    await Promise.allSettled([gateway.close()]);
-    await Promise.allSettled([runtime.dispose()]);
+    const surfaceClose = Promise.all([
+      Promise.resolve().then(() => spaBundleSource?.close()),
+      Promise.resolve().then(() => gateway.close()),
+    ]);
+    await runtime.dispose(() => surfaceClose);
     return {
       success: false,
       error: e instanceof Error ? e.message : String(e),
@@ -1510,14 +1534,11 @@ export async function startServer(
   }
 
   removeShutdownHandlers();
-  try {
-    await server.stop(true);
-  } finally {
-    if (spaBundleSource) {
-      await Promise.allSettled([spaBundleSource.close()]);
-    }
-    await Promise.allSettled([gateway.close()]);
-    await Promise.allSettled([runtime.dispose()]);
-  }
+  const surfaceClose = Promise.all([
+    Promise.resolve().then(() => server.stop(true)),
+    Promise.resolve().then(() => spaBundleSource?.close()),
+    Promise.resolve().then(() => gateway.close()),
+  ]);
+  await runtime.dispose(() => surfaceClose);
   return { success: true };
 }

package/src/store/migrations/028-vector-variants.ts

@@ -0,0 +1,54 @@
+/** Additive exact-input variants; existing vectors have no historical proof. */
+import type { Migration } from "./runner";
+
+export const migration: Migration = {
+  version: 28,
+  name: "vector_variants",
+  up(db): void {
+    db.exec(`
+      CREATE TABLE vector_variant_epoch (
+        id INTEGER PRIMARY KEY CHECK (id = 1), epoch INTEGER NOT NULL DEFAULT 0
+      );
+      INSERT INTO vector_variant_epoch(id) VALUES (1);
+      CREATE TABLE vector_partitions (
+        partition_id TEXT PRIMARY KEY,
+        version INTEGER NOT NULL CHECK (version = 1),
+        model TEXT NOT NULL, fingerprint TEXT NOT NULL,
+        dimensions INTEGER NOT NULL CHECK (dimensions > 0),
+        state TEXT NOT NULL DEFAULT 'shadow' CHECK (state IN ('shadow', 'active')),
+        activated_epoch INTEGER,
+        UNIQUE(model, fingerprint, dimensions)
+      );
+      CREATE TABLE vector_variants (
+        variant_id INTEGER PRIMARY KEY,
+        partition_id TEXT NOT NULL REFERENCES vector_partitions(partition_id),
+        input_hash TEXT NOT NULL CHECK (length(input_hash) = 64),
+        embedding BLOB NOT NULL,
+        UNIQUE(partition_id, input_hash), UNIQUE(partition_id, variant_id)
+      );
+      CREATE TABLE vector_owners (
+        document_id INTEGER NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
+        mirror_hash TEXT NOT NULL, seq INTEGER NOT NULL,
+        partition_id TEXT NOT NULL, variant_id INTEGER NOT NULL,
+        PRIMARY KEY(document_id, seq, partition_id),
+        FOREIGN KEY(partition_id, variant_id)
+          REFERENCES vector_variants(partition_id, variant_id)
+      );
+      CREATE INDEX idx_vector_owners_variant ON vector_owners(variant_id);
+    `);
+    // All writers, including old consumers and raw SQL, participate in the fence.
+    for (const table of [
+      "documents",
+      "content_chunks",
+      "vector_owners",
+      "vector_variants",
+    ]) {
+      for (const event of ["INSERT", "UPDATE", "DELETE"]) {
+        db.exec(`CREATE TRIGGER variant_epoch_${table}_${event}
+          AFTER ${event} ON ${table} BEGIN
+            UPDATE vector_variant_epoch SET epoch = epoch + 1 WHERE id = 1;
+          END`);
+      }
+    }
+  },
+};

package/src/store/migrations/029-graph-reference-state.ts

@@ -0,0 +1,77 @@
+/** Durable unresolved references and conservative projection recovery. */
+import type { Migration } from "./runner";
+
+export const migration: Migration = {
+  version: 29,
+  name: "graph_reference_state",
+  up(db): void {
+    db.exec(`
+-- Graph reference inventory (migration 029). Parsed links remain in doc_links.
+-- Snapshots deliberately survive document deletion: closure needs old identities.
+-- Missing inventory, changed version/config, or dirty state requires full recovery.
+-- Begin persists dirty before projection. Complete only after successful edge writes,
+-- unchanged input epoch, and coverage of every active source; compose in a transaction.
+CREATE TABLE graph_projection_state (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  epoch INTEGER NOT NULL DEFAULT 0,
+  version INTEGER,
+  config_fingerprint TEXT,
+  in_progress INTEGER NOT NULL DEFAULT 0 CHECK (in_progress IN (0, 1)),
+  dirty INTEGER NOT NULL DEFAULT 1 CHECK (dirty IN (0, 1))
+);
+INSERT INTO graph_projection_state(id) VALUES (1);
+CREATE TABLE graph_reference_documents (
+  document_id INTEGER PRIMARY KEY,
+  collection TEXT NOT NULL, rel_path TEXT NOT NULL, docid TEXT NOT NULL,
+  uri TEXT NOT NULL, title TEXT, mirror_hash TEXT, source_hash TEXT NOT NULL,
+  content_type TEXT
+);
+CREATE INDEX idx_graph_reference_uri ON graph_reference_documents(uri);
+CREATE INDEX idx_graph_reference_path ON graph_reference_documents(collection, rel_path);
+CREATE INDEX idx_graph_reference_title ON graph_reference_documents(title);
+CREATE TABLE graph_frontmatter_references (
+  source_doc_id INTEGER NOT NULL REFERENCES graph_reference_documents(document_id) ON DELETE CASCADE,
+  ordinal INTEGER NOT NULL,
+  edge_type TEXT NOT NULL,
+  target TEXT NOT NULL,
+  PRIMARY KEY(source_doc_id, ordinal)
+);
+CREATE INDEX idx_graph_reference_target ON graph_frontmatter_references(target);
+`);
+    for (const table of ["documents", "doc_links"]) {
+      for (const operation of ["INSERT", "UPDATE", "DELETE"]) {
+        const changed =
+          table === "documents" && operation === "UPDATE"
+            ? " WHEN " +
+              [
+                "collection",
+                "rel_path",
+                "docid",
+                "uri",
+                "title",
+                "mirror_hash",
+                "source_hash",
+                "content_type",
+                "active",
+              ]
+                .map((column) => `OLD.${column} IS NOT NEW.${column}`)
+                .join(" OR ")
+            : "";
+        db.exec(`CREATE TRIGGER graph_input_${table}_${operation.toLowerCase()}
+          AFTER ${operation} ON ${table}${changed} BEGIN
+          UPDATE graph_projection_state SET epoch = epoch + 1, dirty = 1 WHERE id = 1;
+          END`);
+      }
+    }
+    for (const table of [
+      "graph_reference_documents",
+      "graph_frontmatter_references",
+    ]) {
+      for (const operation of ["INSERT", "UPDATE", "DELETE"]) {
+        db.exec(`CREATE TRIGGER graph_inventory_${table}_${operation.toLowerCase()}
+          AFTER ${operation} ON ${table} BEGIN
+          UPDATE graph_projection_state SET dirty = 1, in_progress = 1 WHERE id = 1; END`);
+      }
+    }
+  },
+};

package/src/store/migrations/index.ts

@@ -41,6 +41,8 @@ import { migration as m024 } from "./024-egress-derived-lineage";
 import { migration as m025 } from "./025-collection-egress-policy-revision";
 import { migration as m026 } from "./026-file-refactor-recovery-journal";
 import { migration as m027 } from "./027-memory-scopes";
+import { migration as m028 } from "./028-vector-variants";
+import { migration as m029 } from "./029-graph-reference-state";
 
 /** All migrations in order */
 export const migrations = [
@@ -71,4 +73,6 @@ export const migrations = [
   m025,
   m026,
   m027,
+  m028,
+  m029,
 ];