@vellumai/assistant 0.10.0-dev.202606200539.c052d10 → 0.10.0-dev.202606201539.0cebd50

package/src/memory/migrations/103-complex-migrations.ts

@@ -1,4 +1,3 @@
-import type { DrizzleDb } from "../db-connection.js";
 import { migrateJobDeferrals } from "./001-job-deferrals.js";
 import { migrateToolInvocationsFk } from "./002-tool-invocations-fk.js";
 import { migrateMemoryEntityRelationDedup } from "./004-entity-relation-dedup.js";
@@ -7,17 +6,19 @@ import { migrateMemoryItemsScopeSaltedFingerprints } from "./006-scope-salted-fi
 import { migrateAssistantIdToSelf } from "./007-assistant-id-to-self.js";
 import { migrateRemoveAssistantIdColumns } from "./008-remove-assistant-id-columns.js";
 import { migrateLlmUsageEventsDropAssistantId } from "./009-llm-usage-events-drop-assistant-id.js";
+import type { MigrationStep } from "./run-migrations.js";
 
 /**
- * Complex multi-step migrations that go beyond simple ALTER TABLE.
+ * Complex multi-step migrations that go beyond simple ALTER TABLE. Spread into
+ * the boot migration list so each runs — and is checkpointed — as its own step.
  */
-export function runComplexMigrations(database: DrizzleDb): void {
-  migrateJobDeferrals(database);
-  migrateToolInvocationsFk(database);
-  migrateMemoryEntityRelationDedup(database);
-  migrateMemoryItemsFingerprintScopeUnique(database);
-  migrateMemoryItemsScopeSaltedFingerprints(database);
-  migrateAssistantIdToSelf(database);
-  migrateRemoveAssistantIdColumns(database);
-  migrateLlmUsageEventsDropAssistantId(database);
-}
+export const complexMigrationSteps: MigrationStep[] = [
+  migrateJobDeferrals,
+  migrateToolInvocationsFk,
+  migrateMemoryEntityRelationDedup,
+  migrateMemoryItemsFingerprintScopeUnique,
+  migrateMemoryItemsScopeSaltedFingerprints,
+  migrateAssistantIdToSelf,
+  migrateRemoveAssistantIdColumns,
+  migrateLlmUsageEventsDropAssistantId,
+];

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

@@ -95,7 +95,7 @@ export function createCoreIndexes(database: DrizzleDb): void {
     /*sql*/ `DROP INDEX IF EXISTS idx_memory_embeddings_provider_model`,
   );
   // Ensure a unique constraint exists on (target_type, target_id, provider, model).
-  // New databases get this via the table-level UNIQUE in 100-core-tables.ts (autoindex),
+  // New databases get this via the table-level UNIQUE in 000-core-tables.ts (autoindex),
   // but for pre-100 databases where CREATE TABLE IF NOT EXISTS was a no-op, the autoindex
   // doesn't exist. Always create the named index — it's a no-op if it already exists and
   // harmless if an autoindex also covers these columns.

package/src/memory/migrations/113-late-migrations.ts

@@ -1,4 +1,3 @@
-import type { DrizzleDb } from "../db-connection.js";
 import { migrateMemoryFtsBackfill } from "./003-memory-fts-backfill.js";
 import { migrateGuardianActionTables } from "./013-guardian-action-tables.js";
 import { migrateMemorySegmentsIndexes } from "./016-memory-segments-indexes.js";
@@ -10,21 +9,24 @@ import { migrateAddOriginInterface } from "./022-add-origin-interface.js";
 import { migrateMemoryItemSourcesIndexes } from "./023-memory-item-sources-indexes.js";
 import { migrateEmbeddingVectorBlob } from "./024-embedding-vector-blob.js";
 import { migrateEmbeddingsNullableVectorJson } from "./026a-embeddings-nullable-vector-json.js";
+import type { MigrationStep } from "./run-migrations.js";
 
 /**
  * Late-stage migrations that must run after all tables and indexes exist:
  * guardian action tables, FTS backfill, index migrations, and channel renames.
+ * Spread into the boot migration list so each runs — and is checkpointed — as
+ * its own step.
  */
