@vellumai/assistant 0.8.6 → 0.8.7

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

@@ -25,16 +25,37 @@ const { initializeDb } = await import("../db-init.js");
 const { deleteMemoryCheckpoint, getMemoryCheckpoint } =
   await import("../checkpoints.js");
 const { maybeRunDbMaintenance } = await import("../db-maintenance.js");
+const { getLastUserMessageTimestamp } = await import("../conversation-crud.js");
 const { getDbPath } = await import("../../util/platform.js");
 
 initializeDb();
 
 const MAINTENANCE_CHECKPOINT_KEY = "db_maintenance:last_run";
+const QUIET_PERIOD_MS = 3 * 60 * 60 * 1000;
 
 beforeEach(() => {
   deleteMemoryCheckpoint(MAINTENANCE_CHECKPOINT_KEY);
+  const sqlite = getSqlite();
+  sqlite.exec("DELETE FROM messages");
+  sqlite.exec("DELETE FROM conversations");
 });
 
+/** Insert a message row directly, bypassing indexing/job side effects. */
+function insertMessage(role: "user" | "assistant", createdAt: number): void {
+  const sqlite = getSqlite();
+  const convId = `conv-${createdAt}-${role}`;
+  sqlite
+    .prepare(
+      "INSERT OR IGNORE INTO conversations (id, created_at, updated_at) VALUES (?, ?, ?)",
+    )
+    .run(convId, createdAt, createdAt);
+  sqlite
+    .prepare(
+      "INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)",
+    )
+    .run(`msg-${createdAt}-${role}`, convId, role, "[]", createdAt);
+}
+
 /** Inflate the test DB with bloat that VACUUM can reclaim. */
 function inflateAndDelete(byteTarget: number): void {
   const sqlite = getSqlite();
@@ -112,4 +133,111 @@ describe("maybeRunDbMaintenance", () => {
     const pagesAfter = readPageCount();
     expect(pagesAfter).toBeLessThan(pagesBefore);
   }, 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
+     *  message keeps maintenance deferred. */
+    // GIVEN the user sent a message one minute ago (well within the quiet period)
+    const now = Date.now();
+    insertMessage("user", now - 60_000);
+
+    // WHEN maintenance is considered
+    await maybeRunDbMaintenance(now);
+
+    // THEN it is deferred — the checkpoint is never stamped, so a later idle
+    // tick will retry
+    expect(getMemoryCheckpoint(MAINTENANCE_CHECKPOINT_KEY)).toBeNull();
+  });
+
+  test("runs maintenance once the quiet period has elapsed since the last user message", async () => {
+    /** After the user has been quiet for longer than the quiet period,
+     *  maintenance is allowed to run. */
+    // GIVEN the last user message is older than the quiet period
+    const now = Date.now();
+    insertMessage("user", now - (QUIET_PERIOD_MS + 60_000));
+
+    // WHEN maintenance is considered
+    await maybeRunDbMaintenance(now);
+
+    // THEN it runs and stamps the checkpoint
+    expect(getMemoryCheckpoint(MAINTENANCE_CHECKPOINT_KEY)).toBe(String(now));
+  });
+
+  test("ignores quiet period when no user message exists", async () => {
+    /** A fresh install with no user messages must not be blocked from ever
+     *  running maintenance. */
+    // GIVEN no user messages exist
+    const now = Date.now();
+
+    // WHEN maintenance is considered
+    await maybeRunDbMaintenance(now);
+
+    // THEN it runs and stamps the checkpoint
+    expect(getMemoryCheckpoint(MAINTENANCE_CHECKPOINT_KEY)).toBe(String(now));
+  });
+
+  test("a recent assistant message does not keep maintenance deferred", async () => {
+    /** The gate keys off user activity only — background assistant writes
+     *  must not postpone maintenance indefinitely. */
+    // GIVEN the user has been quiet past the quiet period
+    const now = Date.now();
+    insertMessage("user", now - (QUIET_PERIOD_MS + 60_000));
+    // AND the assistant wrote a message recently
+    insertMessage("assistant", now - 60_000);
+
+    // WHEN maintenance is considered
+    await maybeRunDbMaintenance(now);
+
+    // THEN it still runs, since only user activity gates it
+    expect(getMemoryCheckpoint(MAINTENANCE_CHECKPOINT_KEY)).toBe(String(now));
+  });
+});
+
+describe("getLastUserMessageTimestamp", () => {
+  test("returns 0 when no user message exists", () => {
+    /** With only non-user rows present, there is no user activity to report. */
+    // GIVEN only an assistant message exists
+    insertMessage("assistant", Date.now());
+
+    // WHEN the last user message timestamp is read
+    const result = getLastUserMessageTimestamp();
+
+    // THEN it reports 0 (no user activity)
+    expect(result).toBe(0);
+  });
+
+  test("returns the most recent user message by timestamp, ignoring assistant rows", () => {
+    /** The lookup reports the newest user-message timestamp and must skip
+     *  non-user rows even when they are more recent. */
+    // GIVEN two user messages and a newer assistant message
+    const base = Date.now();
+    insertMessage("user", base - 10_000);
+    insertMessage("user", base - 5_000);
+    insertMessage("assistant", base);
+
+    // WHEN the last user message timestamp is read
+    const result = getLastUserMessageTimestamp();
+
+    // THEN it returns the most recent user message, not the assistant row
+    expect(result).toBe(base - 5_000);
+  });
+
+  test("reports the newest user timestamp even when an older turn was inserted later", () => {
+    /** `forkConversation` copies a parent's user turns into the fork with
+     *  their original (older) `created_at` but fresh row ids, so insertion
+     *  order can place an old turn last. The lookup must key off `created_at`
+     *  so a fork can't make recent activity look stale and prematurely
+     *  un-gate maintenance. */
+    // GIVEN a recent user message
+    const base = Date.now();
+    insertMessage("user", base - 5_000);
+    // AND a later insert of an older user turn (as a fork copy would produce)
+    insertMessage("user", base - 60 * 60 * 1000);
+
+    // WHEN the last user message timestamp is read
+    const result = getLastUserMessageTimestamp();
+
+    // THEN it reports the genuinely most recent turn, not the last-inserted one
+    expect(result).toBe(base - 5_000);
+  });
 });

