@vellumai/assistant 0.8.5 → 0.8.7

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

@@ -1,6 +1,19 @@
-import { and, asc, desc, eq, gte, inArray, isNull, lte, sql } from "drizzle-orm";
+import {
+  and,
+  asc,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  isNull,
+  lt,
+  lte,
+  sql,
+} from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import { CALL_SITE_SYNTHETIC_AGENT_ERROR_MESSAGE } from "../api/constants/call-sites.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { AssistantError, ProviderError } from "../util/errors.js";
 import {
@@ -105,6 +118,80 @@ export function recordRequestLog(
   return id;
 }
 
+/**
+ * Insert a synthetic `llm_request_logs` row for an agent-loop error
+ * message that has no LLM call backing it but should appear in the
+ * inspector rail. Today the only caller is the
+ * `budget_yield_unrecovered` persistence path
+ * (`conversation-agent-loop.ts`); the helper is named generically so
+ * the next out-of-funds / provider-error / etc. path can route through
+ * the same primitive.
+ *
+ * The caller persists the user-visible assistant message separately
+ * via the `persistence` pipeline; this helper only writes the synthetic
+ * call row. `messageId` should be the id of the just-persisted notice
+ * so `getRequestLogsByMessageId` surfaces both together.
+ *
+ * Payload semantics mirror real LLM-call rows:
+ *  - `requestPayload`: the best-known LLM request body the loop was
+ *    about to send when it yielded — typically the prepared messages
+ *    snapshot and any input-token budget context. Stored as JSON so
+ *    the Raw tab renders it consistently with real calls.
+ *  - `responsePayload`: the synthetic notice text the user saw plus
+ *    the exit reason. This is the "response" from the user's point of
+ *    view — what came back from a call that never actually happened.
+ *
+ * Stamps `agent_loop_exit_reason` directly so the row already carries
+ * the reason at insert time — the post-loop
+ * `setAgentLoopExitReasonOnLatestLog` query then skips it (its IS NULL
+ * guard) and stamps the prior real LLM call instead, preserving the
+ * existing "latest LLM call carries the exit reason" invariant that
+ * other consumers depend on.
+ */
+export function recordSyntheticAgentErrorMessageLog(args: {
+  conversationId: string;
+  messageId: string;
+  exitReason: string;
+  /** User-visible notice text — goes into `response_payload`. */
+  noticeText: string;
+  /**
+   * Best-known LLM request state at the moment the loop gave up.
+   * `null` when no prepared request was available (rare — generally
+   * we know at least the conversation history we were about to send).
+   */
+  preparedRequest: unknown | null;
+  createdAt: number;
+}): string {
+  const db = getDb();
+  const id = uuid();
+  const requestPayload = JSON.stringify({
+    syntheticAgentErrorMessage: {
+      exitReason: args.exitReason,
+      preparedRequest: args.preparedRequest,
+    },
+  });
+  const responsePayload = JSON.stringify({
+    syntheticAgentErrorMessage: {
+      exitReason: args.exitReason,
+      noticeText: args.noticeText,
+    },
+  });
+  db.insert(llmRequestLogs)
+    .values({
+      id,
+      conversationId: args.conversationId,
+      messageId: args.messageId,
+      provider: null,
+      requestPayload,
+      responsePayload,
+      createdAt: args.createdAt,
+      agentLoopExitReason: args.exitReason,
+      callSite: CALL_SITE_SYNTHETIC_AGENT_ERROR_MESSAGE,
+    })
+    .run();
+  return id;
+}
+
 /**
  * Stamp an `agent_loop_exit_reason` onto the most-recent unstamped
  * `llm_request_logs` row for the given conversation. Called by the
@@ -208,7 +295,9 @@ function selectLogsByMessageIds(messageIds: string[]): LogRow[] {
  * not apply turn recovery: the `conversation_id` column already includes
  * linked, unlinked, and orphaned rows for the full conversation.
  */
-export function getRequestLogsByConversationId(conversationId: string): LogRow[] {
+export function getRequestLogsByConversationId(
+  conversationId: string,
+): LogRow[] {
   const db = getDb();
   return db
     .select({
@@ -310,6 +399,61 @@ function selectUnlinkedLogsInRange(
     .all();
 }
 
+/**
+ * Fetch every `compactionAgent` log row in the conversation whose
+ * `createdAt` falls in the **open window** `(afterCreatedAt, beforeCreatedAt)`,
+ * ordered chronologically.
+ *
+ * Drives the Inspector's Compaction tab. The caller resolves both
+ * bounds:
+ *   - `beforeCreatedAt` = the selected LLM call's `createdAt` (ceiling).
+ *   - `afterCreatedAt` = the previous non-`compactionAgent` call's
+ *     `createdAt` (floor), or `null` when the selected call is the first
+ *     real call in the conversation.
+ *
+ * Both bounds are **strict**: the selected call itself never appears in
+ * its own trail (`<` ceiling), and compactions that fed an earlier real
+ * call's context don't bleed into this call's window (`>` floor). When
+ * `afterCreatedAt` is `null` the floor is dropped entirely — every
+ * preceding compaction is in scope, which is the right behavior for the
+ * very first real call in the conversation.
+ *
+ * NULL `callSite` rows (pre-migration-264) are excluded by the explicit
+ * `callSite = 'compactionAgent'` predicate without a separate IS NOT
+ * NULL clause.
+ */
+export function getCompactionLogsBetween(
+  conversationId: string,
+  afterCreatedAt: number | null,
+  beforeCreatedAt: number,
+): LogRow[] {
+  const db = getDb();
+  const predicates = [
+    eq(llmRequestLogs.conversationId, conversationId),
+    eq(llmRequestLogs.callSite, "compactionAgent"),
+    lt(llmRequestLogs.createdAt, beforeCreatedAt),
+  ];
+  if (afterCreatedAt !== null) {
+    predicates.push(gt(llmRequestLogs.createdAt, afterCreatedAt));
+  }
+  return db
+    .select({
+      id: llmRequestLogs.id,
+      conversationId: llmRequestLogs.conversationId,
+      messageId: llmRequestLogs.messageId,
+      provider: llmRequestLogs.provider,
+      requestPayload: llmRequestLogs.requestPayload,
+      responsePayload: llmRequestLogs.responsePayload,
+      createdAt: llmRequestLogs.createdAt,
+      agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
+      callSite: llmRequestLogs.callSite,
+    })
+    .from(llmRequestLogs)
+    .where(and(...predicates))
+    .orderBy(asc(llmRequestLogs.createdAt), asc(llmRequestLogs.id))
+    .all();
+}
+
 export function getRequestLogById(logId: string): LogRow | null {
   const db = getDb();
   return (
@@ -323,7 +467,7 @@ export function getRequestLogById(logId: string): LogRow | null {
         responsePayload: llmRequestLogs.responsePayload,
         createdAt: llmRequestLogs.createdAt,
         agentLoopExitReason: llmRequestLogs.agentLoopExitReason,
-      callSite: llmRequestLogs.callSite,
+        callSite: llmRequestLogs.callSite,
       })
       .from(llmRequestLogs)
       .where(eq(llmRequestLogs.id, logId))

package/src/memory/llm-usage-store.ts

@@ -6,6 +6,7 @@ import type {
   UsageEvent,
   UsageEventInput,
 } from "../usage/types.js";
+import { APP_VERSION } from "../version.js";
 import { getDb } from "./db-connection.js";
 import { rawAll } from "./raw-query.js";
 import { conversations, llmUsageEvents } from "./schema.js";
@@ -39,6 +40,7 @@ export function recordUsageEvent(
     inferenceProfileSource: input.inferenceProfileSource ?? null,
     estimatedCostUsd: pricing.estimatedCostUsd,
     pricingStatus: pricing.pricingStatus,
+    assistantVersion: APP_VERSION,
   };
   db.insert(llmUsageEvents)
     .values({
@@ -62,6 +64,11 @@ export function recordUsageEvent(
       pricingStatus: event.pricingStatus,
       llmCallCount: event.llmCallCount ?? 1,
       metadataJson: null,
+      // Capture the assistant's version at RECORD time so a batch flush
+      // days later doesn't mis-attribute this row to whatever version
+      // the assistant happens to be running on at upload time. See
+      // migration 267 + `TelemetryEventBase.assistant_version` (wire).
+      assistantVersion: event.assistantVersion,
     })
     .run();
   return event;
@@ -91,6 +98,7 @@ function rowToUsageEvent(row: {
   rawUsage: string | null;
   estimatedCostUsd: number | null;
   pricingStatus: string;
+  assistantVersion: string | null;
 }): UsageEvent {
   return {
     id: row.id,
@@ -112,6 +120,7 @@ function rowToUsageEvent(row: {
     rawUsage: parseRawUsage(row.rawUsage),
     estimatedCostUsd: row.estimatedCostUsd,
     pricingStatus: row.pricingStatus as "priced" | "unpriced",
+    assistantVersion: row.assistantVersion,
   };
 }
 
@@ -213,6 +222,7 @@ export function queryUnreportedUsageEvents(
       rawUsage: llmUsageEvents.rawUsage,
       estimatedCostUsd: llmUsageEvents.estimatedCostUsd,
       pricingStatus: llmUsageEvents.pricingStatus,
+      assistantVersion: llmUsageEvents.assistantVersion,
       conversationType: conversations.conversationType,
       // Null when conversationId is null (no parent conversation).
       // Otherwise the count of eligible user turns up to and including

package/src/memory/memory-marker.ts

@@ -0,0 +1,17 @@
+/**
+ * The shared `<memory>…</memory>` injection marker.
+ *
+ * Both the v2 graph-memory producers (`conversation-graph-memory.ts`) and the
+ * v3 live renderer (`v3/render-injection.ts`) emit memory blocks with this
+ * exact wrapper, and the strip/recognition machinery in
+ * `conversation-graph-memory.ts` (`countMemoryPrefixBlocks`) matches the same
+ * `"<memory>\n"` / `"\n</memory>"` delimiters. Keeping the producer wrapper in
+ * one leaf module guarantees the byte-for-byte marker contract across v2 and
+ * v3 — a change here updates every producer at once.
+ *
+ * This is a tiny dependency-free leaf so the pure v3 renderer can import it
+ * without pulling in the heavyweight graph-memory module.
+ */
+export function wrapMemoryBlock(text: string): string {
+  return `<memory>\n${text}\n</memory>`;
+}

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

@@ -208,6 +208,7 @@ async function runLegacyRetrospective(
       source: MEMORY_RETROSPECTIVE_SOURCE,
       trustContext: INTERNAL_GUARDIAN_TRUST_CONTEXT,
       callSite: "memoryRetrospective",
+      allowedTools: ["remember"],
       // The background conversation's title already reads "Memory
       // Retrospective", and `hint` is the full retrospective prompt — surfacing
       // it verbatim as a "Conversation Woke" card body is noisy internal
@@ -382,8 +383,10 @@ async function runForkBasedRetrospective(
       forkId,
       "user",
       JSON.stringify([{ type: "text", text: instruction }]),
-      { kind: MEMORY_RETROSPECTIVE_INSTRUCTION_KIND, hidden: true },
-      { skipIndexing: true },
+      {
+        metadata: { kind: MEMORY_RETROSPECTIVE_INSTRUCTION_KIND, hidden: true },
+        skipIndexing: true,
+      },
     );
   } catch (err) {
     log.error(
@@ -407,6 +410,7 @@ async function runForkBasedRetrospective(
       source: MEMORY_RETROSPECTIVE_SOURCE,
       trustContext: INTERNAL_GUARDIAN_TRUST_CONTEXT,
       callSite: "memoryRetrospective",
+      allowedTools: ["remember"],
       hintRole: "user",
       skipHintInjection: true,
       suppressAutoCompaction: true,

package/src/memory/memory-v2-activation-log-store.ts

@@ -1,4 +1,4 @@
-import { and, desc, eq, inArray, isNull } from "drizzle-orm";
+import { and, desc, eq, inArray, isNull, ne } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "./db-connection.js";
@@ -94,6 +94,14 @@ export interface MemoryV2ConceptRowRecord {
     | "not_injected"
     | "page_missing"
     | "corrupt";
+  /**
+   * v3 shadow only: the retrieval lane that surfaced this slug
+   * (`hot` | `sparse` | `dense` | `tree` | `edge`). Lets a shadow run be
+   * analyzed by provenance — which lane each v3 pick came from. Undefined on
+   * `router`/`per-turn`/etc. v2 rows; stored in the JSON concept blob, so older
+   * rows decode with `undefined`.
+   */
+  lane?: string;
 }
 
 export interface MemoryV2ConfigSnapshot {
@@ -157,12 +165,16 @@ export function backfillMemoryV2ActivationMessageId(
   messageId: string,
 ): void {
   const db = getDb();
+  // `v3_shadow` rows are detached telemetry written outside the live turn with
+  // a null messageId; they are not tied to any specific message. Excluding them
+  // keeps their messageId null instead of stamping them with a later turn's id.
   db.update(memoryV2ActivationLogs)
     .set({ messageId })
     .where(
       and(
         eq(memoryV2ActivationLogs.conversationId, conversationId),
         isNull(memoryV2ActivationLogs.messageId),
+        ne(memoryV2ActivationLogs.mode, "v3_shadow"),
       ),
     )
     .run();

package/src/memory/migrations/265-drop-provider-connection-status.ts

@@ -0,0 +1,26 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Drops the `status` column from the `provider_connections` table.
+ *
+ * Connection status ("active" | "disabled") has been removed — connections
+ * either exist or they don't. Profile status (enabled/disabled) is a separate
+ * concept and is untouched by this migration.
+ *
+ * Idempotent: checks PRAGMA table_info before issuing the DROP so re-running
+ * on a database that already lacks the column is a no-op.
+ *
+ * SQLite 3.35.0+ (Bun bundles a recent SQLite) supports ALTER TABLE DROP COLUMN.
+ */
+export function migrateDropProviderConnectionStatus(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  const columns = raw
+    .query(`PRAGMA table_info(provider_connections)`)
+    .all() as Array<{ name: string }>;
+  const columnNames = new Set(columns.map((c) => c.name));
+
+  if (columnNames.has("status")) {
+    raw.exec(`ALTER TABLE provider_connections DROP COLUMN status`);
+  }
+}

package/src/memory/migrations/266-messages-client-message-id.ts

@@ -0,0 +1,43 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Adds `client_message_id` (nullable TEXT) to the `messages` table and
+ * creates a partial unique index on `(conversation_id, client_message_id)`
+ * for rows where `client_message_id IS NOT NULL`.
+ *
+ * The client-generated correlation nonce was previously wire-protocol-only
+ * (echoed on SSE `user_message_echo` events for optimistic-row dedup) but
+ * never persisted. Storing it enables server-side idempotency: a duplicate
+ * INSERT with the same `(conversation_id, client_message_id)` pair is
+ * silently skipped via `ON CONFLICT DO NOTHING`.
+ *
+ * Idempotent — re-running is a no-op once the column and index exist.
+ */
+export function migrateMessagesClientMessageId(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  const columns = raw.query(`PRAGMA table_info(messages)`).all() as Array<{
+    name: string;
+  }>;
+  const columnNames = new Set(columns.map((c) => c.name));
+
+  if (!columnNames.has("client_message_id")) {
+    raw.exec(`ALTER TABLE messages ADD COLUMN client_message_id TEXT`);
+  }
+
+  // Partial unique index: only enforced when client_message_id is non-NULL.
+  // Messages without a client_message_id (assistant messages, system-generated
+  // messages, legacy rows) are unconstrained.
+  const indexes = raw.query(`PRAGMA index_list(messages)`).all() as Array<{
+    name: string;
+  }>;
+  const indexNames = new Set(indexes.map((i) => i.name));
+
+  if (!indexNames.has("idx_messages_conv_client_msg_id")) {
+    raw.exec(
+      `CREATE UNIQUE INDEX idx_messages_conv_client_msg_id
+       ON messages (conversation_id, client_message_id)
+       WHERE client_message_id IS NOT NULL`,
+    );
+  }
+}

package/src/memory/migrations/267-llm-usage-events-add-assistant-version.ts

@@ -0,0 +1,46 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+const COLUMN = "assistant_version";
+const TABLE = "llm_usage_events";
+
+/**
+ * Add a nullable `assistant_version TEXT` column to `llm_usage_events`.
+ *
+ * Stamps the version of the assistant binary at the moment the event was
+ * RECORDED, not when the batch was uploaded. The previous shape sent the
+ * version only on the upload envelope, which silently mis-attributes
+ * delayed flushes: an assistant that buffered events for days (offline
+ * laptop, network outage, ingest clog — see May 2026 incident) and
+ * finally flushed under its current version stamps that current version
+ * onto every backlogged event, breaking the version filter on
+ * `/admin/inference`.
+ *
+ * `NULL` for rows persisted before this migration ran. The reporter
+ * falls back to the running binary's `APP_VERSION` when the per-event
+ * column is null, so legacy rows still produce a concrete version on
+ * the wire.
+ *
+ * Scope: only `llm_usage_events` for now. `lifecycle_events` (#18112)
+ * and `onboarding_events` (#30733) share the same record-time-attribution
+ * issue and will get the column in a follow-up. Turn events derive from
+ * the `messages` table and are also out of scope — see follow-up that
+ * adds the column to `messages`.
+ *
+ * Idempotent — re-running is a no-op once the column exists. Pure DDL
+ * with a PRAGMA guard, no registry entry needed (matches the 252 / 261
+ * / 264 / 265 pattern).
+ */
+export function migrateLlmUsageEventsAddAssistantVersion(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+
+  const columns = raw.query(`PRAGMA table_info(${TABLE})`).all() as Array<{
+    name: string;
+  }>;
+  const columnNames = new Set(columns.map((c) => c.name));
+
+  if (!columnNames.has(COLUMN)) {
+    raw.exec(`ALTER TABLE ${TABLE} ADD COLUMN ${COLUMN} TEXT`);
+  }
+}

package/src/memory/migrations/268-add-memory-v3-selections.ts

@@ -0,0 +1,28 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Adds `memory_v3_selections` for memory-v3 working-set persistence:
+ * one row per (conversation, turn, page-slug) the v3 retriever selected,
+ * tagged with the lane (`source`) that produced it. `pinned` marks slugs
+ * carried forward across turns rather than re-selected cold.
+ *
+ * Idempotent — re-running is a no-op once the table and index exist.
+ */
+export function migrateAddMemoryV3Selections(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.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,
+      PRIMARY KEY (conversation_id, turn, slug)
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_v3_selections_conv
+      ON memory_v3_selections (conversation_id, turn DESC)
+  `);
+}

package/src/memory/migrations/269-schedule-script-timeout.ts

@@ -0,0 +1,11 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateScheduleScriptTimeout(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(`ALTER TABLE cron_jobs ADD COLUMN timeout_ms INTEGER`);
+  } catch {
+    /* Column already exists */
+  }
+}

package/src/memory/migrations/270-messages-role-created-at-index.ts

@@ -0,0 +1,18 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+/**
+ * Indexes `messages(role, created_at)` so the most recent message of a given
+ * role can be found with an indexed seek instead of a table scan.
+ *
+ * The database-maintenance quiet-period gate looks up the newest user-message
+ * timestamp on every idle worker tick; without this index that lookup scans
+ * the (potentially multi-GB) messages table on the daemon's synchronous
+ * connection.
+ *
+ * Idempotent — `CREATE INDEX IF NOT EXISTS` is a no-op once the index exists.
+ */
+export function migrateMessagesRoleCreatedAtIndex(database: DrizzleDb): void {
+  database.run(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_messages_role_created_at ON messages(role, created_at)`,
+  );
+}

package/src/memory/migrations/__tests__/267-llm-usage-events-add-assistant-version.test.ts

@@ -0,0 +1,117 @@
+import { Database } from "bun:sqlite";
+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 { migrateLlmUsageEventsAddAssistantVersion } from "../267-llm-usage-events-add-assistant-version.js";
+
+interface ColumnRow {
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: string | null;
+  pk: number;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+/**
+ * Inline minimal CREATE TABLE for just `llm_usage_events`. We deliberately
+ * don't call migration 101 — it also sets up FTS triggers + other tables
+ * that aren't relevant here and pull in more surface area than we need to
+ * validate this migration.
+ *
+ * Schema mirrors the post-251 (llm_usage_events incl. inference profile)
+ * state on purpose so the test reflects what the migration runs against
+ * in prod.
+ */
+function bootstrap(db: ReturnType<typeof createTestDb>): void {
+  db.run(/*sql*/ `
+    CREATE TABLE llm_usage_events (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL,
+      output_tokens INTEGER NOT NULL
+    )
+  `);
+}
+
+describe("migration 267 — llm_usage_events add assistant_version", () => {
+  test("adds nullable assistant_version TEXT to llm_usage_events", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    const before = raw
+      .query(`PRAGMA table_info(llm_usage_events)`)
+      .all() as ColumnRow[];
+    expect(before.map((c) => c.name)).not.toContain("assistant_version");
+
+    migrateLlmUsageEventsAddAssistantVersion(db);
+
+    const after = raw
+      .query(`PRAGMA table_info(llm_usage_events)`)
+      .all() as ColumnRow[];
+    const col = after.find((c) => c.name === "assistant_version");
+    expect(col).toBeDefined();
+    expect(col!.type).toBe("TEXT");
+    // Nullable, no default — pre-migration rows stay NULL.
+    expect(col!.notnull).toBe(0);
+    expect(col!.dflt_value).toBeNull();
+  });
+
+  test("is idempotent — running twice does not throw", () => {
+    const db = createTestDb();
+    bootstrap(db);
+    migrateLlmUsageEventsAddAssistantVersion(db);
+    expect(() => migrateLlmUsageEventsAddAssistantVersion(db)).not.toThrow();
+  });
+
+  test("pre-migration rows survive with assistant_version = NULL", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    raw.run(`
+      INSERT INTO llm_usage_events
+        (id, created_at, provider, model, input_tokens, output_tokens)
+      VALUES
+        ('u1', 1, 'anthropic', 'claude-sonnet-4', 10, 20)
+    `);
+
+    migrateLlmUsageEventsAddAssistantVersion(db);
+
+    const usage = raw
+      .query(`SELECT id, assistant_version FROM llm_usage_events`)
+      .all() as Array<{ id: string; assistant_version: string | null }>;
+    expect(usage).toEqual([{ id: "u1", assistant_version: null }]);
+  });
+
+  test("post-migration rows can be inserted with assistant_version", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+    migrateLlmUsageEventsAddAssistantVersion(db);
+
+    raw.run(`
+      INSERT INTO llm_usage_events
+        (id, created_at, provider, model, input_tokens, output_tokens,
+         assistant_version)
+      VALUES
+        ('u2', 4, 'anthropic', 'claude-sonnet-4', 10, 20, '0.8.4')
+    `);
+    const row = raw
+      .query(`SELECT assistant_version FROM llm_usage_events WHERE id = 'u2'`)
+      .get() as { assistant_version: string };
+    expect(row.assistant_version).toBe("0.8.4");
+  });
+});

package/src/memory/migrations/index.ts

@@ -251,6 +251,12 @@ export {
   migrateMemoryV3AutoEdges,
 } from "./263-memory-v3-auto-edges.js";
 export { migrateLlmRequestLogCallSite } from "./264-llm-request-log-call-site.js";
+export { migrateDropProviderConnectionStatus } from "./265-drop-provider-connection-status.js";
+export { migrateMessagesClientMessageId } from "./266-messages-client-message-id.js";
+export { migrateLlmUsageEventsAddAssistantVersion } from "./267-llm-usage-events-add-assistant-version.js";
+export { migrateAddMemoryV3Selections } from "./268-add-memory-v3-selections.js";
+export { migrateScheduleScriptTimeout } from "./269-schedule-script-timeout.js";
+export { migrateMessagesRoleCreatedAtIndex } from "./270-messages-role-created-at-index.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/schema/conversations.ts

@@ -1,9 +1,11 @@
+import { sql } from "drizzle-orm";
 import {
   index,
   integer,
   real,
   sqliteTable,
   text,
+  uniqueIndex,
 } from "drizzle-orm/sqlite-core";
 
 export const conversations = sqliteTable(
@@ -66,8 +68,14 @@ export const messages = sqliteTable(
     content: text("content").notNull(),
     createdAt: integer("created_at").notNull(),
     metadata: text("metadata"),
+    clientMessageId: text("client_message_id"),
   },
-  (table) => [index("idx_messages_conversation_id").on(table.conversationId)],
+  (table) => [
+    index("idx_messages_conversation_id").on(table.conversationId),
+    uniqueIndex("idx_messages_conv_client_msg_id")
+      .on(table.conversationId, table.clientMessageId)
+      .where(sql`client_message_id IS NOT NULL`),
+  ],
 );
 
 export const toolInvocations = sqliteTable(

package/src/memory/schema/inference.ts

@@ -15,7 +15,6 @@ export const providerConnections = sqliteTable(
     name: text("name").primaryKey(),
     provider: text("provider").notNull(),
     auth: text("auth").notNull(),
-    status: text("status").notNull().default("active"),
     label: text("label"),
     baseUrl: text("base_url"),
     models: text("models"),