@vellumai/assistant 0.8.5 → 0.8.7

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-connection.ts

@@ -6,12 +6,15 @@ import { Database } from "bun:sqlite";
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { ensureDataDir, getDbPath } from "../util/platform.js";
+import {
+  clearStoredDb,
+  getStoredDb,
+  setStoredDb,
+} from "./db-singleton.js";
 import * as schema from "./schema.js";
 
 export type DrizzleDb = ReturnType<typeof drizzle<typeof schema>>;
 
-let db: DrizzleDb | null = null;
-
 function canonicalizePathThroughExistingParent(path: string): string {
   const resolvedPath = resolve(path);
   const pendingSegments: string[] = [];
@@ -71,18 +74,20 @@ function assertTestDbIsIsolated(): void {
 }
 
 export function getDb(): DrizzleDb {
-  if (!db) {
-    assertTestDbIsIsolated();
-    ensureDataDir();
-    const sqlite = new Database(getDbPath());
-    sqlite.exec("PRAGMA journal_mode=WAL");
-    sqlite.exec("PRAGMA synchronous=FULL");
-    sqlite.exec("PRAGMA busy_timeout=5000");
-    sqlite.exec("PRAGMA foreign_keys = ON");
-    sqlite.exec("PRAGMA cache_size=-256000");
-    sqlite.exec("PRAGMA temp_store=MEMORY");
-    db = drizzle(sqlite, { schema });
-  }
+  const existing = getStoredDb<DrizzleDb>();
+  if (existing) return existing;
+
+  assertTestDbIsIsolated();
+  ensureDataDir();
+  const sqlite = new Database(getDbPath());
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA synchronous=FULL");
+  sqlite.exec("PRAGMA busy_timeout=5000");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  sqlite.exec("PRAGMA cache_size=-256000");
+  sqlite.exec("PRAGMA temp_store=MEMORY");
+  const db = drizzle(sqlite, { schema });
+  setStoredDb(db, () => sqlite.close());
   return db;
 }
 
@@ -107,10 +112,15 @@ export function getSqliteFrom(drizzleDb: DrizzleDb): Database {
   return (drizzleDb as unknown as { $client: Database }).$client;
 }
 
-/** Reset the db singleton. Used by tests to ensure isolation between test files. */
+/**
+ * Reset the db singleton. Used by production callers that need to close
+ * the live connection so the file can be replaced (post-migration,
+ * post-restore, post-vbundle-import) and on graceful shutdown.
+ *
+ * Tests should use `resetDbForTesting()` from
+ * `__tests__/db-test-helpers.ts` instead so they don't depend on this
+ * module's heavy import chain (`drizzle-orm/bun-sqlite`).
+ */
 export function resetDb(): void {
-  if (db) {
-    getSqliteFrom(db).close();
-    db = null;
-  }
+  clearStoredDb();
 }

package/src/memory/db-init.ts

@@ -43,6 +43,7 @@ import {
   migrateActivationState,
   migrateActivationStateFkCascade,
   migrateAddConversationInferenceProfile,
+  migrateAddMemoryV3Selections,
   migrateAddSourceTypeColumns,
   migrateAssistantContactMetadata,
   migrateBackfillAudioAttachmentMimeTypes,
@@ -96,6 +97,7 @@ import {
   migrateDropMemoryItemsTables,
   migrateDropMemorySegmentFts,
   migrateDropOrphanedMediaTables,
+  migrateDropProviderConnectionStatus,
   migrateDropRemindersTable,
   migrateDropSetupSkillIdColumn,
   migrateDropSimplifiedMemory,
@@ -124,6 +126,7 @@ import {
   migrateLlmRequestLogsCreatedAtIndex,
   migrateLlmUsageAddRawUsage,
   migrateLlmUsageAttribution,
+  migrateLlmUsageEventsAddAssistantVersion,
   migrateMemoryGraphImageRefs,
   migrateMemoryItemSupersession,
   migrateMemoryRecallLogsQueryContext,
@@ -133,8 +136,10 @@ import {
   migrateMemoryV3AutoEdges,
   migrateMemoryV3Coactivation,
   migrateMessageBookmarks,
+  migrateMessagesClientMessageId,
   migrateMessagesConversationCreatedAtIndex,
   migrateMessagesFtsBackfill,
+  migrateMessagesRoleCreatedAtIndex,
   migrateNormalizePhoneIdentities,
   migrateNormalizeSlackExternalContent,
   migrateNormalizeUserFileByPrincipal,
@@ -182,6 +187,7 @@ import {
   migrateScheduleRetryPolicy,
   migrateScheduleReuseConversation,
   migrateScheduleScriptColumn,
+  migrateScheduleScriptTimeout,
   migrateScheduleWakeConversationId,
   migrateSchemaIndexesAndColumns,
   migrateScrubCorruptedImageAttachments,
@@ -462,6 +468,12 @@ export function initializeDb(): void {
     migrateMemoryV3Coactivation,
     migrateMemoryV3AutoEdges,
     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();

package/src/memory/db-singleton.ts

@@ -0,0 +1,77 @@
+/**
+ * Holds the assistant DB connection singleton and its close callback.
+ *
+ * Lives in its own module (rather than alongside the resolver in
+ * `db-connection.ts`) so test code can reset the singleton without
+ * importing `db-connection.ts` — which transitively pulls
+ * `drizzle-orm/bun-sqlite`. Stdlib-only by design: this file must remain
+ * safe to import from the test preload's load-time chain, where a broken
+ * `node_modules` symlink has historically tripped the env override
+ * (see DB ghost #3, /workspace/journal/2026-05-25-db-ghost-3-recovery.md).
+ *
+ * State is held on `globalThis.vellumAssistant.dbSingleton` so test
+ * helpers in `__tests__/` can read/write it WITHOUT importing this
+ * module — they declare the same slot shape locally and access the
+ * globalThis namespace directly. See
+ * `__tests__/db-test-helpers.ts` for the test-side mirror; the slot
+ * shape MUST stay in sync between the two.
+ *
+ * The stored value is typed as `unknown` so this file never has to import
+ * Drizzle types. Callers in `db-connection.ts` narrow via the type
+ * parameter on `getStoredDb<DrizzleDb>()`.
+ *
+ * Consumers:
+ *   - `db-connection.ts` (opens/owns the connection)
+ *   - production callers that need to close the active connection
+ *     (migration routes, vbundle import, backup/restore, daemon shutdown)
+ *   - `__tests__/db-test-helpers.ts` (per-test reset, via globalThis)
+ */
+
+type DbSlot = {
+  db: unknown;
+  closer: (() => void) | null;
+};
+
+type VellumAssistantNamespace = {
+  dbSingleton?: DbSlot;
+};
+
+function slot(): DbSlot {
+  const g = globalThis as { vellumAssistant?: VellumAssistantNamespace };
+  const ns = (g.vellumAssistant ??= {});
+  return (ns.dbSingleton ??= { db: null, closer: null });
+}
+
+/** Read the current singleton, narrowed to `T`. `null` means not yet opened. */
+export function getStoredDb<T>(): T | null {
+  return slot().db as T | null;
+}
+
+/**
+ * Store a freshly-opened connection and the closer to run on
+ * `clearStoredDb()`. The closer must be self-contained — it is invoked
+ * inside a try/catch, so partial failures are swallowed (best-effort
+ * close on shutdown / restore paths).
+ */
+export function setStoredDb<T>(newDb: T, close: () => void): void {
+  const s = slot();
+  s.db = newDb;
+  s.closer = close;
+}
+
+/**
+ * Close the active connection (if any) via the stored closer, then drop
+ * both. Idempotent: safe to call when no connection is stored.
+ */
+export function clearStoredDb(): void {
+  const s = slot();
+  if (s.closer) {
+    try {
+      s.closer();
+    } catch {
+      /* best-effort close */
+    }
+  }
+  s.db = null;
+  s.closer = null;
+}

package/src/memory/delivery-channels.ts

@@ -10,6 +10,36 @@ import { eq } from "drizzle-orm";
 import { getDb } from "./db-connection.js";
 import { channelInboundEvents } from "./schema.js";
 
+const SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES =
+  "slackDmLiveDeliveredTextResponseIndexes";
+
+function parseRawPayload(
+  rawPayload: string | null,
+): Record<string, unknown> | undefined {
+  if (!rawPayload) return undefined;
+  try {
+    const parsed = JSON.parse(rawPayload) as unknown;
+    if (
+      parsed === null ||
+      typeof parsed !== "object" ||
+      Array.isArray(parsed)
+    ) {
+      return undefined;
+    }
+    return parsed as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+}
+
+function normalizePositiveIntegerIndexes(value: unknown): number[] {
+  if (!Array.isArray(value)) return [];
+  const indexes = value.filter(
+    (item): item is number => Number.isSafeInteger(item) && item > 0,
+  );
+  return [...new Set(indexes)].sort((a, b) => a - b);
+}
+
 // ── Pending verification reply helpers ───────────────────────────────
 //
 // When a guardian verification succeeds but the confirmation reply fails
@@ -100,6 +130,58 @@ export function updateDeliveredSegmentCount(
     .run();
 }
 
+export function getSlackDmLiveDeliveredTextResponseIndexes(
+  eventId: string,
+): number[] {
+  const db = getDb();
+  const row = db
+    .select({ rawPayload: channelInboundEvents.rawPayload })
+    .from(channelInboundEvents)
+    .where(eq(channelInboundEvents.id, eventId))
+    .get();
+  const payload = parseRawPayload(row?.rawPayload ?? null);
+  if (!payload) return [];
+  return normalizePositiveIntegerIndexes(
+    payload[SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES],
+  );
+}
+
+export function addSlackDmLiveDeliveredTextResponseIndex(
+  eventId: string,
+  responseIndex: number,
+): void {
+  if (!Number.isSafeInteger(responseIndex) || responseIndex <= 0) return;
+
+  const db = getDb();
+  db.transaction((tx) => {
+    const row = tx
+      .select({ rawPayload: channelInboundEvents.rawPayload })
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, eventId))
+      .get();
+    if (!row?.rawPayload) return;
+
+    const payload = parseRawPayload(row.rawPayload);
+    if (!payload) return;
+    const indexes = normalizePositiveIntegerIndexes(
+      payload[SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES],
+    );
+    if (!indexes.includes(responseIndex)) indexes.push(responseIndex);
+    indexes.sort((a, b) => a - b);
+
+    tx.update(channelInboundEvents)
+      .set({
+        rawPayload: JSON.stringify({
+          ...payload,
+          [SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES]: indexes,
+        }),
+        updatedAt: Date.now(),
+      })
+      .where(eq(channelInboundEvents.id, eventId))
+      .run();
+  });
+}
+
 // ── Deliver-once guard for terminal reply idempotency ────────────────
 //
 // When both the main poll (processChannelMessageWithApprovals) and the

package/src/memory/graph/__tests__/conversation-graph-memory-v2-routing.test.ts

@@ -28,6 +28,7 @@ import {
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
+import { createMockLoggerModule } from "../../../__tests__/helpers/mock-logger.js";
 import type { AssistantConfig } from "../../../config/types.js";
 import type { Message } from "../../../providers/types.js";
 
@@ -35,10 +36,7 @@ import type { Message } from "../../../providers/types.js";
 // Module mocks (must precede the dynamic imports below)
 // ---------------------------------------------------------------------------
 
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
+mock.module("../../../util/logger.js", () => createMockLoggerModule());
 
 // Stub the v1 retriever so we don't reach Qdrant. Both modes return zero
 // nodes — the v1 injection branch becomes a no-op, isolating the assertion

package/src/memory/graph/consolidation.ts

@@ -279,17 +279,14 @@ async function identifyDuplicateGroups(
 
   const systemPrompt = `You are scanning a list of memory nodes for DUPLICATES — nodes that describe the exact same specific event or fact. Group duplicates together. Two nodes are duplicates ONLY if they describe the same underlying thing with substantially the same details. Be conservative — nodes about the same person or topic but with different details, timestamps, or context are NOT duplicates. Only include nodes that have at least one true duplicate.`;
 
-  const response = await provider.sendMessage(
-    [userMessage(listing)],
-    [DUPE_DETECT_TOOL],
+  const response = await provider.sendMessage([userMessage(listing)], {
+    tools: [DUPE_DETECT_TOOL],
     systemPrompt,
-    {
-      config: {
-        callSite: "memoryConsolidation" as const,
-        tool_choice: { type: "tool" as const, name: "report_duplicate_groups" },
-      },
+    config: {
+      callSite: "memoryConsolidation" as const,
+      tool_choice: { type: "tool" as const, name: "report_duplicate_groups" },
     },
-  );
+  });
 
   const toolBlock = extractToolUse(response);
   if (!toolBlock) return [];
@@ -458,9 +455,9 @@ async function consolidateChunk(
         "Consolidate this partition. Focus on merging duplicates and fading old memories.",
       ),
     ],
-    [CONSOLIDATE_TOOL_SCHEMA],
-    systemPrompt,
     {
+      tools: [CONSOLIDATE_TOOL_SCHEMA],
+      systemPrompt,
       config: {
         callSite: "memoryConsolidation" as const,
         tool_choice: { type: "tool" as const, name: "consolidate_diff" },

package/src/memory/graph/conversation-graph-memory.ts

@@ -22,6 +22,7 @@ import { getWorkspaceDir } from "../../util/platform.js";
 import { getDb } from "../db-connection.js";
 import { embedWithRetry } from "../embed.js";
 import { generateSparseEmbedding } from "../embedding-backend.js";
+import { wrapMemoryBlock } from "../memory-marker.js";
 import type { QdrantSparseVector } from "../qdrant-client.js";
 import { memorySummaries } from "../schema.js";
 import { conversations } from "../schema/conversations.js";
@@ -895,13 +896,45 @@ export function stripExistingMemoryInjections(messages: Message[]): Message[] {
   const last = messages[messages.length - 1];
   if (!last || last.role !== "user") return messages;
 
-  const firstNonMemory = countMemoryPrefixBlocks(last.content);
-  if (firstNonMemory === 0) return messages;
+  const stripped = stripMemoryPrefixFromUserMessage(last);
+  if (stripped === last) return messages;
 
-  return [
-    ...messages.slice(0, -1),
-    { ...last, content: last.content.slice(firstNonMemory) },
-  ];
+  return [...messages.slice(0, -1), stripped];
+}
+
+/**
+ * Strip the memory-injected prefix from a single user message. Returns the
+ * same message reference unchanged when it is not a user message or carries no
+ * injected prefix, so callers can cheaply detect no-ops. Shared by
+ * `stripExistingMemoryInjections` (last message only) and
+ * `stripAllMemoryInjections` (every user message).
+ */
+function stripMemoryPrefixFromUserMessage(message: Message): Message {
+  if (message.role !== "user") return message;
+  const firstNonMemory = countMemoryPrefixBlocks(message.content);
+  if (firstNonMemory === 0) return message;
+  return { ...message, content: message.content.slice(firstNonMemory) };
+}
+
+/**
+ * Remove memory-injected blocks from EVERY user message, not just the last.
+ *
+ * memory-v3 live mode strips the injected `<memory>` block from all historical
+ * user messages each turn: it keeps the prompt lean and makes history
+ * byte-stable for prompt caching (v2 strips only the last user message — see
+ * `stripExistingMemoryInjections`). Reuses the same per-message block
+ * recognition as the last-message strip. Wired into the runtime-assembly
+ * suppression step (`conversation-runtime-assembly.ts`), which calls it when
+ * `memory-v3-live` is on and the v3 injector produced a block this turn.
+ */
+export function stripAllMemoryInjections(messages: Message[]): Message[] {
+  let changed = false;
+  const result = messages.map((message) => {
+    const stripped = stripMemoryPrefixFromUserMessage(message);
+    if (stripped !== message) changed = true;
+    return stripped;
+  });
+  return changed ? result : messages;
 }
 
 /**
@@ -933,7 +966,7 @@ function injectTextBlock(messages: Message[], text: string): Message[] {
       content: [
         {
           type: "text" as const,
-          text: `<memory>\n${text}\n</memory>`,
+          text: wrapMemoryBlock(text),
         },
         ...userTail.content,
       ],
@@ -977,7 +1010,7 @@ function injectMemoryBlock(
 
   blocks.push({
     type: "text" as const,
-    text: `<memory>\n${text}\n</memory>`,
+    text: wrapMemoryBlock(text),
   });
 
   return [

package/src/memory/graph/extraction.ts

@@ -1071,17 +1071,14 @@ export async function runGraphExtraction(
         ),
       ];
 
-  const response = await provider.sendMessage(
-    extractionMessages,
-    [EXTRACT_TOOL_SCHEMA],
+  const response = await provider.sendMessage(extractionMessages, {
+    tools: [EXTRACT_TOOL_SCHEMA],
     systemPrompt,
-    {
-      config: {
-        callSite: "memoryExtraction" as const,
-        tool_choice: { type: "tool" as const, name: "extract_graph_diff" },
-      },
+    config: {
+      callSite: "memoryExtraction" as const,
+      tool_choice: { type: "tool" as const, name: "extract_graph_diff" },
     },
-  );
+  });
 
   const toolBlock = extractToolUse(response);
   if (!toolBlock) {

package/src/memory/graph/narrative.ts

@@ -192,9 +192,9 @@ export async function runNarrativeRefinement(
         "Review and refine the narrative structure of these memories. Identify story arcs and assign roles with the benefit of hindsight.",
       ),
     ],
-    [NARRATIVE_TOOL_SCHEMA],
-    systemPrompt,
     {
+      tools: [NARRATIVE_TOOL_SCHEMA],
+      systemPrompt,
       config: {
         callSite: "narrativeRefinement" as const,
         tool_choice: { type: "tool" as const, name: "refine_narratives" },