@vellumai/assistant 0.8.0 → 0.8.2

package/src/memory/migrations/231-repair-memory-graph-event-dates.ts

@@ -12,6 +12,7 @@ interface GraphNodeEventDateRow {
   id: string;
   created: number;
   event_date: number;
+  content: string;
 }
 
 interface EventDateRepair {
@@ -37,9 +38,14 @@ function replaceUtcYear(epochMs: number, year: number): number {
   );
 }
 
+function contentMentionsYear(content: string, year: number): boolean {
+  return new RegExp(`\\b${year}\\b`).test(content);
+}
+
 export function repairMemoryGraphEventDate(
   createdMs: number,
   eventDateMs: number,
+  content: string,
 ): number | null {
   if (!Number.isFinite(createdMs) || !Number.isFinite(eventDateMs)) {
     return null;
@@ -50,6 +56,10 @@ export function repairMemoryGraphEventDate(
   if (createdYear !== REPAIR_CREATED_YEAR) return null;
   if (!CORRUPT_EVENT_YEARS.includes(eventYear as 2024 | 2025)) return null;
 
+  // If the memory's prose explicitly mentions the prior year, the date is
+  // user-anchored history — not the partial-date inference bug — so leave it.
+  if (contentMentionsYear(content, eventYear)) return null;
+
   const corrected = replaceUtcYear(eventDateMs, createdYear);
   if (corrected === eventDateMs) return null;
 
@@ -71,7 +81,7 @@ export function migrate231RepairMemoryGraphEventDates(
     const rows = raw
       .query(
         /*sql*/ `
-          SELECT id, created, event_date
+          SELECT id, created, event_date, content
           FROM memory_graph_nodes
           WHERE event_date IS NOT NULL
             AND CAST(strftime('%Y', created / 1000, 'unixepoch') AS INTEGER) = ?
@@ -85,7 +95,11 @@ export function migrate231RepairMemoryGraphEventDates(
 
     const repairs: EventDateRepair[] = [];
     for (const row of rows) {
-      const corrected = repairMemoryGraphEventDate(row.created, row.event_date);
+      const corrected = repairMemoryGraphEventDate(
+        row.created,
+        row.event_date,
+        row.content ?? "",
+      );
       if (corrected == null) continue;
       repairs.push({
         id: row.id,

package/src/memory/migrations/240-conversation-inference-profile-session.ts

@@ -0,0 +1,25 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateConversationInferenceProfileSession(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(
+      `ALTER TABLE conversations ADD COLUMN inference_profile_session_id TEXT DEFAULT NULL`,
+    );
+  } catch {
+    // Column already exists — nothing to do.
+  }
+  try {
+    raw.exec(
+      `ALTER TABLE conversations ADD COLUMN inference_profile_expires_at INTEGER DEFAULT NULL`,
+    );
+  } catch {
+    // Column already exists — nothing to do.
+  }
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_conversations_inference_profile_expires_at ON conversations (inference_profile_expires_at) WHERE inference_profile_expires_at IS NOT NULL`,
+  );
+}

package/src/memory/migrations/241-activation-state-fk-cascade.ts

@@ -0,0 +1,50 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Rebuild activation_state to add a foreign key on conversation_id with
+ * ON DELETE CASCADE so rows are cleaned up when their conversation is
+ * deleted, matching the pattern of conversation_graph_memory_state and
+ * every other conversation-keyed table. SQLite doesn't support
+ * ALTER TABLE ADD CONSTRAINT, so we rebuild the table; the INSERT...SELECT
+ * filters out any orphan rows already accumulated under the prior schema.
+ */
+export function migrateActivationStateFkCascade(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const row = raw
+    .query(
+      `SELECT sql FROM sqlite_master WHERE type='table' AND name='activation_state'`,
+    )
+    .get() as { sql: string } | null;
+  if (!row) return;
+  if (row.sql.includes("ON DELETE CASCADE")) return;
+
+  raw.exec("PRAGMA foreign_keys = OFF");
+  try {
+    raw.exec(/*sql*/ `
+      BEGIN;
+      CREATE TABLE activation_state_new (
+        conversation_id TEXT PRIMARY KEY REFERENCES conversations(id) ON DELETE CASCADE,
+        message_id TEXT NOT NULL,
+        state_json TEXT NOT NULL,
+        ever_injected_json TEXT NOT NULL DEFAULT '[]',
+        current_turn INTEGER NOT NULL DEFAULT 0,
+        updated_at INTEGER NOT NULL
+      );
+      INSERT INTO activation_state_new
+        SELECT a.* FROM activation_state a
+        WHERE EXISTS (SELECT 1 FROM conversations c WHERE c.id = a.conversation_id);
+      DROP TABLE activation_state;
+      ALTER TABLE activation_state_new RENAME TO activation_state;
+      COMMIT;
+    `);
+  } catch (e) {
+    try {
+      raw.exec("ROLLBACK");
+    } catch {
+      /* no active transaction */
+    }
+    throw e;
+  } finally {
+    raw.exec("PRAGMA foreign_keys = ON");
+  }
+}

package/src/memory/migrations/242-message-bookmarks.ts

@@ -0,0 +1,38 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_message_bookmarks_v1";
+
+/**
+ * Create the message_bookmarks table for user-saved message bookmarks.
+ *
+ * Both foreign keys cascade so bookmarks are cleaned up automatically when
+ * their parent message or conversation is deleted. A unique index on
+ * message_id keeps the create-bookmark code path idempotent (a message can
+ * be bookmarked at most once at a time).
+ */
+export function migrateMessageBookmarks(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS message_bookmarks (
+        id TEXT PRIMARY KEY,
+        message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+        conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+        created_at INTEGER NOT NULL
+      )
+    `);
+
+    raw.exec(/*sql*/ `
+      CREATE UNIQUE INDEX IF NOT EXISTS message_bookmarks_message_id_uniq
+      ON message_bookmarks (message_id)
+    `);
+
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS message_bookmarks_created_at_idx
+      ON message_bookmarks (created_at)
+    `);
+  });
+}

