@vellumai/assistant 0.3.4 → 0.3.6

package/src/memory/migrations/008-remove-assistant-id-columns.ts

@@ -0,0 +1,208 @@
+import { getSqliteFrom, type DrizzleDb } from '../db-connection.js';
+
+/**
+ * One-shot migration: rebuild tables that previously stored assistant_id to remove
+ * that column now that all rows are keyed to the implicit single-tenant identity ("self").
+ *
+ * Must run AFTER migrateAssistantIdToSelf (which normalises all values to "self")
+ * so there are no constraint violations when recreating the tables without the
+ * assistant_id dimension.
+ *
+ * Each table section is guarded by a DDL check so this is safe on fresh installs
+ * where the column was never created in the first place.
+ *
+ * Tables rebuilt:
+ *   - conversation_keys       UNIQUE (conversation_key)
+ *   - attachments             no structural unique; content-dedup index updated
+ *   - channel_inbound_events  UNIQUE (source_channel, external_chat_id, external_message_id)
+ *   - message_runs            no unique constraint on assistant_id
+ *   - llm_usage_events        nullable column with no constraint
+ */
+export function migrateRemoveAssistantIdColumns(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const checkpointKey = 'migration_remove_assistant_id_columns_v1';
+  const checkpoint = raw.query(
+    `SELECT 1 FROM memory_checkpoints WHERE key = ?`,
+  ).get(checkpointKey);
+  if (checkpoint) return;
+
+  raw.exec('PRAGMA foreign_keys = OFF');
+  try {
+    raw.exec('BEGIN');
+
+    // --- conversation_keys ---
+    const ckDdl = raw.query(
+      `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'conversation_keys'`,
+    ).get() as { sql: string } | null;
+    if (ckDdl?.sql.includes('assistant_id')) {
+      raw.exec(/*sql*/ `
+        CREATE TABLE conversation_keys_new (
+          id TEXT PRIMARY KEY,
+          conversation_key TEXT NOT NULL UNIQUE,
+          conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+          created_at INTEGER NOT NULL
+        )
+      `);
+      raw.exec(/*sql*/ `
+        INSERT INTO conversation_keys_new (id, conversation_key, conversation_id, created_at)
+        SELECT id, conversation_key, conversation_id, created_at FROM conversation_keys
+      `);
+      raw.exec(/*sql*/ `DROP TABLE conversation_keys`);
+      raw.exec(/*sql*/ `ALTER TABLE conversation_keys_new RENAME TO conversation_keys`);
+    }
+
+    // --- attachments ---
+    const attDdl = raw.query(
+      `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'attachments'`,
+    ).get() as { sql: string } | null;
+    if (attDdl?.sql.includes('assistant_id')) {
+      raw.exec(/*sql*/ `
+        CREATE TABLE attachments_new (
+          id TEXT PRIMARY KEY,
+          original_filename TEXT NOT NULL,
+          mime_type TEXT NOT NULL,
+          size_bytes INTEGER NOT NULL,
+          kind TEXT NOT NULL,
+          data_base64 TEXT NOT NULL,
+          content_hash TEXT,
+          thumbnail_base64 TEXT,
+          created_at INTEGER NOT NULL
+        )
+      `);
+      raw.exec(/*sql*/ `
+        INSERT INTO attachments_new (id, original_filename, mime_type, size_bytes, kind, data_base64, content_hash, thumbnail_base64, created_at)
+        SELECT id, original_filename, mime_type, size_bytes, kind, data_base64, content_hash, thumbnail_base64, created_at FROM attachments
+      `);
+      raw.exec(/*sql*/ `DROP TABLE attachments`);
+      raw.exec(/*sql*/ `ALTER TABLE attachments_new RENAME TO attachments`);
+    }
+
+    // --- channel_inbound_events ---
+    const cieDdl = raw.query(
+      `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'channel_inbound_events'`,
+    ).get() as { sql: string } | null;
+    if (cieDdl?.sql.includes('assistant_id')) {
+      raw.exec(/*sql*/ `
+        CREATE TABLE channel_inbound_events_new (
+          id TEXT PRIMARY KEY,
+          source_channel TEXT NOT NULL,
+          external_chat_id TEXT NOT NULL,
+          external_message_id TEXT NOT NULL,
+          source_message_id TEXT,
+          conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+          message_id TEXT REFERENCES messages(id) ON DELETE CASCADE,
+          delivery_status TEXT NOT NULL DEFAULT 'pending',
+          processing_status TEXT NOT NULL DEFAULT 'pending',
+          processing_attempts INTEGER NOT NULL DEFAULT 0,
+          last_processing_error TEXT,
+          retry_after INTEGER,
+          raw_payload TEXT,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL,
+          UNIQUE (source_channel, external_chat_id, external_message_id)
+        )
+      `);
+      raw.exec(/*sql*/ `
+        INSERT INTO channel_inbound_events_new (
+          id, source_channel, external_chat_id, external_message_id, source_message_id,
+          conversation_id, message_id, delivery_status, processing_status,
+          processing_attempts, last_processing_error, retry_after, raw_payload,
+          created_at, updated_at
+        )
+        SELECT
+          id, source_channel, external_chat_id, external_message_id, source_message_id,
+          conversation_id, message_id, delivery_status, processing_status,
+          processing_attempts, last_processing_error, retry_after, raw_payload,
+          created_at, updated_at
+        FROM channel_inbound_events
+      `);
+      raw.exec(/*sql*/ `DROP TABLE channel_inbound_events`);
+      raw.exec(/*sql*/ `ALTER TABLE channel_inbound_events_new RENAME TO channel_inbound_events`);
+    }
+
+    // --- message_runs ---
+    const mrDdl = raw.query(
+      `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'message_runs'`,
+    ).get() as { sql: string } | null;
+    if (mrDdl?.sql.includes('assistant_id')) {
+      raw.exec(/*sql*/ `
+        CREATE TABLE message_runs_new (
+          id TEXT PRIMARY KEY,
+          conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+          message_id TEXT REFERENCES messages(id) ON DELETE CASCADE,
+          status TEXT NOT NULL DEFAULT 'running',
+          pending_confirmation TEXT,
+          input_tokens INTEGER NOT NULL DEFAULT 0,
+          output_tokens INTEGER NOT NULL DEFAULT 0,
+          estimated_cost REAL NOT NULL DEFAULT 0,
+          error TEXT,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL
+        )
+      `);
+      raw.exec(/*sql*/ `
+        INSERT INTO message_runs_new (
+          id, conversation_id, message_id, status, pending_confirmation,
+          input_tokens, output_tokens, estimated_cost, error, created_at, updated_at
+        )
+        SELECT
+          id, conversation_id, message_id, status, pending_confirmation,
+          input_tokens, output_tokens, estimated_cost, error, created_at, updated_at
+        FROM message_runs
+      `);
+      raw.exec(/*sql*/ `DROP TABLE message_runs`);
+      raw.exec(/*sql*/ `ALTER TABLE message_runs_new RENAME TO message_runs`);
+    }
+
+    // --- llm_usage_events ---
+    const lueDdl = raw.query(
+      `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'llm_usage_events'`,
+    ).get() as { sql: string } | null;
+    if (lueDdl?.sql.includes('assistant_id')) {
+      raw.exec(/*sql*/ `
+        CREATE TABLE llm_usage_events_new (
+          id TEXT PRIMARY KEY,
+          created_at INTEGER NOT NULL,
+          conversation_id TEXT,
+          run_id TEXT,
+          request_id TEXT,
+          actor TEXT NOT NULL,
+          provider TEXT NOT NULL,
+          model TEXT NOT NULL,
+          input_tokens INTEGER NOT NULL,
+          output_tokens INTEGER NOT NULL,
+          cache_creation_input_tokens INTEGER,
+          cache_read_input_tokens INTEGER,
+          estimated_cost_usd REAL,
+          pricing_status TEXT NOT NULL,
+          metadata_json TEXT
+        )
+      `);
+      raw.exec(/*sql*/ `
+        INSERT INTO llm_usage_events_new (
+          id, created_at, conversation_id, run_id, request_id, actor, provider, model,
+          input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens,
+          estimated_cost_usd, pricing_status, metadata_json
+        )
+        SELECT
+          id, created_at, conversation_id, run_id, request_id, actor, provider, model,
+          input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens,
+          estimated_cost_usd, pricing_status, metadata_json
+        FROM llm_usage_events
+      `);
+      raw.exec(/*sql*/ `DROP TABLE llm_usage_events`);
+      raw.exec(/*sql*/ `ALTER TABLE llm_usage_events_new RENAME TO llm_usage_events`);
+    }
+
+    raw.query(
+      `INSERT OR IGNORE INTO memory_checkpoints (key, value, updated_at) VALUES (?, '1', ?)`,
+    ).run(checkpointKey, Date.now());
+
+    raw.exec('COMMIT');
+  } catch (e) {
+    try { raw.exec('ROLLBACK'); } catch { /* no active transaction */ }
+    throw e;
+  } finally {
+    raw.exec('PRAGMA foreign_keys = ON');
+  }
+}

