@vellumai/assistant 0.6.0 → 0.6.2

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

@@ -91,10 +91,7 @@ export function backfillMessageIdOnLogs(
  * for a conversation), this targets only the given log rows — safe for
  * concurrent watch/assistant turns.
  */
-export function setMessageIdOnLogs(
-  logIds: string[],
-  messageId: string,
-): void {
+export function setMessageIdOnLogs(logIds: string[], messageId: string): void {
   if (logIds.length === 0) return;
   const db = getDb();
   db.update(llmRequestLogs)
@@ -185,18 +182,75 @@ function selectOrphanedLogsInRange(
     .all();
 }
 
+/**
+ * Find unlinked logs — logs with `message_id IS NULL` that haven't been
+ * backfilled yet. This covers the race where the client queries the inspector
+ * before `backfillMessageIdOnLogs` runs in `handleMessageComplete`, or when
+ * the backfill fails silently (try-catch in the agent loop).
+ *
+ * Scoped to a single conversation and a time range to avoid cross-turn bleed.
+ */
+function selectUnlinkedLogsInRange(
+  conversationId: string,
+  startTime: number,
+  endTime: number,
+): LogRow[] {
+  if (endTime <= startTime) return [];
+  const db = getDb();
+  return db
+    .select({
+      id: llmRequestLogs.id,
+      conversationId: llmRequestLogs.conversationId,
+      messageId: llmRequestLogs.messageId,
+      provider: llmRequestLogs.provider,
+      requestPayload: llmRequestLogs.requestPayload,
+      responsePayload: llmRequestLogs.responsePayload,
+      createdAt: llmRequestLogs.createdAt,
+    })
+    .from(llmRequestLogs)
+    .where(
+      and(
+        eq(llmRequestLogs.conversationId, conversationId),
+        gte(llmRequestLogs.createdAt, startTime),
+        lte(llmRequestLogs.createdAt, endTime),
+        isNull(llmRequestLogs.messageId),
+      ),
+    )
+    .orderBy(llmRequestLogs.createdAt)
+    .all();
+}
+
+export function getRequestLogById(logId: string): LogRow | null {
+  const db = getDb();
+  return (
+    db
+      .select({
+        id: llmRequestLogs.id,
+        conversationId: llmRequestLogs.conversationId,
+        messageId: llmRequestLogs.messageId,
+        provider: llmRequestLogs.provider,
+        requestPayload: llmRequestLogs.requestPayload,
+        responsePayload: llmRequestLogs.responsePayload,
+        createdAt: llmRequestLogs.createdAt,
+      })
+      .from(llmRequestLogs)
+      .where(eq(llmRequestLogs.id, logId))
+      .get() ?? null
+  );
+}
+
 export function getRequestLogsByMessageId(messageId: string): LogRow[] {
   // Resolve all assistant message IDs in the same turn so the inspector
   // shows every LLM call from the entire agent turn, not just the queried message.
   const turnMessageIds = getAssistantMessageIdsInTurn(messageId);
   const turnLogs = selectLogsByMessageIds(turnMessageIds);
 
-  // Orphaned-log recovery: intermediate assistant messages within a turn can
-  // be deleted (e.g. by retry / deleteLastExchange) while their
-  // llm_request_logs rows survive. When that happens the message-ID-based
-  // query misses those logs. We detect orphaned logs (logs whose message_id
-  // references a deleted message) within the turn's time window and merge
-  // them with the message-ID-based results.
+  // Recovery: find logs in the turn's time window that the message-ID-based
+  // query missed. Two categories:
+  //  1. Orphaned — messageId references a deleted message (retry/deleteLastExchange).
+  //  2. Unlinked — messageId is still NULL because the backfill hasn't run yet
+  //     or failed silently. This covers the race where the client queries the
+  //     inspector before handleMessageComplete persists and backfills.
   const message = getMessageById(messageId);
   if (message) {
     const bounds = getTurnTimeBounds(message.conversationId, message.createdAt);
@@ -206,10 +260,16 @@ export function getRequestLogsByMessageId(messageId: string): LogRow[] {
         bounds.startTime,
         bounds.endTime,
       );
-      if (orphanedLogs.length > 0) {
+      const unlinkedLogs = selectUnlinkedLogsInRange(
+        message.conversationId,
+        bounds.startTime,
+        bounds.endTime,
+      );
+
+      if (orphanedLogs.length > 0 || unlinkedLogs.length > 0) {
         const seen = new Set(turnLogs.map((l) => l.id));
         const merged = [...turnLogs];
-        for (const log of orphanedLogs) {
+        for (const log of [...orphanedLogs, ...unlinkedLogs]) {
           if (!seen.has(log.id)) {
             merged.push(log);
             seen.add(log.id);
@@ -218,6 +278,30 @@ export function getRequestLogsByMessageId(messageId: string): LogRow[] {
         merged.sort(
           (a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id),
         );
+
+        // Opportunistically backfill recovered unlinked logs so future queries
+        // hit the fast indexed-by-messageId path.  Guard with isNull so this
+        // recovery path never overwrites a messageId already set by an
+        // authoritative caller (e.g. watch-notifier).
+        if (unlinkedLogs.length > 0 && turnMessageIds.length > 0) {
+          try {
+            const db = getDb();
+            const ids = unlinkedLogs.map((l) => l.id);
+            const targetMessageId = turnMessageIds[turnMessageIds.length - 1]!;
+            db.update(llmRequestLogs)
+              .set({ messageId: targetMessageId })
+              .where(
+                and(
+                  inArray(llmRequestLogs.id, ids),
+                  isNull(llmRequestLogs.messageId),
+                ),
+              )
+              .run();
+          } catch {
+            // non-fatal — the recovery already returned the right data
+          }
+        }
+
         return merged;
       }
     }

package/src/memory/memory-recall-log-store.ts

@@ -23,9 +23,12 @@ export interface RecordMemoryRecallLogParams {
   topCandidatesJson: unknown;
   injectedText?: string;
   reason?: string;
+  queryContext?: string;
 }
 
-export function recordMemoryRecallLog(params: RecordMemoryRecallLogParams): void {
+export function recordMemoryRecallLog(
+  params: RecordMemoryRecallLogParams,
+): void {
   const db = getDb();
   db.insert(memoryRecallLogs)
     .values({
@@ -51,6 +54,7 @@ export function recordMemoryRecallLog(params: RecordMemoryRecallLogParams): void
       topCandidatesJson: JSON.stringify(params.topCandidatesJson),
       injectedText: params.injectedText ?? null,
       reason: params.reason ?? null,
+      queryContext: params.queryContext ?? null,
       createdAt: Date.now(),
     })
     .run();
@@ -90,6 +94,47 @@ export interface MemoryRecallLog {
   topCandidates: unknown;
   injectedText: string | null;
   reason: string | null;
+  queryContext: string | null;
+}
+
+/**
+ * Normalizes top-candidate entries from the stored SSE-event format
+ * (key/finalScore/semantic/recency/kind) to the inspector format expected
+ * by the Swift MemoryRecallCandidate struct (nodeId/score/semanticSimilarity/recencyBoost).
+ * Entries already in inspector format pass through unchanged.
+ */
+export function normalizeTopCandidates(raw: unknown): unknown {
+  if (!Array.isArray(raw)) return raw;
+  return raw.flatMap((entry: Record<string, unknown>) => {
+    if (!entry || typeof entry !== "object") return [];
+
+    // Start with a shallow copy, then apply field renames
+    const { key, finalScore, semantic, recency, kind: _kind, ...rest } = entry;
+
+    // nodeId: prefer existing nodeId, fall back to key
+    if (rest.nodeId === undefined && key !== undefined) {
+      rest.nodeId = key;
+    }
+
+    // score: prefer existing score, fall back to finalScore
+    if (rest.score === undefined && finalScore !== undefined) {
+      rest.score = finalScore;
+    }
+
+    // semanticSimilarity: prefer existing, fall back to semantic
+    if (rest.semanticSimilarity === undefined && semantic !== undefined) {
+      rest.semanticSimilarity = semantic;
+    }
+
+    // recencyBoost: prefer existing, fall back to recency
+    if (rest.recencyBoost === undefined && recency !== undefined) {
+      rest.recencyBoost = recency;
+    }
+
+    // kind is stripped (not in the Swift model) — already excluded via destructuring
+
+    return rest;
+  });
 }
 
 export function getMemoryRecallLogByMessageIds(
@@ -109,9 +154,7 @@ export function getMemoryRecallLogByMessageIds(
     degraded: !!row.degraded,
     provider: row.provider,
     model: row.model,
-    degradation: row.degradationJson
-      ? JSON.parse(row.degradationJson)
-      : null,
+    degradation: row.degradationJson ? JSON.parse(row.degradationJson) : null,
     semanticHits: row.semanticHits,
     mergedCount: row.mergedCount,
     selectedCount: row.selectedCount,
@@ -121,8 +164,9 @@ export function getMemoryRecallLogByMessageIds(
     sparseVectorUsed: !!row.sparseVectorUsed,
     injectedTokens: row.injectedTokens,
     latencyMs: row.latencyMs,
-    topCandidates: JSON.parse(row.topCandidatesJson),
+    topCandidates: normalizeTopCandidates(JSON.parse(row.topCandidatesJson)),
     injectedText: row.injectedText,
     reason: row.reason,
+    queryContext: row.queryContext,
   };
 }

package/src/memory/migrations/203-drop-memory-items-tables.ts

@@ -6,13 +6,45 @@ import { getSqliteFrom } from "../db-connection.js";
  *
  * All consumers have been migrated to memory_graph_nodes (#22698).
  * These tables are now dead weight.
+ *
+ * Safety: only drops tables when they are empty or the tool-created-items
+ * migration has already copied relevant rows into memory_graph_nodes.
+ * Workspaces that haven't run migrateToolCreatedItems() yet keep the tables
+ * so data isn't silently lost.
  */
 export function migrateDropMemoryItemsTables(database: DrizzleDb): void {
   const raw = getSqliteFrom(database);
 
+  // Guard: verify tables are safe to drop (empty or already migrated).
+  try {
+    const row = raw
+      .prepare(
+        /*sql*/ `SELECT COUNT(*) as cnt FROM memory_items WHERE status = 'active'`,
+      )
+      .get() as { cnt: number } | undefined;
+
+    if (row && row.cnt > 0) {
+      // Tables have active rows — only drop if the migration checkpoint exists.
+      const checkpoint = raw
+        .prepare(
+          /*sql*/ `SELECT value FROM memory_checkpoints WHERE key = ?`,
+        )
+        .get("graph_bootstrap:migrated_tool_items") as
+        | { value: string }
+        | undefined;
+
+      if (!checkpoint?.value) {
+        // Data exists but hasn't been migrated — skip the drop to prevent data loss.
+        return;
+      }
+    }
+  } catch {
+    // Table doesn't exist (fresh install) — proceed with drop (IF EXISTS is a no-op).
+  }
+
   // Drop indexes first (idempotent — IF EXISTS).
   raw.exec(
-    /*sql*/ `DROP INDEX IF EXISTS idx_memory_item_sources_memory_item_id`
+    /*sql*/ `DROP INDEX IF EXISTS idx_memory_item_sources_memory_item_id`,
   );
   raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_memory_items_scope_id`);
   raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_memory_items_fingerprint`);

package/src/memory/migrations/206-memory-graph-node-edits.ts

@@ -0,0 +1,19 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateCreateMemoryGraphNodeEdits(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(`
+    CREATE TABLE IF NOT EXISTS memory_graph_node_edits (
+      id                TEXT PRIMARY KEY,
+      node_id           TEXT NOT NULL REFERENCES memory_graph_nodes(id) ON DELETE CASCADE,
+      previous_content  TEXT NOT NULL,
+      new_content       TEXT NOT NULL,
+      source            TEXT NOT NULL,
+      conversation_id   TEXT,
+      created           INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_graph_node_edits_node_id ON memory_graph_node_edits(node_id);
+    CREATE INDEX IF NOT EXISTS idx_graph_node_edits_created ON memory_graph_node_edits(created);
+  `);
+}

package/src/memory/migrations/206-scrub-corrupted-image-attachments.ts

@@ -0,0 +1,131 @@
+import { readFileSync, unlinkSync } from "node:fs";
+
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Remove image attachments that contain HTML error pages instead of actual
+ * image data. This can happen when a CDN (e.g. Slack) returns an HTML sign-in
+ * page due to a missing OAuth scope, and the gateway stores the response body
+ * as an image attachment.
+ *
+ * Handles both inline (data_base64) and on-disk (file_path) storage.
+ */
+
+const HTML_MARKERS = ["<!doctype", "<html"];
+
+function looksLikeHtml(bytes: Buffer): boolean {
+  // Strip leading BOM / whitespace
+  const text = bytes.toString("utf-8").trimStart().toLowerCase();
+  return HTML_MARKERS.some((marker) => text.startsWith(marker));
+}
+
+export function migrateScrubCorruptedImageAttachments(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(
+    database,
+    "migration_scrub_corrupted_image_attachments_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+
+      function deleteCorruptedAttachment(
+        id: string,
+        filePath: string | null,
+      ): void {
+        raw
+          .query(`DELETE FROM message_attachments WHERE attachment_id = ?`)
+          .run(id);
+        raw.query(`DELETE FROM attachments WHERE id = ?`).run(id);
+
+        if (filePath) {
+          try {
+            unlinkSync(filePath);
+          } catch {
+            // File already missing — ignore
+          }
+        }
+
+        console.log(
+          `[scrub-corrupted-attachments] Removed corrupted attachment ${id}`,
+        );
+      }
+
+      // Step A — Find and remove corrupted attachments stored inline (data_base64)
+      // Process in batches using rowid cursor to ensure all rows are scanned
+      // even when corrupted rows are non-contiguous.
+      const BATCH_SIZE = 100;
+      let lastRowid = 0;
+      for (;;) {
+        const rows = raw
+          .query(
+            `SELECT rowid, id, data_base64, file_path FROM attachments
+             WHERE mime_type LIKE 'image/%'
+               AND data_base64 IS NOT NULL
+               AND data_base64 != ''
+               AND rowid > ?
+             ORDER BY rowid
+             LIMIT ?`,
+          )
+          .all(lastRowid, BATCH_SIZE) as Array<{
+          rowid: number;
+          id: string;
+          data_base64: string;
+          file_path: string | null;
+        }>;
+
+        if (rows.length === 0) break;
+
+        for (const row of rows) {
+          lastRowid = row.rowid;
+          try {
+            const decoded = Buffer.from(
+              row.data_base64.slice(0, 200),
+              "base64",
+            );
+            if (looksLikeHtml(decoded)) {
+              deleteCorruptedAttachment(row.id, row.file_path);
+            }
+          } catch {
+            // Skip rows with invalid base64
+          }
+        }
+      }
+
+      // Step B — Find and remove corrupted attachments stored on disk (file_path)
+      // Disk-backed attachments are typically fewer; query all at once.
+      const diskRows = raw
+        .query(
+          `SELECT id, file_path FROM attachments
+           WHERE mime_type LIKE 'image/%'
+             AND file_path IS NOT NULL
+             AND (data_base64 IS NULL OR data_base64 = '')`,
+        )
+        .all() as Array<{ id: string; file_path: string }>;
+
+      for (const row of diskRows) {
+        try {
+          const bytes = readFileSync(row.file_path);
+          const head = bytes.subarray(0, 100);
+          if (looksLikeHtml(head)) {
+            deleteCorruptedAttachment(row.id, row.file_path);
+          }
+        } catch {
+          // File doesn't exist or can't be read — skip
+        }
+      }
+    },
+  );
+}
+
+/**
+ * Reverse: no-op.
+ *
+ * Corrupted data (HTML stored as image) has no value to restore.
+ */
+export function migrateScrubCorruptedImageAttachmentsDown(
+  _database: DrizzleDb,
+): void {
+  // No-op — corrupted data (HTML stored as image) has no value to restore.
+}

package/src/memory/migrations/207-conversation-graph-memory-state.ts

@@ -0,0 +1,20 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Persist ConversationGraphMemory + InContextTracker state across eviction.
+ * Idempotent — uses CREATE TABLE IF NOT EXISTS.
+ */
+export function migrateCreateConversationGraphMemoryState(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(`
+    CREATE TABLE IF NOT EXISTS conversation_graph_memory_state (
+      conversation_id TEXT PRIMARY KEY REFERENCES conversations(id) ON DELETE CASCADE,
+      state_json TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+}

package/src/memory/migrations/208-conversations-last-message-at.ts

@@ -0,0 +1,35 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Add last_message_at denormalized column to conversations for sorting by
+ * latest message timestamp instead of updatedAt (which is bumped by non-message
+ * events like title changes and context compaction).
+ *
+ * Idempotent — uses ALTER TABLE try/catch and IF NOT EXISTS guards.
+ */
+export function migrateConversationsLastMessageAt(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  try {
+    raw.exec(`ALTER TABLE conversations ADD COLUMN last_message_at INTEGER`);
+  } catch {
+    // Column already exists
+  }
+
+  // Backfill from the latest message in each conversation.
+  // Idempotent: re-running produces the same result.
+  raw.exec(`
+    UPDATE conversations
+    SET last_message_at = (
+      SELECT MAX(created_at) FROM messages
+      WHERE messages.conversation_id = conversations.id
+    )
+    WHERE last_message_at IS NULL
+  `);
+
+  raw.exec(`
+    CREATE INDEX IF NOT EXISTS idx_conversations_last_message_at
+    ON conversations(last_message_at)
+  `);
+}

package/src/memory/migrations/209-strip-thinking-from-consolidated.ts

@@ -0,0 +1,85 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Strip thinking and redacted_thinking blocks from all assistant messages.
+ *
+ * Consolidated messages merge thinking blocks from different API responses,
+ * making their cryptographic signatures invalid. Previously the Anthropic
+ * provider stripped these on every request, mutating the conversation prefix
+ * and defeating prompt caching. This migration cleans them at rest so the
+ * provider no longer needs to strip, enabling append-only conversation
+ * history and stable prefix caching.
+ *
+ * Idempotent — safe to re-run.
+ */
+export function migrateStripThinkingFromConsolidated(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(
+    database,
+    "migration_strip_thinking_from_consolidated_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+
+      const BATCH_SIZE = 100;
+      let lastRowid = 0;
+
+      for (;;) {
+        const rows = raw
+          .query(
+            `SELECT rowid, id, content FROM messages
+             WHERE role = 'assistant'
+               AND rowid > ?
+             ORDER BY rowid
+             LIMIT ?`,
+          )
+          .all(lastRowid, BATCH_SIZE) as Array<{
+          rowid: number;
+          id: string;
+          content: string;
+        }>;
+
+        if (rows.length === 0) break;
+
+        for (const row of rows) {
+          lastRowid = row.rowid;
+
+          let blocks: Array<{ type: string }>;
+          try {
+            const parsed = JSON.parse(row.content);
+            if (!Array.isArray(parsed)) continue;
+            blocks = parsed;
+          } catch {
+            continue;
+          }
+
+          const hasThinking = blocks.some(
+            (b) => b.type === "thinking" || b.type === "redacted_thinking",
+          );
+          if (!hasThinking) continue;
+
+          const stripped = blocks.filter(
+            (b) => b.type !== "thinking" && b.type !== "redacted_thinking",
+          );
+
+          // Preserve at least one block so the message isn't empty.
+          const finalContent =
+            stripped.length > 0
+              ? stripped
+              : [
+                  {
+                    type: "text" as const,
+                    text: "\x00__PLACEHOLDER__[internal blocks omitted]",
+                  },
+                ];
+
+          raw
+            .query(`UPDATE messages SET content = ? WHERE id = ?`)
+            .run(JSON.stringify(finalContent), row.id);
+        }
+      }
+    },
+  );
+}

package/src/memory/migrations/210-schedule-reuse-conversation.ts

@@ -0,0 +1,13 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateScheduleReuseConversation(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(
+      `ALTER TABLE cron_jobs ADD COLUMN reuse_conversation INTEGER NOT NULL DEFAULT 0`,
+    );
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

package/src/memory/migrations/211-memory-recall-logs-query-context.ts

@@ -0,0 +1,21 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_memory_recall_logs_query_context_v1";
+
+/**
+ * Add query_context column to memory_recall_logs to persist the query text
+ * that drove semantic search, enabling the inspector to show what was searched.
+ */
+export function migrateMemoryRecallLogsQueryContext(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (!tableHasColumn(database, "memory_recall_logs", "query_context")) {
+      const raw = getSqliteFrom(database);
+      raw.exec(
+        `ALTER TABLE memory_recall_logs ADD COLUMN query_context TEXT`,
+      );
+    }
+  });
+}

package/src/memory/migrations/212-llm-request-logs-created-at-index.ts

@@ -0,0 +1,19 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_llm_request_logs_created_at_index_v1";
+
+/**
+ * Add an index on `llm_request_logs.created_at` so time-range deletes
+ * (used by the log-pruning GC job) can scan efficiently without a full
+ * table scan.
+ */
+export function migrateLlmRequestLogsCreatedAtIndex(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+    raw.exec(
+      `CREATE INDEX IF NOT EXISTS idx_llm_request_logs_created_at ON llm_request_logs(created_at)`,
+    );
+  });
+}

package/src/memory/migrations/index.ts

@@ -146,6 +146,14 @@ export { migrateCreateMemoryGraphTables } from "./202-memory-graph-tables.js";
 export { migrateDropMemoryItemsTables } from "./203-drop-memory-items-tables.js";
 export { migrateRenameMemoryGraphTypeValues } from "./204-rename-memory-graph-type-values.js";
 export { migrateMemoryGraphImageRefs } from "./205-memory-graph-image-refs.js";
+export { migrateCreateMemoryGraphNodeEdits } from "./206-memory-graph-node-edits.js";
+export { migrateScrubCorruptedImageAttachments } from "./206-scrub-corrupted-image-attachments.js";
+export { migrateCreateConversationGraphMemoryState } from "./207-conversation-graph-memory-state.js";
+export { migrateConversationsLastMessageAt } from "./208-conversations-last-message-at.js";
+export { migrateStripThinkingFromConsolidated } from "./209-strip-thinking-from-consolidated.js";
+export { migrateScheduleReuseConversation } from "./210-schedule-reuse-conversation.js";
+export { migrateMemoryRecallLogsQueryContext } from "./211-memory-recall-logs-query-context.js";
+export { migrateLlmRequestLogsCreatedAtIndex } from "./212-llm-request-logs-created-at-index.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -40,6 +40,7 @@ import { migrateBackfillAudioAttachmentMimeTypesDown } from "./191-backfill-audi
 import { migrateAddSourceTypeColumnsDown } from "./193-add-source-type-columns.js";
 import { migrateStripIntegrationPrefixFromProviderKeysDown } from "./196-strip-integration-prefix-from-provider-keys.js";
 import { migrateRenameMemoryGraphTypeValuesDown } from "./204-rename-memory-graph-type-values.js";
+import { migrateScrubCorruptedImageAttachmentsDown } from "./206-scrub-corrupted-image-attachments.js";
 
 export interface MigrationRegistryEntry {
   /** The checkpoint key written to memory_checkpoints on completion. */
@@ -349,6 +350,13 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
       "Rename legacy memory graph node type values: style → behavioral, relationship → semantic",
     down: migrateRenameMemoryGraphTypeValuesDown,
   },
+  {
+    key: "migration_scrub_corrupted_image_attachments_v1",
+    version: 40,
+    description:
+      "Remove image attachments containing HTML error pages instead of image data",
+    down: migrateScrubCorruptedImageAttachmentsDown,
+  },
 ];
 
 export function getMaxMigrationVersion(): number {