@vellumai/assistant 0.4.43 → 0.4.45

package/src/memory/job-handlers/index-maintenance.ts

@@ -1,16 +1,21 @@
-import { eq } from "drizzle-orm";
+import { eq, like } from "drizzle-orm";
 
+import { getConfig } from "../../config/loader.js";
 import { getLogger } from "../../util/logger.js";
 import { getDb, rawExec } from "../db.js";
+import { selectedBackendSupportsMultimodal } from "../embedding-backend.js";
 import { asString, BackendUnavailableError } from "../job-utils.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
+import { extractMediaBlockMeta } from "../message-content.js";
 import { withQdrantBreaker } from "../qdrant-circuit-breaker.js";
 import { getQdrantClient } from "../qdrant-client.js";
 import {
+  mediaAssets,
   memoryEmbeddings,
   memoryItems,
   memorySegments,
   memorySummaries,
+  messages,
 } from "../schema.js";
 
 const log = getLogger("memory-jobs-worker");
@@ -48,6 +53,35 @@ export function rebuildIndexJob(): void {
   for (const segment of segments) {
     enqueueMemoryJob("embed_segment", { segmentId: segment.id });
   }
+
+  // Re-enqueue multimodal embedding jobs only when the resolved embedding
+  // backend supports multimodal inputs. Without this gate, embed_media and
+  // embed_attachment jobs would all fail for text-only backends.
+  if (selectedBackendSupportsMultimodal(getConfig())) {
+    const assets = db
+      .select({ id: mediaAssets.id })
+      .from(mediaAssets)
+      .where(eq(mediaAssets.status, "indexed"))
+      .all();
+    for (const asset of assets) {
+      enqueueMemoryJob("embed_media", { assetId: asset.id });
+    }
+
+    const imageMessages = db
+      .select({ id: messages.id, content: messages.content })
+      .from(messages)
+      .where(like(messages.content, '%"type":"image"%'))
+      .all();
+    for (const msg of imageMessages) {
+      const blocks = extractMediaBlockMeta(msg.content);
+      for (const block of blocks) {
+        enqueueMemoryJob("embed_attachment", {
+          messageId: msg.id,
+          blockIndex: block.index,
+        });
+      }
+    }
+  }
 }
 
 export async function deleteQdrantVectorsJob(job: MemoryJob): Promise<void> {

package/src/memory/job-handlers/media-processing.ts

@@ -6,9 +6,11 @@ import {
 import { mapSegmentsForAsset } from "../../config/bundled-skills/media-processing/tools/analyze-keyframes.js";
 import { preprocessForAsset } from "../../config/bundled-skills/media-processing/tools/extract-keyframes.js";
 import { reduceForAsset } from "../../config/bundled-skills/media-processing/tools/query-media-events.js";
+import { getConfig } from "../../config/loader.js";
 import { getLogger } from "../../util/logger.js";
+import { selectedBackendSupportsMultimodal } from "../embedding-backend.js";
 import { asString } from "../job-utils.js";
-import type { MemoryJob } from "../jobs-store.js";
+import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
 import { getMediaAssetById, updateMediaAssetStatus } from "../media-store.js";
 
 const log = getLogger("media-processing-job");
@@ -32,6 +34,9 @@ export async function mediaProcessingJob(job: MemoryJob): Promise<void> {
       "Skipping media processing pipeline — only video assets are supported",
     );
     updateMediaAssetStatus(mediaAssetId, "indexed");
+    if (selectedBackendSupportsMultimodal(getConfig())) {
+      enqueueMemoryJob("embed_media", { assetId: mediaAssetId });
+    }
     return;
   }
 
@@ -107,4 +112,9 @@ export async function mediaProcessingJob(job: MemoryJob): Promise<void> {
   if (result.cancelled) {
     throw new Error(`Media processing cancelled for asset ${mediaAssetId}`);
   }
+
+  updateMediaAssetStatus(mediaAssetId, "indexed");
+  if (selectedBackendSupportsMultimodal(getConfig())) {
+    enqueueMemoryJob("embed_media", { assetId: mediaAssetId });
+  }
 }

package/src/memory/job-utils.ts

@@ -1,4 +1,4 @@
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 
 import { and, eq } from "drizzle-orm";
 
@@ -10,6 +10,11 @@ import {
   embedWithBackend,
   getMemoryBackendStatus,
 } from "./embedding-backend.js";
+import type { EmbeddingInput } from "./embedding-types.js";
+import {
+  embeddingInputContentHash,
+  normalizeEmbeddingInput,
+} from "./embedding-types.js";
 import { withQdrantBreaker } from "./qdrant-circuit-breaker.js";
 import { getQdrantClient } from "./qdrant-client.js";
 import { memoryEmbeddings } from "./schema.js";
@@ -136,9 +141,9 @@ export function truncate(text: string, max: number): string {
 
 export async function embedAndUpsert(
   config: AssistantConfig,
-  targetType: "segment" | "item" | "summary",
+  targetType: "segment" | "item" | "summary" | "media",
   targetId: string,
-  text: string,
+  input: EmbeddingInput,
   extraPayload?: Record<string, unknown>,
 ): Promise<void> {
   const status = getMemoryBackendStatus(config);
@@ -148,7 +153,7 @@ export async function embedAndUpsert(
     );
   }
 
-  const contentHash = createHash("sha256").update(text).digest("hex");
+  const contentHash = embeddingInputContentHash(input);
   let provider = status.provider;
   let model = status.model!;
   let vector: number[];
@@ -181,13 +186,21 @@ export async function embedAndUpsert(
       vector = JSON.parse(cachedRow.vectorJson!);
     }
   } else {
-    const embedded = await embedWithBackend(config, [text]);
+    const embedded = await embedWithBackend(config, [input]);
     vector = embedded.vectors[0];
     if (!vector) return;
     provider = embedded.provider;
     model = embedded.model;
   }
 
+  // Extract text for Qdrant payload: use the raw text for text inputs,
+  // or a description string for non-text (image/audio/video) inputs.
+  const normalized = normalizeEmbeddingInput(input);
+  const payloadText =
+    normalized.type === "text"
+      ? normalized.text
+      : `[${normalized.type}:${normalized.mimeType}]`;
+
   // Persist embedding in SQLite for cross-restart cache
   const now = Date.now();
   try {
@@ -234,9 +247,11 @@ export async function embedAndUpsert(
   }
 
   try {
+    const modality = normalized.type;
     await withQdrantBreaker(() =>
       qdrant.upsert(targetType, targetId, vector, {
-        text,
+        text: payloadText,
+        modality,
         created_at: (extraPayload?.created_at as number) ?? now,
         ...(extraPayload as Record<string, unknown> | undefined),
       }),

package/src/memory/jobs-store.ts

@@ -27,12 +27,16 @@ export type MemoryJobType =
   | "rebuild_index"
   | "reconcile_fts"
   | "delete_qdrant_vectors"
-  | "media_processing";
+  | "media_processing"
+  | "embed_media"
+  | "embed_attachment";
 
 const EMBED_JOB_TYPES: MemoryJobType[] = [
   "embed_segment",
   "embed_item",
   "embed_summary",
+  "embed_media",
+  "embed_attachment",
 ];
 
 export interface MemoryJob<T = Record<string, unknown>> {

package/src/memory/jobs-worker.ts

@@ -18,7 +18,9 @@ import {
 } from "./job-handlers/conflict.js";
 // ── Per-job-type handlers ──────────────────────────────────────────
 import {
+  embedAttachmentJob,
   embedItemJob,
+  embedMediaJob,
   embedSegmentJob,
   embedSummaryJob,
 } from "./job-handlers/embedding.js";
@@ -334,6 +336,12 @@ async function processJob(
     case "media_processing":
       await mediaProcessingJob(job);
       return;
+    case "embed_media":
+      await embedMediaJob(job, config);
+      return;
+    case "embed_attachment":
+      await embedAttachmentJob(job, config);
+      return;
     default:
       throw new Error(
         `Unknown memory job type: ${(job as { type: string }).type}`,

package/src/memory/message-content.ts

@@ -45,6 +45,17 @@ export function extractTextFromStoredMessageContent(raw: string): string {
             );
           }
           break;
+        case "server_tool_use": {
+          const query =
+            typeof block.input?.query === "string"
+              ? block.input.query
+              : block.name;
+          lines.push(`[web search: ${query}]`);
+          break;
+        }
+        case "web_search_tool_result":
+          lines.push("[web search results]");
+          break;
         default:
           lines.push("<unknown_content_block />");
       }
@@ -55,6 +66,61 @@ export function extractTextFromStoredMessageContent(raw: string): string {
   }
 }
 
+export function extractMediaBlocks(raw: string): Array<{
+  type: "image";
+  data: Buffer;
+  mimeType: string;
+  index: number;
+}> {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return [];
+    const results: Array<{
+      type: "image";
+      data: Buffer;
+      mimeType: string;
+      index: number;
+    }> = [];
+    for (let i = 0; i < parsed.length; i++) {
+      const block = parsed[i] as ContentBlock;
+      if (block.type === "image") {
+        results.push({
+          type: "image" as const,
+          data: Buffer.from(block.source.data, "base64"),
+          mimeType: block.source.media_type,
+          index: i,
+        });
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Lightweight variant of extractMediaBlocks that returns only type and index
+ * metadata without decoding base64 image data into Buffers.
+ */
+export function extractMediaBlockMeta(
+  raw: string,
+): Array<{ type: "image"; index: number }> {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return [];
+    const results: Array<{ type: "image"; index: number }> = [];
+    for (let i = 0; i < parsed.length; i++) {
+      const block = parsed[i] as { type?: string };
+      if (block.type === "image") {
+        results.push({ type: "image" as const, index: i });
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
 function stableJson(value: unknown): string {
   try {
     return JSON.stringify(value);

package/src/memory/migrations/100-core-tables.ts

@@ -5,7 +5,7 @@ import type { DrizzleDb } from "../db-connection.js";
  * memory_items, memory_item_sources, memory_item_conflicts, memory_summaries,
  * memory_embeddings, memory_jobs, memory_checkpoints, attachments,
  * message_attachments, message_surfaces, channel_inbound_events,
- * message_runs, reminders, cron_jobs, cron_runs, accounts, documents,
+ * message_runs, cron_jobs, cron_runs, documents,
  * published_pages, shared_app_links, home_base_app_links.
  */
 export function createCoreTables(database: DrizzleDb): void {
@@ -228,21 +228,6 @@ export function createCoreTables(database: DrizzleDb): void {
     )
   `);
 
-  database.run(/*sql*/ `
-    CREATE TABLE IF NOT EXISTS reminders (
-      id TEXT PRIMARY KEY,
-      label TEXT NOT NULL,
-      message TEXT NOT NULL,
-      fire_at INTEGER NOT NULL,
-      mode TEXT NOT NULL,
-      status TEXT NOT NULL,
-      fired_at INTEGER,
-      conversation_id TEXT,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    )
-  `);
-
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS cron_jobs (
       id TEXT PRIMARY KEY,
@@ -277,21 +262,6 @@ export function createCoreTables(database: DrizzleDb): void {
     )
   `);
 
-  database.run(/*sql*/ `
-    CREATE TABLE IF NOT EXISTS accounts (
-      id TEXT PRIMARY KEY,
-      service TEXT NOT NULL,
-      username TEXT,
-      email TEXT,
-      display_name TEXT,
-      status TEXT NOT NULL DEFAULT 'active',
-      credential_ref TEXT,
-      metadata_json TEXT,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    )
-  `);
-
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS documents (
       surface_id TEXT PRIMARY KEY,

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

@@ -198,10 +198,6 @@ export function createCoreIndexes(database: DrizzleDb): void {
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_message_runs_conversation ON message_runs(conversation_id)`,
   );
 
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_reminders_status_fire_at ON reminders(status, fire_at)`,
-  );
-
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled_next_run ON cron_jobs(enabled, next_run_at)`,
   );
@@ -212,13 +208,6 @@ export function createCoreIndexes(database: DrizzleDb): void {
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_runs_job_id ON cron_runs(job_id)`,
   );
 
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_accounts_service ON accounts(service)`,
-  );
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_accounts_status ON accounts(status)`,
-  );
-
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_llm_usage_events_created_at ON llm_usage_events(created_at)`,
   );

package/src/memory/migrations/145-drop-accounts-table.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";
+
+/**
+ * Drop the unused legacy accounts table and its indexes.
+ *
+ * The daemon no longer exposes account_manage or reads from the backing
+ * account-store path, so retaining the table only leaves dead state around.
+ */
+export function migrateDropAccountsTable(database: DrizzleDb): void {
+  withCrashRecovery(database, "migration_drop_accounts_table_v1", () => {
+    const raw = getSqliteFrom(database);
+
+    raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_accounts_service`);
+    raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_accounts_status`);
+    raw.exec(/*sql*/ `DROP TABLE IF EXISTS accounts`);
+  });
+}

package/src/memory/migrations/146-schedule-oneshot-routing.ts

@@ -0,0 +1,94 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Extend cron_jobs table with one-shot and routing support.
+ *
+ * - Make `cron_expression` nullable (SQLite requires table rebuild for
+ *   nullability changes). One-shot schedules have NULL cron_expression.
+ * - Add `mode` column: 'notify' | 'execute'
+ * - Add `routing_intent` column: 'single_channel' | 'multi_channel' | 'all_channels'
+ * - Add `routing_hints_json` column: opaque JSON routing hints
+ * - Add `status` column: 'active' | 'firing' | 'fired' | 'cancelled'
+ * - Add composite index for one-shot claiming: (status, next_run_at)
+ */
+export function migrateScheduleOneShotRouting(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  // Check if migration is already done by inspecting whether the status column exists
+  const tableInfo = raw
+    .query("PRAGMA table_info(cron_jobs)")
+    .all() as Array<{ name: string }>;
+  const hasStatusColumn = tableInfo.some((col) => col.name === "status");
+  if (hasStatusColumn) {
+    // Ensure all indexes exist even if the column migration already ran
+    raw.exec(
+      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled_next_run ON cron_jobs(enabled, next_run_at)`,
+    );
+    raw.exec(
+      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_jobs_syntax_enabled_next_run ON cron_jobs(schedule_syntax, enabled, next_run_at)`,
+    );
+    raw.exec(
+      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_jobs_status_next_run_at ON cron_jobs(status, next_run_at)`,
+    );
+    return;
+  }
+
+  raw.exec("PRAGMA foreign_keys = OFF");
+  try {
+    raw.exec(/*sql*/ `
+      BEGIN;
+
+      CREATE TABLE cron_jobs_new (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        cron_expression TEXT,
+        schedule_syntax TEXT NOT NULL DEFAULT 'cron',
+        timezone TEXT,
+        message TEXT NOT NULL,
+        next_run_at INTEGER NOT NULL,
+        last_run_at INTEGER,
+        last_status TEXT,
+        retry_count INTEGER NOT NULL DEFAULT 0,
+        created_by TEXT NOT NULL,
+        mode TEXT NOT NULL DEFAULT 'execute',
+        routing_intent TEXT NOT NULL DEFAULT 'all_channels',
+        routing_hints_json TEXT NOT NULL DEFAULT '{}',
+        status TEXT NOT NULL DEFAULT 'active',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      INSERT INTO cron_jobs_new (
+        id, name, enabled, cron_expression, schedule_syntax, timezone,
+        message, next_run_at, last_run_at, last_status, retry_count,
+        created_by, mode, routing_intent, routing_hints_json, status,
+        created_at, updated_at
+      )
+      SELECT
+        id, name, enabled, cron_expression, schedule_syntax, timezone,
+        message, next_run_at, last_run_at, last_status, retry_count,
+        created_by, 'execute', 'all_channels', '{}', 'active',
+        created_at, updated_at
+      FROM cron_jobs;
+
+      DROP TABLE cron_jobs;
+      ALTER TABLE cron_jobs_new RENAME TO cron_jobs;
+
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled_next_run ON cron_jobs(enabled, next_run_at);
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_syntax_enabled_next_run ON cron_jobs(schedule_syntax, enabled, next_run_at);
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_status_next_run_at ON cron_jobs(status, next_run_at);
+
+      COMMIT;
+    `);
+  } catch (e) {
+    try {
+      raw.exec("ROLLBACK");
+    } catch {
+      /* no active transaction */
+    }
+    throw e;
+  } finally {
+    raw.exec("PRAGMA foreign_keys = ON");
+  }
+}

package/src/memory/migrations/147-migrate-reminders-to-schedules.ts

@@ -0,0 +1,129 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Migrate all existing reminders into the cron_jobs (schedules) table as
+ * one-shot schedules.
+ *
+ * Field mapping:
+ *   reminder.label          → cron_jobs.name
+ *   reminder.message        → cron_jobs.message
+ *   reminder.fire_at        → cron_jobs.next_run_at
+ *   reminder.fired_at       → cron_jobs.last_run_at
+ *   reminder.mode           → cron_jobs.mode
+ *   reminder.routing_intent → cron_jobs.routing_intent
+ *   reminder.routing_hints_json → cron_jobs.routing_hints_json
+ *   reminder.created_at     → cron_jobs.created_at
+ *   reminder.updated_at     → cron_jobs.updated_at
+ *
+ * Status mapping:
+ *   pending   → active
+ *   firing    → firing
+ *   fired     → fired
+ *   cancelled → cancelled
+ *
+ * Enabled: pending → 1, all others → 0
+ *
+ * last_status: fired → 'ok', others → NULL
+ *
+ * One-shot schedules have NULL cron_expression. The reminders table is
+ * preserved for the subsequent cleanup PR.
+ */
+export function migrateRemindersToSchedules(database: DrizzleDb): void {
+  withCrashRecovery(
+    database,
+    "migration_reminders_to_schedules_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+
+      // Guard: if the reminders table doesn't exist, nothing to migrate.
+      const hasReminders = raw
+        .query(
+          "SELECT name FROM sqlite_master WHERE type='table' AND name='reminders'",
+        )
+        .get();
+      if (!hasReminders) return;
+
+      // Read all reminders into memory. We use the reminder's original ID as
+      // the cron_jobs primary key so that INSERT OR IGNORE deduplicates
+      // correctly if the migration re-runs after a crash.
+      const reminders = raw.query("SELECT * FROM reminders").all() as Array<{
+        id: string;
+        label: string;
+        message: string;
+        fire_at: number;
+        mode: string;
+        status: string;
+        fired_at: number | null;
+        routing_intent: string;
+        routing_hints_json: string;
+        created_at: number;
+        updated_at: number;
+      }>;
+
+      if (reminders.length === 0) return;
+
+      const insert = raw.query(/*sql*/ `
+        INSERT OR IGNORE INTO cron_jobs (
+          id, name, enabled, cron_expression, schedule_syntax, timezone,
+          message, next_run_at, last_run_at, last_status, retry_count,
+          created_by, mode, routing_intent, routing_hints_json, status,
+          created_at, updated_at
+        ) VALUES (
+          ?, ?, ?, NULL, 'cron', NULL,
+          ?, ?, ?, ?, 0,
+          'agent', ?, ?, ?, ?,
+          ?, ?
+        )
+      `);
+
+      // Mark migrated pending reminders as fired so the legacy
+      // claimDueReminders path doesn't fire them a second time.
+      const markFired = raw.query(/*sql*/ `
+        UPDATE reminders SET status = 'fired', fired_at = ?
+        WHERE id = ? AND status = 'pending'
+      `);
+
+      try {
+        raw.exec("BEGIN");
+
+        for (const r of reminders) {
+          const statusMap: Record<string, string> = {
+            pending: "active",
+            firing: "firing",
+            fired: "fired",
+            cancelled: "cancelled",
+          };
+
+          insert.run(
+            r.id,
+            r.label,
+            r.status === "pending" ? 1 : 0,
+            // message, next_run_at, last_run_at, last_status
+            r.message,
+            r.fire_at,
+            r.fired_at,
+            r.status === "fired" ? "ok" : null,
+            // mode, routing_intent, routing_hints_json, status
+            r.mode,
+            r.routing_intent,
+            r.routing_hints_json,
+            statusMap[r.status] ?? "active",
+            // created_at, updated_at
+            r.created_at,
+            r.updated_at,
+          );
+
+          if (r.status === "pending") {
+            markFired.run(Date.now(), r.id);
+          }
+        }
+
+        raw.exec("COMMIT");
+      } catch (err) {
+        raw.exec("ROLLBACK");
+        throw err;
+      }
+    },
+  );
+}

package/src/memory/migrations/148-drop-reminders-table.ts

@@ -0,0 +1,18 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Drop the legacy reminders table and its index now that all data has been
+ * migrated into cron_jobs as one-shot schedules (migration 147).
+ */
+export function migrateDropRemindersTable(database: DrizzleDb): void {
+  withCrashRecovery(
+    database,
+    "migration_drop_reminders_table_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+      raw.run("DROP INDEX IF EXISTS idx_reminders_status_fire_at");
+      raw.run("DROP TABLE IF EXISTS reminders");
+    },
+  );
+}

package/src/memory/migrations/index.ts

@@ -86,6 +86,10 @@ export { migrateRenameVerificationTable } from "./141-rename-verification-table.
 export { migrateRenameVerificationSessionIdColumn } from "./142-rename-verification-session-id-column.js";
 export { migrateRenameGuardianVerificationValues } from "./143-rename-guardian-verification-values.js";
 export { migrateRenameVoiceToPhone } from "./144-rename-voice-to-phone.js";
+export { migrateDropAccountsTable } from "./145-drop-accounts-table.js";
+export { migrateScheduleOneShotRouting } from "./146-schedule-oneshot-routing.js";
+export { migrateRemindersToSchedules } from "./147-migrate-reminders-to-schedules.js";
+export { migrateDropRemindersTable } from "./148-drop-reminders-table.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -171,6 +171,25 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
     description:
       'Rename stored "voice" channel values to "phone" across all tables with channel text columns',
   },
+  {
+    key: "migration_drop_accounts_table_v1",
+    version: 25,
+    description:
+      "Drop the unused legacy accounts table and its leftover indexes after account_manage removal",
+  },
+  {
+    key: "migration_reminders_to_schedules_v1",
+    version: 26,
+    description:
+      "Copy all existing reminders into cron_jobs as one-shot schedules with correct status and field mapping",
+  },
+  {
+    key: "migration_drop_reminders_table_v1",
+    version: 27,
+    dependsOn: ["migration_reminders_to_schedules_v1"],
+    description:
+      "Drop the legacy reminders table and its index after data migration to cron_jobs",
+  },
 ];
 
 export interface MigrationValidationResult {