@vellumai/assistant 0.5.2 → 0.5.4

package/src/memory/job-handlers/reduce-conversation-memory.ts

@@ -0,0 +1,229 @@
+/**
+ * Job handler for `reduce_conversation_memory`.
+ *
+ * Ties together the reducer service ({@link runReducer}) and the transactional
+ * store ({@link applyReducerResult}) to process unreduced conversation turns
+ * as a background job.
+ *
+ * The handler:
+ *   1. Loads the conversation and validates the dirty tail marker.
+ *   2. Loads the unreduced message span (messages since the dirty tail).
+ *   3. Loads active time contexts and open loops for the conversation's scope.
+ *   4. Includes the current `contextSummary` when present (prepended as a
+ *      synthetic system message so the reducer has compacted context).
+ *   5. Calls `runReducer` with the assembled input.
+ *   6. Applies the result transactionally via `applyReducerResult`.
+ *
+ * If the reducer fails or returns the {@link EMPTY_REDUCER_RESULT} sentinel
+ * (unparseable output), the checkpoint is NOT advanced — the dirty tail stays
+ * in place so the next run retries. A valid-but-empty model response (e.g.
+ * `{}`) returns a normal empty result that advances the checkpoint normally.
+ */
+
+import { and, asc, eq, gte } from "drizzle-orm";
+
+import { getLogger } from "../../util/logger.js";
+import { type ConversationRow, getConversation } from "../conversation-crud.js";
+import { getDb } from "../db.js";
+import { asString } from "../job-utils.js";
+import type { MemoryJob } from "../jobs-store.js";
+import { type ReducerPromptInput, runReducer } from "../reducer.js";
+import {
+  applyReducerResult,
+  getActiveOpenLoops,
+  getActiveTimeContexts,
+} from "../reducer-store.js";
+import { EMPTY_REDUCER_RESULT } from "../reducer-types.js";
+import { messages } from "../schema.js";
+
+const log = getLogger("reduce-conversation-memory-job");
+
+export interface ReduceConversationMemoryPayload {
+  conversationId: string;
+}
+
+/**
+ * Process a `reduce_conversation_memory` job.
+ *
+ * @throws Re-throws reducer errors so the job worker can classify and retry.
+ */
+export async function reduceConversationMemoryJob(
+  job: MemoryJob,
+): Promise<void> {
+  const conversationId = asString(job.payload.conversationId);
+  if (!conversationId) {
+    log.warn({ jobId: job.id }, "Missing conversationId in job payload");
+    return;
+  }
+
+  // ── 1. Load conversation and validate dirty tail ────────────────
+  const conversation = getConversation(conversationId);
+  if (!conversation) {
+    log.warn(
+      { jobId: job.id, conversationId },
+      "Conversation not found, skipping reduction",
+    );
+    return;
+  }
+
+  const dirtyTailMessageId = conversation.memoryDirtyTailSinceMessageId;
+  if (!dirtyTailMessageId) {
+    log.debug(
+      { jobId: job.id, conversationId },
+      "No dirty tail marker — conversation is already fully reduced",
+    );
+    return;
+  }
+
+  // ── 2. Load unreduced message span ──────────────────────────────
+  const unreducedMessages = loadUnreducedMessages(
+    conversationId,
+    dirtyTailMessageId,
+  );
+
+  if (unreducedMessages.length === 0) {
+    log.debug(
+      { jobId: job.id, conversationId, dirtyTailMessageId },
+      "No messages found from dirty tail — nothing to reduce",
+    );
+    return;
+  }
+
+  // ── 3. Load active brief-state context ──────────────────────────
+  const scopeId = conversation.memoryScopeId;
+  const now = Date.now();
+
+  const existingTimeContexts = getActiveTimeContexts(scopeId, now);
+  const existingOpenLoops = getActiveOpenLoops(scopeId);
+
+  // ── 4. Build reducer input ──────────────────────────────────────
+  const newMessages = buildNewMessages(conversation, unreducedMessages);
+
+  const reducerInput: ReducerPromptInput = {
+    conversationId,
+    newMessages,
+    existingTimeContexts: existingTimeContexts.map((tc) => ({
+      id: tc.id,
+      summary: tc.summary,
+    })),
+    existingOpenLoops: existingOpenLoops.map((ol) => ({
+      id: ol.id,
+      summary: ol.summary,
+      status: ol.status,
+    })),
+    nowMs: now,
+    scopeId,
+  };
+
+  // ── 5. Run the reducer ──────────────────────────────────────────
+  const result = await runReducer(reducerInput);
+
+  // If the reducer returns the empty sentinel, skip applying — the dirty
+  // tail stays in place so a future run can retry.
+  if (result === EMPTY_REDUCER_RESULT) {
+    log.warn(
+      { jobId: job.id, conversationId },
+      "Reducer returned empty result — not advancing checkpoint",
+    );
+    return;
+  }
+
+  // ── 6. Apply result transactionally ─────────────────────────────
+  const lastMessage = unreducedMessages[unreducedMessages.length - 1];
+  applyReducerResult({
+    result,
+    conversationId,
+    scopeId,
+    reducedThroughMessageId: lastMessage.id,
+    now,
+  });
+
+  log.info(
+    {
+      jobId: job.id,
+      conversationId,
+      reducedThroughMessageId: lastMessage.id,
+      messageCount: unreducedMessages.length,
+      timeContextOps: result.timeContexts.length,
+      openLoopOps: result.openLoops.length,
+    },
+    "Conversation memory reduction completed",
+  );
+}
+
+// ── Internal helpers ────────────────────────────────────────────────
+
+interface MessageRow {
+  id: string;
+  role: string;
+  content: string;
+  createdAt: number;
+}
+
+/**
+ * Load messages from `dirtyTailMessageId` onward (inclusive), ordered by
+ * createdAt ascending. Uses the message's createdAt as the boundary since
+ * message ordering is timestamp-based.
+ */
+function loadUnreducedMessages(
+  conversationId: string,
+  dirtyTailMessageId: string,
+): MessageRow[] {
+  const db = getDb();
+
+  // First, find the createdAt of the dirty tail message
+  const tailMessage = db
+    .select({ createdAt: messages.createdAt })
+    .from(messages)
+    .where(eq(messages.id, dirtyTailMessageId))
+    .get();
+
+  if (!tailMessage) {
+    return [];
+  }
+
+  // Load all messages from that timestamp onward
+  return db
+    .select({
+      id: messages.id,
+      role: messages.role,
+      content: messages.content,
+      createdAt: messages.createdAt,
+    })
+    .from(messages)
+    .where(
+      and(
+        eq(messages.conversationId, conversationId),
+        gte(messages.createdAt, tailMessage.createdAt),
+      ),
+    )
+    .orderBy(asc(messages.createdAt))
+    .all();
+}
+
+/**
+ * Build the `newMessages` array for the reducer input.
+ *
+ * When the conversation has a `contextSummary` (from context window
+ * compaction), it is prepended as a synthetic `system` message so the
+ * reducer has access to prior compacted context.
+ */
+function buildNewMessages(
+  conversation: ConversationRow,
+  unreducedMessages: MessageRow[],
+): Array<{ role: string; content: string }> {
+  const result: Array<{ role: string; content: string }> = [];
+
+  if (conversation.contextSummary) {
+    result.push({
+      role: "system",
+      content: `[Prior context summary] ${conversation.contextSummary}`,
+    });
+  }
+
+  for (const msg of unreducedMessages) {
+    result.push({ role: msg.role, content: msg.content });
+  }
+
+  return result;
+}