package/src/memory/migrations/243-provider-connections.ts

@@ -0,0 +1,68 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Creates the `provider_connections` table and seeds the three canonical
+ * connections that every installation ships with.
+ *
+ * Canonical connections:
+ *   - anthropic-managed  → provider=anthropic, auth={type:platform}
+ *   - openai-managed     → provider=openai,    auth={type:platform}
+ *   - gemini-managed     → provider=gemini,    auth={type:platform}
+ *
+ * Idempotent: checks sqlite_master for the table before running DDL;
+ * canonical rows are inserted with INSERT OR IGNORE.
+ */
+export function migrateCreateProviderConnections(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  const tableExists = raw
+    .query(
+      `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'provider_connections'`,
+    )
+    .get();
+
+  if (!tableExists) {
+    try {
+      raw.exec("BEGIN");
+
+      raw.exec(/*sql*/ `
+        CREATE TABLE provider_connections (
+          name        TEXT PRIMARY KEY,
+          provider    TEXT NOT NULL,
+          auth        TEXT NOT NULL,
+          created_at  INTEGER NOT NULL,
+          updated_at  INTEGER NOT NULL
+        )
+      `);
+
+      raw.exec(/*sql*/ `
+        CREATE INDEX idx_provider_connections_provider
+          ON provider_connections(provider)
+      `);
+
+      raw.exec("COMMIT");
+    } catch (e) {
+      try {
+        raw.exec("ROLLBACK");
+      } catch {
+        /* no active transaction */
+      }
+      throw e;
+    }
+  }
+
+  // Seed canonical connections — idempotent via INSERT OR IGNORE.
+  const now = Date.now();
+  const canonicals = [
+    { name: "anthropic-managed", provider: "anthropic", auth: JSON.stringify({ type: "platform" }) },
+    { name: "openai-managed",    provider: "openai",    auth: JSON.stringify({ type: "platform" }) },
+    { name: "gemini-managed",    provider: "gemini",    auth: JSON.stringify({ type: "platform" }) },
+  ];
+
+  for (const { name, provider, auth } of canonicals) {
+    raw.run(
+      `INSERT OR IGNORE INTO provider_connections (name, provider, auth, created_at, updated_at) VALUES (?, ?, ?, ?, ?)`,
+      [name, provider, auth, now, now],
+    );
+  }
+}

