@vellumai/assistant 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/src/persistence/llm-request-log-store.ts

@@ -778,11 +778,50 @@ export function getRequestLogById(logId: string): LogRow | null {
   );
 }
 
+/**
+ * Authoritative post-persist linkage: stamp `message_id` onto rows a flow
+ * inserted unlinked because its user-facing message persists afterwards
+ * (the /compact and summarize-up-to result cards). Dispatched through the
+ * IS-NULL-guarded {@link LlmRequestLogWriter.backfillMessageIdOnRecoveredLogs}
+ * so a concurrent inspector-recovery stamp is never overwritten. Non-fatal —
+ * an unlinked row degrades to time-window recovery, not data loss.
+ */
+export function linkRequestLogsToMessage(
+  logIds: string[],
+  messageId: string,
+): void {
+  if (logIds.length === 0) {
+    return;
+  }
+  try {
+    resolveLlmRequestLogWriter().backfillMessageIdOnRecoveredLogs(
+      logIds,
+      messageId,
+    );
+  } catch {
+    // non-fatal — the row stays unlinked and time-window recovery finds it
+  }
+}
+
+/**
+ * True when a log row was authored by the turn's own agent loop — a
+ * `mainAgent` row, or a legacy row from before call sites were stamped
+ * (`call_site` NULL). Companion rows a turn merely hosts (e.g.
+ * `compactionAgent`) don't count: a fork-local turn whose only rows are
+ * companions still needs the fork-source fallback to surface the turn's
+ * real calls.
+ */
+function isTurnAuthoredLog(row: LogRow): boolean {
+  return row.callSite == null || row.callSite === "mainAgent";
+}
+
 export function getRequestLogsByMessageId(messageId: string): LogRow[] {
   // Resolve all assistant message IDs in the same turn so the inspector
   // shows every LLM call from the entire agent turn, not just the queried message.
   const turnMessageIds = getAssistantMessageIdsInTurn(messageId);
   const turnLogs = selectLogsByMessageIds(turnMessageIds);
+  const seen = new Set(turnLogs.map((l) => l.id));
+  const merged = [...turnLogs];
 
   // Recovery: find logs in the turn's time window that the message-ID-based
   // query missed. Two categories:
@@ -805,65 +844,62 @@ export function getRequestLogsByMessageId(messageId: string): LogRow[] {
         bounds.endTime,
       );
 
-      if (orphanedLogs.length > 0 || unlinkedLogs.length > 0) {
-        const seen = new Set(turnLogs.map((l) => l.id));
-        const merged = [...turnLogs];
-        for (const log of [...orphanedLogs, ...unlinkedLogs]) {
+      for (const log of [...orphanedLogs, ...unlinkedLogs]) {
+        if (!seen.has(log.id)) {
+          merged.push(log);
+          seen.add(log.id);
+        }
+      }
+
+      // Opportunistically backfill recovered unlinked logs so future queries
+      // hit the fast indexed-by-messageId path. Dispatched through the
+      // active write backend like every other table writer — INSERT-only
+      // backends no-op.
+      if (unlinkedLogs.length > 0 && turnMessageIds.length > 0) {
+        try {
+          const ids = unlinkedLogs.map((l) => l.id);
+          const targetMessageId = turnMessageIds[turnMessageIds.length - 1]!;
+          resolveLlmRequestLogWriter().backfillMessageIdOnRecoveredLogs(
+            ids,
+            targetMessageId,
+          );
+        } catch {
+          // non-fatal — the recovery already returned the right data
+        }
+      }
+    }
+  }
+
+  // Fork-source fallback: pre-fork turns keep their calls under the SOURCE
+  // conversation's message ids, so a fork-local turn with no turn-authored
+  // row resolves the source turn and merges its calls. Gating on "no
+  // turn-authored row" (not "no rows at all") keeps the fallback alive when
+  // a companion row — e.g. a summarize-up-to compaction call landing inside
+  // the turn's time window — was claimed by the recovery above; without it
+  // that companion would eclipse the turn's real calls.
+  if (message?.metadata && !merged.some(isTurnAuthoredLog)) {
+    try {
+      const parsed = messageMetadataSchema.safeParse(
+        JSON.parse(message.metadata),
+      );
+      const sourceMessageId =
+        parsed.success && typeof parsed.data.forkSourceMessageId === "string"
+          ? parsed.data.forkSourceMessageId
+          : null;
+      if (sourceMessageId && sourceMessageId !== messageId) {
+        const sourceTurnIds = getAssistantMessageIdsInTurn(sourceMessageId);
+        for (const log of selectLogsByMessageIds(sourceTurnIds)) {
           if (!seen.has(log.id)) {
             merged.push(log);
             seen.add(log.id);
           }
         }
-        merged.sort(
-          (a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id),
-        );
-
-        // Opportunistically backfill recovered unlinked logs so future queries
-        // hit the fast indexed-by-messageId path. Dispatched through the
-        // active write backend like every other table writer — INSERT-only
-        // backends no-op.
-        if (unlinkedLogs.length > 0 && turnMessageIds.length > 0) {
-          try {
-            const ids = unlinkedLogs.map((l) => l.id);
-            const targetMessageId = turnMessageIds[turnMessageIds.length - 1]!;
-            resolveLlmRequestLogWriter().backfillMessageIdOnRecoveredLogs(
-              ids,
-              targetMessageId,
-            );
-          } catch {
-            // non-fatal — the recovery already returned the right data
-          }
-        }
-
-        return merged;
       }
+    } catch {
+      // malformed metadata — no fork source to resolve
     }
   }
 
-  if (turnLogs.length > 0) {
-    return turnLogs;
-  }
-
-  // Fork-source fallback: if no logs found for the turn, check whether
-  // the queried message was forked from a source and resolve that source's turn.
-  if (!message?.metadata) {
-    return [];
-  }
-
-  try {
-    const parsed = messageMetadataSchema.safeParse(
-      JSON.parse(message.metadata),
-    );
-    const sourceMessageId =
-      parsed.success && typeof parsed.data.forkSourceMessageId === "string"
-        ? parsed.data.forkSourceMessageId
-        : null;
-    if (!sourceMessageId || sourceMessageId === messageId) {
-      return [];
-    }
-    const sourceTurnIds = getAssistantMessageIdsInTurn(sourceMessageId);
-    return selectLogsByMessageIds(sourceTurnIds);
-  } catch {
-    return [];
-  }
+  merged.sort((a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id));
+  return merged;
 }

