@vellumai/assistant 0.5.16 → 0.6.1

package/src/memory/migrations/202-memory-graph-tables.ts

@@ -0,0 +1,130 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Create the memory graph tables: nodes, edges, and triggers.
+ *
+ * Uses CREATE TABLE IF NOT EXISTS so this is inherently idempotent
+ * and does not need a registry entry.
+ */
+export function migrateCreateMemoryGraphTables(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  // -- Nodes --
+  raw.exec(`
+    CREATE TABLE IF NOT EXISTS memory_graph_nodes (
+      id                    TEXT PRIMARY KEY,
+      content               TEXT NOT NULL,
+      type                  TEXT NOT NULL,
+      created               INTEGER NOT NULL,
+      last_accessed         INTEGER NOT NULL,
+      last_consolidated     INTEGER NOT NULL,
+      emotional_charge      TEXT NOT NULL,
+      fidelity              TEXT NOT NULL DEFAULT 'vivid',
+      confidence            REAL NOT NULL,
+      significance          REAL NOT NULL,
+      stability             REAL NOT NULL DEFAULT 14,
+      reinforcement_count   INTEGER NOT NULL DEFAULT 0,
+      last_reinforced       INTEGER NOT NULL,
+      source_conversations  TEXT NOT NULL DEFAULT '[]',
+      source_type           TEXT NOT NULL DEFAULT 'inferred',
+      narrative_role        TEXT,
+      part_of_story         TEXT,
+      scope_id              TEXT NOT NULL DEFAULT 'default'
+    )
+  `);
+
+  // -- Edges --
+  raw.exec(`
+    CREATE TABLE IF NOT EXISTS memory_graph_edges (
+      id              TEXT PRIMARY KEY,
+      source_node_id  TEXT NOT NULL REFERENCES memory_graph_nodes(id) ON DELETE CASCADE,
+      target_node_id  TEXT NOT NULL REFERENCES memory_graph_nodes(id) ON DELETE CASCADE,
+      relationship    TEXT NOT NULL,
+      weight          REAL NOT NULL DEFAULT 1.0,
+      created         INTEGER NOT NULL
+    )
+  `);
+
+  // -- Triggers --
+  raw.exec(`
+    CREATE TABLE IF NOT EXISTS memory_graph_triggers (
+      id                   TEXT PRIMARY KEY,
+      node_id              TEXT NOT NULL REFERENCES memory_graph_nodes(id) ON DELETE CASCADE,
+      type                 TEXT NOT NULL,
+      schedule             TEXT,
+      condition            TEXT,
+      condition_embedding  BLOB,
+      threshold            REAL,
+      event_date           INTEGER,
+      ramp_days            INTEGER,
+      follow_up_days       INTEGER,
+      recurring            INTEGER NOT NULL DEFAULT 0,
+      consumed             INTEGER NOT NULL DEFAULT 0,
+      cooldown_ms          INTEGER,
+      last_fired           INTEGER
+    )
+  `);
+
+  // -- Indexes (IF NOT EXISTS for idempotency) --
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_graph_nodes_scope_id ON memory_graph_nodes(scope_id)`,
+  );
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_graph_nodes_type ON memory_graph_nodes(type)`,
+  );
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_graph_nodes_fidelity ON memory_graph_nodes(fidelity)`,
+  );
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_graph_nodes_created ON memory_graph_nodes(created)`,
+  );
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_graph_nodes_significance ON memory_graph_nodes(significance)`,
+  );
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_graph_edges_source ON memory_graph_edges(source_node_id)`,
+  );
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_graph_edges_target ON memory_graph_edges(target_node_id)`,
+  );
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_graph_triggers_node_id ON memory_graph_triggers(node_id)`,
+  );
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_graph_triggers_type ON memory_graph_triggers(type)`,
+  );
+
+  // -- Add event_date column to nodes (idempotent) --
+  try {
+    raw.exec(
+      `ALTER TABLE memory_graph_nodes ADD COLUMN event_date INTEGER`,
+    );
+  } catch {
+    // Column already exists — safe to ignore.
+  }
+
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_graph_nodes_event_date ON memory_graph_nodes(event_date)`,
+  );
+
+  // -- Backfill event_date from existing event triggers --
+  raw.exec(`
+    UPDATE memory_graph_nodes
+    SET event_date = (
+      SELECT t.event_date
+      FROM memory_graph_triggers t
+      WHERE t.node_id = memory_graph_nodes.id
+        AND t.type = 'event'
+        AND t.event_date IS NOT NULL
+      LIMIT 1
+    )
+    WHERE event_date IS NULL
+      AND id IN (
+        SELECT t2.node_id
+        FROM memory_graph_triggers t2
+        WHERE t2.type = 'event'
+          AND t2.event_date IS NOT NULL
+      )
+  `);
+}

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