package/src/memory/migrations/009-llm-usage-events-drop-assistant-id.ts

@@ -0,0 +1,83 @@
+import { getSqliteFrom, type DrizzleDb } from '../db-connection.js';
+
+/**
+ * One-shot migration: rebuild llm_usage_events to drop the assistant_id column.
+ *
+ * This is a SEPARATE migration from migrateRemoveAssistantIdColumns so that installs
+ * where the 4-table version of that migration already ran (checkpoint already set)
+ * still get the llm_usage_events column removed. Without a separate checkpoint key,
+ * those installs would skip the llm_usage_events rebuild entirely.
+ *
+ * Safe on fresh installs (DDL guard exits early) and idempotent via checkpoint.
+ */
+export function migrateLlmUsageEventsDropAssistantId(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const checkpointKey = 'migration_remove_assistant_id_lue_v1';
+  const checkpoint = raw.query(
+    `SELECT 1 FROM memory_checkpoints WHERE key = ?`,
+  ).get(checkpointKey);
+  if (checkpoint) return;
+
+  // DDL guard: if the column was already removed (fresh install or migrateRemoveAssistantIdColumns
+  // ran with the llm_usage_events block), just record the checkpoint and exit.
+  const lueDdl = raw.query(
+    `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'llm_usage_events'`,
+  ).get() as { sql: string } | null;
+
+  if (!lueDdl?.sql.includes('assistant_id')) {
+    raw.query(
+      `INSERT OR IGNORE INTO memory_checkpoints (key, value, updated_at) VALUES (?, '1', ?)`,
+    ).run(checkpointKey, Date.now());
+    return;
+  }
+
+  raw.exec('PRAGMA foreign_keys = OFF');
+  try {
+    raw.exec('BEGIN');
+
+    raw.exec(/*sql*/ `
+      CREATE TABLE llm_usage_events_new (
+        id TEXT PRIMARY KEY,
+        created_at INTEGER NOT NULL,
+        conversation_id TEXT,
+        run_id TEXT,
+        request_id TEXT,
+        actor TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model TEXT NOT NULL,
+        input_tokens INTEGER NOT NULL,
+        output_tokens INTEGER NOT NULL,
+        cache_creation_input_tokens INTEGER,
+        cache_read_input_tokens INTEGER,
+        estimated_cost_usd REAL,
+        pricing_status TEXT NOT NULL,
+        metadata_json TEXT
+      )
+    `);
+    raw.exec(/*sql*/ `
+      INSERT INTO llm_usage_events_new (
+        id, created_at, conversation_id, run_id, request_id, actor, provider, model,
+        input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens,
+        estimated_cost_usd, pricing_status, metadata_json
+      )
+      SELECT
+        id, created_at, conversation_id, run_id, request_id, actor, provider, model,
+        input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens,
+        estimated_cost_usd, pricing_status, metadata_json
+      FROM llm_usage_events
+    `);
+    raw.exec(/*sql*/ `DROP TABLE llm_usage_events`);
+    raw.exec(/*sql*/ `ALTER TABLE llm_usage_events_new RENAME TO llm_usage_events`);
+
+    raw.query(
+      `INSERT OR IGNORE INTO memory_checkpoints (key, value, updated_at) VALUES (?, '1', ?)`,
+    ).run(checkpointKey, Date.now());
+
+    raw.exec('COMMIT');
+  } catch (e) {
+    try { raw.exec('ROLLBACK'); } catch { /* no active transaction */ }
+    throw e;
+  } finally {
+    raw.exec('PRAGMA foreign_keys = ON');
+  }
+}

