@vellumai/assistant 0.10.0-dev.202606200318.c052d10 → 0.10.0-dev.202606201453.1417592

package/src/agent/loop.ts

@@ -493,12 +493,6 @@ export function shouldCaptureAgentLoopError(err: Error): boolean {
   return true;
 }
 
-export interface ResolvedSystemPrompt {
-  systemPrompt: string;
-  maxTokens?: number;
-  model?: string;
-}
-
 export interface AgentLoopRunOptions {
   /** Input history the run starts from; the loop appends its output onto a copy. */
   messages: Message[];
@@ -506,6 +500,20 @@ export interface AgentLoopRunOptions {
   onEvent: (event: AgentEvent) => void | Promise<void>;
   signal?: AbortSignal;
   requestId: string;
+  /**
+   * System prompt for this run, resolved by the caller (Conversation) before
+   * invoking the loop. One turn == one agent loop == one system prompt; the
+   * prompt is NOT re-resolved mid-loop (that would bust the provider's
+   * prefix cache). When omitted, falls back to the constructor's
+   * {@link AgentLoopConstructorOptions.systemPrompt}.
+   */
+  systemPrompt?: string;
+  /**
+   * Explicit model override (provider/model string) for every LLM call in
+   * this run. When omitted, the model is resolved through the normal
+   * call-site / profile resolution path.
+   */
+  model?: string;
   onCheckpoint?: (
     checkpoint: CheckpointInfo,
   ) => CheckpointDecision | Promise<CheckpointDecision>;
@@ -634,7 +642,6 @@ export interface AgentLoopConstructorOptions {
   tools?: ToolDefinition[];
   toolExecutor?: LoopToolExecutor;
   resolveTools?: (history: Message[]) => ToolDefinition[];
-  resolveSystemPrompt?: (history: Message[]) => ResolvedSystemPrompt;
   /**
    * Conversation this loop drives. Scopes the loop-held compaction circuit
    * breaker and is the source of truth the loop's pipeline contexts and
@@ -659,9 +666,6 @@ export class AgentLoop {
   private config: AgentLoopConfig;
   private tools: ToolDefinition[];
   private resolveTools: ((history: Message[]) => ToolDefinition[]) | null;
-  private resolveSystemPrompt:
-    | ((history: Message[]) => ResolvedSystemPrompt)
-    | null;
   private toolExecutor: LoopToolExecutor | null;
 
   /**
@@ -692,7 +696,6 @@ export class AgentLoop {
       tools,
       toolExecutor,
       resolveTools,
-      resolveSystemPrompt,
       conversationId,
       resolveConversationDir,
     } = options;
@@ -701,7 +704,6 @@ export class AgentLoop {
     this.config = { ...DEFAULT_CONFIG, ...config };
     this.tools = tools ?? [];
     this.resolveTools = resolveTools ?? null;
-    this.resolveSystemPrompt = resolveSystemPrompt ?? null;
     this.toolExecutor = toolExecutor ?? null;
     this.conversationId = conversationId;
     this.resolveConversationDir = resolveConversationDir ?? null;
@@ -910,7 +912,14 @@ export class AgentLoop {
       compactInPlace = false,
       isNonInteractive = false,
       modelProfileKey = null,
+      systemPrompt: runSystemPrompt,
+      model: runModel,
     } = options;
+    // Resolve the system prompt once per run — the caller (Conversation)
+    // builds it before invoking the loop. Re-resolving mid-loop would bust
+    // the provider's prefix cache. Falls back to the constructor seed when
+    // the caller doesn't supply one.
+    const resolvedSystemPrompt = runSystemPrompt ?? this.systemPrompt;
     let history = [...messages];
     // Index into `history` where this run's appended output begins. It starts
     // after the input and resets to the new base whenever the loop rewrites the
@@ -1218,15 +1227,14 @@ export class AgentLoop {
           ? this.resolveTools(history)
           : this.tools;
 
-        // Resolve system prompt, per-turn maxTokens, and model
-        const resolved = this.resolveSystemPrompt
-          ? this.resolveSystemPrompt(history)
-          : null;
-        const turnSystemPrompt = resolved?.systemPrompt ?? this.systemPrompt;
-        const turnModel = resolved?.model;
+        // System prompt and model are resolved once per run (by the caller),
+        // not per-LLM-call — re-resolving mid-loop would bust the provider's
+        // prefix cache.
+        const turnSystemPrompt = resolvedSystemPrompt;
+        const turnModel = runModel;
 
         // Field precedence (highest wins):
-        //   1. Per-turn explicit (`resolved.maxTokens` / `resolved.model`)
+        //   1. Per-run explicit (`runModel`)
         //   2. Call-site resolved values (filled by
         //      `RetryProvider.normalizeSendMessageOptions` from
         //      `resolveCallSiteConfig(callSite, llm)`)
@@ -1244,9 +1252,7 @@ export class AgentLoop {
         // they always come from `this.config` regardless of `callSite`.
         const providerConfig: Record<string, unknown> = {};
 
-        if (resolved?.maxTokens !== undefined) {
-          providerConfig.max_tokens = resolved.maxTokens;
-        } else if (!callSite) {
+        if (!callSite) {
           providerConfig.max_tokens = this.config.maxTokens;
         }
 

package/src/config/schemas/memory-lifecycle.ts

@@ -169,7 +169,7 @@ export const MemoryMaintenanceConfigSchema = z
       .positive("memory.maintenance.intervalMs must be a positive integer")
       .default(24 * 60 * 60 * 1000)
       .describe(
-        "Minimum interval between database maintenance (VACUUM / PRAGMA optimize) runs, in milliseconds",
+        "Minimum interval between database maintenance (PRAGMA optimize / WAL checkpoint) runs, in milliseconds",
       ),
     quietPeriodMs: z
       .number({ error: "memory.maintenance.quietPeriodMs must be a number" })
@@ -177,10 +177,12 @@ export const MemoryMaintenanceConfigSchema = z
       .nonnegative("memory.maintenance.quietPeriodMs must be non-negative")
       .default(3 * 60 * 60 * 1000)
       .describe(
-        "Database maintenance is deferred unless at least this many milliseconds have elapsed since the last user message, so the VACUUM's exclusive lock never collides with an active user (0 disables the quiet-period gate)",
+        "Database maintenance is deferred unless at least this many milliseconds have elapsed since the last user message, so maintenance's write locks never collide with an active user (0 disables the quiet-period gate)",
       ),
   })
-  .describe("Database maintenance (VACUUM / PRAGMA optimize) scheduling");
+  .describe(
+    "Database maintenance (PRAGMA optimize / WAL checkpoint) scheduling",
+  );
 
 export type MemoryJobsConfig = z.infer<typeof MemoryJobsConfigSchema>;
 export type MemoryRetentionConfig = z.infer<typeof MemoryRetentionConfigSchema>;

package/src/config/schemas/timeouts.ts

@@ -42,6 +42,30 @@ export const TimeoutConfigSchema = z
       .describe(
         "Timeout for waiting on the LLM provider's streaming response (seconds)",
       ),
+    backgroundTurnTimeoutSec: z
+      .number({ error: "timeouts.backgroundTurnTimeoutSec must be a number" })
+      .int("timeouts.backgroundTurnTimeoutSec must be an integer")
+      .positive("timeouts.backgroundTurnTimeoutSec must be a positive integer")
+      .max(
+        2147483,
+        "timeouts.backgroundTurnTimeoutSec must be at most 2147483 (setTimeout-safe limit)",
+      )
+      .default(1800)
+      .describe(
+        "Hard timeout for heartbeat and generic background agent turns (seconds)",
+      ),
+    scheduleTurnTimeoutSec: z
+      .number({ error: "timeouts.scheduleTurnTimeoutSec must be a number" })
+      .int("timeouts.scheduleTurnTimeoutSec must be an integer")
+      .positive("timeouts.scheduleTurnTimeoutSec must be a positive integer")
+      .max(
+        2147483,
+        "timeouts.scheduleTurnTimeoutSec must be at most 2147483 (setTimeout-safe limit)",
+      )
+      .default(1800)
+      .describe(
+        "Hard timeout for deliberately-launched scheduled (talk-mode) agent turns (seconds)",
+      ),
   })
   .describe("Timeout configuration for various operations");
 

package/src/daemon/app-source-watcher.ts

@@ -11,11 +11,9 @@
 
 import { existsSync, type FSWatcher, watch } from "node:fs";
 
-import {
-  getAppsDir,
-  resolveAppIdByDirName,
-} from "../memory/app-store.js";
+import { getAppsDir, resolveAppIdByDirName } from "../memory/app-store.js";
 import { DebouncerMap } from "../util/debounce.js";
+import { attachFsWatcherErrorHandler } from "../util/fs-watcher-error.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("app-source-watcher");
@@ -51,8 +49,10 @@ function resolveAppIdFromRelPath(relPath: string): string | null {
 
   // Skip non-source directories (include bare directory names for fs.watch events)
   if (
-    innerPath === "records" || innerPath.startsWith("records/") ||
-    innerPath === "dist" || innerPath.startsWith("dist/")
+    innerPath === "records" ||
+    innerPath.startsWith("records/") ||
+    innerPath === "dist" ||
+    innerPath.startsWith("dist/")
   ) {
     return null;
   }
@@ -89,7 +89,9 @@ export class AppSourceWatcher {
     try {
       appsDir = getAppsDir();
     } catch {
-      log.warn("Could not resolve apps directory; app source watching disabled");
+      log.warn(
+        "Could not resolve apps directory; app source watching disabled",
+      );
       return;
     }
 
@@ -102,19 +104,30 @@ export class AppSourceWatcher {
     if (!onChange) return;
 
     try {
-      this.watcher = watch(appsDir, { recursive: true }, (_eventType, filename) => {
-        if (!filename) return;
-
-        const appId = resolveAppIdFromRelPath(filename);
-        if (!appId) return;
-
-        this.debouncer.schedule(`app:${appId}`, () => {
-          onChange(appId);
-        });
-      });
+      this.watcher = watch(
+        appsDir,
+        { recursive: true },
+        (_eventType, filename) => {
+          if (!filename) return;
+
+          const appId = resolveAppIdFromRelPath(filename);
+          if (!appId) return;
+
+          this.debouncer.schedule(`app:${appId}`, () => {
+            onChange(appId);
+          });
+        },
+      );
+      // Recursive watches over app trees (incl. node_modules) can exhaust the
+      // inotify watch limit and emit ENOSPC asynchronously. Without an 'error'
+      // listener that unhandled emitter error crashes the daemon.
+      attachFsWatcherErrorHandler(this.watcher, log, appsDir);
       log.info("App source watcher started");
     } catch (err) {
-      log.warn({ err }, "Failed to watch apps directory; source watching disabled");
+      log.warn(
+        { err },
+        "Failed to watch apps directory; source watching disabled",
+      );
     }
   }
 

package/src/daemon/conversation-agent-loop.ts

@@ -190,8 +190,8 @@ export interface AssistantSurface {
 // ── abort watchdog ───────────────────────────────────────────────────
 
 /**
- * Generous backstop that drives an aborted turn to its `finally` even if some
- * awaited operation fails to observe the abort signal.
+ * Backstop that drives an aborted turn to its `finally` even if some awaited
+ * operation fails to observe the abort signal.
  *
  * Abort is otherwise cooperative and already wired into the slow paths: the
  * provider call forwards the signal to its HTTP/streaming fetch, and tool
@@ -199,10 +199,11 @@ export interface AssistantSurface {
  * watchdog only fires when a future code path silently ignores abort — without
  * it, such a path would hang the loop forever and latch the conversation's
  * `processing` flag true (the wedged "Thinking…" indicator). It is
- * defense-in-depth, not the primary mechanism, so the timeout is deliberately
- * generous; in the common case abort settles in-flight work well before it.
+ * defense-in-depth, not the primary mechanism: in the common case abort settles
+ * in-flight work in well under a second, so a few seconds is ample headroom for
+ * a cooperative unwind while still releasing a genuinely wedged turn promptly.
  */
-const ABORT_WATCHDOG_MS = 45_000;
+const ABORT_WATCHDOG_MS = 5_000;
 
 /**
  * Race `work` against an abort watchdog. The watchdog stays disarmed until the
@@ -980,6 +981,8 @@ export async function runAgentLoopImpl(
           compactInPlace,
           isNonInteractive,
           modelProfileKey,
+          systemPrompt: ctx.buildCurrentSystemPrompt(),
+          ...(ctx.modelOverride ? { model: ctx.modelOverride } : {}),
         }),
         abortController.signal,
         watchdogMs,

package/src/daemon/conversation.ts

@@ -15,7 +15,7 @@
  * - conversation-usage.ts        — recordUsage
  */
 
-import type { AgentLoopConfig, ResolvedSystemPrompt } from "../agent/loop.js";
+import type { AgentLoopConfig } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
 import type { AssistantActivityStateEvent } from "../api/events/assistant-activity-state.js";
 import type {
@@ -537,6 +537,7 @@ export class Conversation {
   };
   public readonly traceEmitter: TraceEmitter;
   /** @internal */ hasSystemPromptOverride: boolean;
+  /** @internal */ modelOverride: string | undefined;
   /** @internal */ readonly graphMemory: ConversationGraphMemory;
   /** @internal */ activeContextNodeIds?: string[];
   /** @internal */ streamThinking: boolean;
@@ -666,34 +667,9 @@ export class Conversation {
     const hasSystemPromptOverride = systemPrompt !== buildSystemPrompt();
     this.hasSystemPromptOverride = hasSystemPromptOverride;
 
-    // If an explicit modelOverride is supplied, use it verbatim. Otherwise
-    // leave the model unset and let `RetryProvider`'s call-site resolver pick
-    // it up from `llm.default` / `llm.callSites.<id>` on every turn.
-    const resolvedModel: string | undefined = modelOverride;
-
-    const resolveSystemPromptCallback = (
-      _history: Message[],
-    ): ResolvedSystemPrompt => {
-      const resolved: ResolvedSystemPrompt = {
-        systemPrompt: this.hasSystemPromptOverride
-          ? systemPrompt
-          : buildSystemPrompt({
-              hasNoClient: this.hasNoClient,
-              trustContext: this.currentTurnTrustContext,
-              channelCapabilities: this.currentTurnChannelCapabilities,
-              personaOverride: this.wakePersonaOverride,
-              onboardingContext: this.getOnboardingContext(),
-              conversationId: this.conversationId,
-            }),
-      };
-      if (configuredMaxTokens !== undefined) {
-        resolved.maxTokens = configuredMaxTokens;
-      }
-      if (resolvedModel !== undefined) {
-        resolved.model = resolvedModel;
-      }
-      return resolved;
-    };
+    // Store the model override for per-run resolution. The loop receives it
+    // as a top-level `model` param on `run()`.
+    this.modelOverride = modelOverride;
 
     const fastModeEnabled = isAssistantFeatureFlagEnabled("fast-mode", config);
     const resolvedSpeed = speedOverride ?? resolvedMainAgent.speed;
@@ -726,7 +702,6 @@ export class Conversation {
       tools: toolDefs.length > 0 ? toolDefs : undefined,
       toolExecutor: toolDefs.length > 0 ? toolExecutor : undefined,
       resolveTools,
-      resolveSystemPrompt: resolveSystemPromptCallback,
       resolveConversationDir: () => {
         const conv = getConversation(this.conversationId);
         if (!conv) return null;
@@ -738,7 +713,7 @@ export class Conversation {
     });
     createContextWindowManager({
       provider,
-      systemPrompt: () => resolveSystemPromptCallback([]).systemPrompt,
+      systemPrompt: () => this.buildCurrentSystemPrompt(),
       config: initialContextWindowConfig,
       toolTokenBudget: this.agentLoop.getToolTokenBudget(),
       conversationId: this.conversationId,
@@ -799,6 +774,29 @@ export class Conversation {
     this.inferenceProfileExpiresAt = state.expiresAt;
   }
 
+  /**
+   * Build the system prompt for the current conversation state. When a
+   * system-prompt override was supplied at construction, use it as-is;
+   * otherwise rebuild the full prompt (picks up workspace file changes,
+   * live trust/channel context, persona overrides, onboarding context).
+   *
+   * Called by the caller before invoking `agentLoop.run()` — the loop
+   * itself never re-resolves the prompt mid-loop (re-resolving would bust
+   * the provider's prefix cache).
+   */
+  buildCurrentSystemPrompt(): string {
+    return this.hasSystemPromptOverride
+      ? this.systemPrompt
+      : buildSystemPrompt({
+          hasNoClient: this.hasNoClient,
+          trustContext: this.currentTurnTrustContext,
+          channelCapabilities: this.currentTurnChannelCapabilities,
+          personaOverride: this.wakePersonaOverride,
+          onboardingContext: this.getOnboardingContext(),
+          conversationId: this.conversationId,
+        });
+  }
+
   // ── Prompt Cache Warming ─────────────────────────────────────────
 
   /**
@@ -811,16 +809,7 @@ export class Conversation {
     const abort = new AbortController();
     this.cacheWarmAbort = abort;
 
-    const systemPrompt = this.hasSystemPromptOverride
-      ? this.systemPrompt
-      : buildSystemPrompt({
-          hasNoClient: this.hasNoClient,
-          trustContext: this.currentTurnTrustContext,
-          channelCapabilities: this.currentTurnChannelCapabilities,
-          personaOverride: this.wakePersonaOverride,
-          onboardingContext: this.getOnboardingContext(),
-          conversationId: this.conversationId,
-        });
+    const systemPrompt = this.buildCurrentSystemPrompt();
     const tools = getAllToolDefinitions();
     const provider = this.provider;
 

package/src/daemon/handlers/conversations.ts

@@ -1,5 +1,6 @@
 import { v4 as uuid } from "uuid";
 
+import { peekAcpSessionManager } from "../../acp/index.js";
 import { clearAll, getConversation } from "../../memory/conversation-crud.js";
 import { resolveConversationId } from "../../memory/conversation-key-store.js";
 import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
@@ -106,6 +107,12 @@ export function cancelGeneration(conversationId: string): boolean {
   // being cancelled, so enqueuing synthetic messages would trigger
   // unwanted model activity after the user pressed stop.
   getSubagentManager().abortAllForParent(conversationId);
+  // Cancel any in-flight ACP agent sessions this conversation spawned, for the
+  // same reason: a backgrounded ACP prompt would otherwise keep running (and
+  // holding a child process) past the stop and, on completion, enqueue a
+  // follow-up message back into the conversation the user just cancelled. Peek
+  // the singleton so a conversation that never used ACP doesn't spin one up.
+  peekAcpSessionManager()?.cancelForParent(conversationId);
   // The processing flag is cleared by the in-flight turn's `finally`, not here.
   // Abort propagates into the provider call and tool execution (and is backed
   // by the agent loop's abort watchdog), so the turn reaches its `finally`

package/src/daemon/plugin-source-watcher.ts

@@ -39,6 +39,7 @@ import { type FSWatcher, mkdirSync, readdirSync, watch } from "node:fs";
 
 import { getRegisteredPlugin } from "../plugins/registry.js";
 import { DebouncerMap } from "../util/debounce.js";
+import { attachFsWatcherErrorHandler } from "../util/fs-watcher-error.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspacePluginsDir } from "../util/platform.js";
 import { reregisterExternalPlugin } from "./external-plugins-bootstrap.js";
@@ -267,6 +268,10 @@ export class PluginSourceWatcher {
           });
         },
       );
+      // Recursive watches over plugin trees (incl. node_modules) can exhaust
+      // the inotify watch limit and emit ENOSPC asynchronously. Without an
+      // 'error' listener that unhandled emitter error crashes the daemon.
+      attachFsWatcherErrorHandler(this.watcher, log, pluginsDir);
       log.info({ pluginsDir }, "Plugin source watcher started");
     } catch (err) {
       log.warn(

package/src/daemon/workspace-tools-watcher.ts

@@ -57,6 +57,7 @@ import {
   loadSingleWorkspaceTool,
 } from "../tools/workspace-tools/loader.js";
 import { DebouncerMap } from "../util/debounce.js";
+import { attachFsWatcherErrorHandler } from "../util/fs-watcher-error.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceToolsDir } from "../util/platform.js";
 
@@ -154,6 +155,9 @@ export class WorkspaceToolsWatcher {
           });
         },
       );
+      // Async FSWatcher errors (e.g. ENOSPC, ENXIO) arrive as an 'error' event;
+      // without a listener they crash the daemon. Degrade to a dead watcher.
+      attachFsWatcherErrorHandler(this.watcher, log, toolsDir);
       log.info({ toolsDir }, "Workspace tools watcher started");
     } catch (err) {
       log.warn(

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -88,6 +88,9 @@ const stubConfig: {
     maxDailyRuns: number | null;
     disposition: string;
   };
+  timeouts: {
+    backgroundTurnTimeoutSec: number;
+  };
 } = {
   heartbeat: {
     enabled: true,
@@ -98,6 +101,9 @@ const stubConfig: {
     maxDailyRuns: null,
     disposition: "Default disposition text.",
   },
+  timeouts: {
+    backgroundTurnTimeoutSec: 1800,
+  },
 };
 mock.module("../../config/loader.js", () => ({
   getConfig: () => stubConfig,

package/src/heartbeat/heartbeat-service.ts

@@ -46,7 +46,6 @@ const DEFAULT_CHECKLIST = `- Check in with yourself. Read NOW.md. Is it still ac
 
 const EARLY_HEARTBEAT_THRESHOLD = 3;
 const REENGAGEMENT_COOLDOWN_MS = 18 * 60 * 60 * 1000; // 18 hours
-const HEARTBEAT_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
 
 // Stripped-comment form of the guardian persona scaffold. Computed
 // once at module load because stripping comment lines is deterministic
@@ -774,8 +773,8 @@ export class HeartbeatService {
     //
     // The runner fires `onConversationCreated` synchronously after
     // bootstrap so the macOS sidebar gets the new conversation
-    // immediately rather than waiting up to HEARTBEAT_TIMEOUT_MS for
-    // the LLM turn to finish. If the model judges the run worth
+    // immediately rather than waiting up to the full background-turn timeout
+    // for the LLM turn to finish. If the model judges the run worth
     // surfacing to the guardian, it calls the `notifications` skill
     // directly — no in-band marker.
     let conversationId: string | undefined;
@@ -789,7 +788,7 @@ export class HeartbeatService {
         trustClass: "guardian",
       },
       callSite: "heartbeatAgent",
-      timeoutMs: HEARTBEAT_TIMEOUT_MS,
+      timeoutMs: getConfig().timeouts.backgroundTurnTimeoutSec * 1000,
       origin: "heartbeat",
       deferNotifications: true,
       onConversationCreated: (newConversationId) => {

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

@@ -2,14 +2,12 @@
  * Tests for `db-maintenance.ts` (orchestration) and the underlying
  * `db-async-query.ts` abstraction.
  *
- * The contract this PR locks in:
- *   1. `runDbMaintenance` runs `VACUUM` through the async abstraction
- *      — when the `sqlite3` CLI is available, that means a subprocess
- *      and the daemon's main event loop keeps ticking. (The structural
- *      anti-block assertion lives in
- *      `db-async-query.test.ts`; here we focus on orchestration.)
- *   2. The subprocess actually shrinks the on-disk page count when
- *      there's reclaimable space.
+ * The contract this locks in:
+ *   1. `runDbMaintenance` runs `PRAGMA optimize` through the async
+ *      abstraction and then truncates the WAL on the daemon connection.
+ *      It intentionally does NOT run a full VACUUM (which in WAL mode
+ *      inflates the WAL to ~the DB size and needs ~2x the DB size free).
+ *   2. The truncating checkpoint shrinks the WAL file once it has grown.
  *   3. `maybeRunDbMaintenance` is genuinely async — callers can `await`
  *      it and observe completion.
  *   4. The 24 h interval guard short-circuits a recent re-run.
@@ -17,7 +15,7 @@
  * The per-file temp workspace is set up by `test-preload.ts`; tests just
  * dynamic-import the DB modules so they resolve paths under that temp dir.
  */
-import { Database } from "bun:sqlite";
+import { existsSync, statSync } from "node:fs";
 import { beforeEach, describe, expect, test } from "bun:test";
 
 const { getSqlite } = await import("../db-connection.js");
@@ -56,8 +54,9 @@ function insertMessage(role: "user" | "assistant", createdAt: number): void {
     .run(`msg-${createdAt}-${role}`, convId, role, "[]", createdAt);
 }
 
-/** Inflate the test DB with bloat that VACUUM can reclaim. */
-function inflateAndDelete(byteTarget: number): void {
+/** Pile writes into the WAL (without checkpointing) so a truncating
+ *  checkpoint has measurable work to do. */
+function inflateWal(byteTarget: number): void {
   const sqlite = getSqlite();
   sqlite.exec(
     "CREATE TABLE IF NOT EXISTS bloat (id INTEGER PRIMARY KEY, payload BLOB)",
@@ -72,11 +71,10 @@ function inflateAndDelete(byteTarget: number): void {
   for (let i = 0; i < rowsTarget; i++) {
     insert.run(payload);
   }
+  // Commit, but do not checkpoint — the frames stay in the WAL, leaving it at
+  // its high-water mark (a PASSIVE auto-checkpoint resets the WAL for reuse but
+  // never shrinks the file). Maintenance is what should truncate it.
   sqlite.exec("COMMIT");
-  sqlite.exec("DELETE FROM bloat");
-  sqlite.exec("DROP TABLE bloat");
-  // Force the WAL onto the main DB file so the bloat is visible on disk.
-  sqlite.exec("PRAGMA wal_checkpoint(TRUNCATE)");
 }
 
 describe("maybeRunDbMaintenance", () => {
@@ -106,36 +104,30 @@ describe("maybeRunDbMaintenance", () => {
     expect(getMemoryCheckpoint(MAINTENANCE_CHECKPOINT_KEY)).toBe(String(now));
   });
 
-  test("VACUUM reclaims pages on a bloated DB", async () => {
+  test("truncates a bloated WAL", async () => {
     const sqlite = getSqlite();
     sqlite.exec("DROP TABLE IF EXISTS bloat");
     sqlite.exec("PRAGMA wal_checkpoint(TRUNCATE)");
 
-    inflateAndDelete(8 * 1024 * 1024);
-
-    const dbPath = getDbPath();
-    // Read page_count from a fresh connection so we observe post-write
-    // ground truth without snapshot caching on the main test connection.
-    const readPageCount = (): number => {
-      const probe = new Database(dbPath, { readonly: true });
-      try {
-        return (
-          probe.query("PRAGMA page_count").get() as { page_count: number }
-        ).page_count;
-      } finally {
-        probe.close();
-      }
-    };
-    const pagesBefore = readPageCount();
+    const walPath = `${getDbPath()}-wal`;
+    const walSize = (): number =>
+      existsSync(walPath) ? statSync(walPath).size : 0;
+
+    inflateWal(4 * 1024 * 1024);
+    // Sanity: the writes really did grow the WAL on disk.
+    expect(walSize()).toBeGreaterThan(1024 * 1024);
 
     await maybeRunDbMaintenance();
 
-    const pagesAfter = readPageCount();
-    expect(pagesAfter).toBeLessThan(pagesBefore);
+    // Maintenance truncates the WAL back down (no VACUUM, so the data is folded
+    // into the main file rather than rebuilt).
+    expect(walSize()).toBeLessThan(64 * 1024);
+
+    sqlite.exec("DROP TABLE IF EXISTS bloat");
   }, 60_000);
 
   test("defers maintenance while the last user message is within the quiet period", async () => {
-    /** VACUUM must not fire while the user is active, so a recent user
+    /** Maintenance must not fire while the user is active, so a recent user
      *  message keeps maintenance deferred. */
     // GIVEN the user sent a message one minute ago (well within the quiet period)
     const now = Date.now();

package/src/memory/conversation-crud.ts

@@ -37,6 +37,7 @@ import { publishSyncInvalidation } from "../runtime/sync/sync-publisher.js";
 import { UserError } from "../util/errors.js";
 import { safeParseRecord } from "../util/json.js";
 import { getLogger } from "../util/logger.js";
+import { getLogsDbPath } from "../util/logs-db-path.js";
 import { getConversationsDir } from "../util/platform.js";
 import { createRowMapper } from "../util/row-mapper.js";
 import {
@@ -2140,8 +2141,11 @@ export async function clearAll(): Promise<{
   // Each DELETE goes through `runAsyncSqlite`. The original code threw
   // on rawExec failure; mirror that here by throwing when the async
   // result reports `ok: false`, so the route handler still returns 500.
-  const runOrThrow = async (sql: string): Promise<void> => {
-    const result = await runAsyncSqlite(sql);
+  const runOrThrow = async (
+    sql: string,
+    options?: { dbPath?: string },
+  ): Promise<void> => {
+    const result = await runAsyncSqlite(sql, options);
     if (!result.ok) {
       throw new Error(
         `clearAll: \`${sql}\` failed (${result.backend}): ${result.error ?? "unknown"}`,
@@ -2163,7 +2167,9 @@ export async function clearAll(): Promise<{
   await runOrThrow("DELETE FROM memory_embeddings");
   await runOrThrow("DELETE FROM memory_jobs");
   await runOrThrow("DELETE FROM memory_checkpoints");
-  await runOrThrow("DELETE FROM llm_request_logs");
+  // llm_request_logs lives in the attached logs database; point the sqlite3
+  // subprocess at that file (the in-process fallback resolves it via ATTACH).
+  await runOrThrow("DELETE FROM llm_request_logs", { dbPath: getLogsDbPath() });
   await runOrThrow("DELETE FROM llm_usage_events");
   await runOrThrow("DELETE FROM message_attachments");
   await runOrThrow("DELETE FROM attachments");