@@ -0,0 +1,55 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Drop the legacy memory_items and memory_item_sources tables.
+ *
+ * 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`,
+  );
+  raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_memory_items_scope_id`);
+  raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_memory_items_fingerprint`);
+
+  // Drop tables (idempotent — IF EXISTS). Child table first.
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_item_sources`);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_items`);
+}

package/src/memory/migrations/204-rename-memory-graph-type-values.ts

@@ -0,0 +1,46 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * One-shot migration: rename legacy memory graph node type values.
+ *
+ * The PR that introduced the memory graph used "style" and "relationship"
+ * as type values.  These were renamed to "behavioral" and "semantic" in
+ * code, but existing rows in the database still carry the old values.
+ */
+export function migrateRenameMemoryGraphTypeValues(database: DrizzleDb): void {
+  withCrashRecovery(
+    database,
+    "migration_rename_memory_graph_type_values_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+      raw
+        .prepare(
+          /*sql*/ `UPDATE memory_graph_nodes SET type = 'behavioral' WHERE type = 'style'`,
+        )
+        .run();
+      raw
+        .prepare(
+          /*sql*/ `UPDATE memory_graph_nodes SET type = 'semantic' WHERE type = 'relationship'`,
+        )
+        .run();
+    },
+  );
+}
+
+/**
+ * Reverse: no-op.
+ *
+ * A blanket revert (`behavioral` → `style`, `semantic` → `relationship`) is
+ * unsafe because normal runtime may have created new `behavioral` / `semantic`
+ * nodes after the forward migration ran.  Those nodes were never `style` /
+ * `relationship` and reverting them would corrupt data.  Since the forward
+ * migration is idempotent and the old type values are no longer referenced in
+ * code, a no-op rollback is the safest option.
+ */
+export function migrateRenameMemoryGraphTypeValuesDown(
+  _database: DrizzleDb,
+): void {
+  // intentional no-op — see comment above
+}

package/src/memory/migrations/205-memory-graph-image-refs.ts

@@ -0,0 +1,11 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateMemoryGraphImageRefs(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(`ALTER TABLE memory_graph_nodes ADD COLUMN image_refs TEXT`);
+  } catch {
+    // Column already exists — idempotent
+  }
+}

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

@@ -142,6 +142,18 @@ export { migrateGuardianRequestEnrichmentColumns } from "./199-guardian-request-
 export { migrateUsageLlmCallCount } from "./200-usage-llm-call-count.js";
 export { migrateOAuthProvidersFeatureFlag } from "./201-oauth-providers-feature-flag.js";
 export { migrateDropCallbackTransportColumn } from "./202-drop-callback-transport-column.js";
+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

@@ -39,6 +39,8 @@ import { migrateRenameThreadStartersCheckpointsDown } from "./181-rename-thread-
 import { migrateBackfillAudioAttachmentMimeTypesDown } from "./191-backfill-audio-attachment-mime-types.js";
 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. */
@@ -341,6 +343,20 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
       "Strip integration: prefix from provider_key across oauth_providers, oauth_apps, and oauth_connections",
     down: migrateStripIntegrationPrefixFromProviderKeysDown,
   },
+  {
+    key: "migration_rename_memory_graph_type_values_v1",
+    version: 39,
+    description:
+      "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 {