package/src/memory/job-utils.ts

@@ -142,7 +142,7 @@ export function truncate(text: string, max: number): string {
 
 export async function embedAndUpsert(
   config: AssistantConfig,
-  targetType: "segment" | "item" | "summary" | "media",
+  targetType: "segment" | "item" | "summary" | "observation" | "chunk" | "episode" | "media",
   targetId: string,
   input: EmbeddingInput,
   extraPayload?: Record<string, unknown>,

package/src/memory/jobs-store.ts

@@ -12,6 +12,9 @@ export type MemoryJobType =
   | "embed_segment"
   | "embed_item"
   | "embed_summary"
+  | "embed_chunk"
+  | "embed_episode"
+  | "embed_observation"
   | "extract_items"
   | "extract_entities"
   | "cleanup_stale_superseded_items"
@@ -27,6 +30,8 @@ export type MemoryJobType =
   | "embed_media"
   | "embed_attachment"
   | "generate_conversation_starters"
+  | "reduce_conversation_memory"
+  | "backfill_simplified_memory"
   | "generate_capability_cards" // legacy compat — silently dropped by worker (capability cards removed)
   | "generate_thread_starters"; // legacy compat — silently dropped by worker (renamed to generate_conversation_starters)
 
@@ -34,6 +39,9 @@ const EMBED_JOB_TYPES: MemoryJobType[] = [
   "embed_segment",
   "embed_item",
   "embed_summary",
+  "embed_chunk",
+  "embed_episode",
+  "embed_observation",
   "embed_media",
   "embed_attachment",
 ];

package/src/memory/jobs-worker.ts

@@ -3,6 +3,7 @@ import type { AssistantConfig } from "../config/types.js";
 import { getLogger } from "../util/logger.js";
 import { rawRun } from "./db.js";
 import { backfillJob } from "./job-handlers/backfill.js";
+import { backfillSimplifiedMemoryJob } from "./job-handlers/backfill-simplified-memory.js";
 import {
   cleanupStaleSupersededItemsJob,
   pruneOldConversationsJob,
@@ -11,8 +12,11 @@ import { generateConversationStartersJob } from "./job-handlers/conversation-sta
 // ── Per-job-type handlers ──────────────────────────────────────────
 import {
   embedAttachmentJob,
+  embedChunkJob,
+  embedEpisodeJob,
   embedItemJob,
   embedMediaJob,
+  embedObservationJob,
   embedSegmentJob,
   embedSummaryJob,
 } from "./job-handlers/embedding.js";
@@ -22,6 +26,7 @@ import {
   rebuildIndexJob,
 } from "./job-handlers/index-maintenance.js";
 import { mediaProcessingJob } from "./job-handlers/media-processing.js";
+import { reduceConversationMemoryJob } from "./job-handlers/reduce-conversation-memory.js";
 import { buildConversationSummaryJob } from "./job-handlers/summarization.js";
 import {
   BackendUnavailableError,
@@ -267,6 +272,15 @@ async function processJob(
     case "embed_summary":
       await embedSummaryJob(job, config);
       return;
+    case "embed_chunk":
+      await embedChunkJob(job, config);
+      return;
+    case "embed_episode":
+      await embedEpisodeJob(job, config);
+      return;
+    case "embed_observation":
+      await embedObservationJob(job, config);
+      return;
     case "extract_items":
       await extractItemsJob(job);
       return;
@@ -307,6 +321,12 @@ async function processJob(
     case "embed_attachment":
       await embedAttachmentJob(job, config);
       return;
+    case "reduce_conversation_memory":
+      await reduceConversationMemoryJob(job);
+      return;
+    case "backfill_simplified_memory":
+      await backfillSimplifiedMemoryJob(job);
+      return;
     case "generate_conversation_starters":
       await generateConversationStartersJob(job);
       return;

package/src/memory/migrations/036-normalize-phone-identities.ts

@@ -79,9 +79,27 @@ export function migrateNormalizePhoneIdentities(database: DrizzleDb): void {
       .get(table);
     const orderBy = hasUpdatedAt ? "updated_at DESC, rowid DESC" : "rowid DESC";
 
-    const selectColumns = [`id`, column];
+    // Filter uniqueKeyScope to only include peer columns that actually exist in the table.
+    // If a peer column is missing, its unique index can't exist either, so no collision risk.
+    let effectiveScope = uniqueKeyScope;
     if (uniqueKeyScope) {
-      for (const peer of uniqueKeyScope.peerColumns) {
+      const validPeers = uniqueKeyScope.peerColumns.filter(
+        (col) =>
+          !!raw
+            .query(`SELECT 1 FROM pragma_table_info(?) WHERE name = ?`)
+            .get(table, col),
+      );
+      effectiveScope =
+        validPeers.length === uniqueKeyScope.peerColumns.length
+          ? uniqueKeyScope
+          : validPeers.length > 0
+            ? { ...uniqueKeyScope, peerColumns: validPeers }
+            : undefined;
+    }
+
+    const selectColumns = [`id`, column];
+    if (effectiveScope) {
+      for (const peer of effectiveScope.peerColumns) {
         if (!selectColumns.includes(peer)) selectColumns.push(peer);
       }
     }
@@ -104,14 +122,14 @@ export function migrateNormalizePhoneIdentities(database: DrizzleDb): void {
       if (!original) continue;
       const normalized = normalizePhoneNumber(original);
       if (normalized && normalized !== original) {
-        if (uniqueKeyScope) {
+        if (effectiveScope) {
           // Check if another row already has the normalized value within the same unique-key scope
-          const peerConditions = uniqueKeyScope.peerColumns
+          const peerConditions = effectiveScope.peerColumns
             .map((col) => `${col} = ?`)
             .join(" AND ");
-          const peerValues = uniqueKeyScope.peerColumns.map((col) => row[col]);
-          const whereExtra = uniqueKeyScope.whereClause
-            ? ` AND (${uniqueKeyScope.whereClause})`
+          const peerValues = effectiveScope.peerColumns.map((col) => row[col]);
+          const whereExtra = effectiveScope.whereClause
+            ? ` AND (${effectiveScope.whereClause})`
             : "";
           const existing = raw
             .query(
@@ -154,9 +172,26 @@ export function migrateNormalizePhoneIdentities(database: DrizzleDb): void {
       .get(table);
     const orderBy = hasUpdatedAt ? "updated_at DESC, rowid DESC" : "rowid DESC";
 
-    const selectColumns = [`id`, column];
+    // Filter uniqueKeyScope to only include peer columns that actually exist in the table.
+    let effectiveScope = uniqueKeyScope;
     if (uniqueKeyScope) {
-      for (const peer of uniqueKeyScope.peerColumns) {
+      const validPeers = uniqueKeyScope.peerColumns.filter(
+        (col) =>
+          !!raw
+            .query(`SELECT 1 FROM pragma_table_info(?) WHERE name = ?`)
+            .get(table, col),
+      );
+      effectiveScope =
+        validPeers.length === uniqueKeyScope.peerColumns.length
+          ? uniqueKeyScope
+          : validPeers.length > 0
+            ? { ...uniqueKeyScope, peerColumns: validPeers }
+            : undefined;
+    }
+
+    const selectColumns = [`id`, column];
+    if (effectiveScope) {
+      for (const peer of effectiveScope.peerColumns) {
         if (!selectColumns.includes(peer)) selectColumns.push(peer);
       }
     }
@@ -179,13 +214,13 @@ export function migrateNormalizePhoneIdentities(database: DrizzleDb): void {
       if (!original) continue;
       const normalized = normalizePhoneNumber(original);
       if (normalized && normalized !== original) {
-        if (uniqueKeyScope) {
-          const peerConditions = uniqueKeyScope.peerColumns
+        if (effectiveScope) {
+          const peerConditions = effectiveScope.peerColumns
             .map((col) => `${col} = ?`)
             .join(" AND ");
-          const peerValues = uniqueKeyScope.peerColumns.map((col) => row[col]);
-          const whereExtra = uniqueKeyScope.whereClause
-            ? ` AND (${uniqueKeyScope.whereClause})`
+          const peerValues = effectiveScope.peerColumns.map((col) => row[col]);
+          const whereExtra = effectiveScope.whereClause
+            ? ` AND (${effectiveScope.whereClause})`
             : "";
           const existing = raw
             .query(

package/src/memory/migrations/135-backfill-contact-interaction-stats.ts

@@ -1,4 +1,4 @@
-import type { DrizzleDb } from "../db-connection.js";
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
 import { withCrashRecovery } from "./validate-migration-state.js";
 
 /**
@@ -7,6 +7,14 @@ import { withCrashRecovery } from "./validate-migration-state.js";
  * existing data, so it stays at 0 and accumulates going forward.
  */
 export function migrateBackfillContactInteractionStats(db: DrizzleDb): void {
+  const raw = getSqliteFrom(db);
+  const colExists = raw
+    .query(
+      `SELECT 1 FROM pragma_table_info('contacts') WHERE name = 'last_interaction'`,
+    )
+    .get();
+  if (!colExists) return;
+
   withCrashRecovery(db, "backfill_contact_interaction_stats", () => {
     db.run(/*sql*/ `
       UPDATE contacts

package/src/memory/migrations/141-rename-verification-table.ts

@@ -18,6 +18,14 @@ export function migrateRenameVerificationTable(database: DrizzleDb): void {
       .get();
     if (!oldTableExists) return;
 
+    // If the new table already exists, the rename would collide — skip
+    const newTableExists = raw
+      .query(
+        `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'channel_verification_sessions'`,
+      )
+      .get();
+    if (newTableExists) return;
+
     // Rename the physical table
     raw.exec(
       /*sql*/ `ALTER TABLE channel_guardian_verification_challenges RENAME TO channel_verification_sessions`,

package/src/memory/migrations/142-rename-verification-session-id-column.ts

@@ -15,14 +15,19 @@ export function migrateRenameVerificationSessionIdColumn(
     () => {
       const raw = getSqliteFrom(database);
 
-      // Check the old column exists before attempting the rename
+      // Check the old column exists and the new column doesn't before attempting the rename.
+      // Both checks are needed for crash recovery: if the rename succeeded but the checkpoint
+      // didn't commit, the old column is gone and the new one already exists.
       const columns = raw
         .query(`PRAGMA table_info(call_sessions)`)
         .all() as Array<{ name: string }>;
       const hasOldColumn = columns.some(
         (c) => c.name === "guardian_verification_session_id",
       );
-      if (!hasOldColumn) return;
+      const hasNewColumn = columns.some(
+        (c) => c.name === "verification_session_id",
+      );
+      if (!hasOldColumn || hasNewColumn) return;
 
       raw.exec(
         /*sql*/ `ALTER TABLE call_sessions RENAME COLUMN guardian_verification_session_id TO verification_session_id`,

package/src/memory/migrations/174-rename-thread-starters-table.ts

@@ -21,6 +21,14 @@ export function migrateRenameThreadStartersTable(database: DrizzleDb): void {
         .get();
       if (!oldTableExists) return;
 
+      // If the new table already exists (crash recovery), skip the rename
+      const newTableExists = raw
+        .query(
+          `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'conversation_starters'`,
+        )
+        .get();
+      if (newTableExists) return;
+
       // Rename the physical table
       raw.exec(
         /*sql*/ `ALTER TABLE thread_starters RENAME TO conversation_starters`,

package/src/memory/migrations/185-memory-brief-state.ts

@@ -0,0 +1,52 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Create the memory brief state tables: time_contexts and open_loops.
+ *
+ * Both tables use CREATE TABLE IF NOT EXISTS and CREATE INDEX IF NOT EXISTS,
+ * making this migration inherently idempotent — safe to re-run on every startup
+ * without a checkpoint guard.
+ */
+export function migrateMemoryBriefState(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  // -- time_contexts: bounded temporal windows for the brief --
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS time_contexts (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      source TEXT NOT NULL,
+      active_from INTEGER NOT NULL,
+      active_until INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_time_contexts_scope_active_until
+    ON time_contexts (scope_id, active_until)
+  `);
+
+  // -- open_loops: unresolved items the brief should surface --
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS open_loops (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'open',
+      source TEXT NOT NULL,
+      due_at INTEGER,
+      surfaced_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_open_loops_scope_status_due
+    ON open_loops (scope_id, status, due_at)
+  `);
+}

package/src/memory/migrations/186-memory-archive.ts

@@ -0,0 +1,109 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Create the memory archive tables (memory_observations, memory_chunks,
+ * memory_episodes) with prefetch indexes on scopeId, conversationId, and
+ * createdAt.
+ *
+ * All statements use IF NOT EXISTS / IF NOT EXISTS guards so the migration
+ * is safe to re-run on every startup.
+ */
+export function migrateMemoryArchiveTables(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  // -- memory_observations --------------------------------------------------
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_observations (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL DEFAULT 'default',
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      message_id TEXT REFERENCES messages(id) ON DELETE SET NULL,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      modality TEXT NOT NULL DEFAULT 'text',
+      source TEXT,
+      created_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_observations_scope_id
+    ON memory_observations (scope_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_observations_conversation_id
+    ON memory_observations (conversation_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_observations_created_at
+    ON memory_observations (created_at)
+  `);
+
+  // -- memory_chunks --------------------------------------------------------
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_chunks (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL DEFAULT 'default',
+      observation_id TEXT NOT NULL REFERENCES memory_observations(id) ON DELETE CASCADE,
+      content TEXT NOT NULL,
+      token_estimate INTEGER NOT NULL,
+      content_hash TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_chunks_scope_id
+    ON memory_chunks (scope_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_chunks_observation_id
+    ON memory_chunks (observation_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_chunks_content_hash
+    ON memory_chunks (scope_id, content_hash)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_chunks_created_at
+    ON memory_chunks (created_at)
+  `);
+
+  // -- memory_episodes ------------------------------------------------------
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_episodes (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL DEFAULT 'default',
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      token_estimate INTEGER NOT NULL,
+      source TEXT,
+      start_at INTEGER NOT NULL,
+      end_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_episodes_scope_id
+    ON memory_episodes (scope_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_episodes_conversation_id
+    ON memory_episodes (conversation_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_episodes_created_at
+    ON memory_episodes (created_at)
+  `);
+}

package/src/memory/migrations/187-memory-reducer-checkpoints.ts

@@ -0,0 +1,19 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateMemoryReducerCheckpoints(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const columns = [
+    "memory_reduced_through_message_id TEXT",
+    "memory_dirty_tail_since_message_id TEXT",
+    "memory_last_reduced_at INTEGER",
+  ];
+
+  for (const column of columns) {
+    try {
+      raw.exec(`ALTER TABLE conversations ADD COLUMN ${column}`);
+    } catch {
+      // Column already exists — nothing to do.
+    }
+  }
+}