@vellumai/assistant 0.8.3 → 0.8.5

package/src/memory/migrations/253-document-comments.ts

@@ -0,0 +1,47 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Create the `document_comments` table for inline and document-level comments.
+ *
+ * Supports threaded replies via `parent_comment_id` and resolution tracking
+ * via `status`, `resolved_by`, and `resolved_at`. The FK on `surface_id`
+ * cascades deletes from `documents` — when a document is removed, all its
+ * comments are cleaned up automatically.
+ *
+ * Idempotent — re-running is a no-op once the table and indices exist.
+ */
+export function migrateCreateDocumentComments(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS document_comments (
+      id TEXT PRIMARY KEY,
+      surface_id TEXT NOT NULL,
+      conversation_id TEXT NOT NULL,
+      author TEXT NOT NULL,
+      content TEXT NOT NULL,
+      anchor_start INTEGER,
+      anchor_end INTEGER,
+      anchor_text TEXT,
+      parent_comment_id TEXT,
+      status TEXT NOT NULL DEFAULT 'open',
+      resolved_by TEXT,
+      resolved_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (surface_id) REFERENCES documents(surface_id) ON DELETE CASCADE,
+      FOREIGN KEY (parent_comment_id) REFERENCES document_comments(id) ON DELETE CASCADE
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_document_comments_surface
+    ON document_comments(surface_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_document_comments_parent
+    ON document_comments(parent_comment_id)
+  `);
+}

package/src/memory/migrations/254-external-conversation-binding-chat-name.ts

@@ -0,0 +1,43 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_external_conversation_binding_chat_name_v1";
+
+export function migrateExternalConversationBindingChatName(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (
+      tableHasColumn(
+        database,
+        "external_conversation_bindings",
+        "external_chat_name",
+      )
+    ) {
+      return;
+    }
+
+    database.run(
+      `ALTER TABLE external_conversation_bindings ADD COLUMN external_chat_name TEXT`,
+    );
+  });
+}
+
+export function downExternalConversationBindingChatName(
+  database: DrizzleDb,
+): void {
+  if (
+    !tableHasColumn(
+      database,
+      "external_conversation_bindings",
+      "external_chat_name",
+    )
+  ) {
+    return;
+  }
+
+  database.run(
+    `ALTER TABLE external_conversation_bindings DROP COLUMN external_chat_name`,
+  );
+}

package/src/memory/migrations/255-channel-inbound-delivery-attempts.ts

@@ -0,0 +1,24 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_channel_inbound_delivery_attempts_v1";
+
+/** Add a delivery-specific retry counter for channel inbound events. */
+export function migrateChannelInboundDeliveryAttempts(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (
+      tableHasColumn(database, "channel_inbound_events", "delivery_attempts")
+    ) {
+      return;
+    }
+    const raw = getSqliteFrom(database);
+    raw.exec(/*sql*/ `
+      ALTER TABLE channel_inbound_events
+        ADD COLUMN delivery_attempts INTEGER NOT NULL DEFAULT 0
+    `);
+  });
+}

package/src/memory/migrations/256-memory-v2-injection-events.ts

@@ -0,0 +1,113 @@
+import { getLogger } from "../../util/logger.js";
+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_v2_injection_events_v1";
+const log = getLogger("memory-v2-injection-events-migration");
+
+/**
+ * Create the memory_v2_injection_events table — an append-only event log of
+ * (slug, injected_at) tuples capturing every router selection.
+ *
+ * This is the data source for the time-decayed injection frequency score
+ * that drives tier 2 assignment in memory router v4. Score is computed on
+ * read as `Σ exp(-λ × (now - tᵢ))` with `λ = ln(2) / 3 days`, so the table
+ * just accumulates raw events; the formula or half-life can change later
+ * without losing signal.
+ *
+ * Backfill: walks existing `memory_v2_activation_logs` and replays each
+ * row's router-sourced slugs as historical events. Without backfill the
+ * scores would take ~3 half-lives (≈9 days) to reach steady state; with
+ * backfill tier 2 assignment has signal from day one.
+ *
+ * Indexes:
+ * - `(slug, injected_at)` for per-slug score reads (the hot path).
+ * - `(injected_at)` for time-range pruning later.
+ */
+export function migrateMemoryV2InjectionEvents(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS memory_v2_injection_events (
+        id INTEGER PRIMARY KEY,
+        slug TEXT NOT NULL,
+        injected_at INTEGER NOT NULL
+      )
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_memory_v2_injection_events_slug_time
+        ON memory_v2_injection_events (slug, injected_at)
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_memory_v2_injection_events_time
+        ON memory_v2_injection_events (injected_at)
+    `);
+
+    // Bail before backfill on databases that predate memory_v2_activation_logs
+    // (migration 234) — there's no historical signal to replay.
+    const logsTable = raw
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_v2_activation_logs'`,
+      )
+      .get();
+    if (!logsTable) return;
+
+    // Re-run safety net independent of the checkpoint: if events already
+    // exist, do not append duplicates. The checkpoint normally short-circuits
+    // re-runs in withCrashRecovery; this guards the manual-clear path.
+    const existing = raw
+      .query(`SELECT COUNT(*) as n FROM memory_v2_injection_events`)
+      .get() as { n: number };
+    if (existing.n > 0) return;
+
+    const rows = raw
+      .query(
+        `SELECT concepts_json, created_at FROM memory_v2_activation_logs ORDER BY created_at ASC`,
+      )
+      .all() as Array<{ concepts_json: string; created_at: number }>;
+    if (rows.length === 0) return;
+
+    const insert = raw.prepare(
+      `INSERT INTO memory_v2_injection_events (slug, injected_at) VALUES (?, ?)`,
+    );
+    const replay = raw.transaction(
+      (events: ReadonlyArray<{ slug: string; t: number }>) => {
+        for (const e of events) insert.run(e.slug, e.t);
+      },
+    );
+
+    const buffer: Array<{ slug: string; t: number }> = [];
+    let parseFailures = 0;
+    for (const row of rows) {
+      let concepts: Array<{ slug?: unknown; source?: unknown }>;
+      try {
+        concepts = JSON.parse(row.concepts_json) as Array<{
+          slug?: unknown;
+          source?: unknown;
+        }>;
+      } catch {
+        parseFailures += 1;
+        continue;
+      }
+      if (!Array.isArray(concepts)) continue;
+      for (const c of concepts) {
+        if (typeof c.slug !== "string") continue;
+        // Carry-over entries were not router-selected this turn — exclude.
+        if (c.source !== "router") continue;
+        buffer.push({ slug: c.slug, t: row.created_at });
+      }
+    }
+
+    if (buffer.length > 0) replay(buffer);
+    log.info(
+      { inserted: buffer.length, rowsScanned: rows.length, parseFailures },
+      `Backfilled ${buffer.length} injection events from ${rows.length} activation log rows`,
+    );
+  });
+}
+
+export function downMemoryV2InjectionEvents(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_v2_injection_events`);
+}

package/src/memory/migrations/257-strip-base-url-non-openai-compatible.ts

@@ -0,0 +1,22 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Strip `base_url` from provider connections whose provider is NOT
+ * `openai-compatible`. These values should never have been accepted — the
+ * route layer now rejects them, but existing rows may still carry one from
+ * before the validation was added. Setting it to NULL prevents
+ * API-key exfiltration via a redirected base URL.
+ *
+ * Idempotent — re-running is a no-op once all non-openai-compatible rows
+ * already have NULL base_url.
+ */
+export function migrateStripBaseUrlNonOpenaiCompatible(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+
+  // Only clear base_url on rows where provider is NOT openai-compatible.
+  raw.exec(
+    `UPDATE provider_connections SET base_url = NULL WHERE provider != 'openai-compatible' AND base_url IS NOT NULL`,
+  );
+}

package/src/memory/migrations/258-onboarding-events-prior-assistants.ts

@@ -0,0 +1,13 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+export function migrateOnboardingEventsPriorAssistants(
+  database: DrizzleDb,
+): void {
+  try {
+    database.run(
+      /*sql*/ `ALTER TABLE onboarding_events ADD COLUMN prior_assistants_json TEXT`,
+    );
+  } catch {
+    /* already exists */
+  }
+}

package/src/memory/migrations/259-conversation-cleaned-at.ts

@@ -0,0 +1,33 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_conversation_cleaned_at_v1";
+
+const COLUMN_NAME = "cleaned_at";
+const COLUMN_DEFINITION = "cleaned_at INTEGER";
+
+/**
+ * Add a `cleaned_at` timestamp to conversations.
+ *
+ * Records the moment `/clean` ran. The load path uses it to skip metadata
+ * reinjection (and strip injection prefixes from message content) for
+ * messages whose `created_at < cleaned_at`, so the clean survives daemon
+ * restart and conversation eviction. `forkConversation` copies the marker
+ * to the child only when the fork point is at-or-after the clean.
+ */
+export function migrateConversationCleanedAt(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (tableHasColumn(database, "conversations", COLUMN_NAME)) {
+      return;
+    }
+    database.run(`ALTER TABLE conversations ADD COLUMN ${COLUMN_DEFINITION}`);
+  });
+}
+
+export function downConversationCleanedAt(database: DrizzleDb): void {
+  if (!tableHasColumn(database, "conversations", COLUMN_NAME)) {
+    return;
+  }
+  database.run(`ALTER TABLE conversations DROP COLUMN ${COLUMN_NAME}`);
+}

package/src/memory/migrations/260-rename-cleaned-at.ts

@@ -0,0 +1,44 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_rename_cleaned_at_v1";
+
+const OLD_COLUMN = "cleaned_at";
+const NEW_COLUMN = "history_stripped_at";
+
+/**
+ * Rename `conversations.cleaned_at` → `conversations.history_stripped_at`.
+ *
+ * The marker now records any injection-strip event (`/clean` or compaction),
+ * not just `/clean`. Renaming reflects the broader semantics; compaction
+ * sets it alongside its summary state instead of destructively wiping
+ * message metadata.
+ */
+export function migrateRenameCleanedAt(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (tableHasColumn(database, "conversations", NEW_COLUMN)) {
+      return;
+    }
+    if (!tableHasColumn(database, "conversations", OLD_COLUMN)) {
+      // 259 didn't run (fresh install on a newer schema where 259's column
+      // was added under the new name) — nothing to rename.
+      return;
+    }
+    database.run(
+      `ALTER TABLE conversations RENAME COLUMN ${OLD_COLUMN} TO ${NEW_COLUMN}`,
+    );
+  });
+}
+
+export function downRenameCleanedAt(database: DrizzleDb): void {
+  if (!tableHasColumn(database, "conversations", NEW_COLUMN)) {
+    return;
+  }
+  if (tableHasColumn(database, "conversations", OLD_COLUMN)) {
+    return;
+  }
+  database.run(
+    `ALTER TABLE conversations RENAME COLUMN ${NEW_COLUMN} TO ${OLD_COLUMN}`,
+  );
+}

package/src/memory/migrations/261-llm-usage-add-raw-usage.ts

@@ -0,0 +1,36 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_llm_usage_add_raw_usage_v1";
+
+const TABLE = "llm_usage_events";
+const COLUMN = "raw_usage";
+
+/**
+ * Add a `raw_usage` TEXT column to `llm_usage_events` for storing the
+ * provider's untouched `usage` block as JSON.
+ *
+ * The Anthropic API surfaces a TTL breakdown of cache writes
+ * (`usage.cache_creation.ephemeral_5m_input_tokens`,
+ * `usage.cache_creation.ephemeral_1h_input_tokens`); OpenAI surfaces
+ * nested `prompt_tokens_details` and `completion_tokens_details`; both
+ * are kept as opaque JSON so admin charts and downstream consumers can
+ * extract provider-specific detail without requiring a new column every
+ * time a provider adds a usage field. `NULL` for rows persisted before
+ * this migration ran and for providers that did not return a usage
+ * payload.
+ */
+export function migrateLlmUsageAddRawUsage(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (!tableHasColumn(database, TABLE, COLUMN)) {
+      database.run(`ALTER TABLE ${TABLE} ADD COLUMN ${COLUMN} TEXT`);
+    }
+  });
+}
+
+export function downLlmUsageAddRawUsage(database: DrizzleDb): void {
+  if (tableHasColumn(database, TABLE, COLUMN)) {
+    database.run(`ALTER TABLE ${TABLE} DROP COLUMN ${COLUMN}`);
+  }
+}

package/src/memory/migrations/262-memory-v3-coactivation.ts

@@ -0,0 +1,57 @@
+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_v3_coactivation_v1";
+
+/**
+ * Create the memory_v3_coactivation table — an append-only log of
+ * pass-1 → pass-N co-activation pairs observed during a v3 retrieval loop.
+ *
+ * Each row records that a page (`target_slug`) first surfaced on a later
+ * descent pass was co-selected alongside a page (`source_slug`) that surfaced
+ * on pass 1, with `pass_gap` = passOf(target) − passOf(source). This is the
+ * raw gradient signal that edge-learning later reconciles into curated-graph
+ * edge weights: a source that repeatedly precedes a target across turns is a
+ * candidate association. `used` is the usefulness flag (0 here — the loop
+ * cannot know whether the target was actually load-bearing for the turn; a
+ * later edge-learning pass reconciles it).
+ *
+ * The table just accumulates raw events; the edge-learning formula or the
+ * decay/weighting can change later without losing signal.
+ *
+ * Indexes:
+ * - `(source_slug, target_slug)` for per-pair aggregation (the hot path for
+ *   edge-learning reads).
+ * - `(created_at)` for time-range pruning later.
+ */
+export function migrateMemoryV3Coactivation(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS memory_v3_coactivation (
+        id INTEGER PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        turn INTEGER NOT NULL,
+        source_slug TEXT NOT NULL,
+        target_slug TEXT NOT NULL,
+        pass_gap INTEGER NOT NULL,
+        used INTEGER NOT NULL,
+        created_at INTEGER NOT NULL
+      )
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_memory_v3_coactivation_pair
+        ON memory_v3_coactivation (source_slug, target_slug)
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_memory_v3_coactivation_time
+        ON memory_v3_coactivation (created_at)
+    `);
+  });
+}
+
+export function downMemoryV3Coactivation(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_v3_coactivation`);
+}

package/src/memory/migrations/263-memory-v3-auto-edges.ts

@@ -0,0 +1,50 @@
+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_v3_auto_edges_v1";
+
+/**
+ * Create the memory_v3_auto_edges table — the **learned** edge graph, a
+ * distinct class from the curated `edges:` frontmatter graph.
+ *
+ * Each row is a weighted directed association `source_slug → target_slug` that
+ * the edge-learning job (`memory_v3_edge_learning`) accrues from *used*
+ * co-activations (migration 262's `memory_v3_coactivation` rows) and decays
+ * over time. `weight` is a multiplicatively-decaying real; `last_reinforced_at`
+ * is the wall-clock ms of the most recent reinforcement, used by the decay
+ * pass to compute elapsed time per pair.
+ *
+ * Auto-edges are advisory: the read path consumes only above-threshold pairs
+ * via edge-expansion's `extraAdjacency` seam, and high-weight pairs surface as
+ * promotion *candidates* for the assistant to ratify into curated `edges:`
+ * during consolidation. This table never auto-writes page frontmatter.
+ *
+ * `PRIMARY KEY(source_slug, target_slug)` makes each ordered pair unique, so
+ * reinforce is a single UPSERT. The index on `(weight)` keeps the
+ * above-threshold scan and top-N promotion-candidate read cheap as the learned
+ * graph grows.
+ */
+export function migrateMemoryV3AutoEdges(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS memory_v3_auto_edges (
+        source_slug TEXT NOT NULL,
+        target_slug TEXT NOT NULL,
+        weight REAL NOT NULL,
+        last_reinforced_at INTEGER NOT NULL,
+        PRIMARY KEY (source_slug, target_slug)
+      )
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_memory_v3_auto_edges_weight
+        ON memory_v3_auto_edges (weight)
+    `);
+  });
+}
+
+export function downMemoryV3AutoEdges(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS memory_v3_auto_edges`);
+}

package/src/memory/migrations/264-llm-request-log-call-site.ts

@@ -0,0 +1,29 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Adds `call_site` (nullable TEXT) to the `llm_request_logs` table.
+ *
+ * Records the logical call site that produced the row — `mainAgent`,
+ * `compactionAgent`, etc. (string values from `LLMCallSite` in
+ * `config/schemas/llm.ts`). Lets the LLM Context Inspector and other
+ * observability tools filter "show me only compaction calls" without
+ * having to infer from request payload shape.
+ *
+ * No backfill — historical rows stay NULL ("we don't know"). New rows
+ * stamped at insertion time by callers of `recordRequestLog`.
+ *
+ * Idempotent — re-running is a no-op once the column exists. Modeled on
+ * migration 252 (`llm-request-log-agent-loop-exit-reason`).
+ */
+export function migrateLlmRequestLogCallSite(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  const columns = raw
+    .query(`PRAGMA table_info(llm_request_logs)`)
+    .all() as Array<{ name: string }>;
+  const columnNames = new Set(columns.map((c) => c.name));
+
+  if (!columnNames.has("call_site")) {
+    raw.exec(`ALTER TABLE llm_request_logs ADD COLUMN call_site TEXT`);
+  }
+}

package/src/memory/migrations/index.ts

@@ -217,6 +217,40 @@ export {
 export { migrateProviderConnectionBaseUrlAndModels } from "./250-provider-connection-base-url-and-models.js";
 export { downA2ATasks, migrateA2ATasks } from "./251-a2a-tasks.js";
 export { migrateLlmRequestLogAgentLoopExitReason } from "./252-llm-request-log-agent-loop-exit-reason.js";
+export { migrateConversationLastNotifiedProfile } from "./253-conversation-last-notified-profile.js";
+export { migrateCreateDocumentComments } from "./253-document-comments.js";
+export {
+  downExternalConversationBindingChatName,
+  migrateExternalConversationBindingChatName,
+} from "./254-external-conversation-binding-chat-name.js";
+export { migrateChannelInboundDeliveryAttempts } from "./255-channel-inbound-delivery-attempts.js";
+export {
+  downMemoryV2InjectionEvents,
+  migrateMemoryV2InjectionEvents,
+} from "./256-memory-v2-injection-events.js";
+export { migrateStripBaseUrlNonOpenaiCompatible } from "./257-strip-base-url-non-openai-compatible.js";
+export { migrateOnboardingEventsPriorAssistants } from "./258-onboarding-events-prior-assistants.js";
+export {
+  downConversationCleanedAt,
+  migrateConversationCleanedAt,
+} from "./259-conversation-cleaned-at.js";
+export {
+  downRenameCleanedAt,
+  migrateRenameCleanedAt,
+} from "./260-rename-cleaned-at.js";
+export {
+  downLlmUsageAddRawUsage,
+  migrateLlmUsageAddRawUsage,
+} from "./261-llm-usage-add-raw-usage.js";
+export {
+  downMemoryV3Coactivation,
+  migrateMemoryV3Coactivation,
+} from "./262-memory-v3-coactivation.js";
+export {
+  downMemoryV3AutoEdges,
+  migrateMemoryV3AutoEdges,
+} from "./263-memory-v3-auto-edges.js";
+export { migrateLlmRequestLogCallSite } from "./264-llm-request-log-call-site.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -50,6 +50,13 @@ import { downToolInvocationsMatchedRuleId } from "./236-tool-invocations-matched
 import { downHeartbeatRuns } from "./237-heartbeat-runs.js";
 import { downNormalizeSlackExternalContent } from "./249-normalize-slack-external-content.js";
 import { downA2ATasks } from "./251-a2a-tasks.js";
+import { downExternalConversationBindingChatName } from "./254-external-conversation-binding-chat-name.js";
+import { downMemoryV2InjectionEvents } from "./256-memory-v2-injection-events.js";
+import { downConversationCleanedAt } from "./259-conversation-cleaned-at.js";
+import { downRenameCleanedAt } from "./260-rename-cleaned-at.js";
+import { downLlmUsageAddRawUsage } from "./261-llm-usage-add-raw-usage.js";
+import { downMemoryV3Coactivation } from "./262-memory-v3-coactivation.js";
+import { downMemoryV3AutoEdges } from "./263-memory-v3-auto-edges.js";
 
 export interface MigrationRegistryEntry {
   /** The checkpoint key written to memory_checkpoints on completion. */
@@ -428,6 +435,57 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
       "Create a2a_tasks table for tracking A2A request/response lifecycle",
     down: downA2ATasks,
   },
+  {
+    key: "migration_external_conversation_binding_chat_name_v1",
+    version: 50,
+    description:
+      "Add external_chat_name to external conversation bindings for channel footer metadata",
+    down: downExternalConversationBindingChatName,
+  },
+  {
+    key: "migration_memory_v2_injection_events_v1",
+    version: 51,
+    dependsOn: ["migration_memory_v2_activation_logs_v1"],
+    description:
+      "Create memory_v2_injection_events table and backfill from activation logs for EMA-based tier 2 routing",
+    down: downMemoryV2InjectionEvents,
+  },
+  {
+    key: "migration_conversation_cleaned_at_v1",
+    version: 52,
+    description:
+      "Add cleaned_at timestamp to conversations so /clean survives reload and forks inherit conditionally on fork point",
+    down: downConversationCleanedAt,
+  },
+  {
+    key: "migration_rename_cleaned_at_v1",
+    version: 53,
+    dependsOn: ["migration_conversation_cleaned_at_v1"],
+    description:
+      "Rename conversations.cleaned_at to history_stripped_at; the marker now records any injection-strip event (including compaction), not just /clean",
+    down: downRenameCleanedAt,
+  },
+  {
+    key: "migration_llm_usage_add_raw_usage_v1",
+    version: 54,
+    description:
+      "Add raw_usage TEXT column to llm_usage_events for storing the provider's untouched usage block as JSON (Anthropic TTL breakdown, OpenAI prompt/completion token details, etc.) so downstream consumers can extract provider-specific detail without per-field schema changes",
+    down: downLlmUsageAddRawUsage,
+  },
+  {
+    key: "migration_memory_v3_coactivation_v1",
+    version: 55,
+    description:
+      "Create memory_v3_coactivation table — append-only log of pass-1 → pass-N co-activation pairs (gradient signal) emitted by the v3 retrieval loop and reconciled later by edge-learning",
+    down: downMemoryV3Coactivation,
+  },
+  {
+    key: "migration_memory_v3_auto_edges_v1",
+    version: 56,
+    description:
+      "Create memory_v3_auto_edges table — weighted, decaying learned association graph (distinct from curated edges:) accrued by the edge-learning job from used co-activations and consumed above-threshold by edge expansion",
+    down: downMemoryV3AutoEdges,
+  },
 ];
 
 export function getMaxMigrationVersion(): number {

package/src/memory/onboarding-events-store.ts

@@ -14,6 +14,7 @@ export interface OnboardingEvent {
   tone: string | null;
   googleConnected: boolean | null;
   googleScopesJson: string | null;
+  priorAssistantsJson: string | null;
   abVariant: string | null;
 }
 
@@ -24,6 +25,7 @@ export interface RecordOnboardingEventParams {
   tone?: string;
   googleConnected?: boolean;
   googleScopes?: string[];
+  priorAssistants?: string[];
   abVariant?: string;
 }
 
@@ -47,6 +49,9 @@ export function recordOnboardingEvent(
     googleScopesJson: params.googleScopes
       ? JSON.stringify(params.googleScopes)
       : null,
+    priorAssistantsJson: params.priorAssistants
+      ? JSON.stringify(params.priorAssistants)
+      : null,
     abVariant: params.abVariant ?? null,
   };
   db.insert(onboardingEvents)
@@ -59,6 +64,7 @@ export function recordOnboardingEvent(
       tone: event.tone,
       googleConnected: event.googleConnected,
       googleScopesJson: event.googleScopesJson,
+      priorAssistantsJson: event.priorAssistantsJson,
       abVariant: event.abVariant,
     })
     .run();
@@ -85,6 +91,7 @@ export function queryUnreportedOnboardingEvents(
       tone: onboardingEvents.tone,
       googleConnected: onboardingEvents.googleConnected,
       googleScopesJson: onboardingEvents.googleScopesJson,
+      priorAssistantsJson: onboardingEvents.priorAssistantsJson,
       abVariant: onboardingEvents.abVariant,
     })
     .from(onboardingEvents)