package/src/memory/migrations/244-provider-connection-status-label.ts

@@ -0,0 +1,23 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Adds `status` (NOT NULL DEFAULT 'active') and `label` (nullable) columns
+ * to the `provider_connections` table.
+ *
+ * Idempotent: reads PRAGMA table_info before each ALTER so re-running on a
+ * database that already has the columns is a no-op.
+ */
+export function migrateProviderConnectionStatusLabel(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 ADD COLUMN status TEXT NOT NULL DEFAULT 'active'`);
+  }
+
+  if (!columnNames.has("label")) {
+    raw.exec(`ALTER TABLE provider_connections ADD COLUMN label TEXT`);
+  }
+}

package/src/memory/migrations/245-memory-retrospective-state.ts

@@ -0,0 +1,36 @@
+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_retrospective_state_v1";
+
+/**
+ * Create the memory_retrospective_state table.
+ *
+ * One row per source conversation tracks two independent pointers used by
+ * the memory-retrospective background job:
+ *
+ *   - `last_processed_message_id`: advances ONLY when a retrospective run
+ *     completes successfully (wake invoked + returned without error). On any
+ *     failure path this stays unchanged so the next run reprocesses the same
+ *     messages — the load-bearing correctness invariant.
+ *   - `last_run_at`: advances on EVERY job end (success or failure). Drives
+ *     the per-conversation cooldown gate in the trigger-check helper so a
+ *     failing job can't loop in tight retries across trigger types.
+ *
+ * The foreign key cascades so the state row dies with its source
+ * conversation. Without the cascade, deleted conversations would leak rows.
+ */
+export function migrateMemoryRetrospectiveState(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS memory_retrospective_state (
+        conversation_id TEXT PRIMARY KEY REFERENCES conversations(id) ON DELETE CASCADE,
+        last_processed_message_id TEXT NOT NULL,
+        last_run_at INTEGER NOT NULL
+      )
+    `);
+  });
+}

package/src/memory/migrations/246-backfill-provider-connection-label.ts