package/src/persistence/migrations/298-move-memory-jobs-to-memory-db.ts

@@ -1,15 +1,10 @@
 import type { Database } from "bun:sqlite";
 
 import { getMemoryDbPath } from "../../util/memory-db-path.js";
+import type { DrizzleDb } from "../db-connection.js";
 import {
-  type DrizzleDb,
-  getMemorySqlite,
-  getSqliteFrom,
-} from "../db-connection.js";
-import {
-  drainStagedTable,
   type RelocationSpec,
-  stageTableForRelocation,
+  runMemoryTableRelocation,
 } from "./helpers/relocation.js";
 
 /**
@@ -94,35 +89,16 @@ function createIndexes(raw: Database) {
  * The jobs store reads/writes the queue over the dedicated memory connection
  * (see `getMemoryDb()`).
  *
- * Like the `llm_request_logs` move (migration 297) this is incremental: create
- * the table (and indexes) on the memory connection, rename any populated
- * `main.memory_jobs` aside to `memory_jobs__relocating`, then drain it in
- * awaited batches (see `helpers/relocation.ts`) per {@link MEMORY_JOBS_RELOCATION}.
- *
  * Because the drain is awaited as part of this step, the pending/running jobs
  * are in their new home before the memory jobs worker starts later in daemon
  * startup — the worker never observes a transiently empty queue.
- *
- * Throws (rather than returning) if the memory database cannot be opened, so
- * the runner records the step as failed instead of applied and retries it on a
- * later boot — never renaming the source aside without a target to write to,
- * and never marking the relocation done while it has not happened. The throw is
- * caught per-step by the runner, so startup is not aborted.
  */
 export async function migrateMoveMemoryJobsToMemoryDb(
   database: DrizzleDb,
 ): Promise<void> {
-  const memoryRaw = getMemorySqlite();
-  if (!memoryRaw) {
-    throw new Error(
-      "memory database unavailable — deferring memory_jobs relocation",
-    );
-  }
-
-  ensureMemoryJobsSchema(memoryRaw);
-
-  const raw = getSqliteFrom(database);
-  const needsDrain = stageTableForRelocation(raw, MEMORY_JOBS_RELOCATION.table);
-
-  if (needsDrain) await drainStagedTable(raw, MEMORY_JOBS_RELOCATION);
+  await runMemoryTableRelocation(
+    database,
+    MEMORY_JOBS_RELOCATION,
+    ensureMemoryJobsSchema,
+  );
 }