package/src/memory/migrations/010-ext-conv-bindings-channel-chat-unique.ts

@@ -0,0 +1,56 @@
+import { getSqliteFrom, type DrizzleDb } from '../db-connection.js';
+
+/**
+ * One-shot migration: deduplicate external_conversation_bindings rows that
+ * share the same (source_channel, external_chat_id), then create a unique
+ * index to enforce the invariant at DB level.
+ *
+ * For each duplicate group, the binding with the newest updatedAt (then
+ * createdAt) is kept; older duplicates are deleted.
+ */
+export function migrateExtConvBindingsChannelChatUnique(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  // If the unique index already exists, nothing to do.
+  const idxExists = raw.query(
+    `SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = 'idx_ext_conv_bindings_channel_chat_unique'`,
+  ).get();
+  if (idxExists) return;
+
+  // Check if the table exists (first boot edge case).
+  const tableExists = raw.query(
+    `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'external_conversation_bindings'`,
+  ).get();
+  if (!tableExists) return;
+
+  // Remove duplicates: keep the row with the newest updatedAt, then createdAt.
+  // Since conversation_id is the PK (rowid alias), we use it for ordering ties.
+  try {
+    raw.exec('BEGIN');
+
+    raw.exec(/*sql*/ `
+      DELETE FROM external_conversation_bindings
+      WHERE rowid NOT IN (
+        SELECT rowid FROM (
+          SELECT rowid,
+                 ROW_NUMBER() OVER (
+                   PARTITION BY source_channel, external_chat_id
+                   ORDER BY updated_at DESC, created_at DESC, rowid DESC
+                 ) AS rn
+          FROM external_conversation_bindings
+        )
+        WHERE rn = 1
+      )
+    `);
+
+    raw.exec(/*sql*/ `
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_ext_conv_bindings_channel_chat_unique
+      ON external_conversation_bindings(source_channel, external_chat_id)
+    `);
+
+    raw.exec('COMMIT');
+  } catch (e) {
+    try { raw.exec('ROLLBACK'); } catch { /* no active transaction */ }
+    throw e;
+  }
+}

