@gmickel/gno 2.9.1 → 2.10.0

package/src/serve/resident-runtime.ts

@@ -209,6 +209,7 @@ export type ResidentRuntimeDeps = {
     callbacks?: CollectionWatchCallbacks;
     syncOptions?: Parameters<typeof withContentTypeRules>[0];
     acquireWriteLease?: () => Promise<(() => Promise<void>) | null>;
+    reconcileOnStart?: boolean;
   }) => CollectionWatchService;
   modelManagerFactory?: (config: Config) => ModelManager;
 };
@@ -392,6 +393,8 @@ export async function startResidentRuntime(
     },
     syncOptions: withContentTypeRules({}, initialConfig),
     acquireWriteLease: leaseFor(`gno ${mode} (watch sync)`),
+    // serve has no initial sync of its own; the daemon runs one unless told not to.
+    reconcileOnStart: mode === "serve",
   });
   watchService.start();
   // A backlog left by `--no-embed` or an earlier run gets a pass without
@@ -502,8 +505,24 @@ export async function startResidentRuntime(
     indexName: canonicalizeIndexName(options.index ?? DEFAULT_INDEX_NAME),
   };
   let configRefresh: Promise<void> | undefined;
+  // Every read request refreshes the config. Re-reading and re-parsing an
+  // unchanged file each time kept the main thread busy under load; skip it
+  // while the file's identity, size and times match the last good load. Any
+  // write, rename, chmod or delete changes the stamp, so a broken file is
+  // still reported, never served stale.
+  let loadedConfigStamp: string | undefined;
+  const configStamp = async (): Promise<string | undefined> => {
+    try {
+      const stat = await Bun.file(instance.configPath).stat();
+      return `${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+    } catch {
+      return undefined;
+    }
+  };
   const refreshConfig = (): Promise<void> => {
     configRefresh ??= (async () => {
+      const stamp = await configStamp();
+      if (stamp !== undefined && stamp === loadedConfigStamp) return;
       const file = await readInstanceConfig(
         instance,
         deps.loadConfig ?? loadConfig
@@ -514,7 +533,10 @@ export async function startResidentRuntime(
         collections: file.collections,
         contexts: file.contexts,
       };
-      if (Bun.deepEquals(next, served)) return;
+      if (Bun.deepEquals(next, served)) {
+        loadedConfigStamp = stamp;
+        return;
+      }
       await adoptServedConfig(
         {
           ...instance,
@@ -529,6 +551,7 @@ export async function startResidentRuntime(
         },
         next
       );
+      loadedConfigStamp = stamp;
     })().finally(() => {
       configRefresh = undefined;
     });

package/src/serve/resident-shutdown.ts

@@ -16,6 +16,7 @@ import {
   SHUTDOWN_ABORT_MS,
   SHUTDOWN_EXIT_MS,
 } from "../core/shutdown-budget";
+import { killImportChildren } from "../sessions/import-child";
 
 interface ResidentShutdownResources {
   options: ResidentRuntimeOptions;
@@ -78,6 +79,9 @@ export async function disposeResidentResources(
         (error: unknown) => console.error("Resident cleanup failed:", error)
       );
   stopFindings();
+  // A session import runs in a child that would outlive this process and hold
+  // up the drain below; cutting it short is safe (one transaction per file).
+  killImportChildren();
   const schedulerDrain = observe(() =>
     scheduler.stop ? scheduler.stop() : scheduler.dispose()
   );

package/src/serve/server.ts

@@ -3,6 +3,8 @@ import type { RequestPeerServer } from "./request-locality";
 import type { ResidentRuntime } from "./resident-runtime";
 import type { ContextHolder } from "./routes/api";
 
+import { markResidentShutdownHandlerInstalled } from "../core/resident-shutdown-handler";
+import { sighupHandlerAllowed } from "../core/sighup-disposition";
 import { getActivePreset } from "../llm/registry";
 import {
   isHttpGatewayLoopbackBind,
@@ -25,6 +27,7 @@ import {
  * @module src/serve/server
  */
 import { withRemoteHostPathRedaction } from "./host-path-redaction";
+import { watchParentLifeline } from "./parent-lifeline";
 import { PDFJS_ASSET_CACHE_CONTROL } from "./pdfjs-assets";
 // HTML import - Bun handles bundling TSX/CSS automatically via routes
 import homepage from "./public/index.html";
@@ -401,7 +404,7 @@ export function loopbackHttpOrigin(host: string, port: number): string {
 
 /**
  * Start the web server.
- * Opens DB once, closes on SIGINT/SIGTERM.
+ * Opens DB once, closes on SIGINT/SIGTERM/SIGHUP.
  */
 export async function startServer(
   options: ServeOptions = {},
@@ -478,9 +481,22 @@ export async function startServer(
 
   process.once("SIGINT", shutdown);
   process.once("SIGTERM", shutdown);
+  // A closed terminal or logout: shut down cleanly, as on SIGTERM, unless
+  // SIGHUP was ignored at start (nohup), which must keep working.
+  const handleSighup = sighupHandlerAllowed();
+  if (handleSighup) process.once("SIGHUP", shutdown);
+  markResidentShutdownHandlerInstalled();
+  // A launcher that owns this process (the desktop shell) closes our stdin
+  // when it exits or is killed; shut down instead of running orphaned.
+  const stopLifeline = watchParentLifeline(() => {
+    console.log("\nParent process gone.");
+    shutdown();
+  });
   const removeShutdownHandlers = (): void => {
     process.off("SIGINT", shutdown);
     process.off("SIGTERM", shutdown);
+    if (handleSighup) process.off("SIGHUP", shutdown);
+    stopLifeline();
   };
 
   // Start server with try/catch for port-in-use etc.
@@ -1778,6 +1794,11 @@ export async function startServer(
     await dependencies.waitForShutdown(shutdownController.signal);
   } else {
     await new Promise<void>((resolve) => {
+      // The lifeline can fire while the listener is still starting.
+      if (shutdownController.signal.aborted) {
+        resolve();
+        return;
+      }
       shutdownController.signal.addEventListener("abort", () => resolve(), {
         once: true,
       });

package/src/serve/status.ts

@@ -12,6 +12,7 @@ import type {
   SuggestedCollection,
 } from "./status-model";
 
+import { BUN_ENGINE_RANGE } from "../app/bun-runtime";
 import { getModelsCachePath } from "../app/constants";
 import { buildContentTypeBoostStatus } from "../config/content-types";
 import { isEmptyActivationCollection } from "../core/activation-empty";
@@ -513,7 +514,7 @@ async function buildBootstrapState(
       kind: "bun",
       strategy: "manual-install-beta",
       currentVersion: Bun.version,
-      requiredVersion: ">=1.3.0",
+      requiredVersion: BUN_ENGINE_RANGE,
       ready: true,
       managedByApp: false,
       summary: `This beta runs on Bun ${Bun.version}.`,

package/src/serve/watch-reconciliation.ts

@@ -10,8 +10,13 @@
 import type { Collection } from "../config/types";
 import type { SqliteAdapter } from "../store/sqlite/adapter";
 
+import { relPathUnderAnyPrefix } from "../ingestion";
 import { WATCHER_ACTIVE_SOURCE_PATH_MAX } from "../store/types";
 import { fallbackClassifyDirtyHints } from "./watch-reconciliation-fallback";
+import {
+  fallbackFs,
+  inspectNoFollowPresence,
+} from "./watch-reconciliation-fallback-disk";
 import {
   filterEligiblePaths,
   type ClassificationResult,
@@ -48,6 +53,112 @@ export {
   type WatcherEventClassification,
 } from "./watch-reconciliation-shared";
 
+type StoreOnlyRemovals =
+  | { status: "ok"; paths: string[] }
+  | { status: "overflow" }
+  | { status: "error"; cause: unknown; stage: "scan" | "store" };
+
+/**
+ * Store-known active paths under the dirty hints that are gone from disk.
+ * The snapshot only knows what it scanned: a note indexed from its own exact
+ * event after the baseline is in the store but not the snapshot, and when
+ * its directory is then moved or replaced (one directory event) the snapshot
+ * diff alone would leave it active (fn-209).
+ *
+ * A path the fresh snapshot lists as a file or symlink is present. Paths in
+ * subtrees the snapshot left unproven are left alone. Every other path gets
+ * the fallback classifier's no-follow, availability-aware proof: missing or
+ * no longer a regular source is a removal; an inconclusive check is a scan
+ * error, so the watcher keeps the work and retries rather than infer a
+ * delete. The root hint (a watcher event without a filename) uses the
+ * bounded whole-collection inventory.
+ */
+async function storeOnlyRemovals(options: {
+  store: SqliteAdapter;
+  collection: Collection;
+  rootAbs: string;
+  dirtyHints: readonly string[];
+  next: WatcherSnapshot | null;
+  sourcePathMax: number;
+  snapshotOptions?: WatcherSnapshotOptions;
+}): Promise<StoreOnlyRemovals> {
+  const { store, collection, rootAbs, next, sourcePathMax } = options;
+  const hints = [...new Set(options.dirtyHints)].sort();
+  const storePaths: string[] = [];
+  if (hints.includes("")) {
+    if (typeof store.listActiveSourcePaths !== "function") {
+      return { status: "ok", paths: [] };
+    }
+    const listed = await store.listActiveSourcePaths(
+      collection.name,
+      sourcePathMax
+    );
+    if (!listed.ok) {
+      if (listed.error.code === "OVERFLOW") return { status: "overflow" };
+      return {
+        status: "error",
+        cause: new Error(listed.error.message),
+        stage: "store",
+      };
+    }
+    storePaths.push(...listed.value);
+  } else {
+    if (typeof store.listActiveDescendantSourcePaths !== "function") {
+      return { status: "ok", paths: [] };
+    }
+    // A hint under another hint is covered by the outer descendant lookup.
+    const roots = hints.filter(
+      (hint, index) =>
+        !hints.slice(0, index).some((outer) => hint.startsWith(`${outer}/`))
+    );
+    for (const dir of roots) {
+      const listed = await store.listActiveDescendantSourcePaths(
+        collection.name,
+        dir,
+        Math.max(1, sourcePathMax - storePaths.length)
+      );
+      if (!listed.ok) {
+        if (listed.error.code === "OVERFLOW") return { status: "overflow" };
+        // Not a directory path the store can scope (e.g. escapes the root).
+        if (listed.error.code === "INVALID_INPUT") continue;
+        return {
+          status: "error",
+          cause: new Error(listed.error.message),
+          stage: "store",
+        };
+      }
+      storePaths.push(...listed.value);
+      if (storePaths.length > sourcePathMax) return { status: "overflow" };
+    }
+  }
+
+  const unproven = [...(next?.unprovenSubtrees ?? [])];
+  const fs = options.snapshotOptions?.fs ?? fallbackFs();
+  const removals: string[] = [];
+  for (const path of storePaths) {
+    if (relPathUnderAnyPrefix(path, unproven)) continue;
+    const slash = path.lastIndexOf("/");
+    const parent = slash === -1 ? "" : path.slice(0, slash);
+    const kind = next?.directories
+      .get(parent)
+      ?.get(path.slice(slash + 1))?.kind;
+    if (kind === "file" || kind === "symlink") continue;
+    const presence = await inspectNoFollowPresence(
+      rootAbs,
+      path,
+      fs,
+      options.snapshotOptions?.directoryAvailability
+    );
+    if (presence.status === "error") {
+      return { status: "error", cause: presence.cause, stage: "scan" };
+    }
+    if (presence.status === "missing" || !presence.indexable) {
+      removals.push(path);
+    }
+  }
+  return { status: "ok", paths: removals };
+}
+
 /**
  * Snapshot-first classification of dirty hints. On overflow/scan/metadata
  * failure, uses bounded store + disk enumeration without inferring deletes
@@ -96,10 +207,32 @@ export async function classifyDirtyHints(options: {
       snapshotOptions
     );
     if (diff.status === "ok") {
+      const storeRemovals = await storeOnlyRemovals({
+        store,
+        collection,
+        rootAbs,
+        dirtyHints,
+        next: diff.nextSnapshot,
+        sourcePathMax,
+        snapshotOptions,
+      });
+      if (storeRemovals.status === "overflow") {
+        return { status: "full_reconcile", reason: "budget_overflow" };
+      }
+      if (storeRemovals.status === "error") {
+        return {
+          status: "error",
+          cause: storeRemovals.cause,
+          stage: storeRemovals.stage,
+        };
+      }
       return {
         status: "ok",
         candidates: filterEligiblePaths(diff.candidates, collection),
-        removals: filterEligiblePaths(diff.removals, collection),
+        removals: filterEligiblePaths(
+          [...new Set([...diff.removals, ...storeRemovals.paths])],
+          collection
+        ),
         nextSnapshot: diff.nextSnapshot,
         usedFallback: false,
       };

package/src/serve/watch-service-flush-generation.ts

@@ -7,18 +7,65 @@
 // node:path — Bun has no path utilities
 import { normalize } from "node:path";
 
+import type { CollectionSyncResult } from "../ingestion";
 import type {
   FlushCollectionInput,
   FlushCollectionOutcome,
 } from "./watch-service-flush";
 
-import { defaultSyncService } from "../ingestion";
+import { defaultSyncService, isSourceAvailabilitySkip } from "../ingestion";
 import { hasFileLevelSyncError } from "./watch-reconciliation";
 import {
   contentChangedPaths,
   notifyCompletedSync,
 } from "./watch-service-flush-helpers";
 
+/** Failure codes from the store side of a sync: transient, worth a retry. */
+const STORE_SIDE_FAILURE_CODES = new Set(["QUERY_FAILED", "STORE_ERROR"]);
+const SOURCE_AVAILABILITY_PREFIX = "SOURCE_AVAILABILITY_";
+
+interface ReconcileFailures {
+  /** A collection-level failure (no path): the reconcile itself is incomplete. */
+  unscoped: boolean;
+  /** Every named failed path, from file receipts and walker errors alike. */
+  named: string[];
+  /** Named paths that failed in the store, not on the file's content. */
+  storeSide: string[];
+}
+
+/** Classify the failures of a completed full-collection sync. */
+function classifyReconcileFailures(
+  result: CollectionSyncResult
+): ReconcileFailures {
+  const named = new Set<string>();
+  const storeSide = new Set<string>();
+  let unscoped = false;
+  for (const file of result.files ?? []) {
+    if (file.status !== "error") continue;
+    named.add(file.relPath);
+    if (STORE_SIDE_FAILURE_CODES.has(file.errorCode ?? ""))
+      storeSide.add(file.relPath);
+  }
+  // A collection whose source availability cannot be proven fails the same
+  // way on every attempt until its config or volume changes (a config edit
+  // starts a new reconcile): record it once, like a content failure.
+  let unavailable = false;
+  // Walker failures (TOO_LARGE, PERMISSION...) appear only here.
+  for (const entry of result.errors) {
+    if (isSourceAvailabilitySkip(entry.code)) continue;
+    if (!entry.relPath) {
+      if (entry.code.startsWith(SOURCE_AVAILABILITY_PREFIX)) unavailable = true;
+      else unscoped = true;
+      continue;
+    }
+    named.add(entry.relPath);
+    if (STORE_SIDE_FAILURE_CODES.has(entry.code)) storeSide.add(entry.relPath);
+  }
+  // A failure count with nothing named is collection-level too.
+  if (named.size === 0 && !unavailable) unscoped = true;
+  return { unscoped, named: [...named], storeSide: [...storeSide] };
+}
+
 /**
  * When collection generation advanced during/before flush, run full
  * syncCollection. Failures leave durable generation work and never advance
@@ -96,11 +143,38 @@ export async function runGenerationReconcile(
         contentChangedPaths(result);
 
       if (hasFileLevelSyncError(result)) {
-        // Notify completed sync once; keep durable generation work.
-        notifyCompletedSync(input, operationPaths, result, ownership);
         const error = new Error(
           "One or more paths failed during watcher generation reconcile"
         );
+        const failures = classifyReconcileFailures(result);
+        // The walk completed: the collection is reconciled except for the
+        // named failed paths (fn-211). Requeuing the whole generation
+        // re-walked the collection every backoff step for as long as one file
+        // kept failing. Store-side failures are transient and can leave a
+        // stale document, so only those paths are retried (exact paths,
+        // failure backoff). Content failures (unreadable, corrupt, too
+        // large...) are recorded once, as `gno update` and the daemon's
+        // initial sync do; the next edit to the file retries it. Keep the
+        // whole generation when any failure is collection-level (e.g. the
+        // document inventory failed) or this flush no longer owns the
+        // collection (its requeue would be dropped).
+        if (
+          !failures.unscoped &&
+          input.getCurrentGeneration() === input.ownerGeneration
+        ) {
+          input.invalidateSnapshot(stillCurrent);
+          notifyCompletedSync(input, operationPaths, result, ownership);
+          input.onSyncError(failures.named, error);
+          if (failures.storeSide.length > 0) {
+            input.requeue(failures.storeSide, []);
+            return { status: "failed", error };
+          }
+          completedGeneration = currentGeneration;
+          needsWork = input.getCurrentGeneration() !== completedGeneration;
+          continue;
+        }
+        // Notify completed sync once; keep durable generation work.
+        notifyCompletedSync(input, operationPaths, result, ownership);
         input.onSyncError([], error);
         input.requeueGeneration();
         return { status: "failed", error };

package/src/serve/watch-service.ts

@@ -49,7 +49,11 @@ import {
 } from "./watch-service-lifecycle";
 import { runOwnedCollectionFlush } from "./watch-service-run-flush";
 import { beginSnapshotInit } from "./watch-service-snapshot";
-import { pendingHasWork, type CollectionPending } from "./watch-service-state";
+import {
+  emptyPending,
+  pendingHasWork,
+  type CollectionPending,
+} from "./watch-service-state";
 
 export interface CollectionWatchState {
   expectedCollections: string[];
@@ -111,6 +115,12 @@ interface CollectionWatchServiceOptions {
   snapshotEntryCeiling?: number;
   /** Shared writer lease taken (no wait) around each flush's writes. */
   acquireWriteLease?: () => Promise<(() => Promise<void>) | null>;
+  /**
+   * Queue a full reconcile of every watched collection at start, so changes
+   * made while no resident ran reach the index. Off for the daemon, whose
+   * initial sync (unless --no-sync-on-start) covers the same ground.
+   */
+  reconcileOnStart?: boolean;
 }
 
 export class CollectionWatchService {
@@ -152,6 +162,7 @@ export class CollectionWatchService {
   readonly #snapshotFs: WatcherSnapshotFs | undefined;
   readonly #snapshotEntryCeiling: number | undefined;
   readonly #acquireWriteLease: CollectionWatchServiceOptions["acquireWriteLease"];
+  readonly #reconcileOnStart: boolean;
   #nextCollectionGeneration = 0;
   #disposed = false;
   #lastEventAt: string | null = null;
@@ -176,11 +187,24 @@ export class CollectionWatchService {
     this.#snapshotFs = options.snapshotFs;
     this.#snapshotEntryCeiling = options.snapshotEntryCeiling;
     this.#acquireWriteLease = options.acquireWriteLease;
+    this.#reconcileOnStart = options.reconcileOnStart ?? false;
   }
 
   start(): void {
-    if (!this.#disposed) {
-      this.updateCollections(this.#collections);
+    if (this.#disposed) {
+      return;
+    }
+    this.updateCollections(this.#collections);
+    if (!this.#reconcileOnStart) {
+      return;
+    }
+    // Generation work waits for the snapshot baseline, then runs a full
+    // syncCollection through the normal flush path (write lease, failure
+    // backoff, source availability). Unwatchable collections queue nothing.
+    for (const name of this.#watchers.keys()) {
+      const pending = this.#pendingByCollection.get(name) ?? emptyPending();
+      pending.generationReconcile = true;
+      this.#pendingByCollection.set(name, pending);
     }
   }
 

package/src/sessions/import-child.ts

@@ -9,8 +9,11 @@
  * store connection: the archive import lock, receipts and error codes are
  * unchanged.
  *
- * The child reads one request from stdin and writes one JSON result line to
- * stdout. The request carries the caller's loaded config: the child opens
+ * The child reads one request line from stdin and writes one JSON result line
+ * to stdout. The parent keeps stdin open for the child's lifetime: EOF means
+ * the parent died, and the child exits instead of importing on as an orphan.
+ * A resident kills its import children when it shuts down, and every import
+ * has a timeout. The request carries the caller's loaded config: the child opens
  * the index without syncing any config into it and imports with exactly the
  * config the server holds. From source the child runs this module; a
  * compiled executable re-runs itself with `IMPORT_CHILD_ENV` set, which the
@@ -87,12 +90,24 @@ async function importInThisProcess(
   }
 }
 
+/** Longest a single import may run before its child is killed. */
+export const SESSION_IMPORT_TIMEOUT_MS = 30 * 60_000;
+
+/** Import children still running in this process. */
+const liveChildren = new Set<Bun.Subprocess>();
+
+/** Kill every running import child (resident shutdown). */
+export function killImportChildren(): void {
+  for (const child of liveChildren) child.kill("SIGKILL");
+}
+
 /**
  * Import a registered source without blocking the caller's event loop.
  * Throws a `SessionsError` for typed failures and a plain `Error` otherwise.
  */
 export async function importInChildProcess(
-  request: ImportChildRequest
+  request: ImportChildRequest,
+  options: { timeoutMs?: number } = {}
 ): Promise<SessionImportReceipt> {
   // A compiled executable cannot run an external TS entry: it re-runs itself.
   // Shared check: covers the POSIX `/$bunfs/` and Windows `B:/~BUN/` roots.
@@ -100,15 +115,38 @@ export async function importInChildProcess(
   const child = Bun.spawn({
     cmd: compiled ? [process.execPath] : [process.execPath, import.meta.path],
     env: compiled ? { ...process.env, [IMPORT_CHILD_ENV]: "1" } : process.env,
-    stdin: new Blob([JSON.stringify(request)]),
+    // The request line, then held open as the child's lifeline.
+    stdin: "pipe",
     stdout: "pipe",
     stderr: "pipe",
   });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(child.stdout).text(),
-    new Response(child.stderr).text(),
-    child.exited,
-  ]);
+  liveChildren.add(child);
+  const timeoutMs = options.timeoutMs ?? SESSION_IMPORT_TIMEOUT_MS;
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    child.kill("SIGKILL");
+  }, timeoutMs);
+  let output: [string, string, number];
+  try {
+    void child.stdin.write(`${JSON.stringify(request)}\n`);
+    void child.stdin.flush();
+    output = await Promise.all([
+      new Response(child.stdout).text(),
+      new Response(child.stderr).text(),
+      child.exited,
+    ]);
+  } finally {
+    clearTimeout(timer);
+    liveChildren.delete(child);
+    void Promise.resolve(child.stdin.end()).catch(() => undefined);
+  }
+  const [stdout, stderr, exitCode] = output;
+  if (timedOut) {
+    throw new Error(
+      `session import timed out after ${Math.round(timeoutMs / 1000)} s`
+    );
+  }
   const line = stdout.trim().split("\n").at(-1) ?? "";
   let result: ImportChildResult | null = null;
   try {
@@ -126,15 +164,43 @@ export async function importInChildProcess(
   throw new Error(result.message);
 }
 
-/** Child entry: one request on stdin, one JSON result line on stdout. */
+/** Read the request line; afterwards stdin is only the lifeline. */
+async function readRequestLine(
+  reader: ReadableStreamDefaultReader<Uint8Array>
+): Promise<string> {
+  const decoder = new TextDecoder();
+  let text = "";
+  while (!text.includes("\n")) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    text += decoder.decode(chunk.value, { stream: true });
+  }
+  return text.split("\n")[0] ?? "";
+}
+
+/** Child entry: one request line on stdin, one JSON result line on stdout. */
 export async function runImportChild(): Promise<void> {
   // Nothing this child starts may re-enter child mode.
   delete process.env[IMPORT_CHILD_ENV];
+  const reader = Bun.stdin.stream().getReader();
+  let finished = false;
   let result: ImportChildResult;
   try {
     const request = JSON.parse(
-      await new Response(Bun.stdin.stream()).text()
+      await readRequestLine(reader)
     ) as ImportChildRequest;
+    // The parent holds stdin open until it has our result; EOF before that
+    // means it died. Noticed between import steps.
+    void (async () => {
+      try {
+        while (!(await reader.read()).done) {
+          // nothing is written after the request
+        }
+      } catch {
+        // a broken pipe is the same as EOF
+      }
+      if (!finished) process.exit(1);
+    })();
     result = { ok: true, receipt: await importInThisProcess(request) };
   } catch (error) {
     result =
@@ -146,7 +212,9 @@ export async function runImportChild(): Promise<void> {
             message: error instanceof Error ? error.message : String(error),
           };
   }
+  finished = true;
   process.stdout.write(`${JSON.stringify(result)}\n`);
+  void reader.cancel().catch(() => undefined);
 }
 
 if (import.meta.main) await runImportChild();

package/src/store/migrations/035-vector-length-index.ts

@@ -0,0 +1,30 @@
+/**
+ * Migration: index stored vector byte lengths per model.
+ *
+ * Status checks the stored embedding dimensions for the active model by
+ * comparing the smallest and largest vector in its partition. Without an
+ * index that is a scan of every vector on each status build (about 0.6 ms
+ * per thousand vectors), run on the resident's main thread. With this
+ * covering index each bound is a single index seek.
+ *
+ * @module src/store/migrations/035-vector-length-index
+ */
+
+import type { Database } from "bun:sqlite";
+
+import type { Migration } from "./runner";
+
+export const migration: Migration = {
+  version: 35,
+  name: "vector_length_index",
+
+  up(db: Database): void {
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_vectors_model_bytes ON content_vectors(model, length(embedding))"
+    );
+  },
+
+  down(db: Database): void {
+    db.exec("DROP INDEX IF EXISTS idx_vectors_model_bytes");
+  },
+};

package/src/store/migrations/index.ts

@@ -48,6 +48,7 @@ import { migration as m031 } from "./031-runtime-independent-vectors";
 import { migration as m032 } from "./032-vector-runtime-callers";
 import { migration as m033 } from "./033-drop-documents-active-index";
 import { migration as m034 } from "./034-collection-link-workspace";
+import { migration as m035 } from "./035-vector-length-index";
 
 /** All migrations in order */
 export const migrations = [
@@ -85,4 +86,5 @@ export const migrations = [
   m032,
   m033,
   m034,
+  m035,
 ];

package/src/store/sqlite/adapter.ts

@@ -979,7 +979,10 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
         }
       });
 
-      transaction();
+      // Read-then-write: take the write lock up front. A deferred transaction
+      // whose snapshot goes stale (another process commits meanwhile) fails at
+      // once with "database is locked" instead of waiting out the busy timeout.
+      transaction.immediate();
       return ok(undefined);
     } catch (cause) {
       return err(