@vellumai/assistant 0.10.3-dev.202606271934.9783ef3 → 0.10.3-dev.202606272129.e87b552

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.3-dev.202606271934.9783ef3",
+  "version": "0.10.3-dev.202606272129.e87b552",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/processing-flag-persist-failure.test.ts

@@ -0,0 +1,280 @@
+/**
+ * Regression: `Conversation.setProcessing(value)` flips the in-memory flag and
+ * then persists it to the `processing_started_at` column. If that DB write
+ * throws (e.g. SQLITE_BUSY under contention), the in-memory flag must not be
+ * left stranded out of sync with the column — it reverts to its prior value
+ * and the error re-throws so callers' existing failure handling still runs.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent } from "../agent/loop.js";
+import type { Message, ProviderResponse } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Persistence mock — `setConversationProcessingStartedAt` throws on demand so
+// the test can simulate a locked SQLite write.
+// ---------------------------------------------------------------------------
+
+let persistShouldThrow = false;
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: async () => {},
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    memory: { enabled: false },
+  }),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: () => "system prompt",
+}));
+
+mock.module("../config/skills.js", () => ({
+  loadSkillCatalog: () => [],
+  loadSkillBySelector: () => ({ skill: null }),
+  ensureSkillIcon: async () => null,
+}));
+
+mock.module("../config/skill-state.js", () => ({
+  resolveSkillStates: () => [],
+}));
+
+mock.module("../permissions/trust-store.js", () => ({
+  addRule: () => {},
+  findHighestPriorityRule: () => null,
+  clearCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  resetAllowlist: () => {},
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {
+    if (persistShouldThrow) {
+      throw new Error("database is locked (SQLITE_BUSY)");
+    }
+  },
+  isConversationProcessing: () => false,
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  getMessages: () => [],
+  getConversation: () => ({
+    id: "conv-1",
+    createdAt: Date.parse("2026-03-19T12:00:00.000Z"),
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    contextCompactedAt: null,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+  }),
+  addMessage: () => ({ id: "msg-1" }),
+  updateConversationUsage: () => {},
+  updateConversationTitle: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => ({ segmentIds: [], deletedSummaryIds: [] }),
+  deleteLastExchange: () => 0,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../memory/conversation-queries.js", () => ({
+  isLastUserMessageToolResult: () => false,
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  uploadAttachment: () => ({ id: "att-1" }),
+  linkAttachmentToMessage: () => {},
+}));
+
+mock.module("../memory/retriever.js", () => ({
+  buildMemoryRecall: async () => null,
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
+}));
+
+mock.module("../memory/query-builder.js", () => ({
+  buildMemoryQuery: () => "",
+}));
+
+mock.module("../memory/retrieval-budget.js", () => ({
+  computeRecallBudget: () => 0,
+}));
+
+mock.module("../runtime/sync/sync-publisher.js", () => ({
+  publishSyncInvalidation: () => {},
+}));
+
+mock.module("../daemon/message-types/sync.js", () => ({
+  conversationMetadataSyncTag: (id: string) => `conversation-metadata:${id}`,
+}));
+
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
+  ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
+    constructor() {}
+    updateConfig() {}
+    shouldCompact() {
+      return { needed: false, estimatedTokens: 0 };
+    }
+    async maybeCompact() {
+      return { compacted: false };
+    }
+    resetOverflowRecovery() {}
+  },
+  createContextSummaryMessage: () => ({
+    role: "user",
+    content: [{ type: "text", text: "summary" }],
+  }),
+  getSummaryFromContextMessage: () => null,
+}));
+
+mock.module("../memory/llm-usage-store.js", () => ({
+  recordUsageEvent: () => ({ id: "usage-1", createdAt: Date.now() }),
+}));
+
+mock.module("../memory/app-store.js", () => ({
+  getApp: () => null,
+  updateApp: () => {},
+}));
+
+mock.module("../agent/loop.js", () => ({
+  AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
+    constructor() {}
+    getToolTokenBudget() {
+      return 0;
+    }
+    getResolvedTools() {
+      return [];
+    }
+    getActiveModel() {
+      return undefined;
+    }
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
+      return options.messages;
+    }
+  },
+}));
+
+import { Conversation } from "../daemon/conversation.js";
+
+function makeConversation(): Conversation {
+  const provider = {
+    name: "mock",
+    async sendMessage(): Promise<ProviderResponse> {
+      return {
+        content: [],
+        model: "mock",
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+  return new Conversation(
+    "conv-1",
+    provider,
+    "system prompt",
+    () => {},
+    "/tmp",
+    { maxTokens: 4096 },
+  );
+}
+
+describe("Conversation.setProcessing persistence failure", () => {
+  let conversation: Conversation;
+
+  beforeEach(() => {
+    persistShouldThrow = false;
+    conversation = makeConversation();
+  });
+
+  test("reverts the in-memory flag and re-throws when the DB write fails", () => {
+    expect(conversation.isProcessing()).toBe(false);
+
+    persistShouldThrow = true;
+    expect(() => conversation.setProcessing(true)).toThrow(
+      "database is locked",
+    );
+
+    // The persisted column never landed, so the in-memory flag must not be
+    // stranded at `true`.
+    expect(conversation.isProcessing()).toBe(false);
+  });
+
+  test("restores the prior value when clearing fails mid-turn", () => {
+    conversation.setProcessing(true);
+    expect(conversation.isProcessing()).toBe(true);
+
+    persistShouldThrow = true;
+    expect(() => conversation.setProcessing(false)).toThrow(
+      "database is locked",
+    );
+
+    // Clear didn't persist, so the flag stays consistent with the column.
+    expect(conversation.isProcessing()).toBe(true);
+  });
+
+  test("commits the flag when the DB write succeeds", () => {
+    conversation.setProcessing(true);
+    expect(conversation.isProcessing()).toBe(true);
+
+    conversation.setProcessing(false);
+    expect(conversation.isProcessing()).toBe(false);
+  });
+});

package/src/daemon/conversation.ts

@@ -1352,11 +1352,20 @@ export class Conversation {
     this._processing = value;
     // Persist the cross-process source of truth so out-of-process callers
     // (retrospective CLI, future detached workers) can detect mid-turn state
-    // by reading the conversations row directly.
-    setConversationProcessingStartedAt(
-      this.conversationId,
-      value ? Date.now() : null,
-    );
+    // by reading the conversations row directly. If the write fails (e.g.
+    // SQLITE_BUSY), the persisted column keeps its prior value, so revert the
+    // in-memory flag to match rather than stranding `processing = true` in
+    // memory against a NULL column. Re-throw so callers' existing failure
+    // handling still runs.
+    try {
+      setConversationProcessingStartedAt(
+        this.conversationId,
+        value ? Date.now() : null,
+      );
+    } catch (err) {
+      this._processing = wasProcessing;
+      throw err;
+    }
     if (wasProcessing && !value) {
       void publishSyncInvalidation([
         conversationMetadataSyncTag(this.conversationId),

package/src/daemon/lifecycle.ts

@@ -38,10 +38,7 @@ import { FilingService } from "../filing/filing-service.js";
 import { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import { backfillRelationshipStateIfMissing } from "../home/relationship-state-writer.js";
 import { closeSentry, initSentry, setSentryDeviceId } from "../instrument.js";
-import {
-  startGatewayFlagListener,
-  stopGatewayFlagListener,
-} from "../ipc/gateway-flag-listener.js";
+import { startGatewayFlagListener } from "../ipc/gateway-flag-listener.js";
 import { getMcpServerManager } from "../mcp/manager.js";
 import {
   getAttachmentsByIds,
@@ -112,11 +109,7 @@ import { repairAdaptiveThinkingOnManagedProfiles } from "../workspace/adaptive-t
 import { WorkspaceHeartbeatService } from "../workspace/heartbeat-service.js";
 import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
 import { runWorkspaceMigrations } from "../workspace/migrations/runner.js";
-import {
-  cleanupPidFile,
-  cleanupPidFileIfOwner,
-  writePid,
-} from "./daemon-control.js";
+import { cleanupPidFileIfOwner, writePid } from "./daemon-control.js";
 import {
   evaluateDiskPressureNow,
   startDiskPressureGuard,
@@ -1440,13 +1433,6 @@ export async function runDaemon(): Promise<void> {
       getQdrantManager: () => bgRefs.qdrantManager,
       mcpManager,
       telemetryReporter,
-      cleanupPidFile: () => {
-        stopGatewayFlagListener();
-        stopDiskPressureGuardForLifecycle();
-        stopOrphanReaper();
-        stopEventLoopWatchdog();
-        cleanupPidFile();
-      },
     });
 
     log.info(

package/src/daemon/shutdown-handlers.ts

@@ -2,6 +2,7 @@ import * as Sentry from "@sentry/node";
 
 import type { FilingService } from "../filing/filing-service.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
+import { stopGatewayFlagListener } from "../ipc/gateway-flag-listener.js";
 import type { McpServerManager } from "../mcp/manager.js";
 import { getSqlite, resetDb } from "../memory/db-connection.js";
 import type { QdrantManager } from "../memory/qdrant-manager.js";
@@ -12,11 +13,28 @@ import { cleanupShellOutputTempFiles } from "../tools/shared/shell-output.js";
 import { getLogger } from "../util/logger.js";
 import { getEnrichmentService } from "../workspace/commit-message-enrichment-service.js";
 import type { WorkspaceHeartbeatService } from "../workspace/heartbeat-service.js";
+import { cleanupPidFile } from "./daemon-control.js";
+import { stopEventLoopWatchdog } from "./event-loop-watchdog.js";
+import { stopDiskPressureGuardForLifecycle } from "./lifecycle.js";
+import { stopOrphanReaper } from "./orphan-reaper.js";
 import type { DaemonServer } from "./server.js";
 import { runShutdownHooks } from "./shutdown-registry.js";
 
 const log = getLogger("lifecycle");
 
+/**
+ * Stop the daemon's background services and remove the PID file. Invoked on
+ * both the graceful-shutdown and force-exit-timeout paths so the process never
+ * leaves a stale PID file or orphaned timers behind.
+ */
+function stopBackgroundServicesAndCleanupPidFile(): void {
+  stopGatewayFlagListener();
+  stopDiskPressureGuardForLifecycle();
+  stopOrphanReaper();
+  stopEventLoopWatchdog();
+  cleanupPidFile();
+}
+
 export interface ShutdownDeps {
   server: DaemonServer;
   workspaceHeartbeat: WorkspaceHeartbeatService;
@@ -28,7 +46,6 @@ export interface ShutdownDeps {
   getQdrantManager: () => QdrantManager | null;
   mcpManager: McpServerManager | null;
   telemetryReporter: { stop(): Promise<void> } | null;
-  cleanupPidFile: () => void;
 }
 
 export function installShutdownHandlers(deps: ShutdownDeps): void {
@@ -51,7 +68,7 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     // bump only changes behavior for the stuck-shutdown path.
     const forceTimer = setTimeout(() => {
       log.warn("Graceful shutdown timed out, forcing exit");
-      deps.cleanupPidFile();
+      stopBackgroundServicesAndCleanupPidFile();
       process.exit(1);
     }, 20_000);
     forceTimer.unref();
@@ -171,7 +188,7 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
 
     await Sentry.flush(2000);
     clearTimeout(forceTimer);
-    deps.cleanupPidFile();
+    stopBackgroundServicesAndCleanupPidFile();
     process.exit(exitCode);
   };
 

package/src/memory/__tests__/db-busy-timeout.test.ts

@@ -0,0 +1,26 @@
+/**
+ * Locks in that every assistant SQLite connection shares one busy_timeout.
+ *
+ * `runAsyncSqlite` can open an out-of-process (sqlite3 CLI) or transient
+ * in-process connection that writes the same database file as the live
+ * daemon connection. If those connections don't wait the same amount of
+ * time for a lock, a concurrent writer fails immediately with SQLITE_BUSY
+ * instead of waiting its turn. The shared `SQLITE_BUSY_TIMEOUT_MS` constant
+ * is the single source of truth; this test guards against the live daemon
+ * connection drifting away from it.
+ */
+import { expect, test } from "bun:test";
+
+const { getSqlite, SQLITE_BUSY_TIMEOUT_MS } =
+  await import("../db-connection.js");
+const { initializeDb } = await import("../db-init.js");
+
+await initializeDb();
+
+test("the daemon connection runs with the shared busy_timeout", () => {
+  const sqlite = getSqlite();
+  const value = (
+    sqlite.query("PRAGMA busy_timeout").get() as { timeout: number }
+  ).timeout;
+  expect(value).toBe(SQLITE_BUSY_TIMEOUT_MS);
+});

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

@@ -31,7 +31,7 @@ import { Database } from "bun:sqlite";
 import { getLogger } from "../util/logger.js";
 import { getDbPath } from "../util/platform.js";
 import { findSqlite3 } from "../util/sqlite3-runtime.js";
-import { getSqlite } from "./db-connection.js";
+import { getSqlite, SQLITE_BUSY_TIMEOUT_MS } from "./db-connection.js";
 
 const log = getLogger("db-async-query");
 
@@ -172,8 +172,14 @@ async function runViaCli(
     stderr: "pipe",
   });
 
