@vellumai/assistant 0.10.3-dev.202606281138.e89180c → 0.10.3-dev.202606281337.481c7ef

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.3-dev.202606281138.e89180c",
+  "version": "0.10.3-dev.202606281337.481c7ef",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/config/schemas/conversations.ts

@@ -20,6 +20,14 @@ export const ConversationsConfigSchema = z
       .describe(
         "Inner text injected into the tail user message of non-interactive turns in background/scheduled conversations. The injector wraps this in <background_turn>...</background_turn> tags. Empty string disables the injection.",
       ),
+    resumeProcessingOnStartup: z
+      .boolean({
+        error: "conversations.resumeProcessingOnStartup must be a boolean",
+      })
+      .default(false)
+      .describe(
+        "Controls how conversations left mid-turn by a previous shutdown are handled on startup. When false (default), their stale processing flag is cleared so they come up idle. When true, the daemon will instead automatically resume the interrupted turn for each such conversation.",
+      ),
   })
   .describe("Conversation behavior configuration");
 

package/src/daemon/lifecycle.ts

@@ -12,8 +12,6 @@ import { setVoiceBridgeDeps } from "../calls/voice-session-bridge.js";
 import { initFeatureFlagOverrides } from "../config/assistant-feature-flags.js";
 import {
   getPlatformAssistantId,
-  getRuntimeHttpHost,
-  getRuntimeHttpPort,
   setIngressPublicBaseUrl,
   validateEnv,
 } from "../config/env.js";
@@ -44,14 +42,18 @@ import {
   getSourcePathsForAttachments,
 } from "../memory/attachments-store.js";
 import { expireAllPendingCanonicalRequests } from "../memory/canonical-guardian-store.js";
-import { deleteMessageById, getMessages } from "../memory/conversation-crud.js";
+import {
+  clearStaleProcessingFlags,
+  deleteMessageById,
+  getMessages,
+} from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { selectEmbeddingBackend } from "../memory/embedding-backend.js";
 import { enqueueMemoryJob, isMemoryEnabled } from "../memory/jobs-store.js";
 import { startMemoryJobsWorker } from "../memory/jobs-worker.js";
 import { initQdrantClient, resolveQdrantUrl } from "../memory/qdrant-client.js";
-import { QdrantManager } from "../memory/qdrant-manager.js";
+import { createQdrantManager } from "../memory/qdrant-manager.js";
 import { rotateToolInvocations } from "../memory/tool-usage-store.js";
 import { sweepConceptPageFrontmatter } from "../memory/v2/frontmatter-sweep.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
@@ -69,7 +71,7 @@ import {
   initAuthSigningKey,
   resolveSigningKey,
 } from "../runtime/auth/token-service.js";
-import { RuntimeHttpServer } from "../runtime/http-server.js";
+import { startRuntimeHttpServer } from "../runtime/http-server.js";
 import { warmLocalGuardianPrincipalCache } from "../runtime/local-actor-identity.js";
 import { recoverInterruptedImport } from "../runtime/migrations/vbundle-streaming-importer.js";
 import { registerSecretsDeps } from "../runtime/routes/secrets-deps.js";