package/src/memory/migrations/011-call-sessions-provider-sid-dedup.ts

@@ -0,0 +1,63 @@
+import { getSqliteFrom, type DrizzleDb } from '../db-connection.js';
+import { getLogger } from '../../util/logger.js';
+
+const log = getLogger('memory-db');
+
+/**
+ * One-shot migration: remove duplicate (provider, provider_call_sid) rows from
+ * call_sessions so that the unique index can be created safely on upgraded databases
+ * that pre-date the constraint.
+ *
+ * For each set of duplicates, the most recently updated row is kept.
+ */
+export function migrateCallSessionsProviderSidDedup(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  // Quick check: if the unique index already exists, no dedup is needed.
+  const idxExists = raw.query(
+    `SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = 'idx_call_sessions_provider_sid_unique'`,
+  ).get();
+  if (idxExists) return;
+
+  // Check if the table even exists yet (first boot).
+  const tableExists = raw.query(
+    `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'call_sessions'`,
+  ).get();
+  if (!tableExists) return;
+
+  // Count duplicates before doing any work.
+  const dupCount = raw.query(/*sql*/ `
+    SELECT COUNT(*) AS c FROM (
+      SELECT provider, provider_call_sid
+      FROM call_sessions
+      WHERE provider_call_sid IS NOT NULL
+      GROUP BY provider, provider_call_sid
+      HAVING COUNT(*) > 1
+    )
+  `).get() as { c: number } | null;
+
+  if (!dupCount || dupCount.c === 0) return;
+
+  log.warn({ duplicateGroups: dupCount.c }, 'Deduplicating call_sessions with duplicate provider_call_sid before creating unique index');
+
+  try {
+    raw.exec('BEGIN');
+
+    // Keep the most recently updated row per (provider, provider_call_sid);
+    // delete the rest.
+    raw.exec(/*sql*/ `
+      DELETE FROM call_sessions
+      WHERE provider_call_sid IS NOT NULL
+        AND rowid NOT IN (
+          SELECT MAX(rowid) FROM call_sessions
+          WHERE provider_call_sid IS NOT NULL
+          GROUP BY provider, provider_call_sid
+        )
+    `);
+
+    raw.exec('COMMIT');
+  } catch (e) {
+    try { raw.exec('ROLLBACK'); } catch { /* no active transaction */ }
+    throw e;
+  }
+}