-export function runLateMigrations(database: DrizzleDb): void {
-  migrateGuardianActionTables(database);
-  migrateMemoryFtsBackfill(database);
-  migrateMemorySegmentsIndexes(database);
-  migrateMemoryItemsIndexes(database);
-  migrateRemainingTableIndexes(database);
-  migrateRenameChannelToVellum(database);
-  migrateConversationStatusIndexes(database);
-  migrateAddOriginInterface(database);
-  migrateMemoryItemSourcesIndexes(database);
-  migrateEmbeddingVectorBlob(database);
-  migrateEmbeddingsNullableVectorJson(database);
-}
+export const lateMigrationSteps: MigrationStep[] = [
+  migrateGuardianActionTables,
+  migrateMemoryFtsBackfill,
+  migrateMemorySegmentsIndexes,
+  migrateMemoryItemsIndexes,
+  migrateRemainingTableIndexes,
+  migrateRenameChannelToVellum,
+  migrateConversationStatusIndexes,
+  migrateAddOriginInterface,
+  migrateMemoryItemSourcesIndexes,
+  migrateEmbeddingVectorBlob,
+  migrateEmbeddingsNullableVectorJson,
+];

package/src/memory/migrations/297-move-llm-request-logs-to-logs-db.ts

@@ -0,0 +1,130 @@
+import {
+  type DrizzleDb,
+  getSqliteFrom,
+  LOGS_DB_SCHEMA,
+} from "../db-connection.js";
+
+/**
+ * Column names of `llm_request_logs`, in a fixed order used for the
+ * cross-database copy. Listed explicitly (rather than `SELECT *`) so the copy
+ * is insensitive to the physical column order of the `main` table, which varies
+ * with the historical sequence of `ALTER TABLE ... ADD COLUMN` migrations.
+ *
+ * The first columns are the original base columns; the rest were added by later
+ * column migrations.
+ */
+const COLUMN_NAMES = [
+  "id",
+  "conversation_id",
+  "message_id",
+  "provider",
+  "request_payload",
+  "response_payload",
+  "created_at",
+  "agent_loop_exit_reason",
+  "call_site",
+];
+const COLUMNS = COLUMN_NAMES.join(", ");
+
+const CREATE_TABLE = (schema: string): string => /*sql*/ `
+  CREATE TABLE IF NOT EXISTS ${schema}.llm_request_logs (
+    id TEXT PRIMARY KEY,
+    conversation_id TEXT NOT NULL,
+    message_id TEXT,
+    provider TEXT,
+    request_payload TEXT NOT NULL,
+    response_payload TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    agent_loop_exit_reason TEXT,
+    call_site TEXT
+  )
+`;
+
+/**
+ * Create the three indexes in `schema`. The index names are schema-qualified;
+ * the table name in `CREATE INDEX` must be unqualified and is resolved within
+ * the index's schema — so the table must already resolve to `schema` (i.e. no
+ * same-named table shadowing it in `main`) when this runs.
+ */
+function createIndexes(raw: ReturnType<typeof getSqliteFrom>, schema: string) {
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS ${schema}.idx_llm_request_logs_message_id ON llm_request_logs(message_id)`,
+  );
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS ${schema}.idx_llm_request_logs_created_at ON llm_request_logs(created_at)`,
+  );
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS ${schema}.idx_llm_request_logs_conv_created ON llm_request_logs(conversation_id, created_at)`,
+  );
+}
+
+function tableExists(
+  raw: ReturnType<typeof getSqliteFrom>,
+  schema: string,
+): boolean {
+  return (
+    raw
+      .query(
+        `SELECT name FROM ${schema}.sqlite_master WHERE type='table' AND name='llm_request_logs'`,
+      )
+      .get() != null
+  );
+}
+
+/**
+ * Copy every row of `llm_request_logs` from `main` into the `logs` database,
+ * substituting `NULL` for any target column missing in the source. The newer
+ * columns (message_id/provider/agent_loop_exit_reason/call_site) are all
+ * nullable, so NULL is correct for a legacy row that predates them.
+ */
+function copyRowsFromMain(raw: ReturnType<typeof getSqliteFrom>): void {
+  const presentColumns = new Set(
+    (
+      raw
+        .query(`SELECT name FROM pragma_table_info('llm_request_logs', 'main')`)
+        .all() as Array<{ name: string }>
+    ).map((r) => r.name),
+  );
+  const selectList = COLUMN_NAMES.map((c) =>
+    presentColumns.has(c) ? c : "NULL",
+  ).join(", ");
+  raw.exec(/*sql*/ `
+    INSERT OR IGNORE INTO ${LOGS_DB_SCHEMA}.llm_request_logs (${COLUMNS})
+    SELECT ${selectList} FROM main.llm_request_logs
+  `);
+}
+
+/**
+ * Keep `llm_request_logs` housed in the attached append-only `logs` database
+ * (`assistant-logs.db`) rather than the main DB. Keeping this heavy table — and
+ * the request/response payloads it stores — in its own file stops it from
+ * bloating the main DB and its WAL, and lets the two files VACUUM and
+ * checkpoint independently. Once it lives only in `logs`, the unqualified name
+ * used by the Drizzle store resolves to the attached copy, so query code is
+ * unchanged.
+ *
+ * This step is idempotent and runs on every startup (it is not checkpoint-
+ * gated). It must, because the earlier `createWatchersAndLogsTables` migration
+ * recreates an empty `main.llm_request_logs` on every boot via
+ * `CREATE TABLE IF NOT EXISTS`; this step re-relocates and drops that shadow so
+ * the unqualified name keeps resolving to `logs`.
+ *
+ * Ordering within the step matters:
+ *   1. Create the table in `logs` (safe whether or not `main` has it).
+ *   2. If `main` still has the table, copy its rows over (`INSERT OR IGNORE` on
+ *      the id PK, so a re-run is a no-op) and drop it.
+ *   3. Create the indexes — only now is `main` guaranteed not to shadow the
+ *      table, so the unqualified reference resolves to `logs`.
+ */
+export function migrateMoveLlmRequestLogsToLogsDb(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  raw.exec(CREATE_TABLE(LOGS_DB_SCHEMA));
+
+  if (tableExists(raw, "main")) {
+    copyRowsFromMain(raw);
+    raw.exec(`DROP TABLE main.llm_request_logs`);
+  }
+
+  createIndexes(raw, LOGS_DB_SCHEMA);
+}

package/src/memory/migrations/__tests__/297-move-llm-request-logs.test.ts

@@ -0,0 +1,159 @@
+/**
+ * Tests for migration 297 — keeping `llm_request_logs` in the attached
+ * `logs` database.
+ *
+ * Covers:
+ *   1. End state after a full initializeDb(): the table lives in `logs`, not
+ *      `main`, and the Drizzle store round-trips against it.
+ *   2. The relocation itself: rows in a `main.llm_request_logs` are copied into
+ *      `logs` and the main-DB copy is dropped, with indexes built in `logs`.
+ *   3. A legacy base-only `main` table (predating the newer columns) is copied
+ *      without error, NULL-filling the absent columns.
+ *
+ * The step is idempotent and not checkpoint-gated, so each test can drive it
+ * directly without clearing any checkpoint.
+ */
+import { describe, expect, test } from "bun:test";
+
+const { getDb, getSqlite, LOGS_DB_SCHEMA } =
+  await import("../../db-connection.js");
+const { initializeDb } = await import("../../db-init.js");
+const { migrateMoveLlmRequestLogsToLogsDb } =
+  await import("../297-move-llm-request-logs-to-logs-db.js");
+const { recordRequestLog, getRequestLogById } =
+  await import("../../llm-request-log-store.js");
+
+initializeDb();
+
+function tableSchemas(name: string): string[] {
+  return getSqlite()
+    .query<{ schema: string }, []>(
+      `SELECT 'main' AS schema FROM main.sqlite_master WHERE type='table' AND name='${name}'
+       UNION ALL
+       SELECT '${LOGS_DB_SCHEMA}' FROM ${LOGS_DB_SCHEMA}.sqlite_master WHERE type='table' AND name='${name}'`,
+    )
+    .all()
+    .map((r) => r.schema);
+}
+
+describe("migration 297 — llm_request_logs lives in the logs database", () => {
+  test("after init, the table is in logs and not in main", () => {
+    expect(tableSchemas("llm_request_logs")).toEqual([LOGS_DB_SCHEMA]);
+  });
+
+  test("the store round-trips against the relocated table", () => {
+    const id = recordRequestLog(
+      "conv-297",
+      JSON.stringify({ req: 1 }),
+      JSON.stringify({ res: 1 }),
+      "msg-297",
+      "anthropic",
+      "mainAgent",
+    );
+    const row = getRequestLogById(id);
+    expect(row?.conversationId).toBe("conv-297");
+    expect(row?.messageId).toBe("msg-297");
+    expect(row?.provider).toBe("anthropic");
+    expect(row?.callSite).toBe("mainAgent");
+
+    // The written row physically lives in the logs database.
+    const inLogs = getSqlite()
+      .query<
+        { c: number },
+        [string]
+      >(`SELECT COUNT(*) AS c FROM ${LOGS_DB_SCHEMA}.llm_request_logs WHERE id = ?`)
+      .get(id);
+    expect(inLogs?.c).toBe(1);
+  });
+
+  test("relocates rows from a main-DB table and drops it", () => {
+    const sqlite = getSqlite();
+
+    // Simulate the shadow that createWatchersAndLogsTables recreates each boot:
+    // a main-DB table with a row, alongside the logs copy.
+    sqlite.exec(`DROP TABLE IF EXISTS ${LOGS_DB_SCHEMA}.llm_request_logs`);
+    sqlite.exec(`
+      CREATE TABLE main.llm_request_logs (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        message_id TEXT,
+        provider TEXT,
+        request_payload TEXT NOT NULL,
+        response_payload TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        agent_loop_exit_reason TEXT,
+        call_site TEXT
+      )
+    `);
+    sqlite.exec(
+      `INSERT INTO main.llm_request_logs (id, conversation_id, request_payload, response_payload, created_at, provider) VALUES ('legacy-1', 'conv-legacy', '{}', '{}', 123, 'openai')`,
+    );
+
+    migrateMoveLlmRequestLogsToLogsDb(getDb());
+
+    // Main copy gone, logs copy has the row.
+    expect(tableSchemas("llm_request_logs")).toEqual([LOGS_DB_SCHEMA]);
+    const moved = sqlite
+      .query<
+        { conversation_id: string; provider: string },
+        []
+      >(`SELECT conversation_id, provider FROM ${LOGS_DB_SCHEMA}.llm_request_logs WHERE id = 'legacy-1'`)
+      .get();
+    expect(moved?.conversation_id).toBe("conv-legacy");
+    expect(moved?.provider).toBe("openai");
+
+    // Indexes were created in the logs database.
+    const indexes = sqlite
+      .query<{ name: string }, []>(
+        `SELECT name FROM ${LOGS_DB_SCHEMA}.sqlite_master WHERE type='index' AND tbl_name='llm_request_logs'`,
+      )
+      .all()
+      .map((r) => r.name);
+    expect(indexes).toContain("idx_llm_request_logs_message_id");
+    expect(indexes).toContain("idx_llm_request_logs_created_at");
+    expect(indexes).toContain("idx_llm_request_logs_conv_created");
+  });
+
+  test("copies a legacy base-only table, NULL-filling newer columns", () => {
+    const sqlite = getSqlite();
+
+    // A workspace upgrading from a build that predates the
+    // message_id/provider/agent_loop_exit_reason/call_site columns: the main
+    // table has only the original base columns.
+    sqlite.exec(`DROP TABLE IF EXISTS ${LOGS_DB_SCHEMA}.llm_request_logs`);
+    sqlite.exec(`
+      CREATE TABLE main.llm_request_logs (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        request_payload TEXT NOT NULL,
+        response_payload TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      )
+    `);
+    sqlite.exec(
+      `INSERT INTO main.llm_request_logs (id, conversation_id, request_payload, response_payload, created_at) VALUES ('base-1', 'conv-base', '{}', '{}', 7)`,
+    );
+
+    // Must not throw on the absent columns.
+    migrateMoveLlmRequestLogsToLogsDb(getDb());
+
+    expect(tableSchemas("llm_request_logs")).toEqual([LOGS_DB_SCHEMA]);
+    const moved = sqlite
+      .query<
+        {
+          conversation_id: string;
+          message_id: string | null;
+          provider: string | null;
+          call_site: string | null;
+        },
+        []
+      >(
+        `SELECT conversation_id, message_id, provider, call_site FROM ${LOGS_DB_SCHEMA}.llm_request_logs WHERE id = 'base-1'`,
+      )
+      .get();
+    expect(moved?.conversation_id).toBe("conv-base");
+    expect(moved?.message_id).toBeNull();
+    expect(moved?.provider).toBeNull();
+    expect(moved?.call_site).toBeNull();
+  });
+});

package/src/memory/migrations/__tests__/run-migrations.test.ts

@@ -3,8 +3,13 @@ import { describe, expect, test } from "bun:test";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
+import { getSqliteFrom } from "../../db-connection.js";
 import * as schema from "../../schema.js";
-import { type MigrationStep, runMigrationSteps } from "../run-migrations.js";
+import {
+  clearMigrationStepCheckpoints,
+  type MigrationStep,
+  runMigrationSteps,
+} from "../run-migrations.js";
 
 function createTestDb() {
   const sqlite = new Database(":memory:");
@@ -14,10 +19,7 @@ function createTestDb() {
 }
 
 describe("runMigrationSteps — checkpointing", () => {
-  // Skipped: documents the post-checkpointing contract and fails against the
-  // current behavior, which re-runs every forward step on every boot. Promote
-  // to `test` when true checkpointing of initial migrations lands.
-  test.skip("does not re-execute a step that was already applied on a prior run", () => {
+  test("does not re-execute a step that was already applied on a prior run", () => {
     /**
      * Booting an already-migrated database must not re-run forward migration
      * steps. With true checkpointing each step's body executes at most once
@@ -49,4 +51,144 @@ describe("runMigrationSteps — checkpointing", () => {
     // THEN no step body executes a second time
     expect(calls).toEqual({ a: 1, b: 1, c: 1 });
   });
+
+  test("records step completions in the shared memory_checkpoints ledger", () => {
+    /**
+     * Step bookkeeping lives in the same memory_checkpoints table the registry
+     * uses, under the `step:` namespace — one ledger for all applied state.
+     */
+
+    // GIVEN a single named step
+    const db = createTestDb();
+    runMigrationSteps(db, [
+      function dummyMigrationA() {
+        // no-op
+      },
+    ]);
+
+    // THEN its completion is recorded under the step: namespace in memory_checkpoints
+    const row = getSqliteFrom(db)
+      .query(
+        `SELECT value FROM memory_checkpoints WHERE key = 'step:dummyMigrationA'`,
+      )
+      .get() as { value: string } | null;
+    expect(row?.value).toBe("1");
+  });
+
+  test("runs a newly appended step on a later boot while skipping applied ones", () => {
+    /**
+     * Checkpointing must not block migrations added in a later release: an
+     * already-applied step is skipped, but a brand-new step still runs.
+     */
+
+    // GIVEN a database already migrated with two steps
+    const calls = { a: 0, b: 0, c: 0 };
+    const stepA: MigrationStep = function dummyMigrationA() {
+      calls.a++;
+    };
+    const stepB: MigrationStep = function dummyMigrationB() {
+      calls.b++;
+    };
+    const db = createTestDb();
+    runMigrationSteps(db, [stepA, stepB]);
+
+    // AND a third step appended to the list
+    const stepC: MigrationStep = function dummyMigrationC() {
+      calls.c++;
+    };
+
+    // WHEN the expanded list runs against the already-migrated database
+    runMigrationSteps(db, [stepA, stepB, stepC]);
+
+    // THEN only the newly appended step executes
+    expect(calls).toEqual({ a: 1, b: 1, c: 1 });
+  });
+
+  test("recovers crashed migrations before running steps", () => {
+    /**
+     * runMigrationSteps clears stalled `started`/`rolling_back` checkpoints
+     * before the loop so a migration interrupted mid-flight re-runs this boot.
+     */
+
+    // GIVEN a database with a stalled registry checkpoint left by a crash
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    raw.run(
+      `CREATE TABLE IF NOT EXISTS memory_checkpoints (key TEXT PRIMARY KEY, value TEXT NOT NULL, updated_at INTEGER NOT NULL)`,
+    );
+    raw.run(
+      `INSERT INTO memory_checkpoints (key, value, updated_at) VALUES ('migration_stalled_v1', 'started', 0)`,
+    );
+
+    // WHEN the runner executes
+    runMigrationSteps(db, [
+      function dummyMigrationA() {
+        // no-op
+      },
+    ]);
+
+    // THEN the stalled checkpoint has been cleared so its migration can re-run
+    const row = raw
+      .query(
+        `SELECT 1 FROM memory_checkpoints WHERE key = 'migration_stalled_v1'`,
+      )
+      .get();
+    expect(row).toBeNull();
+  });
+
+  test("does not checkpoint a failed step so it retries on the next boot", () => {
+    /**
+     * A step whose body throws is reported in `failed` and left uncheckpointed,
+     * so the next boot retries it instead of silently skipping it.
+     */
+
+    // GIVEN a step that throws on its first run and succeeds afterwards
+    const calls = { flaky: 0 };
+    const steps: MigrationStep[] = [
+      function flakyStep() {
+        calls.flaky++;
+        if (calls.flaky === 1) {
+          throw new Error("transient failure");
+        }
+      },
+    ];
+    const db = createTestDb();
+    const first = runMigrationSteps(db, steps);
+
+    // AND the first run reports the failure
+    expect(first.failed).toEqual(["flakyStep"]);
+
+    // WHEN the step runs again on the next boot
+    const second = runMigrationSteps(db, steps);
+
+    // THEN it retries, succeeds, and is then checkpointed
+    expect(calls.flaky).toBe(2);
+    expect(second.failed).toEqual([]);
+    expect(runMigrationSteps(db, steps).skipped).toEqual(["flakyStep"]);
+  });
+
+  test("clearMigrationStepCheckpoints forces every step to re-run", () => {
+    /**
+     * Clearing the step namespace (as rollback does) makes the next run
+     * re-execute and re-record all steps.
+     */
+
+    // GIVEN a database migrated once
+    const calls = { a: 0 };
+    const steps: MigrationStep[] = [
+      function dummyMigrationA() {
+        calls.a++;
+      },
+    ];
+    const db = createTestDb();
+    runMigrationSteps(db, steps);
+    expect(calls.a).toBe(1);
+
+    // WHEN the step checkpoints are cleared
+    clearMigrationStepCheckpoints(db);
+
+    // THEN the next run re-executes the step
+    runMigrationSteps(db, steps);
+    expect(calls.a).toBe(2);
+  });
 });

package/src/memory/migrations/index.ts

@@ -1,3 +1,4 @@
+export { migrateCoreTables } from "./000-core-tables.js";
 export { migrateJobDeferrals } from "./001-job-deferrals.js";
 export { migrateToolInvocationsFk } from "./002-tool-invocations-fk.js";
 export { migrateMemoryFtsBackfill } from "./003-memory-fts-backfill.js";
@@ -43,10 +44,9 @@ export { createActorTokenRecordsTable } from "./038-actor-token-records.js";
 export { createActorRefreshTokenRecordsTable } from "./039-actor-refresh-token-records.js";
 export { migrateInviteCodeHashColumn } from "./040-invite-code-hash-column.js";
 export { createApprovalPromptTsTrackerTable } from "./041-approval-prompt-ts-tracker.js";
-export { createCoreTables } from "./100-core-tables.js";
 export { createWatchersAndLogsTables } from "./101-watchers-and-logs.js";
 export { addCoreColumns } from "./102-alter-table-columns.js";
-export { runComplexMigrations } from "./103-complex-migrations.js";
+export { complexMigrationSteps } from "./103-complex-migrations.js";
 export { createCoreIndexes } from "./104-core-indexes.js";
 export { createContactsAndTriageTables } from "./105-contacts-and-triage.js";
 export { createCallSessionsTables } from "./106-call-sessions.js";
@@ -56,7 +56,7 @@ export { createExternalConversationBindingsTables } from "./109-external-convers
 export { createChannelGuardianTables } from "./110-channel-guardian.js";
 export { createMediaAssetsTables } from "./111-media-assets.js";
 export { createAssistantInboxTables } from "./112-assistant-inbox.js";
-export { runLateMigrations } from "./113-late-migrations.js";
+export { lateMigrationSteps } from "./113-late-migrations.js";
 export { createNotificationTables } from "./114-notifications.js";
 export { createSequenceTables } from "./115-sequences.js";
 export { createMessagesFts } from "./116-messages-fts.js";
@@ -288,13 +288,14 @@ export { migrateWorkflowJournalLeafTokens } from "./293-workflow-journal-leaf-to
 export { migrateDropExternalUserId } from "./294-drop-external-user-id.js";
 export { dropApprovalPromptTsTrackerTable } from "./295-drop-approval-prompt-ts-tracker.js";
 export { migrateRewriteBalancedEconomyProfilePins } from "./296-rewrite-balanced-economy-profile-pins.js";
+export { migrateMoveLlmRequestLogsToLogsDb } from "./297-move-llm-request-logs-to-logs-db.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,
   type MigrationValidationResult,
 } from "./registry.js";
+export { recoverCrashedMigrations } from "./run-migrations.js";
 export {
-  recoverCrashedMigrations,
   rollbackMemoryMigration,
   validateMigrationState,
   withCrashRecovery,