@@ -326,34 +328,9 @@ export async function runDaemon(): Promise<void> {
   const signingKey = resolveSigningKey();
   initAuthSigningKey(signingKey);
 
-  // Start the runtime HTTP server early so /healthz answers ASAP.
-  let runtimeHttp: RuntimeHttpServer | null = null;
-  const httpPort = getRuntimeHttpPort();
-  const httpHostname = getRuntimeHttpHost();
-  log.info({ httpPort }, "Daemon startup: starting runtime HTTP server");
-
-  runtimeHttp = new RuntimeHttpServer({
-    port: httpPort,
-    hostname: httpHostname,
-  });
-
-  // Isolated try/catch around start() — a bind failure (port in use,
-  // permission denied, fd exhaustion) must not tear down the rest of
-  // daemon startup. The daemon falls back to IPC-only operation when
-  // runtimeHttp is null.
-  try {
-    await runtimeHttp.start();
-    log.info(
-      { port: httpPort, hostname: httpHostname },
-      "Daemon startup: runtime HTTP server listening",
-    );
-  } catch (err) {
-    log.warn(
-      { err, port: httpPort },
-      "Failed to start runtime HTTP server, continuing without it",
-    );
-    runtimeHttp = null;
-  }
+  // Start the runtime HTTP server early so /healthz answers ASAP. A bind
+  // failure is non-fatal — the daemon falls back to IPC-only operation.
+  await startRuntimeHttpServer();
 
   // Pre-populate feature flag overrides so subsequent sync
   // isAssistantFeatureFlagEnabled() calls have data. Fired non-blocking
@@ -628,6 +605,31 @@ export async function runDaemon(): Promise<void> {
   log.info("Daemon startup: loading config");
   const config = loadConfig();
 
+  // Reconcile conversations left mid-turn by the previous shutdown. Their
+  // `processing_started_at` is still set even though the in-memory agent loop
+  // that owned the turn is gone.
+  if (dbReady) {
+    if (config.conversations.resumeProcessingOnStartup) {
+      // TODO: automatically resume the interrupted turn for each conversation
+      // whose processing flag is still set instead of clearing it.
+    } else {
+      try {
+        const cleared = clearStaleProcessingFlags();
+        if (cleared > 0) {
+          log.info(
+            { count: cleared },
+            "Cleared stale conversation processing flags from previous process",
+          );
+        }
+      } catch (err) {
+        log.warn(
+          { err },
+          "Failed to clear stale conversation processing flags — continuing startup",
+        );
+      }
+    }
+  }
+
   // Seed module-level ingress state from the workspace config so that
   // getIngressPublicBaseUrl() returns the correct value immediately after
   // startup (before any handleIngressConfig("set") call). Without this,
@@ -793,20 +795,12 @@ export async function runDaemon(): Promise<void> {
   startOrphanReaper();
   startEventLoopWatchdog();
 
-  // Mutable refs for Qdrant and memory worker so background
-  // init can assign them and the shutdown handler always sees the latest value.
-  const bgRefs: {
-    qdrantManager: QdrantManager | null;
-    memoryWorker: { stop(): void } | null;
-  } = { qdrantManager: null, memoryWorker: null };
-
   // Initialize Qdrant vector store and memory worker in the background so the
   // RuntimeHttpServer can start accepting requests without waiting for Qdrant.
   async function initializeQdrantAndMemory(): Promise<void> {
     const qdrantUrl = resolveQdrantUrl(config);
     log.info({ qdrantUrl }, "Daemon startup: initializing Qdrant");
-    const manager = new QdrantManager({ url: qdrantUrl });
-    bgRefs.qdrantManager = manager;
+    const manager = createQdrantManager({ url: qdrantUrl });
     const QDRANT_START_MAX_ATTEMPTS = 3;
     let qdrantStarted = false;
     for (let attempt = 1; attempt <= QDRANT_START_MAX_ATTEMPTS; attempt++) {
@@ -937,7 +931,7 @@ export async function runDaemon(): Promise<void> {
     // `memory.worker.enabled` is set. Shutdown stops whichever worker is
     // actually running — see shutdown-handlers.ts.
     log.info("Daemon startup: starting memory worker");
-    bgRefs.memoryWorker = startMemoryJobsWorker();
+    startMemoryJobsWorker();
 
     // Seed capability graph nodes (new memory graph system)
     try {
@@ -1087,7 +1081,7 @@ export async function runDaemon(): Promise<void> {
   });
 
   // Fire-and-forget: Qdrant init and memory worker startup run concurrently
-  // with the rest of daemon boot. Must run AFTER `new RuntimeHttpServer(...)`
+  // with the rest of daemon boot. Must run AFTER `startRuntimeHttpServer()`
   // so the analyze-deps singleton (populated inside `buildRouteTable()`) is
   // available before the memory worker can claim leftover
   // `conversation_analyze` jobs from a prior run. See the daemon-startup
@@ -1257,7 +1251,6 @@ export async function runDaemon(): Promise<void> {
       { err },
       "Failed to wire runtime HTTP server deps, continuing without them",
     );
-    runtimeHttp = null;
   }
 
   // Register built-in TTS providers so the provider abstraction can resolve
@@ -1379,10 +1372,6 @@ export async function runDaemon(): Promise<void> {
     workspaceHeartbeat,
     heartbeat,
     filing,
-    runtimeHttp,
-    scheduler,
-    getMemoryWorker: () => bgRefs.memoryWorker,
-    getQdrantManager: () => bgRefs.qdrantManager,
   });
 
   log.info(

package/src/daemon/shutdown-handlers.ts

@@ -5,9 +5,11 @@ import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import { stopGatewayFlagListener } from "../ipc/gateway-flag-listener.js";
 import { stopMcpServerManager } from "../mcp/manager.js";
 import { getSqlite, resetDb } from "../memory/db-connection.js";
-import type { QdrantManager } from "../memory/qdrant-manager.js";
+import { stopMemoryJobsWorker } from "../memory/jobs-worker.js";
+import { stopQdrantManager } from "../memory/qdrant-manager.js";
 import { stopMemoryWorkerProcess } from "../memory/worker-control.js";
-import type { RuntimeHttpServer } from "../runtime/http-server.js";
+import { stopRuntimeHttpServer } from "../runtime/http-server.js";
+import { stopScheduler } from "../schedule/scheduler.js";
 import { stopUsageTelemetryReporter } from "../telemetry/usage-telemetry-reporter.js";
 import { browserManager } from "../tools/browser/browser-manager.js";
 import { cleanupShellOutputTempFiles } from "../tools/shared/shell-output.js";
@@ -41,10 +43,6 @@ export interface ShutdownDeps {
   workspaceHeartbeat: WorkspaceHeartbeatService;
   heartbeat: HeartbeatService;
   filing: FilingService | null;
-  runtimeHttp: RuntimeHttpServer | null;
-  scheduler: { stop(): void };
-  getMemoryWorker: () => { stop(): void } | null;
-  getQdrantManager: () => QdrantManager | null;
 }
 
 export function installShutdownHandlers(deps: ShutdownDeps): void {
@@ -125,14 +123,14 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
       log.warn({ err }, "Telemetry reporter shutdown failed (non-fatal)");
     }
 
-    if (deps.runtimeHttp) await deps.runtimeHttp.stop();
+    await stopRuntimeHttpServer();
     await browserManager.closeAllPages();
     cleanupShellOutputTempFiles();
-    deps.scheduler.stop();
+    stopScheduler();
 
-    // Stop the in-process memory worker if one was started on the daemon's
-    // event loop (memory.worker.enabled = false).
-    deps.getMemoryWorker()?.stop();
+    // Stop the in-process memory worker supervisor if it was started on the
+    // daemon's event loop (memory.worker.enabled = false).
+    stopMemoryJobsWorker();
 
     // Stop the out-of-process memory worker if it's actually running. This is
     // keyed off live state rather than config: the worker may have been
@@ -156,7 +154,7 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
       log.warn({ err }, "MCP server manager shutdown failed (non-fatal)");
     }
 
-    await deps.getQdrantManager()?.stop();
+    await stopQdrantManager();
 
     // Optimize query planner statistics before closing so they persist for
     // the next session. Checkpoint WAL and close SQLite so no writes are

package/src/memory/__tests__/clear-stale-processing-flags.test.ts

@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  clearStaleProcessingFlags,
+  createConversation,
+  isConversationProcessing,
+  setConversationProcessingStartedAt,
+} from "../conversation-crud.js";
+import { getDb } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+
+await initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run(`DELETE FROM messages`);
+  db.run(`DELETE FROM conversations`);
+}
+
+describe("clearStaleProcessingFlags", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("clears the processing flag on conversations left mid-turn", () => {
+    const processing = createConversation("mid-turn");
+    const idle = createConversation("idle");
+    setConversationProcessingStartedAt(processing.id, Date.now());
+
+    expect(isConversationProcessing(processing.id)).toBe(true);
+    expect(isConversationProcessing(idle.id)).toBe(false);
+
+    const cleared = clearStaleProcessingFlags();
+
+    expect(cleared).toBe(1);
+    expect(isConversationProcessing(processing.id)).toBe(false);
+    expect(isConversationProcessing(idle.id)).toBe(false);
+  });
+
+  test("returns 0 when no conversation is processing", () => {
+    createConversation("idle");
+
+    expect(clearStaleProcessingFlags()).toBe(0);
+  });
+});

package/src/memory/__tests__/db-async-query.test.ts

@@ -55,13 +55,13 @@ function inflateAndDelete(byteTarget: number): void {
 
 describe("runAsyncSqlite", () => {
   test("returns ok=true for a trivial statement", async () => {
-    const result = await runAsyncSqlite("SELECT 1");
+    const result = await runAsyncSqlite("SELECT 1", "test:trivial-select");
     expect(result.ok).toBe(true);
     expect(result.error).toBeNull();
   });
 
   test("in-process fallback reports the right backend", async () => {
-    const result = await runAsyncSqlite("SELECT 1", {
+    const result = await runAsyncSqlite("SELECT 1", "test:in-process-backend", {
       forceBackend: "in-process-blocking",
     });
     expect(result.ok).toBe(true);
@@ -87,6 +87,7 @@ describe("runAsyncSqlite", () => {
 
     const result = await runAsyncSqlite(
       "DELETE FROM async_changes_probe WHERE id <= 3; SELECT changes();",
+      "test:in-process-changes-count",
       { forceBackend: "in-process-blocking" },
     );
 
@@ -103,7 +104,10 @@ describe("runAsyncSqlite", () => {
   test.if(sqlite3Available)(
     "sqlite3 CLI backend reports the right backend on success",
     async () => {
-      const result = await runAsyncSqlite("SELECT 1");
+      const result = await runAsyncSqlite(
+        "SELECT 1",
+        "test:cli-backend-success",
+      );
       expect(result.ok).toBe(true);
       expect(result.backend).toBe("sqlite3-cli");
     },
@@ -113,7 +117,10 @@ describe("runAsyncSqlite", () => {
     "surfaces sqlite3 errors as ok=false with the message preserved",
     async () => {
       // Intentional SQL syntax error.
-      const result = await runAsyncSqlite("THIS IS NOT VALID SQL");
+      const result = await runAsyncSqlite(
+        "THIS IS NOT VALID SQL",
+        "test:cli-error",
+      );
       expect(result.ok).toBe(false);
       expect(result.backend).toBe("sqlite3-cli");
       expect(result.error).toBeTruthy();
@@ -148,7 +155,7 @@ describe("runAsyncSqlite", () => {
 
       let result;
       try {
-        result = await runAsyncSqlite("VACUUM");
+        result = await runAsyncSqlite("VACUUM", "test:vacuum-anti-block");
       } finally {
         probing = false;
       }

package/src/memory/__tests__/db-logs-attach.test.ts

@@ -74,6 +74,7 @@ describe("logs database connection", () => {
       try {
         const result = await runAsyncSqlite(
           "CREATE TABLE dbpath_probe (x INTEGER); INSERT INTO dbpath_probe VALUES (42); SELECT changes();",
+          "test:logs-attach-dbpath",
           { dbPath: targetPath, forceBackend: "sqlite3-cli" },
         );
         expect(result.ok).toBe(true);

package/src/memory/__tests__/db-memory-attach.test.ts

@@ -77,6 +77,7 @@ describe("memory database connection", () => {
       try {
         const result = await runAsyncSqlite(
           "CREATE TABLE dbpath_probe (x INTEGER); INSERT INTO dbpath_probe VALUES (42); SELECT changes();",
+          "test:memory-attach-dbpath",
           { dbPath: targetPath, forceBackend: "sqlite3-cli" },
         );
         expect(result.ok).toBe(true);

package/src/memory/conversation-crud.ts

@@ -2236,6 +2236,19 @@ export function setConversationProcessingStartedAt(
   );
 }
 
+/**
+ * Clear the persisted processing flag on every conversation that still has one
+ * set, returning the number of rows cleared. Called at daemon startup to reset
+ * conversations whose `processing_started_at` was left non-NULL because the
+ * previous process shut down mid-turn — the in-memory agent loop driving that
+ * turn is gone, so the flag is stale.
+ */
+export function clearStaleProcessingFlags(): number {
+  return rawRun(
+    "UPDATE conversations SET processing_started_at = NULL WHERE processing_started_at IS NOT NULL",
+  );
+}
+
 /**
  * Read whether a conversation is currently processing. Checks the in-memory
  * `Conversation._processing` flag first (hot path for resident conversations),
@@ -2552,7 +2565,7 @@ export async function clearAll(): Promise<{
     sql: string,
     options?: { dbPath?: string },
   ): Promise<void> => {
-    const result = await runAsyncSqlite(sql, options);
+    const result = await runAsyncSqlite(sql, `clearAll: ${sql}`, options);
     if (!result.ok) {
       throw new Error(
         `clearAll: \`${sql}\` failed (${result.backend}): ${result.error ?? "unknown"}`,
@@ -2584,7 +2597,10 @@ export async function clearAll(): Promise<{
   await runOrThrow("DELETE FROM tool_invocations");
   await runOrThrow("DELETE FROM skill_loaded_events");
   let messagesFtsCorrupted = false;
-  const ftsResult = await runAsyncSqlite("DELETE FROM messages_fts");
+  const ftsResult = await runAsyncSqlite(
+    "DELETE FROM messages_fts",
+    "clearAll:messages-fts",
+  );
   if (!ftsResult.ok) {
     log.warn(
       { error: ftsResult.error, backend: ftsResult.backend },

package/src/memory/db-async-query.ts

@@ -43,6 +43,14 @@ const log = getLogger("db-async-query");
  */
 const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
 
+/**
+ * A successful async statement that runs longer than this is logged at WARN.
+ * These dispatches are meant to be heavy-but-bounded; crossing this threshold
+ * is a signal worth surfacing (lock contention, an unexpectedly large sweep,
+ * a degraded disk) even when the statement ultimately succeeds.
+ */
+const SLOW_WRITE_WARN_MS = 2000;
+
 export type AsyncSqliteBackend = "sqlite3-cli" | "in-process-blocking";
 
 export interface AsyncSqliteResult {
@@ -95,12 +103,14 @@ let warnedAboutFallback = false;
 
 export async function runAsyncSqlite(
   sql: string,
+  label: string,
   options: RunAsyncSqliteOptions = {},
 ): Promise<AsyncSqliteResult> {
   const forced = options.forceBackend;
   const sqlite3Path =
     forced === "in-process-blocking" ? undefined : findSqlite3();
 
+  let result: AsyncSqliteResult;
   if (sqlite3Path && forced !== "in-process-blocking") {
     const attachPrefix = (options.attach ?? [])
       .map(
@@ -108,23 +118,32 @@ export async function runAsyncSqlite(
           `ATTACH DATABASE '${a.path.replace(/'/g, "''")}' AS ${a.alias};\n`,
       )
       .join("");
-    return runViaCli(
+    result = await runViaCli(
       sqlite3Path,
       attachPrefix + sql,
       options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
       options.dbPath ?? getDbPath(),
+      label,
     );
+  } else {
+    if (!warnedAboutFallback) {
+      warnedAboutFallback = true;
+      log.warn(
+        "No sqlite3 CLI found on host — falling back to in-process blocking " +
+          "execution for slow SQLite statements. Install sqlite3 to keep the " +
+          "event loop responsive during VACUUM and other long operations.",
+      );
+    }
+    result = await runInProcessBlocking(sql, options);
   }
 
-  if (!warnedAboutFallback) {
-    warnedAboutFallback = true;
+  if (result.ok && result.elapsedMs > SLOW_WRITE_WARN_MS) {
     log.warn(
-      "No sqlite3 CLI found on host — falling back to in-process blocking " +
-        "execution for slow SQLite statements. Install sqlite3 to keep the " +
-        "event loop responsive during VACUUM and other long operations.",
+      { label, elapsedMs: result.elapsedMs, backend: result.backend },
+      "Async SQL completed but exceeded slow-write threshold",
     );
   }
-  return runInProcessBlocking(sql, options);
+  return result;
 }
 
 /** For tests: reset the once-only fallback warning. */
@@ -155,11 +174,12 @@ async function runViaCli(
   sql: string,
   timeoutMs: number,
   dbPath: string,
+  label: string,
 ): Promise<AsyncSqliteResult> {
   const startMs = Date.now();
 
   log.info(
-    { sqlite3Path, dbPath, timeoutMs, sqlPreview: sql.slice(0, 80) },
+    { label, sqlite3Path, dbPath, timeoutMs, sqlPreview: sql.slice(0, 80) },
     "Running async SQL via sqlite3 CLI subprocess",
   );
 
@@ -203,7 +223,7 @@ async function runViaCli(
 
   if (timedOut) {
     log.error(
-      { timeoutMs, elapsedMs, stderr: stderr.slice(0, 2000) },
+      { label, timeoutMs, elapsedMs, stderr: stderr.slice(0, 2000) },
       "Async SQL subprocess timed out — killed",
     );
     return {
@@ -218,7 +238,7 @@ async function runViaCli(
   }
   if (exitCode !== 0) {
     log.error(
-      { exitCode, elapsedMs, stderr: stderr.slice(0, 2000) },
+      { label, exitCode, elapsedMs, stderr: stderr.slice(0, 2000) },
       "Async SQL subprocess failed",
     );
     return {

package/src/memory/db-init.ts

@@ -181,7 +181,10 @@ function saveTemplate(): void {
 export async function checkpointWalBeforeOpen(): Promise<void> {
   const log = getLogger("db-init");
   try {
-    const result = await runAsyncSqlite("PRAGMA wal_checkpoint(TRUNCATE)");
+    const result = await runAsyncSqlite(
+      "PRAGMA wal_checkpoint(TRUNCATE)",
+      "db-init:pre-open-wal-checkpoint",
+    );
     if (result.ok) {
       log.info(
         { backend: result.backend, elapsedMs: result.elapsedMs },

package/src/memory/db-maintenance.ts

@@ -74,7 +74,10 @@ async function runDbMaintenance(): Promise<void> {
   // Refresh the query planner's statistics. PRAGMA optimize is cheap; it is
   // routed through the async path for consistency and to keep it off the main
   // thread when the sqlite3 CLI backend is available.
-  const optimizeResult = await runAsyncSqlite("PRAGMA optimize");
+  const optimizeResult = await runAsyncSqlite(
+    "PRAGMA optimize",
+    "db-maintenance:optimize",
+  );
   if (!optimizeResult.ok) {
     log.warn(
       { error: optimizeResult.error, backend: optimizeResult.backend },
@@ -97,6 +100,7 @@ async function runDbMaintenance(): Promise<void> {
   // best-effort no-op and the next maintenance pass retries.
   const checkpointResult = await runAsyncSqlite(
     "PRAGMA wal_checkpoint(TRUNCATE)",
+    "db-maintenance:wal-checkpoint-truncate",
   );
   if (!checkpointResult.ok) {
     log.warn(

package/src/memory/fork-message-copy.ts

@@ -33,16 +33,34 @@
 //      `client_message_id` is intentionally NOT copied, matching the
 //      in-process fork (a forked row is not a client-submitted message).
 
-import { type AsyncSqliteResult, runAsyncSqlite } from "./db-async-query.js";
+import { setTimeout as sleep } from "node:timers/promises";
+
+import {
+  type AsyncSqliteBackend,
+  type AsyncSqliteResult,
+  runAsyncSqlite,
+} from "./db-async-query.js";
 
 /**
  * Default batch size for the chunked copy. Each batch is one `INSERT … SELECT`
  * that auto-commits, so this bounds how long the subprocess holds the write
- * lock before releasing it to in-process writers. Small enough to keep the
- * lock-hold window short on a bloated database; large enough that per-batch
- * statement overhead stays negligible against the row copy.
+ * lock before releasing it to in-process writers. Kept small so the worst-case
+ * wait for a contending foreground write is one short batch, even on a bloated
+ * database; per-batch statement overhead stays negligible against the row copy
+ * and fork latency doesn't matter (nobody waits on a background fork).
+ */
+export const DEFAULT_FORK_COPY_BATCH_SIZE = 50;
+
+/**
+ * Pause inserted between batch subprocess calls. Without it the copy releases
+ * the write lock on each batch's auto-commit but greedily re-acquires it
+ * microseconds later, so a concurrent in-process writer (a live user turn
+ * persisting a message) can lose every race. A brief yield lets foreground
+ * writes reliably slip in between batches. The extra fork latency is free —
+ * nothing waits on a background fork — so we trade copy speed for foreground
+ * fairness.
  */
-export const DEFAULT_FORK_COPY_BATCH_SIZE = 500;
+export const DEFAULT_FORK_COPY_INTER_BATCH_DELAY_MS = 25;
 
 /**
  * A single source→fork message-id mapping. `oldId` is an existing source
@@ -143,9 +161,13 @@ FROM messages m JOIN _fork_id_map map ON map.old_id = m.id;`,
 
 /**
  * Copy the message rows for a fork off the event loop, in lock-friendly
- * batches. Resolves once every batch has committed (or rejects via the
- * returned result's `ok: false` on subprocess failure — the caller is
- * responsible for cleaning up the partially-built fork).
+ * batches. Each batch runs as its own subprocess call with a brief yield in
+ * between (see {@link DEFAULT_FORK_COPY_INTER_BATCH_DELAY_MS}) so foreground
+ * writers reliably acquire the write lock between batches instead of losing
+ * every race to the copy's greedy lock re-acquisition. Resolves once every
+ * batch has committed (or returns the failing batch's `ok: false` result on
+ * subprocess failure — the caller is responsible for cleaning up the
+ * partially-built fork).
  *
  * No-op (returns a synthetic ok result) when there is nothing to copy.
  */
@@ -161,10 +183,43 @@ export async function copyForkMessagesViaSubprocess(
     };
   }
 
-  const sql = buildForkCopyScript(options);
-  return runAsyncSqlite(sql, {
-    ...(options.forceInProcess
-      ? { forceBackend: "in-process-blocking" as const }
-      : {}),
-  });
+  const batchSize = Math.max(
+    1,
+    options.batchSize ?? DEFAULT_FORK_COPY_BATCH_SIZE,
+  );
+  const runOptions = options.forceInProcess
+    ? { forceBackend: "in-process-blocking" as const }
+    : {};
+
+  let totalElapsedMs = 0;
+  let backend: AsyncSqliteBackend = "in-process-blocking";
+
+  for (let i = 0; i < options.idPairs.length; i += batchSize) {
+    const batch = options.idPairs.slice(i, i + batchSize);
+    // One subprocess call per batch. Each generated script is self-contained
+    // (it creates and drops its own staging table), so splitting execution
+    // across calls is safe — and it's what lets us yield between batches below.
+    const sql = buildForkCopyScript({
+      forkConversationId: options.forkConversationId,
+      idPairs: batch,
+      batchSize,
+    });
+    const result = await runAsyncSqlite(
+      sql,
+      `fork-message-copy:copy-batch:${options.forkConversationId}`,
+      runOptions,
+    );
+    totalElapsedMs += result.elapsedMs;
+    backend = result.backend;
+    if (!result.ok) {
+      return { ...result, elapsedMs: totalElapsedMs };
+    }
+
+    const isLastBatch = i + batchSize >= options.idPairs.length;
+    if (!isLastBatch) {
+      await sleep(DEFAULT_FORK_COPY_INTER_BATCH_DELAY_MS);
+    }
+  }
+
+  return { ok: true, backend, error: null, elapsedMs: totalElapsedMs };
 }

package/src/memory/job-handlers/cleanup.ts

@@ -57,6 +57,7 @@ export async function pruneOldLlmRequestLogsJob(
   const result = await runAsyncSqlite(
     `DELETE FROM llm_request_logs WHERE rowid IN (SELECT rowid FROM llm_request_logs WHERE created_at < ${cutoffMs} LIMIT ${PRUNE_LOG_BATCH_LIMIT});
 SELECT changes();`,
+    "cleanup:prune-llm-request-logs",
     { dbPath: getLogsDbPath() },
   );
   if (!result.ok) {
@@ -112,6 +113,7 @@ export async function pruneOldTraceEventsJob(
   const result = await runAsyncSqlite(
     `DELETE FROM trace_events WHERE rowid IN (SELECT rowid FROM trace_events WHERE created_at < ${cutoffMs} LIMIT ${PRUNE_LOG_BATCH_LIMIT});
 SELECT changes();`,
+    "cleanup:prune-trace-events",
   );
   if (!result.ok) {
     log.warn(

package/src/memory/jobs-worker.ts

@@ -162,6 +162,9 @@ export interface MemoryJobsWorker {
   stop(): void;
 }
 
+/** The daemon's in-process supervisor, retained so shutdown can stop it. */
+let instance: MemoryJobsWorker | null = null;
+
 /**
  * Start the daemon's memory jobs worker supervisor.
  *
@@ -217,7 +220,21 @@ export function startMemoryJobsWorker(): MemoryJobsWorker {
       );
   }
 
-  return startInProcessMemoryJobsWorker({ standDownForWorkerProcess: true });
+  instance = startInProcessMemoryJobsWorker({
+    standDownForWorkerProcess: true,
+  });
+  return instance;
+}
+
+/**
+ * Stop the daemon's in-process memory jobs supervisor if it was started; no-op
+ * otherwise. Does not touch the out-of-process worker — see
+ * stopMemoryWorkerProcess() in worker-control.ts.
+ */
+export function stopMemoryJobsWorker(): void {
+  if (!instance) return;
+  instance.stop();
+  instance = null;
 }
 
 /**

package/src/memory/memory-retrospective-job.ts

@@ -135,6 +135,9 @@ export async function runForkBasedRetrospective(
   sourceConversationId: string,
   config: AssistantConfig,
 ): Promise<MemoryRetrospectiveOutcome> {
+  // Start stamp for the retrospective's end-to-end wall time, surfaced as
+  // `durationMs` on the "invoked" log (start → invoked).
+  const startedAtMs = Date.now();
   const sourceConversation = getConversation(sourceConversationId);
   if (!sourceConversation) {
     log.warn(
@@ -365,7 +368,11 @@ export async function runForkBasedRetrospective(
       newMessageCount: newMessages.length,
       prior,
       priorRemembers,
-      logFields: { kind: "fork", windowStartTimestamp },
+      logFields: {
+        kind: "fork",
+        windowStartTimestamp,
+        durationMs: Date.now() - startedAtMs,
+      },
     });
   }
 

package/src/memory/migrations/209-strip-thinking-from-consolidated.ts

@@ -160,10 +160,14 @@ export async function migrateStripThinkingFromConsolidated(
   while (lo < maxRow) {
     const hi = Math.min(lo + ROWID_WINDOW, maxRow);
 
-    const res = await runAsyncSqlite(windowSql(lo, hi), {
-      dbPath,
-      timeoutMs: WINDOW_TIMEOUT_MS,
-    });
+    const res = await runAsyncSqlite(
+      windowSql(lo, hi),
+      `migration-209:strip-thinking-window:(${lo},${hi}]`,
+      {
+        dbPath,
+        timeoutMs: WINDOW_TIMEOUT_MS,
+      },
+    );
     if (!res.ok) {
       // Leave the watermark at the last completed window; throwing reports the
       // step failed so the runner retries it (from the watermark) next boot
@@ -179,7 +183,11 @@ export async function migrateStripThinkingFromConsolidated(
 
   // Bound WAL growth left by the windowed rewrites, then drop the watermark so
   // a future re-run (e.g. after a rollback) starts clean.
-  await runAsyncSqlite(`PRAGMA wal_checkpoint(TRUNCATE);`, { dbPath });
+  await runAsyncSqlite(
+    `PRAGMA wal_checkpoint(TRUNCATE);`,
+    "migration-209:wal-checkpoint-truncate",
+    { dbPath },
+  );
   raw.query(`DELETE FROM memory_checkpoints WHERE key = ?`).run(WATERMARK_KEY);
 
   log.info(

package/src/memory/migrations/222-strip-placeholder-sentinels-from-messages.ts

@@ -153,10 +153,14 @@ export async function migrateStripPlaceholderSentinelsFromMessages(
   for (let lo = 0; lo < maxRow; lo += ROWID_WINDOW) {
     const hi = Math.min(lo + ROWID_WINDOW, maxRow);
 
-    const res = await runAsyncSqlite(windowSql(lo, hi), {
-      dbPath,
-      timeoutMs: WINDOW_TIMEOUT_MS,
-    });
+    const res = await runAsyncSqlite(
+      windowSql(lo, hi),
+      `migration-222:strip-placeholder-window:(${lo},${hi}]`,
+      {
+        dbPath,
+        timeoutMs: WINDOW_TIMEOUT_MS,
+      },
+    );
     if (!res.ok) {
       // Surface the failure so the runner leaves the step un-checkpointed and
       // retries the whole sweep on the next boot.
@@ -167,5 +171,9 @@ export async function migrateStripPlaceholderSentinelsFromMessages(
   }
 
   // Bound WAL growth left by the windowed rewrites.
-  await runAsyncSqlite(`PRAGMA wal_checkpoint(TRUNCATE);`, { dbPath });
+  await runAsyncSqlite(
+    `PRAGMA wal_checkpoint(TRUNCATE);`,
+    "migration-222:wal-checkpoint-truncate",
+    { dbPath },
+  );
 }

package/src/memory/migrations/helpers/relocation.ts

@@ -174,6 +174,7 @@ export async function drainStagedTable(
         `DELETE FROM "${staging}" WHERE rowid IN (` +
           `SELECT rowid FROM "${staging}" WHERE NOT (${spec.copyWhere}) LIMIT ${DRAIN_BATCH});\n` +
           `SELECT changes();`,
+        `relocation:purge-batch:${table}`,
         { dbPath },
       );
       if (!res.ok) {
@@ -194,6 +195,7 @@ export async function drainStagedTable(
         `DELETE FROM "${staging}" WHERE rowid IN (` +
         `SELECT rowid FROM "${staging}" ${whereCopy} ORDER BY rowid LIMIT ${DRAIN_BATCH});\n` +
         `SELECT changes();`,
+      `relocation:copy-batch:${table}`,
       {
         dbPath,
         attach: [{ path: spec.targetDbPath(), alias: "_reloc_target" }],
@@ -216,6 +218,7 @@ export async function drainStagedTable(
   // Drained — drop the (now empty) staging table and truncate the main WAL.
   const finalizeRes = await runAsyncSqlite(
     `DROP TABLE IF EXISTS "${staging}";\nPRAGMA wal_checkpoint(TRUNCATE);`,
+    `relocation:finalize:${table}`,
     { dbPath },
   );
   if (!finalizeRes.ok) {

package/src/memory/qdrant-manager.ts

@@ -420,3 +420,31 @@ export class QdrantManager {
     }
   }
 }
+
+// ---------------------------------------------------------------------------
+// Singleton
+// ---------------------------------------------------------------------------
+
+let instance: QdrantManager | null = null;
+
+/**
+ * Construct the singleton Qdrant manager and store it so shutdown can reach it.
+ * The caller (daemon startup) owns starting it — start() carries
+ * lifecycle-specific retry orchestration — but the module holds the reference
+ * so it need not be threaded through call arguments.
+ */
+export function createQdrantManager(
+  config: QdrantManagerConfig,
+): QdrantManager {
+  instance = new QdrantManager(config);
+  return instance;
+}
+
+/**
+ * Stop the singleton Qdrant manager if one was created. No-op when Qdrant init
+ * never ran (e.g. shutdown before background init started).
+ */
+export async function stopQdrantManager(): Promise<void> {
+  if (!instance) return;
+  await instance.stop();
+}

package/src/memory/tool-usage-store.ts

@@ -97,6 +97,7 @@ export async function rotateToolInvocations(
   // integer (see Math.floor above), so inlining it here is safe.
   const result = await runAsyncSqlite(
     `DELETE FROM tool_invocations WHERE created_at < ${cutoffMs}`,
+    "tool-usage-store:prune-tool-invocations",
   );
   if (!result.ok) {
     log.error(

package/src/runtime/http-server.ts

@@ -21,7 +21,11 @@ import {
   handleStatusCallback,
   handleVoiceWebhook,
 } from "../calls/twilio-routes.js";
-import { isHttpAuthDisabled } from "../config/env.js";
+import {
+  getRuntimeHttpHost,
+  getRuntimeHttpPort,
+  isHttpAuthDisabled,
+} from "../config/env.js";
 import { getIsPlatform } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
 import { processMessage } from "../daemon/process-message.js";
@@ -1073,3 +1077,43 @@ export class RuntimeHttpServer {
     return null;
   }
 }
+
+// ---------------------------------------------------------------------------
+// Singleton
+// ---------------------------------------------------------------------------
+
+let instance: RuntimeHttpServer | null = null;
+
+/**
+ * Start the runtime HTTP server singleton early in daemon startup so /healthz
+ * answers ASAP. A bind failure (port in use, permission denied, fd exhaustion)
+ * is non-fatal: it is logged and the daemon falls back to IPC-only operation,
+ * leaving the singleton unset.
+ */
+export async function startRuntimeHttpServer(): Promise<void> {
+  const port = getRuntimeHttpPort();
+  const hostname = getRuntimeHttpHost();
+  log.info({ port }, "Daemon startup: starting runtime HTTP server");
+  const server = new RuntimeHttpServer({ port, hostname });
+  try {
+    await server.start();
+    instance = server;
+    log.info(
+      { port, hostname },
+      "Daemon startup: runtime HTTP server listening",
+    );
+  } catch (err) {
+    log.warn(
+      { err, port },
+      "Failed to start runtime HTTP server, continuing without it",
+    );
+    instance = null;
+  }
+}
+
+/** Stop the runtime HTTP server singleton if one is running; no-op otherwise. */
+export async function stopRuntimeHttpServer(): Promise<void> {
+  if (!instance) return;
+  await instance.stop();
+  instance = null;
+}

package/src/runtime/routes/migration-routes.ts

@@ -171,7 +171,10 @@ const log = getLogger("migration-routes");
  * all the copy needs.
  */
 async function checkpointDbsForExport(): Promise<void> {
-  const mainResult = await runAsyncSqlite("PRAGMA wal_checkpoint(FULL)");
+  const mainResult = await runAsyncSqlite(
+    "PRAGMA wal_checkpoint(FULL)",
+    "export-checkpoint:wal-checkpoint-full",
+  );
   if (!mainResult.ok) {
     log.warn(
       { error: mainResult.error, backend: mainResult.backend, db: "main" },

package/src/schedule/scheduler.ts

@@ -117,6 +117,9 @@ function handleExecutionFailure(params: {
   });
 }
 
+/** The running scheduler, retained so shutdown can stop it. */
+let instance: SchedulerHandle | null = null;
+
 export function startScheduler(
   processMessage: ScheduleMessageProcessor,
   notifyScheduleOneShot: ScheduleNotifyModeNotifier,
@@ -149,7 +152,7 @@ export function startScheduler(
   timer.unref();
   void tick();
 
-  return {
+  instance = {
     async runOnce(): Promise<number> {
       return runScheduleOnce(
         processMessage,
@@ -174,6 +177,14 @@ export function startScheduler(
       clearInterval(timer);
     },
   };
+  return instance;
+}
+
+/** Stop the running scheduler if one was started; no-op otherwise. */
+export function stopScheduler(): void {
+  if (!instance) return;
+  instance.stop();
+  instance = null;
 }
 
 export async function runScheduleOnce(