package/src/memory/migrations/012-call-sessions-add-initiated-from.ts

@@ -0,0 +1,19 @@
+import { getSqliteFrom, type DrizzleDb } from '../db-connection.js';
+
+/**
+ * Add the `initiated_from_conversation_id` column to `call_sessions` so
+ * voice calls can track which conversation triggered them while pointing
+ * the session's `conversation_id` to a dedicated per-call voice conversation.
+ *
+ * Uses ALTER TABLE ... ADD COLUMN which is a no-op if the column already
+ * exists (caught via try/catch, matching the existing migration pattern in
+ * db-init.ts for similar additive columns).
+ */
+export function migrateCallSessionsAddInitiatedFrom(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(/*sql*/ `ALTER TABLE call_sessions ADD COLUMN initiated_from_conversation_id TEXT`);
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

package/src/memory/migrations/013-guardian-action-tables.ts

@@ -0,0 +1,68 @@
+import { getSqliteFrom, type DrizzleDb } from '../db-connection.js';
+
+/**
+ * Create guardian_action_requests and guardian_action_deliveries tables
+ * for cross-channel voice guardian dispatch.
+ *
+ * Uses CREATE TABLE IF NOT EXISTS + CREATE INDEX IF NOT EXISTS for
+ * idempotency across restarts.
+ */
+export function migrateGuardianActionTables(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  try {
+    raw.exec('BEGIN');
+
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS guardian_action_requests (
+        id TEXT PRIMARY KEY,
+        assistant_id TEXT NOT NULL DEFAULT 'self',
+        kind TEXT NOT NULL,
+        source_channel TEXT NOT NULL,
+        source_conversation_id TEXT NOT NULL,
+        call_session_id TEXT NOT NULL REFERENCES call_sessions(id) ON DELETE CASCADE,
+        pending_question_id TEXT NOT NULL REFERENCES call_pending_questions(id) ON DELETE CASCADE,
+        question_text TEXT NOT NULL,
+        request_code TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        answer_text TEXT,
+        answered_by_channel TEXT,
+        answered_by_external_user_id TEXT,
+        answered_at INTEGER,
+        expires_at INTEGER NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS guardian_action_deliveries (
+        id TEXT PRIMARY KEY,
+        request_id TEXT NOT NULL REFERENCES guardian_action_requests(id) ON DELETE CASCADE,
+        destination_channel TEXT NOT NULL,
+        destination_conversation_id TEXT,
+        destination_chat_id TEXT,
+        destination_external_user_id TEXT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        sent_at INTEGER,
+        responded_at INTEGER,
+        last_error TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+
+    raw.exec(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_guardian_action_requests_status ON guardian_action_requests(status)`);
+    raw.exec(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_guardian_action_requests_call_session ON guardian_action_requests(call_session_id)`);
+    raw.exec(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_guardian_action_requests_pending_question ON guardian_action_requests(pending_question_id)`);
+    raw.exec(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_guardian_action_requests_request_code ON guardian_action_requests(request_code)`);
+    raw.exec(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_guardian_action_deliveries_request_id ON guardian_action_deliveries(request_id)`);
+    raw.exec(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_guardian_action_deliveries_status ON guardian_action_deliveries(status)`);
+    raw.exec(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_guardian_action_deliveries_destination ON guardian_action_deliveries(destination_channel, destination_chat_id)`);
+
+    raw.exec('COMMIT');
+  } catch (e) {
+    try { raw.exec('ROLLBACK'); } catch { /* no active transaction */ }
+    throw e;
+  }
+}

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

@@ -0,0 +1,76 @@
+import { getSqliteFrom, type DrizzleDb } from '../db-connection.js';
+
+/**
+ * One-shot migration: seed assistant_inbox_thread_state from existing
+ * external_conversation_bindings so that pre-existing conversations
+ * appear in the inbox without waiting for new inbound activity.
+ *
+ * Uses INSERT OR IGNORE for idempotency (conversation_id is PK).
+ * Counters (unread_count, pending_escalation_count, has_pending_escalation)
+ * are initialised to zero since historical state is unknown.
+ */
+export function migrateBackfillInboxThreadStateFromBindings(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const checkpointKey = 'backfill_inbox_thread_state_from_bindings';
+  const checkpoint = raw.query(
+    `SELECT 1 FROM memory_checkpoints WHERE key = ?`,
+  ).get(checkpointKey);
+  if (checkpoint) return;
+
+  // Guard: skip if either table does not exist yet (first boot edge case).
+  const srcExists = raw.query(
+    `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'external_conversation_bindings'`,
+  ).get();
+  const dstExists = raw.query(
+    `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'assistant_inbox_thread_state'`,
+  ).get();
+  if (!srcExists || !dstExists) {
+    raw.query(
+      `INSERT OR IGNORE INTO memory_checkpoints (key, value, updated_at) VALUES (?, '1', ?)`,
+    ).run(checkpointKey, Date.now());
+    return;
+  }
+
+  try {
+    raw.exec('BEGIN');
+
+    raw.exec(/*sql*/ `
+      INSERT OR IGNORE INTO assistant_inbox_thread_state (
+        conversation_id, 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,
+        created_at, updated_at
+      )
+      SELECT
+        conversation_id,
+        'self',
+        source_channel,
+        external_chat_id,
+        external_user_id,
+        display_name,
+        username,
+        last_inbound_at,
+        last_outbound_at,
+        CASE
+          WHEN last_inbound_at IS NULL AND last_outbound_at IS NULL THEN NULL
+          ELSE MAX(COALESCE(last_inbound_at, 0), COALESCE(last_outbound_at, 0))
+        END,
+        0,
+        0,
+        0,
+        created_at,
+        updated_at
+      FROM external_conversation_bindings
+    `);
+
+    raw.query(
+      `INSERT OR IGNORE INTO memory_checkpoints (key, value, updated_at) VALUES (?, '1', ?)`,
+    ).run(checkpointKey, Date.now());
+
+    raw.exec('COMMIT');
+  } catch (e) {
+    try { raw.exec('ROLLBACK'); } catch { /* no active transaction */ }
+    throw e;
+  }
+}

package/src/memory/migrations/015-drop-active-search-index.ts

@@ -0,0 +1,27 @@
+import { getSqliteFrom, type DrizzleDb } from '../db-connection.js';
+
+/**
+ * One-time migration to drop the old idx_memory_items_active_search index so
+ * it can be recreated with updated covering columns by the idempotent
+ * CREATE INDEX IF NOT EXISTS in db-init.
+ */
+export function migrateDropActiveSearchIndex(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const checkpointKey = 'drop_active_search_index_v1';
+  const checkpoint = raw.query(
+    `SELECT 1 FROM memory_checkpoints WHERE key = ?`,
+  ).get(checkpointKey);
+  if (checkpoint) return;
+
+  try {
+    raw.exec('BEGIN');
+    raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_memory_items_active_search`);
+    raw.query(
+      `INSERT OR IGNORE INTO memory_checkpoints (key, value, updated_at) VALUES (?, '1', ?)`,
+    ).run(checkpointKey, Date.now());
+    raw.exec('COMMIT');
+  } catch (e) {
+    try { raw.exec('ROLLBACK'); } catch { /* no active transaction */ }
+    throw e;
+  }
+}

package/src/memory/migrations/016-memory-segments-indexes.ts

@@ -0,0 +1,11 @@
+import type { DrizzleDb } from '../db-connection.js';
+
+/**
+ * Idempotent migration to ensure memory_segments has indexes on scope_id and
+ * conversation_id for faster lookups.  scope_id was already covered by
+ * db-init, but we include both here for completeness.
+ */
+export function migrateMemorySegmentsIndexes(database: DrizzleDb): void {
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_segments_scope_id ON memory_segments(scope_id)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_segments_conversation_id ON memory_segments(conversation_id)`);
+}

package/src/memory/migrations/017-memory-items-indexes.ts

@@ -0,0 +1,10 @@
+import type { DrizzleDb } from '../db-connection.js';
+
+/**
+ * Idempotent migration to add indexes on memory_items for scope_id and
+ * fingerprint — critical for duplicate detection and scope-filtered queries.
+ */
+export function migrateMemoryItemsIndexes(database: DrizzleDb): void {
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_items_scope_id ON memory_items(scope_id)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_items_fingerprint ON memory_items(fingerprint)`);
+}

package/src/memory/migrations/018-remaining-table-indexes.ts

@@ -0,0 +1,13 @@
+import type { DrizzleDb } from '../db-connection.js';
+
+/**
+ * Idempotent migration to add indexes on foreign-key and scope columns that
+ * lacked them.  messages.conversation_id is a FK used for ON DELETE CASCADE,
+ * so the index also speeds up cascading deletes.
+ */
+export function migrateRemainingTableIndexes(database: DrizzleDb): void {
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_item_conflicts_scope_id ON memory_item_conflicts(scope_id)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_summaries_scope_id ON memory_summaries(scope_id)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_messages_conversation_id ON messages(conversation_id)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_tool_invocations_conversation_id ON tool_invocations(conversation_id)`);
+}

package/src/memory/migrations/index.ts

@@ -0,0 +1,24 @@
+export {
+  type MigrationRegistryEntry,
+  MIGRATION_REGISTRY,
+  type MigrationValidationResult,
+} from './registry.js';
+export { validateMigrationState } from './validate-migration-state.js';
+export { migrateJobDeferrals } from './001-job-deferrals.js';
+export { migrateToolInvocationsFk } from './002-tool-invocations-fk.js';
+export { migrateMemoryFtsBackfill } from './003-memory-fts-backfill.js';
+export { migrateMemoryEntityRelationDedup } from './004-entity-relation-dedup.js';
+export { migrateMemoryItemsFingerprintScopeUnique } from './005-fingerprint-scope-unique.js';
+export { migrateMemoryItemsScopeSaltedFingerprints } from './006-scope-salted-fingerprints.js';
+export { migrateAssistantIdToSelf } from './007-assistant-id-to-self.js';
+export { migrateRemoveAssistantIdColumns } from './008-remove-assistant-id-columns.js';
+export { migrateLlmUsageEventsDropAssistantId } from './009-llm-usage-events-drop-assistant-id.js';
+export { migrateExtConvBindingsChannelChatUnique } from './010-ext-conv-bindings-channel-chat-unique.js';
+export { migrateCallSessionsProviderSidDedup } from './011-call-sessions-provider-sid-dedup.js';
+export { migrateCallSessionsAddInitiatedFrom } from './012-call-sessions-add-initiated-from.js';
+export { migrateGuardianActionTables } from './013-guardian-action-tables.js';
+export { migrateBackfillInboxThreadStateFromBindings } from './014-backfill-inbox-thread-state.js';
+export { migrateDropActiveSearchIndex } from './015-drop-active-search-index.js';
+export { migrateMemorySegmentsIndexes } from './016-memory-segments-indexes.js';
+export { migrateMemoryItemsIndexes } from './017-memory-items-indexes.js';
+export { migrateRemainingTableIndexes } from './018-remaining-table-indexes.js';