@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/memory/llm-request-log-store.ts

@@ -24,9 +24,23 @@ import {
   getTurnTimeBounds,
   messageMetadataSchema,
 } from "./conversation-crud.js";
-import { getDb } from "./db-connection.js";
+import { type DrizzleDb, getDb, getLogsDb } from "./db-connection.js";
 import { llmRequestLogs, messages } from "./schema.js";
 
+/**
+ * The logs connection (`assistant-logs.db`), where `llm_request_logs` lives.
+ * Throws if the file cannot be opened — the store has no fallback, and a
+ * missing logs DB is a genuine failure for these call sites (insert/read of
+ * request logs). Callers that must not fail on this already wrap in try/catch.
+ */
+function logsDb(): DrizzleDb {
+  const db = getLogsDb();
+  if (!db) {
+    throw new Error("logs database unavailable");
+  }
+  return db;
+}
+
 export type LogRow = {
   id: string;
   conversationId: string;
@@ -111,7 +125,7 @@ export function recordRequestLog(
   provider?: string,
   callSite?: LLMCallSite,
 ): string {
-  const db = getDb();
+  const db = logsDb();
   const id = uuid();
   db.insert(llmRequestLogs)
     .values({
@@ -178,7 +192,7 @@ export function recordSyntheticAgentErrorMessageLog(args: {
   preparedRequest: unknown | null;
   createdAt: number;
 }): string {
-  const db = getDb();
+  const db = logsDb();
   const id = uuid();
   const requestPayload = JSON.stringify({
     syntheticAgentErrorMessage: {
@@ -225,7 +239,7 @@ export function setAgentLoopExitReasonOnLatestLog(
   conversationId: string,
   reason: string,
 ): void {
-  const db = getDb();
+  const db = logsDb();
   const latest = db
     .select({ id: llmRequestLogs.id })
     .from(llmRequestLogs)
@@ -249,7 +263,7 @@ export function backfillMessageIdOnLogs(
   conversationId: string,
   messageId: string,
 ): void {
-  const db = getDb();
+  const db = logsDb();
   db.update(llmRequestLogs)
     .set({ messageId })
     .where(
@@ -272,7 +286,7 @@ export function relinkLlmRequestLogs(
   toMessageId: string,
 ): void {
   if (fromMessageIds.length === 0) return;
-  const db = getDb();
+  const db = logsDb();
   db.update(llmRequestLogs)
     .set({ messageId: toMessageId })
     .where(inArray(llmRequestLogs.messageId, fromMessageIds))
@@ -286,7 +300,7 @@ export function relinkLlmRequestLogs(
  */
 function selectLogsByMessageIds(messageIds: string[]): LogRow[] {
   if (messageIds.length === 0) return [];
-  const db = getDb();
+  const db = logsDb();
   return db
     .select({
       id: llmRequestLogs.id,
@@ -314,7 +328,7 @@ function selectLogsByMessageIds(messageIds: string[]): LogRow[] {
 export function getRequestLogsByConversationId(
   conversationId: string,
 ): LogRow[] {
-  const db = getDb();
+  const db = logsDb();
   return db
     .select({
       id: llmRequestLogs.id,
@@ -346,9 +360,13 @@ function selectOrphanedLogsInRange(
   endTime: number,
 ): LogRow[] {
   if (endTime <= startTime) return [];
-  const db = getDb();
-  // LEFT JOIN messages → filter where message row IS NULL (orphaned).
-  return db
+  // `llm_request_logs` and `messages` live in separate connections now, so the
+  // old LEFT JOIN can't span them. Resolve it in three steps:
+  //   (a) logs conn → candidate rows in [start,end] for the conversation with a
+  //       non-NULL message_id;
+  //   (b) main conn → which of those message_ids still exist in `messages`;
+  //   (c) filter to candidates whose message_id is NOT in the existing set.
+  const candidates = logsDb()
     .select({
       id: llmRequestLogs.id,
       conversationId: llmRequestLogs.conversationId,
@@ -361,18 +379,32 @@ function selectOrphanedLogsInRange(
       callSite: llmRequestLogs.callSite,
     })
     .from(llmRequestLogs)
-    .leftJoin(messages, eq(llmRequestLogs.messageId, messages.id))
     .where(
       and(
         eq(llmRequestLogs.conversationId, conversationId),
         gte(llmRequestLogs.createdAt, startTime),
         lte(llmRequestLogs.createdAt, endTime),
-        sql`${messages.id} IS NULL`,
         sql`${llmRequestLogs.messageId} IS NOT NULL`,
       ),
     )
     .orderBy(llmRequestLogs.createdAt)
     .all();
+  if (candidates.length === 0) return [];
+
+  const candidateMessageIds = [
+    ...new Set(candidates.map((c) => c.messageId as string)),
+  ];
+  const existing = new Set(
+    getDb()
+      .select({ id: messages.id })
+      .from(messages)
+      .where(inArray(messages.id, candidateMessageIds))
+      .all()
+      .map((r) => r.id),
+  );
+
+  // Orphaned = the referenced message no longer exists.
+  return candidates.filter((c) => !existing.has(c.messageId as string));
 }
 
 /**
@@ -389,7 +421,7 @@ function selectUnlinkedLogsInRange(
   endTime: number,
 ): LogRow[] {
   if (endTime <= startTime) return [];
-  const db = getDb();
+  const db = logsDb();
   return db
     .select({
       id: llmRequestLogs.id,
@@ -432,7 +464,7 @@ export function getPreviousNonCompactionCallCreatedAt(
   conversationId: string,
   beforeCreatedAt: number,
 ): number | null {
-  const db = getDb();
+  const db = logsDb();
   const row = db
     .select({ createdAt: llmRequestLogs.createdAt })
     .from(llmRequestLogs)
@@ -480,7 +512,7 @@ export function getCompactionLogsBetween(
   afterCreatedAt: number | null,
   beforeCreatedAt: number,
 ): CompactionAgentLogRow[] {
-  const db = getDb();
+  const db = logsDb();
   const predicates = [
     eq(llmRequestLogs.conversationId, conversationId),
     eq(llmRequestLogs.callSite, "compactionAgent"),
@@ -524,7 +556,7 @@ export function getCompactionLogsBetween(
  * full context window.
  */
 export function getRequestLogMetaById(logId: string): LogMetaRow | null {
-  const db = getDb();
+  const db = logsDb();
   return (
     db
       .select({
@@ -543,7 +575,7 @@ export function getRequestLogMetaById(logId: string): LogMetaRow | null {
 }
 
 export function getRequestLogById(logId: string): LogRow | null {
-  const db = getDb();
+  const db = logsDb();
   return (
     db
       .select({
@@ -609,7 +641,7 @@ export function getRequestLogsByMessageId(messageId: string): LogRow[] {
         // authoritative caller (e.g. watch-notifier).
         if (unlinkedLogs.length > 0 && turnMessageIds.length > 0) {
           try {
-            const db = getDb();
+            const db = logsDb();
             const ids = unlinkedLogs.map((l) => l.id);
             const targetMessageId = turnMessageIds[turnMessageIds.length - 1]!;
             db.update(llmRequestLogs)

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

@@ -363,6 +363,14 @@ export interface UsageGroupBreakdown {
   totalCacheReadTokens: number;
   totalEstimatedCostUsd: number;
   eventCount: number;
+  /**
+   * Number of turns in the conversation — the count of eligible user messages
+   * (tool-result turns excluded). Only populated when `groupBy ===
+   * "conversation"` (and `null` for that mode's "Other" bucket, which has no
+   * parent conversation). `null` for every other grouping, where a turn count
+   * has no well-defined meaning.
+   */
+  turnCount: number | null;
 }
 
 // -- raw row shapes returned by SQLite aggregation queries --
@@ -388,6 +396,8 @@ interface GroupRow {
   total_cache_read_tokens: number;
   total_estimated_cost_usd: number | null;
   event_count: number;
+  /** Only selected by the conversation grouping query; absent otherwise. */
+  turn_count?: number | null;
 }
 
 type UsageQueryParam = ScheduleAttributionSqlParam;
@@ -515,7 +525,32 @@ export function getUsageTotals(
   };
 }
 
-/** Fetch raw events in a time range for in-memory bucketing. */
+/**
+ * Width of the SQL pre-aggregation bucket used by the time-series read paths,
+ * in milliseconds. The series/daily endpoints bucket events into local-day or
+ * local-hour buckets in JavaScript (SQLite's `strftime` is UTC-only and can't
+ * honor an IANA timezone). To avoid materializing one JS object per usage event
+ * — which on a 90-day window can mean hundreds of thousands of rows on the
+ * daemon's main thread — we first roll events up in SQL into fixed UTC buckets,
+ * then feed those far-fewer rows into the same JS bucketing logic.
+ *
+ * 15 minutes is the finest quantum every real-world IANA UTC offset divides
+ * into (whole-hour offsets, plus the :30 and :45 zones like Asia/Kolkata and
+ * Asia/Kathmandu). Because every local-day and local-hour boundary therefore
+ * lands on a 15-minute UTC boundary, no pre-aggregation bucket can straddle a
+ * local bucket boundary — so rolling up to 15-minute UTC buckets and then
+ * re-bucketing in local time is exactly equal to bucketing each raw event.
+ * DST fall-back hours stay distinct because their instants fall in different
+ * 15-minute UTC buckets (and the JS layer disambiguates them by UTC offset).
+ */
+const USAGE_PREAGG_BUCKET_MS = 15 * 60 * 1000;
+
+/**
+ * Fetch usage rows for a time range, pre-aggregated into {@link
+ * USAGE_PREAGG_BUCKET_MS} UTC buckets, for in-memory local-time bucketing. Each
+ * returned row's `created_at` is its UTC bucket start, which the JS bucketing
+ * maps to the same local bucket every raw event in that window would map to.
+ */
 function fetchRawBucketRows(
   range: UsageTimeRange,
   filter?: UsageAggregationFilter,
@@ -524,13 +559,14 @@ function fetchRawBucketRows(
   return rawAll<UsageEventBucketRow>(
     /*sql*/ `
     SELECT
-      created_at,
-      input_tokens,
-      output_tokens,
-      estimated_cost_usd,
-      llm_call_count
+      (created_at / ${USAGE_PREAGG_BUCKET_MS}) * ${USAGE_PREAGG_BUCKET_MS} AS created_at,
+      COALESCE(SUM(input_tokens), 0)                AS input_tokens,
+      COALESCE(SUM(output_tokens), 0)               AS output_tokens,
+      SUM(estimated_cost_usd)                       AS estimated_cost_usd,
+      SUM(COALESCE(llm_call_count, 1))              AS llm_call_count
     FROM llm_usage_events
     WHERE ${where.sql}
+    GROUP BY (created_at / ${USAGE_PREAGG_BUCKET_MS})
     ORDER BY created_at ASC
     `,
     ...where.params,
@@ -645,6 +681,9 @@ function mapGroupRow(
     totalCacheReadTokens: row.total_cache_read_tokens,
     totalEstimatedCostUsd: row.total_estimated_cost_usd ?? 0,
     eventCount: row.event_count,
+    // Turns are only meaningful per conversation; other dimensions select no
+    // turn_count column, so this collapses to null.
+    turnCount: groupBy === "conversation" ? (row.turn_count ?? null) : null,
   };
 }
 
@@ -678,7 +717,24 @@ export function getUsageGroupBreakdown(
         COALESCE(SUM(e.cache_creation_input_tokens), 0)  AS total_cache_creation_tokens,
         COALESCE(SUM(e.cache_read_input_tokens), 0)      AS total_cache_read_tokens,
         COALESCE(SUM(e.estimated_cost_usd), 0)           AS total_estimated_cost_usd,
-        COALESCE(SUM(COALESCE(e.llm_call_count, 1)), 0)  AS event_count
+        COALESCE(SUM(COALESCE(e.llm_call_count, 1)), 0)  AS event_count,
+        -- Number of turns in the conversation: the count of eligible user
+        -- messages (tool-result turns excluded, mirroring the turnIndex
+        -- definition). Evaluated once per conversation group via the
+        -- idx_messages_conversation_id index rather than once per usage event,
+        -- so it stays cheap as call volume grows. NULL for the "Other" (no
+        -- conversation) bucket. Note: derived from surviving messages, so a
+        -- turn removed via Undo (deleteLastExchange) stops being counted even
+        -- though its billed usage still shows up in Cost/Tokens.
+        CASE WHEN e.conversation_id IS NULL THEN NULL
+             ELSE (
+               SELECT COUNT(*) FROM messages AS m2
+               WHERE m2.conversation_id = e.conversation_id
+                 AND m2.role = 'user'
+                 AND m2.content NOT LIKE '%"type":"tool\\_result"%' ESCAPE '\\'
+                 AND m2.content NOT LIKE '%"type":"web\\_search\\_tool\\_result"%' ESCAPE '\\'
+             )
+        END                                              AS turn_count
       FROM llm_usage_events e
       LEFT JOIN conversations c ON e.conversation_id = c.id
       WHERE ${where.sql}
@@ -799,17 +855,18 @@ export function getUsageGroupedSeries(
         WHERE ${where.sql}
       )
       SELECT
-        schedule_usage.created_at,
-        schedule_usage.input_tokens,
-        schedule_usage.output_tokens,
-        schedule_usage.estimated_cost_usd,
-        schedule_usage.llm_call_count,
-        schedule_usage.group_key,
-        schedule_group_jobs.name AS group_label
+        (schedule_usage.created_at / ${USAGE_PREAGG_BUCKET_MS}) * ${USAGE_PREAGG_BUCKET_MS} AS created_at,
+        COALESCE(SUM(schedule_usage.input_tokens), 0)            AS input_tokens,
+        COALESCE(SUM(schedule_usage.output_tokens), 0)           AS output_tokens,
+        SUM(schedule_usage.estimated_cost_usd)                   AS estimated_cost_usd,
+        SUM(COALESCE(schedule_usage.llm_call_count, 1))          AS llm_call_count,
+        schedule_usage.group_key                                 AS group_key,
+        MAX(schedule_group_jobs.name)                            AS group_label
       FROM schedule_usage
       LEFT JOIN cron_jobs schedule_group_jobs
         ON schedule_group_jobs.id = schedule_usage.group_key
-      ORDER BY schedule_usage.created_at ASC
+      GROUP BY (schedule_usage.created_at / ${USAGE_PREAGG_BUCKET_MS}), schedule_usage.group_key
+      ORDER BY created_at ASC
       `,
       ...groupKeySubquery.params,
       ...where.params,
@@ -820,15 +877,16 @@ export function getUsageGroupedSeries(
     rows = rawAll<UsageGroupedBucketRow>(
       /*sql*/ `
       SELECT
-        e.created_at,
-        e.input_tokens,
-        e.output_tokens,
-        e.estimated_cost_usd,
-        e.llm_call_count,
+        (e.created_at / ${USAGE_PREAGG_BUCKET_MS}) * ${USAGE_PREAGG_BUCKET_MS} AS created_at,
+        COALESCE(SUM(e.input_tokens), 0)             AS input_tokens,
+        COALESCE(SUM(e.output_tokens), 0)            AS output_tokens,
+        SUM(e.estimated_cost_usd)                    AS estimated_cost_usd,
+        SUM(COALESCE(e.llm_call_count, 1))           AS llm_call_count,
         e.${column} AS group_key
       FROM llm_usage_events e
       WHERE ${where.sql}
-      ORDER BY e.created_at ASC
+      GROUP BY (e.created_at / ${USAGE_PREAGG_BUCKET_MS}), e.${column}
+      ORDER BY created_at ASC
       `,
       ...where.params,
     );

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

@@ -60,12 +60,11 @@ import {
   type ConversationRow,
   deleteConversation,
   findMostRecentRetrospectiveFor,
-  forkConversation,
+  forkConversationForRetrospective,
   getConversation,
   getMessagesAfter,
   resolveOverrideProfile,
 } from "./conversation-crud.js";
-import { isBackgroundConversationType } from "./conversation-types.js";
 import {
   enqueueMemoryJob,
   type MemoryJob,
@@ -131,7 +130,7 @@ export async function memoryRetrospectiveJob(
 // the source's turns.
 // ---------------------------------------------------------------------------
 
-async function runForkBasedRetrospective(
+export async function runForkBasedRetrospective(
   sourceConversationId: string,
   config: AssistantConfig,
 ): Promise<MemoryRetrospectiveOutcome> {
@@ -216,9 +215,14 @@ async function runForkBasedRetrospective(
   // `contextCompactedMessageCount` / `contextCompactedAt` when the fork
   // point sits within the visible window. Compacted source ⇒ compacted
   // fork ⇒ summary + tail visible to the agent natively.
-  let forkConversationRow: ReturnType<typeof forkConversation>;
+  let forkConversationRow: Awaited<
+    ReturnType<typeof forkConversationForRetrospective>
+  >;
   try {
-    forkConversationRow = forkConversation({
+    // Async variant: the source message-row copy runs off the event loop in a
+    // sqlite3 subprocess so this background pass cannot freeze the daemon's
+    // event loop (health probes / gateway IPC) on a large database.
+    forkConversationRow = await forkConversationForRetrospective({
       conversationId: sourceConversationId,
       throughMessageId: cutoffMessageId,
       source: MEMORY_RETROSPECTIVE_FORK_SOURCE,
@@ -230,7 +234,7 @@ async function runForkBasedRetrospective(
     bumpRetrospectiveLastRunAt(sourceConversationId, Date.now());
     log.error(
       { err, sourceConversationId },
-      "memory-retrospective (fork): forkConversation failed",
+      "memory-retrospective (fork): forkConversationForRetrospective failed",
     );
     throw err;
   }
@@ -314,14 +318,13 @@ async function runForkBasedRetrospective(
       // {@link WakeToolContextPin}.
       toolGateMode: "execution" as const,
       toolContextPin,
-      // Reproduce the source's turn block for message-tier cache-prefix
-      // parity: background/scheduled sources ran non-interactive live turns
-      // (which carry `<background_turn>`), so the fork must run non-interactive
-      // too. Standard/user sources ran interactive (no `<background_turn>`), so
-      // the fork stays interactive — preserving their existing byte parity.
-      isNonInteractive: isBackgroundConversationType(
-        sourceConversation.conversationType,
-      ),
+      // Message-tier cache-prefix parity — reproducing the source's
+      // `<background_turn>` / `<channel_capabilities>` / `<non_interactive_context>`
+      // blocks — is handled by metadata rehydration, not by re-running runtime
+      // injection on the fork: the source's live turns persist those blocks onto
+      // message metadata, the fork copies that metadata, and
+      // `Conversation.loadFromDb` rehydrates them byte-for-byte. The wake never
+      // re-runs the injection pipeline, so it needs no interactivity hint here.
       // Profile forcing (model/thinking/effort parity) is a separate concern
       // and stays keyed on `matchConversationProfile` via `matchedProfile`.
       ...(matchedProfile !== undefined
@@ -777,9 +780,14 @@ function extractRememberContents(messages: MessageLike[]): string[] {
       const input = b.input;
       if (!input || typeof input !== "object") continue;
       const content = (input as Record<string, unknown>).content;
-      if (typeof content !== "string") continue;
-      const trimmed = content.trim();
-      if (trimmed.length > 0) contents.push(trimmed);
+      // `remember` accepts a single string or an array of facts (batch form);
+      // flatten both so batched saves still feed the dedup baseline.
+      const facts = Array.isArray(content) ? content : [content];
+      for (const fact of facts) {
+        if (typeof fact !== "string") continue;
+        const trimmed = fact.trim();
+        if (trimmed.length > 0) contents.push(trimmed);
+      }
     }
   }
   return contents;
@@ -849,7 +857,7 @@ function buildForkInstruction({
     ? "Your review window is the full conversation above, ending just before this instruction message."
     : `Your review window starts at ${anchorDescription} and ends just before this instruction message. If you cannot locate that anchoring turn in your visible history (for example, it is behind the compaction summary), fail closed: review only the most recent visible messages after the summary, not the whole conversation.`;
 
-  return `This is an automated background memory pass over the conversation above — not a message from the user. Do not reply conversationally or in persona; just perform the review described here. Only the \`remember\` tool is available for this pass — any other tool call will be rejected, so don't attempt one.
+  return `This is an automated background memory pass over the conversation above — not a message from the user. Do not reply conversationally; just perform the review described here. Only the \`remember\` tool is available for this pass — any other tool call will be rejected, so don't attempt one.
 
 ${windowAnchor}
 
@@ -865,6 +873,6 @@ Two dedup sources to skip:
 1. Anything semantically captured in <already_remembered> above (from prior retrospective passes).
 2. Anything you already called \`remember\` on inline within your review window — those appear as \`tool_use\` blocks with \`name: "remember"\` in your history.
 
-For everything else in your review window, use the \`remember\` tool on facts, plans, decisions, preferences, names, dates, felt moments, corrections, commitments, or anything else concrete and worth carrying forward. One \`remember\` call per fact. If nothing new is worth saving, say "Nothing new to save." and stop.
+For everything else in your review window, use the \`remember\` tool on facts, plans, decisions, preferences, names, dates, felt moments, corrections, commitments, or anything else concrete and worth carrying forward. When several facts are worth saving, pass them all as an array to a single \`remember\` call rather than calling it once per fact. If nothing new is worth saving, say "Nothing new to save." and stop.
 `;
 }

package/src/memory/memory-retrospective-startup-cleanup.ts

@@ -54,7 +54,7 @@ import {
 import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
 import { deleteConversation } from "./conversation-crud.js";
-import { getDb } from "./db-connection.js";
+import { getDb, getMemoryDb } from "./db-connection.js";
 import { MEMORY_RETROSPECTIVE_SOURCES } from "./memory-retrospective-constants.js";
 import { loadRetrospectiveRunMessages } from "./memory-retrospective-fork-boundary.js";
 import { conversations, memoryJobs } from "./schema.js";
@@ -98,6 +98,14 @@ export function sweepOrphanMemoryRetrospectiveConversations(
   const cutoff = now - ORPHAN_AGE_MS;
   const db = getDb();
 
+  // `memory_jobs` lives on the dedicated memory connection. If it is unavailable
+  // we cannot tell which sources have in-flight retrospective jobs, so skip the
+  // sweep rather than risk deleting a conversation whose job is still running.
+  const memoryDb = getMemoryDb();
+  if (!memoryDb) {
+    return { swept: 0 };
+  }
+
   // Job payloads encode the SOURCE conversation id (the conversation being
   // analyzed), not the background-conversation id of the retrospective itself.
   // The background conversation links back to its source via
@@ -105,7 +113,7 @@ export function sweepOrphanMemoryRetrospectiveConversations(
   // memory-retrospective-job.ts). To protect in-flight jobs we therefore
   // compare source-id to source-id by filtering on
   // `conversations.forkParentConversationId`, not `conversations.id`.
-  const activeJobSourceConversationIds = db
+  const activeJobSourceConversationIds = memoryDb
     .select({
       conversationId: sql<string>`json_extract(${memoryJobs.payload}, '$.conversationId')`,
     })

package/src/memory/migrations/{100-core-tables.ts → 000-core-tables.ts}

@@ -3,12 +3,16 @@ import type { DrizzleDb } from "../db-connection.js";
 /**
  * Core tables: conversations, messages, tool_invocations, memory_segments,
  * memory_items, memory_item_sources, memory_item_conflicts, memory_summaries,
- * memory_embeddings, memory_jobs, memory_checkpoints, attachments,
+ * memory_embeddings, memory_jobs, attachments,
  * message_attachments, message_surfaces, channel_inbound_events,
  * message_runs, cron_jobs, cron_runs, documents,
  * published_pages, shared_app_links, home_base_app_links.
+ *
+ * The migration bookkeeping table `memory_checkpoints` is created by the
+ * migration runner (`runMigrationSteps`) before any step runs, so it is not
+ * created here.
  */
-export function createCoreTables(database: DrizzleDb): void {
+export function migrateCoreTables(database: DrizzleDb): void {
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS conversations (
       id TEXT PRIMARY KEY,
@@ -150,14 +154,6 @@ export function createCoreTables(database: DrizzleDb): void {
     )
   `);
 
-  database.run(/*sql*/ `
-    CREATE TABLE IF NOT EXISTS memory_checkpoints (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL,
-      updated_at INTEGER NOT NULL
-    )
-  `);
-
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS attachments (
       id TEXT PRIMARY KEY,

package/src/memory/migrations/014-backfill-inbox-thread-state.ts

@@ -1,4 +1,5 @@
 import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
 
 /**
  * One-shot migration: seed assistant_inbox_thread_state from existing
@@ -39,12 +40,22 @@ export function migrateBackfillInboxThreadStateFromBindings(
     return;
   }
 
+  // The assistant_id column was dropped from assistant_inbox_thread_state by a
+  // later migration (drop-assistant-id-columns). When the backfill checkpoint
+  // hasn't been written yet but that drop has already run, the table no longer
+  // carries assistant_id, so only reference the column when it still exists.
+  const hasAssistantId = tableHasColumn(
+    database,
+    "assistant_inbox_thread_state",
+    "assistant_id",
+  );
+
   try {
     raw.exec("BEGIN");
 
     raw.exec(/*sql*/ `
       INSERT OR IGNORE INTO assistant_inbox_thread_state (
-        conversation_id, assistant_id, source_channel, external_chat_id,
+        conversation_id, ${hasAssistantId ? "assistant_id, " : ""}source_channel, external_chat_id,
         external_user_id, display_name, username,
         last_inbound_at, last_outbound_at, last_message_at,
         unread_count, pending_escalation_count, has_pending_escalation,
@@ -52,8 +63,7 @@ export function migrateBackfillInboxThreadStateFromBindings(
       )
       SELECT
         conversation_id,
-        'self',
-        source_channel,
+        ${hasAssistantId ? "'self',\n        " : ""}source_channel,
         external_chat_id,
         external_user_id,
         display_name,

package/src/memory/migrations/104-core-indexes.ts

@@ -95,7 +95,7 @@ export function createCoreIndexes(database: DrizzleDb): void {
     /*sql*/ `DROP INDEX IF EXISTS idx_memory_embeddings_provider_model`,
   );
   // Ensure a unique constraint exists on (target_type, target_id, provider, model).
-  // New databases get this via the table-level UNIQUE in 100-core-tables.ts (autoindex),
+  // New databases get this via the table-level UNIQUE in 000-core-tables.ts (autoindex),
   // but for pre-100 databases where CREATE TABLE IF NOT EXISTS was a no-op, the autoindex
   // doesn't exist. Always create the named index — it's a no-op if it already exists and
   // harmless if an autoindex also covers these columns.