package/src/persistence/migrations/305-drop-contact-acl-columns.ts

@@ -9,8 +9,9 @@ const log = getLogger("migration-305");
  * Drops the redundant contact ACL columns now owned by the gateway DB.
  *
  * Combo 11 Phase B: the gateway DB is the source of truth for contact ACL,
- * making these assistant-DB columns redundant mirrors. Phase A already drained
- * every production read off them.
+ * making these assistant-DB columns redundant mirrors. Phase A drained the
+ * runtime reads; gateway data migrations m0006/m0008 still read them to seed a
+ * pre-cutover gateway, and checkpoint once they are gone.
  *
  * No DROP INDEX needed: the only contact_channels index
  * (idx_contact_channels_type_ext_chat on (type, external_chat_id)) covers none

package/src/persistence/migrations/326-move-injection-events-to-memory-db.ts

@@ -1,15 +1,10 @@
 import type { Database } from "bun:sqlite";
 
 import { getMemoryDbPath } from "../../util/memory-db-path.js";
+import type { DrizzleDb } from "../db-connection.js";
 import {
-  type DrizzleDb,
-  getMemorySqlite,
-  getSqliteFrom,
-} from "../db-connection.js";
-import {
-  drainStagedTable,
   type RelocationSpec,
-  stageTableForRelocation,
+  runMemoryTableRelocation,
 } from "./helpers/relocation.js";
 
 /**
@@ -69,36 +64,15 @@ export function ensureInjectionEventsSchema(memoryRaw: Database): void {
  * accessors in `plugins/defaults/memory/v2/injection-events.ts` read/write it
  * over the dedicated memory connection (see `getMemoryDb()`).
  *
- * Like migrations 297/298 the move is incremental: create the table (and
- * indexes) on the memory connection, rename any populated
- * `main.memory_v2_injection_events` aside to
- * `memory_v2_injection_events__relocating`, then drain it in awaited batches
- * (see `helpers/relocation.ts`) per {@link INJECTION_EVENTS_RELOCATION}. On a
- * fresh install the main-side table created by migration 256 is empty, so
- * staging just drops it.
- *
- * Throws (rather than returning) if the memory database cannot be opened, so
- * the runner records the step as failed instead of applied and retries it on
- * a later boot — never renaming the source aside without a target to write
- * to. The throw is caught per-step by the runner, so startup is not aborted.
+ * On a fresh install the main-side table created by migration 256 is empty,
+ * so staging just drops it.
  */
 export async function migrateMoveInjectionEventsToMemoryDb(
   database: DrizzleDb,
 ): Promise<void> {
-  const memoryRaw = getMemorySqlite();
-  if (!memoryRaw) {
-    throw new Error(
-      "memory database unavailable — deferring memory_v2_injection_events relocation",
-    );
-  }
-
-  ensureInjectionEventsSchema(memoryRaw);
-
-  const raw = getSqliteFrom(database);
-  const needsDrain = stageTableForRelocation(
-    raw,
-    INJECTION_EVENTS_RELOCATION.table,
+  await runMemoryTableRelocation(
+    database,
+    INJECTION_EVENTS_RELOCATION,
+    ensureInjectionEventsSchema,
   );
-
-  if (needsDrain) await drainStagedTable(raw, INJECTION_EVENTS_RELOCATION);
 }

package/src/persistence/migrations/336-move-memory-v2-activation-logs-to-memory-db.ts

@@ -0,0 +1,90 @@
+import type { Database } from "bun:sqlite";
+
+import { getMemoryDbPath } from "../../util/memory-db-path.js";
+import type { DrizzleDb } from "../db-connection.js";
+import {
+  type RelocationSpec,
+  runMemoryTableRelocation,
+} from "./helpers/relocation.js";
+
+/**
+ * How to drain `memory_v2_activation_logs` from `main` into the memory DB.
+ * Full copy — the concept-frequency aggregator scans the entire history, so
+ * every row is worth preserving.
+ */
+export const ACTIVATION_LOGS_RELOCATION: RelocationSpec = {
+  table: "memory_v2_activation_logs",
+  targetDbPath: getMemoryDbPath,
+  columns: [
+    "id",
+    "conversation_id",
+    "message_id",
+    "turn",
+    "mode",
+    "concepts_json",
+    "skills_json",
+    "config_json",
+    "created_at",
+  ],
+};
+
+const CREATE_TABLE = /*sql*/ `
+  CREATE TABLE IF NOT EXISTS memory_v2_activation_logs (
+    id TEXT PRIMARY KEY,
+    conversation_id TEXT NOT NULL,
+    message_id TEXT,
+    turn INTEGER NOT NULL,
+    mode TEXT NOT NULL,
+    concepts_json TEXT NOT NULL,
+    skills_json TEXT NOT NULL,
+    config_json TEXT NOT NULL,
+    created_at INTEGER NOT NULL
+  )
+`;
+
+/**
+ * Create the `memory_v2_activation_logs` table and its indexes (mirroring
+ * migration 234) on the memory connection. Idempotent (`IF NOT EXISTS`) — the
+ * dedicated connection itself performs no DDL on open, so this migration owns
+ * the schema. Exported so tests can stand up the memory-side schema without
+ * running the full drain.
+ */
+export function ensureActivationLogsSchema(memoryRaw: Database): void {
+  memoryRaw.exec(CREATE_TABLE);
+  memoryRaw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_v2_activation_logs_message_id
+      ON memory_v2_activation_logs (message_id)
+  `);
+  memoryRaw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_v2_activation_logs_conversation_id
+      ON memory_v2_activation_logs (conversation_id)
+  `);
+  memoryRaw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_v2_activation_logs_created_at
+      ON memory_v2_activation_logs (created_at)
+  `);
+}
+
+/**
+ * Move `memory_v2_activation_logs` — the per-turn v2 activation telemetry log
+ * — into the dedicated memory database (`assistant-memory.db`), alongside
+ * `memory_jobs` (migration 298) and `memory_v2_injection_events` (migration
+ * 326). One row is appended per activation pass, so housing the table with
+ * the other high-churn memory state keeps the main DB and its WAL out of
+ * that write path; the accessors in
+ * `plugins/defaults/memory/memory-v2-activation-log-store.ts` read/write it
+ * over the dedicated memory connection.
+ *
+ * Registered with `dependsOn` on migrations 234 (creator) and 256 (whose
+ * backfill reads this table from `main`), so the move never outruns either
+ * on a database where they are still pending.
+ */
+export async function migrateMoveMemoryV2ActivationLogsToMemoryDb(
+  database: DrizzleDb,
+): Promise<void> {
+  await runMemoryTableRelocation(
+    database,
+    ACTIVATION_LOGS_RELOCATION,
+    ensureActivationLogsSchema,
+  );
+}

package/src/persistence/migrations/337-move-memory-recall-logs-to-memory-db.ts

@@ -0,0 +1,114 @@
+import type { Database } from "bun:sqlite";
+
+import { getMemoryDbPath } from "../../util/memory-db-path.js";
+import type { DrizzleDb } from "../db-connection.js";
+import {
+  type RelocationSpec,
+  runMemoryTableRelocation,
+} from "./helpers/relocation.js";
+
+/**
+ * How to drain `memory_recall_logs` from `main` into the memory DB. Full copy
+ * — the inspector reads arbitrary historical turns, so every row is worth
+ * preserving. `query_context` was added by migration 211, so a legacy source
+ * may lack the column; the drain NULL-fills it.
+ */
+export const RECALL_LOGS_RELOCATION: RelocationSpec = {
+  table: "memory_recall_logs",
+  targetDbPath: getMemoryDbPath,
+  columns: [
+    "id",
+    "conversation_id",
+    "message_id",
+    "enabled",
+    "degraded",
+    "provider",
+    "model",
+    "degradation_json",
+    "semantic_hits",
+    "merged_count",
+    "selected_count",
+    "tier1_count",
+    "tier2_count",
+    "hybrid_search_latency_ms",
+    "sparse_vector_used",
+    "injected_tokens",
+    "latency_ms",
+    "top_candidates_json",
+    "injected_text",
+    "reason",
+    "query_context",
+    "created_at",
+  ],
+};
+
+const CREATE_TABLE = /*sql*/ `
+  CREATE TABLE IF NOT EXISTS memory_recall_logs (
+    id TEXT PRIMARY KEY,
+    conversation_id TEXT NOT NULL,
+    message_id TEXT,
+    enabled INTEGER NOT NULL,
+    degraded INTEGER NOT NULL,
+    provider TEXT,
+    model TEXT,
+    degradation_json TEXT,
+    semantic_hits INTEGER NOT NULL,
+    merged_count INTEGER NOT NULL,
+    selected_count INTEGER NOT NULL,
+    tier1_count INTEGER NOT NULL,
+    tier2_count INTEGER NOT NULL,
+    hybrid_search_latency_ms INTEGER NOT NULL,
+    sparse_vector_used INTEGER NOT NULL,
+    injected_tokens INTEGER NOT NULL,
+    latency_ms INTEGER NOT NULL,
+    top_candidates_json TEXT NOT NULL,
+    injected_text TEXT,
+    reason TEXT,
+    query_context TEXT,
+    created_at INTEGER NOT NULL
+  )
+`;
+
+/**
+ * Create the `memory_recall_logs` table and its indexes (mirroring migration
+ * 194, with the `query_context` column from migration 211 built in) on the
+ * memory connection. Idempotent (`IF NOT EXISTS`) — the dedicated connection
+ * itself performs no DDL on open, so this migration owns the schema. Exported
+ * so tests can stand up the memory-side schema without running the full
+ * drain.
+ */
+export function ensureRecallLogsSchema(memoryRaw: Database): void {
+  memoryRaw.exec(CREATE_TABLE);
+  memoryRaw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_recall_logs_message_id
+      ON memory_recall_logs (message_id)
+  `);
+  memoryRaw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_recall_logs_conversation_id
+      ON memory_recall_logs (conversation_id)
+  `);
+}
+
+/**
+ * Move `memory_recall_logs` — the per-turn memory recall telemetry consumed
+ * by the inspector — into the dedicated memory database
+ * (`assistant-memory.db`), alongside the other relocated per-turn memory log
+ * tables. One row is appended per recall pass, so housing the table with the
+ * other high-churn memory state keeps the main DB and its WAL out of that
+ * write path; the accessors in
+ * `plugins/defaults/memory/memory-recall-log-store.ts` read/write it over the
+ * dedicated memory connection.
+ *
+ * Registered with `dependsOn` on migrations 194 (creator) and 211
+ * (`query_context` column), so the move never outruns either on a database
+ * where they are still pending.
+ */
+export async function migrateMoveMemoryRecallLogsToMemoryDb(
+  database: DrizzleDb,
+): Promise<void> {
+  await runMemoryTableRelocation(
+    database,
+    RECALL_LOGS_RELOCATION,
+    ensureRecallLogsSchema,
+  );
+}

package/src/persistence/migrations/338-move-memory-v3-selections-to-memory-db.ts

@@ -0,0 +1,84 @@
+import type { Database } from "bun:sqlite";
+
+import { getMemoryDbPath } from "../../util/memory-db-path.js";
+import type { DrizzleDb } from "../db-connection.js";
+import {
+  type RelocationSpec,
+  runMemoryTableRelocation,
+} from "./helpers/relocation.js";
+
+/**
+ * How to drain `memory_v3_selections` from `main` into the memory DB. Every
+ * row is copied: the hot-set and learned-edge lanes score decayed selection
+ * frequency over the full log, so there is no age cutoff a purge could lean
+ * on. The column list covers migration 268's originals plus the nullable
+ * columns migration 283 added — a source staged before 283 ran simply
+ * NULL-fills them during the copy.
+ */
+export const MEMORY_V3_SELECTIONS_RELOCATION: RelocationSpec = {
+  table: "memory_v3_selections",
+  targetDbPath: getMemoryDbPath,
+  columns: [
+    "conversation_id",
+    "turn",
+    "slug",
+    "source",
+    "pinned",
+    "created_at",
+    "message_id",
+    "section_ordinal",
+    "section_title",
+  ],
+};
+
+/**
+ * Create the `memory_v3_selections` table and its indexes on the memory
+ * connection. Idempotent (`IF NOT EXISTS`) — the dedicated connection itself
+ * performs no DDL on open, so this migration owns the schema. Exported so
+ * tests can stand up the memory-side schema without running the full drain.
+ */
+export function ensureMemoryV3SelectionsSchema(memoryRaw: Database): void {
+  memoryRaw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS 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,
+      message_id TEXT,
+      section_ordinal INTEGER,
+      section_title TEXT,
+      PRIMARY KEY (conversation_id, turn, slug)
+    )
+  `);
+  memoryRaw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_v3_selections_conv
+      ON memory_v3_selections (conversation_id, turn DESC)
+  `);
+  memoryRaw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_v3_selections_message
+      ON memory_v3_selections (message_id)
+  `);
+}
+
+/**
+ * Move `memory_v3_selections` — the per-turn v3 selection log feeding the
+ * hot-set, learned-edge, prune, and inspector readers — into the dedicated
+ * memory database (`assistant-memory.db`), alongside `memory_jobs` (298) and
+ * `memory_v2_injection_events` (326). The log gains rows on every v3 turn;
+ * housing it with the other high-churn memory state keeps the main DB and its
+ * WAL out of that write path.
+ *
+ * On a fresh install the main-side table created by migration 268 is empty,
+ * so staging just drops it.
+ */
+export async function migrateMoveMemoryV3SelectionsToMemoryDb(
+  database: DrizzleDb,
+): Promise<void> {
+  await runMemoryTableRelocation(
+    database,
+    MEMORY_V3_SELECTIONS_RELOCATION,
+    ensureMemoryV3SelectionsSchema,
+  );
+}