+  // Match the busy_timeout the daemon connection uses so this subprocess
+  // waits for — rather than instantly failing against — a lock held by the
+  // still-running in-process connection (and vice versa). Prepended to the
+  // piped SQL so it takes effect before the statement runs.
+  const sqlWithPragma = `PRAGMA busy_timeout=${SQLITE_BUSY_TIMEOUT_MS};\n${sql}`;
+
   // Write the SQL and close stdin so sqlite3 sees EOF and exits.
-  proc.stdin.write(sql + "\n");
+  proc.stdin.write(sqlWithPragma + "\n");
   await proc.stdin.end();
 
   // Begin draining the streams immediately so the subprocess never
@@ -253,6 +259,11 @@ async function runInProcessBlocking(
     let sqlite: Database;
     if (usesDedicatedFile) {
       transient = new Database(options.dbPath ?? getDbPath());
+      // Match the daemon connection's busy_timeout so this transient
+      // connection waits for a lock held by another writer rather than
+      // failing immediately with SQLITE_BUSY. (The daemon connection reused
+      // in the else branch already has it set via applyConnectionPragmas.)
+      transient.exec(`PRAGMA busy_timeout=${SQLITE_BUSY_TIMEOUT_MS}`);
       for (const a of options.attach ?? []) {
         transient.exec(
           `ATTACH DATABASE '${a.path.replace(/'/g, "''")}' AS ${a.alias}`,

package/src/memory/db-connection.ts

@@ -77,6 +77,16 @@ export function assertTestDbIsIsolated(): void {
   }
 }
 
+/**
+ * How long a SQLite connection waits to acquire a lock held by another
+ * writer before giving up with `SQLITE_BUSY`. Every connection that touches
+ * an assistant database — the main/dedicated daemon connections here and the
+ * out-of-process / transient connections in `db-async-query.ts` — must set
+ * the same value, so a writer that grabs the lock can finish without a
+ * concurrent writer failing immediately instead of waiting its turn.
+ */
+export const SQLITE_BUSY_TIMEOUT_MS = 5000;
+
 /**
  * Apply the connection-wide PRAGMAs every assistant SQLite connection runs
  * with. These are per-connection settings, so the dedicated logs/memory
@@ -85,7 +95,7 @@ export function assertTestDbIsIsolated(): void {
 function applyConnectionPragmas(sqlite: Database): void {
   sqlite.exec("PRAGMA journal_mode=WAL");
   sqlite.exec("PRAGMA synchronous=FULL");
-  sqlite.exec("PRAGMA busy_timeout=5000");
+  sqlite.exec(`PRAGMA busy_timeout=${SQLITE_BUSY_TIMEOUT_MS}`);
   sqlite.exec("PRAGMA foreign_keys = ON");
   sqlite.exec("PRAGMA cache_size=-256000");
   sqlite.exec("PRAGMA temp_store=MEMORY");