package/src/memory/__tests__/jobs-store-job-classes.test.ts

@@ -40,11 +40,12 @@ describe("memory job classes", () => {
     expect(set.size).toBe(SLOW_LLM_JOB_TYPES.length);
   });
 
-  test("memory_v3_consolidate is a slow LLM job (lane isolation)", () => {
-    // It hands off to a background agent for up to 15 min, like
+  test("memory_v3_maintain is a slow LLM job (lane isolation)", () => {
+    // It runs an LLM classify-union pass over unassigned pages, like
     // memory_v2_consolidate; it must not sit in the fast lane and starve
-    // short jobs. The mechanical v3 jobs intentionally stay fast.
-    expect(SLOW_LLM_JOB_TYPES).toContain("memory_v3_consolidate");
+    // short jobs. The retired v3 job literals intentionally stay out.
+    expect(SLOW_LLM_JOB_TYPES).toContain("memory_v3_maintain");
+    expect(SLOW_LLM_JOB_TYPES).not.toContain("memory_v3_consolidate");
     expect(SLOW_LLM_JOB_TYPES).not.toContain("memory_v3_index_maintenance");
     expect(SLOW_LLM_JOB_TYPES).not.toContain("memory_v3_edge_learning");
   });

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

@@ -57,7 +57,7 @@ let addMessageCalls: Array<{
   conversationId: string;
   role: string;
   content: string;
-  metadata: unknown;
+  options: unknown;
 }> = [];
 
 // Per-conversation overrides for getConversation. Lets fork-path tests stage
@@ -137,9 +137,9 @@ mock.module("../conversation-crud.js", () => ({
     conversationId: string,
     role: string,
     content: string,
-    metadata: unknown,
+    options: unknown,
   ) => {
-    addMessageCalls.push({ conversationId, role, content, metadata });
+    addMessageCalls.push({ conversationId, role, content, options });
   },
   deleteConversation: (id: string) => {
     deletedConversationIds.push(id);
@@ -316,10 +316,11 @@ describe("memoryRetrospectiveJob", () => {
     expect(bootstrapCalls[0]!.forkParentConversationId).toBe("src-conv-1");
   });
 
-  test("legacy path: wake opts include suppressWakeSurface so the full retrospective prompt isn't rendered as a 'Conversation Woke' card body to clients", async () => {
+  test("legacy path: wake is scoped to memory saves and suppresses the internal wake surface", async () => {
     await memoryRetrospectiveJob(makeJob(), stubConfig);
 
     expect(wakeCalls).toHaveLength(1);
+    expect(wakeCalls[0]!.opts.allowedTools).toEqual(["remember"]);
     expect(wakeCalls[0]!.opts.suppressWakeSurface).toBe(true);
   });
 
@@ -519,7 +520,9 @@ describe("memoryRetrospectiveJob", () => {
     expect(addMessageCalls).toHaveLength(1);
     expect(addMessageCalls[0]!.conversationId).toBe("fork-conv-1");
     expect(addMessageCalls[0]!.role).toBe("user");
-    expect(addMessageCalls[0]!.metadata).toEqual({
+    expect(
+      (addMessageCalls[0]!.options as Record<string, unknown>).metadata,
+    ).toEqual({
       kind: "memory_retrospective_instruction",
       hidden: true,
     });
@@ -535,7 +538,7 @@ describe("memoryRetrospectiveJob", () => {
     expect(forkCalls[0]!.groupId).toBe("system:background");
   });
 
-  test("fork path: wake opts include suppressWakeSurface so clients don't render an empty wake card on top of the '(Retrospective)' fork", async () => {
+  test("fork path: wake is scoped to memory saves and suppresses the internal wake surface", async () => {
     forkFlagEnabled = true;
     await memoryRetrospectiveJob(makeJob(), stubConfig);
 
@@ -543,6 +546,7 @@ describe("memoryRetrospectiveJob", () => {
     expect(wakeCalls).toHaveLength(1);
     expect(wakeCalls[0]!.conversationId).toBe("fork-conv-1");
     const opts = wakeCalls[0]!.opts;
+    expect(opts.allowedTools).toEqual(["remember"]);
     expect(opts.suppressWakeSurface).toBe(true);
     // Sanity: the other fork-specific opts the handler relies on are still set.
     expect(opts.skipHintInjection).toBe(true);

package/src/memory/__tests__/memory-v3-selections-migration.test.ts

@@ -0,0 +1,103 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../db-connection.js";
+import { migrateAddMemoryV3Selections } from "../migrations/268-add-memory-v3-selections.js";
+import * as schema from "../schema.js";
+
+interface ColumnRow {
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: string | null;
+  pk: number;
+}
+
+interface IndexRow {
+  name: string;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+describe("memory_v3_selections migration", () => {
+  test("creates table with expected columns", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateAddMemoryV3Selections(db);
+
+    const columns = raw
+      .query(`PRAGMA table_info(memory_v3_selections)`)
+      .all() as ColumnRow[];
+    const byName = new Map(columns.map((c) => [c.name, c]));
+
+    expect(byName.get("conversation_id")?.type).toBe("TEXT");
+    expect(byName.get("conversation_id")?.notnull).toBe(1);
+    expect(byName.get("conversation_id")?.pk).toBe(1);
+
+    expect(byName.get("turn")?.type).toBe("INTEGER");
+    expect(byName.get("turn")?.notnull).toBe(1);
+    expect(byName.get("turn")?.pk).toBe(2);
+
+    expect(byName.get("slug")?.type).toBe("TEXT");
+    expect(byName.get("slug")?.notnull).toBe(1);
+    expect(byName.get("slug")?.pk).toBe(3);
+
+    expect(byName.get("source")?.type).toBe("TEXT");
+    expect(byName.get("source")?.notnull).toBe(1);
+
+    expect(byName.get("pinned")?.type).toBe("INTEGER");
+    expect(byName.get("pinned")?.notnull).toBe(1);
+    expect(byName.get("pinned")?.dflt_value).toBe("0");
+
+    expect(byName.get("created_at")?.type).toBe("INTEGER");
+    expect(byName.get("created_at")?.notnull).toBe(1);
+  });
+
+  test("creates the conversation-turn index", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateAddMemoryV3Selections(db);
+
+    const indexes = raw
+      .query(`PRAGMA index_list(memory_v3_selections)`)
+      .all() as IndexRow[];
+    const indexNames = new Set(indexes.map((i) => i.name));
+
+    expect(indexNames.has("idx_memory_v3_selections_conv")).toBe(true);
+  });
+
+  test("is idempotent — re-running does not throw and preserves rows", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateAddMemoryV3Selections(db);
+
+    raw
+      .query(
+        /*sql*/ `
+        INSERT INTO memory_v3_selections (
+          conversation_id, turn, slug, source, pinned, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?)
+      `,
+      )
+      .run("conv-abc", 3, "page-slug", "lane-a", 1, 1000);
+
+    expect(() => migrateAddMemoryV3Selections(db)).not.toThrow();
+
+    const row = raw
+      .query(
+        `SELECT slug FROM memory_v3_selections WHERE conversation_id = 'conv-abc' AND turn = 3`,
+      )
+      .get() as { slug: string } | null;
+    expect(row?.slug).toBe("page-slug");
+  });
+});

package/src/memory/context-search/agent-runner.ts

@@ -290,9 +290,8 @@ export async function runAgenticRecall(
     try {
       response = await provider.sendMessage(
         [userTextMessage(promptBundle.prompt)],
-        [...RECALL_AGENT_TOOL_DEFINITIONS],
-        undefined,
         {
+          tools: [...RECALL_AGENT_TOOL_DEFINITIONS],
           // `thinking: disabled` is required because we set `temperature: 0`
           // explicitly. Anthropic 400s on `temperature` ≠ 1 whenever thinking
           // is enabled or in adaptive mode; without this, profiles that
@@ -591,9 +590,8 @@ async function tryFinalFinishRecall(options: {
   try {
     response = await options.provider.sendMessage(
       [userTextMessage(promptBundle.prompt)],
-      [FINISH_RECALL_TOOL_DEFINITION],
-      undefined,
       {
+        tools: [FINISH_RECALL_TOOL_DEFINITION],
         // `thinking: disabled` required for the same reason as the agent
         // round above — Anthropic 400s on `temperature` ≠ 1 whenever
         // thinking is enabled or in adaptive mode.

package/src/memory/conversation-crud.ts

@@ -1195,23 +1195,29 @@ export function wipeConversation(id: string): WipeConversationResult {
   };
 }
 
+/** Options for {@link addMessage}. Only `skipIndexing` and `clientMessageId`
+ *  have defaults; `metadata` is genuinely optional. */
+export interface AddMessageOptions {
+  metadata?: Record<string, unknown>;
+  skipIndexing?: boolean;
+  /** Client-generated nonce for idempotent inserts. When provided,
+   *  duplicate inserts for the same `(conversationId, clientMessageId)`
+   *  pair are silently skipped. */
+  clientMessageId?: string;
+}
+
 /**
  * Persist a message and run post-insert side effects (memory indexing,
  * attention projection). Delegates the core insert + retry logic to
  * {@link insertMessageCore}.
- *
- * @param clientMessageId  Optional client-generated nonce. When
- *   provided, duplicate inserts for the same `(conversationId,
- *   clientMessageId)` pair are silently skipped (idempotent).
  */
 export async function addMessage(
   conversationId: string,
   role: MessageRole,
   content: string,
-  metadata?: Record<string, unknown>,
-  opts?: { skipIndexing?: boolean },
-  clientMessageId?: string,
+  options?: AddMessageOptions,
 ) {
+  const { metadata, skipIndexing, clientMessageId } = options ?? {};
   const inserted = await insertMessageCore({
     conversationId,
     role,
@@ -1226,7 +1232,7 @@ export async function addMessage(
 
   const message = inserted;
 
-  if (!opts?.skipIndexing) {
+  if (!skipIndexing) {
     try {
       const config = getConfig();
       const parsed = metadata
@@ -1613,6 +1619,31 @@ export function getLastUserTimestampBefore(
   return row?.createdAt ?? 0;
 }
 
+/**
+ * Most recent user-message timestamp (epoch ms) across all conversations, or
+ * `0` when no user message exists.
+ *
+ * Ordered by `created_at` rather than insertion order, because `forkConversation`
+ * copies a parent's messages into the fork while preserving their original
+ * `created_at`. Those copies receive fresh row ids, so an insertion-order scan
+ * could surface an old forked turn as if it were the latest activity and let
+ * maintenance run while the user is in fact active. The `(role, created_at)`
+ * index (`idx_messages_role_created_at`) makes this an indexed seek to the
+ * newest `role = "user"` row rather than a scan of the whole (potentially
+ * multi-GB) table.
+ */
+export function getLastUserMessageTimestamp(): number {
+  const db = getDb();
+  const row = db
+    .select({ createdAt: messages.createdAt })
+    .from(messages)
+    .where(eq(messages.role, "user"))
+    .orderBy(desc(messages.createdAt))
+    .limit(1)
+    .get();
+  return row?.createdAt ?? 0;
+}
+
 /** Fetch a single message by ID, optionally scoped to a specific conversation. */
 export function getMessageById(
   messageId: string,

package/src/memory/conversation-queries.ts

@@ -11,6 +11,7 @@ import type { ConversationRow } from "./conversation-crud.js";
 import { parseConversation } from "./conversation-crud.js";
 import { ensureDisplayOrderMigration } from "./conversation-display-order-migration.js";
 import { ensureGroupMigration } from "./conversation-group-migration.js";
+import type { ConversationType } from "./conversation-types.js";
 import { getDb } from "./db-connection.js";
 import { rawAll } from "./raw-query.js";
 import { conversations, messages } from "./schema.js";
@@ -48,30 +49,78 @@ export function buildFtsMatchQuery(
   return unique.map((token) => `"${token.replace(/"/g, '""')}"`).join(" ");
 }
 
+/**
+ * How {@link listConversations} (and friends) treats archived rows.
+ *
+ * - `"active"` — exclude rows with a non-null `archivedAt`. The default
+ *   for sidebar lists, restore, CLI pickers, and anything user-facing.
+ * - `"archived"` — return ONLY archived rows. Powers the Archive page
+ *   so it does not have to pull the entire conversation history and
+ *   filter client-side.
+ * - `"all"` — include both. Reserved for migrations and back-compat
+ *   call sites that genuinely want everything in one query.
+ */
+export type ArchiveStatusFilter = "active" | "archived" | "all";
+
+function archiveStatusClause(status: ArchiveStatusFilter) {
+  switch (status) {
+    case "active":
+      return sql`${conversations.archivedAt} IS NULL`;
+    case "archived":
+      return sql`${conversations.archivedAt} IS NOT NULL`;
+    case "all":
+      return null;
+  }
+}
+
+/**
+ * SQL predicate selecting which bucket {@link listConversations} and
+ * {@link countConversations} return, keyed by the canonical
+ * {@link ConversationType}:
+ *
+ * - `"standard"` — the primary sidebar list: standard conversations only,
+ *   excluding background, scheduled, and private rows. `"private"` is excluded
+ *   defensively because in-place snapshot restore swaps the SQLite file without
+ *   running migrations in-process, so legacy private rows can briefly exist
+ *   before migration cleanup deletes them.
+ * - `"background"` — the background **umbrella**: background *and* scheduled
+ *   rows together. The back-compat bucket for the single
+ *   `conversationType=background` fetch that older clients (e.g. the macOS app,
+ *   which ships out of lockstep with the daemon) rely on to populate both the
+ *   Background and Scheduled sidebar sections from one request.
+ * - `"scheduled"` — scheduled rows only, so the Scheduled section can load
+ *   independently of the broader background backlog without over-fetching it.
+ *
+ * `group_id` is matched alongside `conversationType` so conversations routed to
+ * `system:background` / `system:scheduled` (heartbeat, reminders, schedule-job
+ * runs) but created with conversationType `"standard"` still land in the
+ * correct bucket. Subagent runs are excluded from the background/scheduled
+ * buckets so the sidebar never surfaces them.
+ */
+function conversationTypeClause(type: ConversationType) {
+  const notSubagent = sql`(${conversations.source} IS NULL OR ${conversations.source} != 'subagent')`;
+  switch (type) {
+    case "standard":
+      return sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private') AND COALESCE(group_id, 'system:all') NOT IN ('system:background', 'system:scheduled')`;
+    case "background":
+      return sql`(${conversations.conversationType} IN ('background', 'scheduled') OR group_id IN ('system:background', 'system:scheduled')) AND ${notSubagent}`;
+    case "scheduled":
+      return sql`(${conversations.conversationType} = 'scheduled' OR group_id = 'system:scheduled') AND ${notSubagent}`;
+  }
+}
+
 export function listConversations(
   limit?: number,
-  backgroundOnly = false,
+  conversationType: ConversationType = "standard",
   offset = 0,
-  includeArchived = true,
+  archiveStatus: ArchiveStatusFilter = "active",
 ): ConversationRow[] {
   ensureDisplayOrderMigration();
   ensureGroupMigration();
   const db = getDb();
-  // 'private' is excluded defensively: in-place snapshot restore swaps the
-  // SQLite file without running migrations in-process, so legacy private rows
-  // can briefly exist before migration cleanup. Hide them from foreground
-  // lists until the next migration pass deletes them.
-  //
-  // group_id is checked alongside conversationType so that conversations
-  // routed to system:background (e.g. heartbeat) via conversationMetadata
-  // but created with conversationType "standard" (vellum channel strategy)
-  // appear in the correct bucket.
-  const typeCond = backgroundOnly
-    ? sql`(${conversations.conversationType} IN ('background', 'scheduled') OR group_id IN ('system:background', 'system:scheduled')) AND (${conversations.source} IS NULL OR ${conversations.source} != 'subagent')`
-    : sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private') AND COALESCE(group_id, 'system:all') NOT IN ('system:background', 'system:scheduled')`;
-  const where = includeArchived
-    ? typeCond
-    : sql`${typeCond} AND ${conversations.archivedAt} IS NULL`;
+  const typeCond = conversationTypeClause(conversationType);
+  const archiveCond = archiveStatusClause(archiveStatus);
+  const where = archiveCond ? sql`${typeCond} AND ${archiveCond}` : typeCond;
   const query = db
     .select()
     .from(conversations)
@@ -172,10 +221,13 @@ export function getMessageRoleStatsByConversation(
   );
 }
 
-export function listPinnedConversations(): ConversationRow[] {
+export function listPinnedConversations(
+  archiveStatus: ArchiveStatusFilter = "active",
+): ConversationRow[] {
   ensureDisplayOrderMigration();
   ensureGroupMigration();
   const db = getDb();
+  const archiveCond = archiveStatusClause(archiveStatus);
   const query = db
     .select()
     .from(conversations)
@@ -183,6 +235,7 @@ export function listPinnedConversations(): ConversationRow[] {
       and(
         sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private')`,
         sql`is_pinned = 1`,
+        ...(archiveCond ? [archiveCond] : []),
       ),
     )
     .orderBy(
@@ -247,12 +300,15 @@ export function listConversationsByTitlePrefix(
   }));
 }
 
-export function countConversations(backgroundOnly = false): number {
+export function countConversations(
+  conversationType: ConversationType = "standard",
+  archiveStatus: ArchiveStatusFilter = "active",
+): number {
   ensureGroupMigration();
   const db = getDb();
-  const where = backgroundOnly
-    ? sql`(${conversations.conversationType} IN ('background', 'scheduled') OR group_id IN ('system:background', 'system:scheduled')) AND (${conversations.source} IS NULL OR ${conversations.source} != 'subagent')`
-    : sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private') AND COALESCE(group_id, 'system:all') NOT IN ('system:background', 'system:scheduled')`;
+  const typeCond = conversationTypeClause(conversationType);
+  const archiveCond = archiveStatusClause(archiveStatus);
+  const where = archiveCond ? sql`${typeCond} AND ${archiveCond}` : typeCond;
   const [{ total }] = db
     .select({ total: count() })
     .from(conversations)

package/src/memory/db-init.ts

@@ -43,6 +43,7 @@ import {
   migrateActivationState,
   migrateActivationStateFkCascade,
   migrateAddConversationInferenceProfile,
+  migrateAddMemoryV3Selections,
   migrateAddSourceTypeColumns,
   migrateAssistantContactMetadata,
   migrateBackfillAudioAttachmentMimeTypes,
@@ -125,6 +126,7 @@ import {
   migrateLlmRequestLogsCreatedAtIndex,
   migrateLlmUsageAddRawUsage,
   migrateLlmUsageAttribution,
+  migrateLlmUsageEventsAddAssistantVersion,
   migrateMemoryGraphImageRefs,
   migrateMemoryItemSupersession,
   migrateMemoryRecallLogsQueryContext,
@@ -137,6 +139,7 @@ import {
   migrateMessagesClientMessageId,
   migrateMessagesConversationCreatedAtIndex,
   migrateMessagesFtsBackfill,
+  migrateMessagesRoleCreatedAtIndex,
   migrateNormalizePhoneIdentities,
   migrateNormalizeSlackExternalContent,
   migrateNormalizeUserFileByPrincipal,
@@ -184,6 +187,7 @@ import {
   migrateScheduleRetryPolicy,
   migrateScheduleReuseConversation,
   migrateScheduleScriptColumn,
+  migrateScheduleScriptTimeout,
   migrateScheduleWakeConversationId,
   migrateSchemaIndexesAndColumns,
   migrateScrubCorruptedImageAttachments,
@@ -466,6 +470,10 @@ export function initializeDb(): void {
     migrateLlmRequestLogCallSite,
     migrateDropProviderConnectionStatus,
     migrateMessagesClientMessageId,
+    migrateLlmUsageEventsAddAssistantVersion,
+    migrateAddMemoryV3Selections,
+    migrateScheduleScriptTimeout,
+    migrateMessagesRoleCreatedAtIndex,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/db-maintenance.ts

@@ -1,15 +1,16 @@
 import { statSync } from "node:fs";
 
+import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
 import { getDbPath } from "../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
+import { getLastUserMessageTimestamp } from "./conversation-crud.js";
 import { runAsyncSqlite } from "./db-async-query.js";
 import { getSqlite } from "./db-connection.js";
 
 const log = getLogger("db-maintenance");
 
 const DB_MAINTENANCE_CHECKPOINT_KEY = "db_maintenance:last_run";
-const DB_MAINTENANCE_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 interface DbStats {
   pageSize: number;
@@ -101,11 +102,26 @@ async function runDbMaintenance(): Promise<void> {
 }
 
 export async function maybeRunDbMaintenance(nowMs = Date.now()): Promise<void> {
+  const { intervalMs, quietPeriodMs } = getConfig().memory.maintenance;
+
   const lastRun = parseInt(
     getMemoryCheckpoint(DB_MAINTENANCE_CHECKPOINT_KEY) ?? "0",
     10,
   );
-  if (nowMs - lastRun < DB_MAINTENANCE_INTERVAL_MS) return;
+  if (nowMs - lastRun < intervalMs) return;
+
+  // VACUUM holds an exclusive lock on the database for its full duration —
+  // minutes on a multi-GB DB — during which every other write fails with
+  // SQLITE_BUSY ("database is locked"). Defer maintenance until the user has
+  // been quiet for `quietPeriodMs` so that lock never lands mid-conversation.
+  // The checkpoint below is only written once maintenance actually runs, so a
+  // deferred run is simply retried on a later (still-idle) worker tick.
+  if (quietPeriodMs > 0) {
+    const lastUserMessageAt = getLastUserMessageTimestamp();
+    if (lastUserMessageAt > 0 && nowMs - lastUserMessageAt < quietPeriodMs) {
+      return;
+    }
+  }
 
   try {
     await runDbMaintenance();