@@ -0,0 +1,81 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * One-shot backfill: set `label = name` for any `provider_connections` row
+ * whose `label` is NULL (or empty after trim). Migration 244 added the
+ * `label` column as nullable with no default, so every row that existed
+ * pre-244 (and any row created against an older client that didn't yet
+ * write a label) ended up with NULL.
+ *
+ * Why this matters for users: in 0.8.x the editor modal renders Display
+ * Name from `label` and shows the empty-state placeholder ("e.g. My
+ * OpenAI") whenever it's null. Users who created connections before the
+ * label field existed open the editor and see what looks like an empty
+ * field, then conclude their data was wiped during the upgrade.
+ *
+ * The fix is to give every pre-feature row a sensible default — its own
+ * connection name. The list view already falls back to `name` when label
+ * is empty (see ProvidersSheet.swift `connectionRow`), so this brings the
+ * editor into agreement with what's already on screen.
+ *
+ * Idempotency: guarded by `memory_checkpoints` so a second boot won't
+ * re-clobber a label the user has intentionally cleared after the
+ * backfill ran. New rows created post-backfill follow the normal
+ * label-is-optional contract.
+ */
+export function migrateBackfillProviderConnectionLabel(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const checkpointKey = "backfill_provider_connection_label";
+
+  const checkpoint = raw
+    .query(`SELECT 1 FROM memory_checkpoints WHERE key = ?`)
+    .get(checkpointKey);
+  if (checkpoint) return;
+
+  // Guard: skip if the table doesn't exist yet (first-boot edge case where
+  // migration 243 hasn't run, e.g. fresh install ordering test harness).
+  const tableExists = raw
+    .query(
+      `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'provider_connections'`,
+    )
+    .get();
+  if (!tableExists) {
+    raw
+      .query(
+        `INSERT OR IGNORE INTO memory_checkpoints (key, value, updated_at) VALUES (?, '1', ?)`,
+      )
+      .run(checkpointKey, Date.now());
+    return;
+  }
+
+  // Guard: also skip if the label column hasn't been added yet (migration
+  // 244 hasn't run). Treat as no-op + don't checkpoint, so the backfill
+  // runs the next time it gets a chance against a populated schema.
+  const columns = raw
+    .query(`PRAGMA table_info(provider_connections)`)
+    .all() as Array<{ name: string }>;
+  if (!columns.some((c) => c.name === "label")) {
+    return;
+  }
+
+  try {
+    raw.exec("BEGIN");
+
+    raw.exec(/*sql*/ `
+      UPDATE provider_connections
+      SET label = name
+      WHERE label IS NULL OR TRIM(label) = ''
+    `);
+
+    raw
+      .query(
+        `INSERT OR IGNORE INTO memory_checkpoints (key, value, updated_at) VALUES (?, '1', ?)`,
+      )
+      .run(checkpointKey, Date.now());
+
+    raw.exec("COMMIT");
+  } catch (err) {
+    raw.exec("ROLLBACK");
+    throw err;
+  }
+}

package/src/memory/migrations/247-external-conversation-binding-thread-id.ts

@@ -0,0 +1,78 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Add a provider thread anchor to external conversation bindings.
+ *
+ * Slack conversations are keyed by `(channel_id, thread_ts)`, while legacy
+ * channels still use only `(source_channel, external_chat_id)`. SQLite treats
+ * NULLs as distinct in unique indexes, so use two partial unique indexes:
+ * one for legacy/no-thread bindings and one for threaded bindings.
+ */
+export function migrateExternalConversationBindingThreadId(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+
+  const tableExists = raw
+    .query(
+      `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'external_conversation_bindings'`,
+    )
+    .get();
+  if (!tableExists) return;
+
+  const columns = raw
+    .query(`PRAGMA table_info(external_conversation_bindings)`)
+    .all() as Array<{ name: string }>;
+  if (!columns.some((column) => column.name === "external_thread_id")) {
+    raw.exec(
+      `ALTER TABLE external_conversation_bindings ADD COLUMN external_thread_id TEXT`,
+    );
+  }
+
+  try {
+    raw.exec("BEGIN");
+
+    raw.exec(`DROP INDEX IF EXISTS idx_ext_conv_bindings_channel_chat_unique`);
+
+    raw.exec(/*sql*/ `
+      DELETE FROM external_conversation_bindings
+      WHERE rowid NOT IN (
+        SELECT rowid FROM (
+          SELECT rowid,
+                 ROW_NUMBER() OVER (
+                   PARTITION BY source_channel, external_chat_id, COALESCE(external_thread_id, '')
+                   ORDER BY updated_at DESC, created_at DESC, rowid DESC
+                 ) AS rn
+          FROM external_conversation_bindings
+        )
+        WHERE rn = 1
+      )
+    `);
+
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_ext_conv_bindings_channel_chat_thread
+      ON external_conversation_bindings(source_channel, external_chat_id, external_thread_id)
+    `);
+
+    raw.exec(/*sql*/ `
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_ext_conv_bindings_channel_chat_no_thread_unique
+      ON external_conversation_bindings(source_channel, external_chat_id)
+      WHERE external_thread_id IS NULL
+    `);
+
+    raw.exec(/*sql*/ `
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_ext_conv_bindings_channel_chat_thread_unique
+      ON external_conversation_bindings(source_channel, external_chat_id, external_thread_id)
+      WHERE external_thread_id IS NOT NULL
+    `);
+
+    raw.exec("COMMIT");
+  } catch (err) {
+    try {
+      raw.exec("ROLLBACK");
+    } catch {
+      /* no active transaction */
+    }
+    throw err;
+  }
+}

package/src/memory/migrations/248-create-onboarding-events.ts

@@ -0,0 +1,21 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+/**
+ * Create the onboarding_events table for tracking pre-chat onboarding
+ * selections (tools, tasks, tone, Google connect status).
+ */
+export function createOnboardingEventsTable(database: DrizzleDb): void {
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS onboarding_events (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL,
+      screen TEXT NOT NULL,
+      tools_json TEXT,
+      tasks_json TEXT,
+      tone TEXT,
+      google_connected INTEGER,
+      google_scopes_json TEXT,
+      ab_variant TEXT
+    )
+  `);
+}