@vellumai/assistant 0.8.2 → 0.8.4

package/src/memory/migrations/251-a2a-tasks.ts

@@ -0,0 +1,49 @@
+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_a2a_tasks_v1";
+
+/**
+ * Create the a2a_tasks table for tracking A2A request/response lifecycle.
+ *
+ * Each row represents one inbound A2A task, tracking its state machine
+ * progression through submitted -> working -> completed/failed/canceled/rejected.
+ */
+export function migrateA2ATasks(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    if (tableHasColumn(database, "a2a_tasks", "id")) {
+      return;
+    }
+    const raw = getSqliteFrom(database);
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS a2a_tasks (
+        id TEXT PRIMARY KEY,
+        context_id TEXT,
+        conversation_id TEXT,
+        state TEXT NOT NULL DEFAULT 'submitted',
+        status_message TEXT,
+        request_message_json TEXT NOT NULL,
+        artifacts_json TEXT,
+        push_url TEXT,
+        sender_assistant_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_a2a_tasks_context
+        ON a2a_tasks (context_id)
+    `);
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_a2a_tasks_conversation
+        ON a2a_tasks (conversation_id)
+    `);
+  });
+}
+
+export function downA2ATasks(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.exec(/*sql*/ `DROP TABLE IF EXISTS a2a_tasks`);
+}

package/src/memory/migrations/252-llm-request-log-agent-loop-exit-reason.ts

@@ -0,0 +1,32 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Adds `agent_loop_exit_reason` (nullable TEXT) to the `llm_request_logs`
+ * table.
+ *
+ * The agent loop sets this column on its final log row via
+ * `setAgentLoopExitReasonOnLatestLog` once the `while (true)` body exits.
+ * Intermediate rows keep NULL — downstream tooling (notably the LLM
+ * Context Inspector) reads "row has non-null value" as "this is the final
+ * call of a complete agent-loop run". Encoding the run-end via row state
+ * keeps the schema additive: no new tables, no FK churn.
+ *
+ * Idempotent — re-running is a no-op once the column exists. Modeled on
+ * migration 250 (`provider-connection-base-url-and-models`).
+ */
+export function migrateLlmRequestLogAgentLoopExitReason(
+  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("agent_loop_exit_reason")) {
+    raw.exec(
+      `ALTER TABLE llm_request_logs ADD COLUMN agent_loop_exit_reason TEXT`,
+    );
+  }
+}

package/src/memory/migrations/253-conversation-last-notified-profile.ts

@@ -0,0 +1,15 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateConversationLastNotifiedProfile(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(
+      `ALTER TABLE conversations ADD COLUMN last_notified_inference_profile TEXT DEFAULT NULL`,
+    );
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

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/index.ts

@@ -214,6 +214,26 @@ export {
   downNormalizeSlackExternalContent,
   migrateNormalizeSlackExternalContent,
 } from "./249-normalize-slack-external-content.js";
+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 {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -49,6 +49,10 @@ import { downSlackCompactionWatermark } from "./235-slack-compaction-watermark.j
 import { downToolInvocationsMatchedRuleId } from "./236-tool-invocations-matched-rule-id.js";
 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";
 
 export interface MigrationRegistryEntry {
   /** The checkpoint key written to memory_checkpoints on completion. */
@@ -420,6 +424,35 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
       "Normalize legacy persisted Slack external_content wrappers back to raw message content",
     down: downNormalizeSlackExternalContent,
   },
+  {
+    key: "migration_a2a_tasks_v1",
+    version: 49,
+    description:
+      "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,
+  },
 ];
 
 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)

package/src/memory/schema/a2a.ts

@@ -0,0 +1,15 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const a2aTasks = sqliteTable("a2a_tasks", {
+  id: text("id").primaryKey(),
+  contextId: text("context_id"),
+  conversationId: text("conversation_id"),
+  state: text("state").notNull().default("submitted"),
+  statusMessage: text("status_message"),
+  requestMessageJson: text("request_message_json").notNull(),
+  artifactsJson: text("artifacts_json"),
+  pushUrl: text("push_url"),
+  senderAssistantId: text("sender_assistant_id").notNull(),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});

package/src/memory/schema/calls.ts

@@ -78,6 +78,7 @@ export const externalConversationBindings = sqliteTable(
       .references(() => conversations.id, { onDelete: "cascade" }),
     sourceChannel: text("source_channel").notNull(),
     externalChatId: text("external_chat_id").notNull(),
+    externalChatName: text("external_chat_name"),
     externalThreadId: text("external_thread_id"),
     externalUserId: text("external_user_id"),
     displayName: text("display_name"),

package/src/memory/schema/conversations.ts

@@ -21,6 +21,7 @@ export const conversations = sqliteTable(
       .notNull()
       .default(0),
     contextCompactedAt: integer("context_compacted_at"),
+    cleanedAt: integer("cleaned_at"),
     slackContextCompactionWatermarkTs: text(
       "slack_context_compaction_watermark_ts",
     ),
@@ -41,6 +42,7 @@ export const conversations = sqliteTable(
     inferenceProfile: text("inference_profile"),
     inferenceProfileSessionId: text("inference_profile_session_id"),
     inferenceProfileExpiresAt: integer("inference_profile_expires_at"),
+    lastNotifiedInferenceProfile: text("last_notified_inference_profile"),
   },
   (table) => [
     index("idx_conversations_updated_at").on(table.updatedAt),
@@ -150,6 +152,7 @@ export const channelInboundEvents = sqliteTable("channel_inbound_events", {
   deliveryStatus: text("delivery_status").notNull().default("pending"),
   processingStatus: text("processing_status").notNull().default("pending"),
   processingAttempts: integer("processing_attempts").notNull().default(0),
+  deliveryAttempts: integer("delivery_attempts").notNull().default(0),
   lastProcessingError: text("last_processing_error"),
   retryAfter: integer("retry_after"),
   rawPayload: text("raw_payload"),

package/src/memory/schema/index.ts

@@ -1,3 +1,4 @@
+export * from "./a2a.js";
 export * from "./acp.js";
 export * from "./bookmarks.js";
 export * from "./calls.js";

package/src/memory/schema/inference.ts

@@ -17,6 +17,8 @@ export const providerConnections = sqliteTable(
     auth: text("auth").notNull(),
     status: text("status").notNull().default("active"),
     label: text("label"),
+    baseUrl: text("base_url"),
+    models: text("models"),
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
   },

package/src/memory/schema/infrastructure.ts

@@ -137,6 +137,7 @@ export const llmRequestLogs = sqliteTable(
     requestPayload: text("request_payload").notNull(),
     responsePayload: text("response_payload").notNull(),
     createdAt: integer("created_at").notNull(),
+    agentLoopExitReason: text("agent_loop_exit_reason"),
   },
   (table) => [
     index("idx_llm_request_logs_message_id").on(table.messageId),
@@ -241,6 +242,7 @@ export const onboardingEvents = sqliteTable("onboarding_events", {
   tone: text("tone"),
   googleConnected: integer("google_connected", { mode: "boolean" }),
   googleScopesJson: text("google_scopes_json"),
+  priorAssistantsJson: text("prior_assistants_json"),
   abVariant: text("ab_variant"),
 });