@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/memory/memory-retrospective-startup-cleanup.ts

@@ -24,11 +24,20 @@
 //     conversation might be the active one. We're conservative and only
 //     sweep when no job exists at all, since the worst-case false-positive
 //     is leaving a few extra orphans for the next sweep to catch.)
-//   - AND the row is NOT the most-recent retrospective for its source
-//     conversation. The next retrospective run reads the most-recent prior
-//     retro via `findMostRecentRetrospectiveFor` to seed its
-//     `<already_remembered>` dedup block; sweeping it would force the
-//     next run to re-save facts the prior pass already captured.
+//   - AND the row is NOT the preserved dedup baseline for its source
+//     conversation. The primary dedup baseline is the persisted
+//     `remembered_log` on `memory_retrospective_state`, but state rows that
+//     predate the log column fall back to scanning the most-recent prior
+//     retro (via `findMostRecentRetrospectiveFor`) to seed their
+//     `<already_remembered>` dedup block; sweeping it would force such a
+//     run to re-save facts the prior pass already captured. The baseline is
+//     the most recent row that actually produced output (see
+//     `selectPreservedBaseline`) — a crash orphan with no post-fork
+//     assistant message would seed an EMPTY dedup block, so when an older
+//     row with output exists we preserve that one instead.
+//
+// The sweep is skipped entirely when `memory.retrospective.keepSupersededRuns`
+// is true — see the comment inside the function.
 
 import {
   and,
@@ -42,16 +51,27 @@ import {
   sql,
 } from "drizzle-orm";
 
+import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
 import { deleteConversation } from "./conversation-crud.js";
 import { getDb } from "./db-connection.js";
 import { MEMORY_RETROSPECTIVE_SOURCES } from "./memory-retrospective-constants.js";
+import { loadRetrospectiveRunMessages } from "./memory-retrospective-fork-boundary.js";
 import { conversations, memoryJobs } from "./schema.js";
 
 const log = getLogger("memory-retrospective-startup-cleanup");
 
 const ORPHAN_AGE_MS = 60 * 60 * 1000;
 
+/**
+ * How many of the newest retrospective rows per source the baseline selector
+ * will load messages for when looking for one with output. Bounds the
+ * per-startup query volume — after GC (`deleteSupersededPriorRetrospective`)
+ * a source normally has 1–2 retro rows, so this only matters for pathological
+ * crash pileups, where the older rows are orphans too.
+ */
+const MAX_BASELINE_CANDIDATES_PER_SOURCE = 3;
+
 export interface CleanupResult {
   swept: number;
 }
@@ -65,6 +85,16 @@ export interface CleanupResult {
 export function sweepOrphanMemoryRetrospectiveConversations(
   now: number = Date.now(),
 ): CleanupResult {
+  // When the operator opted into retaining superseded retrospective runs
+  // (`memory.retrospective.keepSupersededRuns`), skip the sweep entirely —
+  // retained runs must survive restarts, and the sweep cannot distinguish a
+  // retained superseded run from a crash orphan. Tradeoff: under this opt-in,
+  // genuine crash orphans persist too. That's acceptable — the operator asked
+  // for full run history, and an orphan is just one more retained conversation.
+  if (getConfig().memory?.retrospective?.keepSupersededRuns === true) {
+    return { swept: 0 };
+  }
+
   const cutoff = now - ORPHAN_AGE_MS;
   const db = getDb();
 
@@ -90,13 +120,14 @@ export function sweepOrphanMemoryRetrospectiveConversations(
     .map((row) => row.conversationId)
     .filter((id): id is string => typeof id === "string" && id.length > 0);
 
-  // Compute the most-recent retro per source so we can preserve it.
-  // `findMostRecentRetrospectiveFor` (called by the next retrospective run)
-  // pulls dedup context from this row; sweeping it would re-introduce the
-  // unbounded retrospective growth this cleanup exists to prevent.
+  // Compute the preserved dedup baseline per source. Runs whose state row
+  // predates the persisted `remembered_log` pull dedup context by scanning
+  // the most-recent prior retro (via `findMostRecentRetrospectiveFor`);
+  // sweeping it would leave those runs with no baseline at all.
   const allRetros = db
     .select({
       id: conversations.id,
+      source: conversations.source,
       forkParentConversationId: conversations.forkParentConversationId,
       createdAt: conversations.createdAt,
     })
@@ -108,21 +139,21 @@ export function sweepOrphanMemoryRetrospectiveConversations(
       ),
     )
     .all();
-  const mostRecentPerSource = new Map<
-    string,
-    { id: string; createdAt: number }
-  >();
+  const retrosPerSource = new Map<string, RetroRow[]>();
   for (const row of allRetros) {
     const parent = row.forkParentConversationId;
     if (parent === null) continue;
-    const cur = mostRecentPerSource.get(parent);
-    if (!cur || row.createdAt > cur.createdAt) {
-      mostRecentPerSource.set(parent, { id: row.id, createdAt: row.createdAt });
+    const rows = retrosPerSource.get(parent);
+    if (rows) {
+      rows.push(row);
+    } else {
+      retrosPerSource.set(parent, [row]);
     }
   }
-  const preservedIds = new Set(
-    Array.from(mostRecentPerSource.values(), (v) => v.id),
-  );
+  const preservedIds = new Set<string>();
+  for (const rows of retrosPerSource.values()) {
+    preservedIds.add(selectPreservedBaseline(rows));
+  }
 
   const orphans = db
     .select({ id: conversations.id })
@@ -173,3 +204,50 @@ export function sweepOrphanMemoryRetrospectiveConversations(
   }
   return { swept };
 }
+
+interface RetroRow {
+  id: string;
+  source: string | null;
+  createdAt: number;
+}
+
+/**
+ * Pick which retrospective row to preserve as the source's dedup baseline:
+ * the most recent row that actually produced output (a crash orphan with no
+ * post-fork assistant message would seed the next run with an EMPTY
+ * `<already_remembered>` block and cause re-saves). Falls back to the plain
+ * most-recent row when no candidate qualifies — preserves the previous
+ * behavior when every row is an orphan, and an orphan baseline at least
+ * keeps `findMostRecentRetrospectiveFor` stable until a successful run
+ * supersedes it.
+ *
+ * PR-E's persisted `remembered_log` reduces the impact of preserving a bad
+ * baseline (the next run can fall back to the persisted log), but the log
+ * fallback path still reads the preserved conversation, so the sweep should
+ * keep preferring a row that's actually useful.
+ *
+ * Only loads messages for the newest `MAX_BASELINE_CANDIDATES_PER_SOURCE`
+ * rows — never for every retro row.
+ */
+function selectPreservedBaseline(rows: RetroRow[]): string {
+  const sorted = [...rows].sort((a, b) => b.createdAt - a.createdAt);
+  const withOutput = sorted
+    .slice(0, MAX_BASELINE_CANDIDATES_PER_SOURCE)
+    .find(retrospectiveHasOutput);
+  return (withOutput ?? sorted[0]!).id;
+}
+
+/**
+ * Whether the retrospective row produced any assistant output of its own.
+ * `loadRetrospectiveRunMessages` scopes fork-kind rows to the post-fork tail
+ * (the copied source prefix contains the source's own assistant turns) and
+ * returns `null` for rows whose output cannot be determined (load failure or
+ * no detectable fork boundary) — those rows contribute nothing to dedup
+ * (`collectPriorRetrospectiveRemembers` treats them as empty), so they don't
+ * qualify. Legacy-kind rows start empty, so any assistant message counts.
+ */
+function retrospectiveHasOutput(row: RetroRow): boolean {
+  const runMessages = loadRetrospectiveRunMessages(row.id, row.source);
+  if (runMessages == null) return false;
+  return runMessages.some((m) => m.role === "assistant");
+}

package/src/memory/memory-retrospective-state.ts

@@ -10,6 +10,13 @@
 //     per-conversation cooldown gate in the trigger-check helper so failing
 //     jobs can't loop in tight retries across trigger types.
 //
+// A third column rides along with the success-path pointer write:
+//   - `rememberedLog` (JSON array of strings) — the cumulative `remember`
+//     contents saved across retrospective passes. The job's
+//     `<already_remembered>` dedup block reads from this log so dedup context
+//     survives GC of superseded retrospective conversations and spans more
+//     than the last pass. Capped — see `appendToRememberedLog`.
+//
 // The schema enforces the foreign key with ON DELETE CASCADE, so deleting a
 // conversation collects its state row automatically.
 
@@ -22,6 +29,59 @@ export interface MemoryRetrospectiveState {
   conversationId: string;
   lastProcessedMessageId: string;
   lastRunAt: number;
+  /**
+   * Cumulative `remember` contents from prior retrospective passes, oldest
+   * first. Empty for rows that predate the `remembered_log` column or have
+   * no saves yet — callers fall back to scanning the prior retrospective
+   * conversation in that case.
+   */
+  rememberedLog: string[];
+}
+
+/**
+ * Cap for the persisted remembered log: keep the most recent entries up to
+ * 100 entries or 8 KB serialized, whichever binds first. The log is injected
+ * verbatim into every retrospective prompt, so the byte cap bounds prompt
+ * growth; the entry cap bounds list length for pathological tiny entries.
+ */
+export const REMEMBERED_LOG_MAX_ENTRIES = 100;
+export const REMEMBERED_LOG_MAX_BYTES = 8 * 1024;
+
+/**
+ * Append new entries to the remembered log and apply the cap, dropping the
+ * OLDEST entries first. A single entry larger than the byte cap is dropped
+ * entirely rather than truncated mid-string.
+ */
+export function appendToRememberedLog(
+  existing: string[],
+  newEntries: string[],
+): string[] {
+  const combined = [...existing, ...newEntries];
+  let result = combined.slice(
+    Math.max(0, combined.length - REMEMBERED_LOG_MAX_ENTRIES),
+  );
+  while (
+    result.length > 0 &&
+    Buffer.byteLength(JSON.stringify(result), "utf8") > REMEMBERED_LOG_MAX_BYTES
+  ) {
+    result = result.slice(1);
+  }
+  return result;
+}
+
+function parseRememberedLog(raw: string | null): string[] {
+  if (!raw) return [];
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((entry): entry is string => typeof entry === "string");
+  } catch {
+    return [];
+  }
+}
+
+function serializeRememberedLog(log: string[]): string | null {
+  return log.length === 0 ? null : JSON.stringify(log);
 }
 
 /**
@@ -40,25 +100,43 @@ export function getRetrospectiveState(
     conversationId: row.conversationId,
     lastProcessedMessageId: row.lastProcessedMessageId,
     lastRunAt: row.lastRunAt,
+    rememberedLog: parseRememberedLog(row.rememberedLog),
   };
 }
 
 /**
  * Upsert both pointers atomically. Used on successful retrospective runs.
+ *
+ * `rememberedLog`, when provided, is written in the same statement so the
+ * cumulative dedup log can never drift from the pointer it was computed
+ * against. When omitted, the stored log is left untouched (and seeded NULL on
+ * first insert).
  */
-export function upsertRetrospectiveState(args: MemoryRetrospectiveState): void {
+export function upsertRetrospectiveState(
+  args: Omit<MemoryRetrospectiveState, "rememberedLog"> & {
+    rememberedLog?: string[];
+  },
+): void {
   const db = getDb();
+  const serializedLog =
+    args.rememberedLog === undefined
+      ? undefined
+      : serializeRememberedLog(args.rememberedLog);
   db.insert(memoryRetrospectiveState)
     .values({
       conversationId: args.conversationId,
       lastProcessedMessageId: args.lastProcessedMessageId,
       lastRunAt: args.lastRunAt,
+      rememberedLog: serializedLog ?? null,
     })
     .onConflictDoUpdate({
       target: memoryRetrospectiveState.conversationId,
       set: {
         lastProcessedMessageId: args.lastProcessedMessageId,
         lastRunAt: args.lastRunAt,
+        ...(serializedLog !== undefined
+          ? { rememberedLog: serializedLog }
+          : {}),
       },
     })
     .run();
@@ -83,6 +161,8 @@ export function upsertRetrospectiveState(args: MemoryRetrospectiveState): void {
  *     wait for new post-fork messages before its first retro fires.
  *
  * `lastRunAt` is copied verbatim — the cooldown gate inherits from source.
+ * `rememberedLog` is copied verbatim — the parent's saves remain the child's
+ * dedup baseline.
  */
 export function forkRetrospectiveState(args: {
   database: DrizzleDb;
@@ -125,12 +205,14 @@ export function forkRetrospectiveState(args: {
       conversationId: forkedConversationId,
       lastProcessedMessageId: forkedPointer,
       lastRunAt: sourceRow.lastRunAt,
+      rememberedLog: sourceRow.rememberedLog,
     })
     .onConflictDoUpdate({
       target: memoryRetrospectiveState.conversationId,
       set: {
         lastProcessedMessageId: forkedPointer,
         lastRunAt: sourceRow.lastRunAt,
+        rememberedLog: sourceRow.rememberedLog,
       },
     })
     .run();
@@ -141,7 +223,8 @@ export function forkRetrospectiveState(args: {
  * applies to subsequent trigger-driven enqueues. If no row exists yet (first
  * attempt failed), seed `lastProcessedMessageId` to the empty string — a
  * sentinel meaning "nothing successfully processed yet" that subsequent
- * `getMessagesSince(...)` queries treat the same as a missing row.
+ * `getMessagesSince(...)` queries treat the same as a missing row. An
+ * existing row's `rememberedLog` is left untouched.
  */
 export function bumpRetrospectiveLastRunAt(
   conversationId: string,

package/src/memory/migrations/281-memory-retrospective-remembered-log.ts

@@ -0,0 +1,40 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_memory_retrospective_remembered_log_v1";
+
+const TABLE = "memory_retrospective_state";
+const COLUMN = "remembered_log";
+
+/**
+ * Add a nullable `remembered_log TEXT` column to `memory_retrospective_state`.
+ *
+ * Stores a JSON array of strings — the cumulative `remember` contents saved
+ * by retrospective passes over the conversation (capped; see
+ * `memory-retrospective-state.ts`). The retrospective job's
+ * `<already_remembered>` dedup block reads from this log so it survives GC of
+ * superseded retrospective conversations and spans more than the last pass.
+ *
+ * `NULL` for rows persisted before this migration ran — the job falls back
+ * to scanning the prior retrospective conversation for those.
+ *
+ * Idempotent — the PRAGMA guard makes re-running a no-op once the column
+ * exists.
+ */
+export function migrateMemoryRetrospectiveRememberedLog(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+
+    const columns = raw.query(`PRAGMA table_info(${TABLE})`).all() as Array<{
+      name: string;
+    }>;
+    const columnNames = new Set(columns.map((c) => c.name));
+
+    if (!columnNames.has(COLUMN)) {
+      raw.exec(`ALTER TABLE ${TABLE} ADD COLUMN ${COLUMN} TEXT`);
+    }
+  });
+}

package/src/memory/migrations/282-schedule-inference-profile.test.ts

@@ -0,0 +1,77 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateScheduleInferenceProfile } from "./282-schedule-inference-profile.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  // Pre-282 shape: no inference_profile column (trimmed to the columns the
+  // migration and assertions touch).
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE cron_jobs (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      message TEXT NOT NULL,
+      next_run_at INTEGER NOT NULL,
+      created_by TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function columnNames(sqlite: Database): string[] {
+  return (
+    sqlite.query("PRAGMA table_info(cron_jobs)").all() as Array<{
+      name: string;
+    }>
+  ).map((c) => c.name);
+}
+
+describe("migration 282: cron_jobs inference_profile", () => {
+  test("adds a nullable inference_profile column", () => {
+    const { sqlite, db } = createTestDb();
+    expect(columnNames(sqlite)).not.toContain("inference_profile");
+
+    migrateScheduleInferenceProfile(db);
+
+    const column = (
+      sqlite.query("PRAGMA table_info(cron_jobs)").all() as Array<{
+        name: string;
+        notnull: number;
+      }>
+    ).find((c) => c.name === "inference_profile");
+    expect(column).toBeDefined();
+    expect(column?.notnull).toBe(0);
+  });
+
+  test("existing rows read back with inference_profile null", () => {
+    const { sqlite, db } = createTestDb();
+    sqlite.exec(/*sql*/ `
+      INSERT INTO cron_jobs (id, name, message, next_run_at, created_by, created_at, updated_at)
+      VALUES ('job-1', 'Daily digest', 'write the digest', 1000, 'agent', 1000, 1000)
+    `);
+
+    migrateScheduleInferenceProfile(db);
+
+    const row = sqlite
+      .query("SELECT inference_profile FROM cron_jobs WHERE id = 'job-1'")
+      .get() as { inference_profile: string | null };
+    expect(row.inference_profile).toBeNull();
+  });
+
+  test("is idempotent — re-run is a no-op", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateScheduleInferenceProfile(db);
+    expect(() => migrateScheduleInferenceProfile(db)).not.toThrow();
+
+    expect(
+      columnNames(sqlite).filter((name) => name === "inference_profile"),
+    ).toHaveLength(1);
+  });
+});

package/src/memory/migrations/282-schedule-inference-profile.ts

@@ -0,0 +1,26 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Add a nullable `inference_profile TEXT` column to `cron_jobs`.
+ *
+ * Stores the `llm.profiles` key a schedule's LLM-executed runs should use as
+ * their per-turn inference-profile override. `NULL` (all pre-existing rows)
+ * means no override — runs resolve through the default `mainAgent` call-site
+ * configuration, exactly as before this migration.
+ *
+ * Idempotent — the PRAGMA guard makes re-running a no-op once the column
+ * exists.
+ */
+export function migrateScheduleInferenceProfile(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  const columns = raw.query(`PRAGMA table_info(cron_jobs)`).all() as Array<{
+    name: string;
+  }>;
+  const columnNames = new Set(columns.map((c) => c.name));
+
+  if (!columnNames.has("inference_profile")) {
+    raw.exec(`ALTER TABLE cron_jobs ADD COLUMN inference_profile TEXT`);
+  }
+}

package/src/memory/migrations/283-memory-v3-selections-message-id-and-sections.test.ts

@@ -0,0 +1,102 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateMemoryV3SelectionsMessageIdAndSections } from "./283-memory-v3-selections-message-id-and-sections.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  // Pre-283 shape: slug/source/pinned only, no message_id or section columns.
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE memory_v3_selections (
+      conversation_id TEXT NOT NULL,
+      turn INTEGER NOT NULL,
+      slug TEXT NOT NULL,
+      source TEXT NOT NULL,
+      pinned INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (conversation_id, turn, slug)
+    )
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function columnNames(sqlite: Database): string[] {
+  return (
+    sqlite.query("PRAGMA table_info(memory_v3_selections)").all() as Array<{
+      name: string;
+    }>
+  ).map((c) => c.name);
+}
+
+function indexNames(sqlite: Database): string[] {
+  return (
+    sqlite.query("PRAGMA index_list(memory_v3_selections)").all() as Array<{
+      name: string;
+    }>
+  ).map((i) => i.name);
+}
+
+describe("migration 283: memory_v3_selections message_id + section columns", () => {
+  test("adds nullable message_id, section_ordinal, section_title + message_id index", () => {
+    const { sqlite, db } = createTestDb();
+    expect(columnNames(sqlite)).not.toContain("message_id");
+
+    migrateMemoryV3SelectionsMessageIdAndSections(db);
+
+    const cols = sqlite
+      .query("PRAGMA table_info(memory_v3_selections)")
+      .all() as Array<{ name: string; notnull: number }>;
+    for (const name of ["message_id", "section_ordinal", "section_title"]) {
+      const col = cols.find((c) => c.name === name);
+      expect(col).toBeDefined();
+      expect(col?.notnull).toBe(0); // nullable
+    }
+    expect(indexNames(sqlite)).toContain("idx_memory_v3_selections_message");
+  });
+
+  test("existing rows read back with the new columns null", () => {
+    const { sqlite, db } = createTestDb();
+    sqlite.exec(/*sql*/ `
+      INSERT INTO memory_v3_selections
+        (conversation_id, turn, slug, source, pinned, created_at)
+      VALUES ('conv-1', 0, 'a/page', 'needle', 0, 1000)
+    `);
+
+    migrateMemoryV3SelectionsMessageIdAndSections(db);
+
+    const row = sqlite
+      .query(
+        `SELECT message_id, section_ordinal, section_title
+           FROM memory_v3_selections WHERE conversation_id = 'conv-1'`,
+      )
+      .get() as {
+      message_id: string | null;
+      section_ordinal: number | null;
+      section_title: string | null;
+    };
+    expect(row.message_id).toBeNull();
+    expect(row.section_ordinal).toBeNull();
+    expect(row.section_title).toBeNull();
+  });
+
+  test("is idempotent — re-run is a no-op", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateMemoryV3SelectionsMessageIdAndSections(db);
+    expect(() =>
+      migrateMemoryV3SelectionsMessageIdAndSections(db),
+    ).not.toThrow();
+
+    expect(columnNames(sqlite).filter((n) => n === "message_id")).toHaveLength(
+      1,
+    );
+    expect(
+      indexNames(sqlite).filter(
+        (n) => n === "idx_memory_v3_selections_message",
+      ),
+    ).toHaveLength(1);
+  });
+});

package/src/memory/migrations/283-memory-v3-selections-message-id-and-sections.ts

@@ -0,0 +1,53 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Add three nullable columns to `memory_v3_selections` for the inspector's
+ * Memory V3 panel:
+ *
+ *   - `message_id TEXT` — the turn's assistant message id, backfilled at turn
+ *     end (mirrors the v2 activation log). The inspector looks selections up by
+ *     the inspected message's turn message ids, which is robust against the
+ *     drift between v2's tracker turn and v3's orchestrator `turnCount` that
+ *     previously left the panel blank. NULL for pre-existing rows and until the
+ *     turn-end backfill stamps it.
+ *   - `section_ordinal INTEGER` / `section_title TEXT` — the matched section a
+ *     finder-lane selection surfaced (from `OrchestrateResult.matchedSections`).
+ *     NULL for pre-existing rows and for core/hot/fresh/edge selections that
+ *     carry no matched section (those render full-page, as before).
+ *
+ * All three are nullable and append-only — old rows degrade to the prior
+ * page-level / turn-keyed behavior. The PK (conversation_id, turn, slug) is
+ * unchanged; these are secondary attributes. The existing offline A/B readers
+ * (`summarizeSelections`, hot-set, learned-edges, prune) ignore them.
+ *
+ * Idempotent — the PRAGMA guards make re-running a no-op once the columns
+ * exist, and the index uses IF NOT EXISTS.
+ */
+export function migrateMemoryV3SelectionsMessageIdAndSections(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+
+  const columns = raw
+    .query(`PRAGMA table_info(memory_v3_selections)`)
+    .all() as Array<{ name: string }>;
+  const columnNames = new Set(columns.map((c) => c.name));
+
+  if (!columnNames.has("message_id")) {
+    raw.exec(`ALTER TABLE memory_v3_selections ADD COLUMN message_id TEXT`);
+  }
+  if (!columnNames.has("section_ordinal")) {
+    raw.exec(
+      `ALTER TABLE memory_v3_selections ADD COLUMN section_ordinal INTEGER`,
+    );
+  }
+  if (!columnNames.has("section_title")) {
+    raw.exec(`ALTER TABLE memory_v3_selections ADD COLUMN section_title TEXT`);
+  }
+
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_memory_v3_selections_message
+       ON memory_v3_selections (message_id)`,
+  );
+}

package/src/memory/migrations/284-workflow-runs.ts

@@ -0,0 +1,51 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+/**
+ * Create the workflow-engine persistence tables.
+ *
+ * `workflow_runs` is one row per orchestration run (a sandboxed script that
+ * spawns parallel leaf agents). `workflow_journal` is an append-only log of
+ * every leaf call (agent / host function / nested workflow) keyed by
+ * `(run_id, seq)`, so a run can RESUME after a daemon restart by replaying
+ * cached results for the unchanged call prefix.
+ *
+ * Idempotent — re-running is a no-op once the tables and index exist.
+ */
+export function migrateWorkflowRuns(database: DrizzleDb): void {
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS workflow_runs (
+      id TEXT PRIMARY KEY,
+      name TEXT,
+      script_source TEXT NOT NULL,
+      script_hash TEXT NOT NULL,
+      args_json TEXT,
+      capabilities_json TEXT,
+      status TEXT NOT NULL,
+      conversation_id TEXT,
+      agents_spawned INTEGER NOT NULL DEFAULT 0,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      result_json TEXT,
+      error TEXT,
+      created_at INTEGER,
+      updated_at INTEGER,
+      finished_at INTEGER
+    )
+  `);
+  database.run(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_workflow_runs_status_created_at ON workflow_runs (status, created_at)`,
+  );
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS workflow_journal (
+      run_id TEXT NOT NULL,
+      seq INTEGER NOT NULL,
+      call_hash TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      request_json TEXT,
+      result_json TEXT,
+      status TEXT NOT NULL,
+      created_at INTEGER,
+      PRIMARY KEY (run_id, seq)
+    )
+  `);
+}