package/src/persistence/migrations/339-move-activation-sessions-to-memory-db.ts

@@ -0,0 +1,52 @@
+import type { Database } from "bun:sqlite";
+
+import { getMemoryDbPath } from "../../util/memory-db-path.js";
+import type { DrizzleDb } from "../db-connection.js";
+import {
+  type RelocationSpec,
+  runMemoryTableRelocation,
+} from "./helpers/relocation.js";
+
+/**
+ * How to drain `activation_sessions` from `main` into the memory DB. Every
+ * row is copied: the table is one row per activation-rail conversation, read
+ * by the activation funnel for the conversation's whole lifetime.
+ */
+export const ACTIVATION_SESSIONS_RELOCATION: RelocationSpec = {
+  table: "activation_sessions",
+  targetDbPath: getMemoryDbPath,
+  columns: ["conversation_id", "created_at"],
+};
+
+/**
+ * Create the `activation_sessions` table on the memory connection. Idempotent
+ * (`IF NOT EXISTS`) — the dedicated connection itself performs no DDL on open,
+ * so this migration owns the schema.
+ */
+function ensureActivationSessionsSchema(memoryRaw: Database): void {
+  memoryRaw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS activation_sessions (
+      conversation_id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL
+    )
+  `);
+}
+
+/**
+ * Move `activation_sessions` — the per-conversation activation-rail marker
+ * behind the activation funnel telemetry — into the dedicated memory database
+ * (`assistant-memory.db`), joining the memory plugin's other relocated state
+ * so its store reads/writes ride the memory connection.
+ *
+ * On a fresh install the main-side table created by migration 274 is empty,
+ * so staging just drops it.
+ */
+export async function migrateMoveActivationSessionsToMemoryDb(
+  database: DrizzleDb,
+): Promise<void> {
+  await runMemoryTableRelocation(
+    database,
+    ACTIVATION_SESSIONS_RELOCATION,
+    ensureActivationSessionsSchema,
+  );
+}