@vellumai/assistant 0.8.0 → 0.8.1

package/src/memory/migrations/229-delete-private-conversations.ts

@@ -47,6 +47,10 @@ export function migrateDeletePrivateConversations(database: DrizzleDb): void {
   database.run(/*sql*/ `
     DELETE FROM scoped_approval_grants
     WHERE conversation_id IN (${PRIVATE_CONVERSATION_IDS})
+       OR call_session_id IN (
+        SELECT id FROM call_sessions
+        WHERE conversation_id IN (${PRIVATE_CONVERSATION_IDS})
+      )
   `);
   database.run(/*sql*/ `
     DELETE FROM guardian_action_deliveries
@@ -193,6 +197,14 @@ export function migrateDeletePrivateConversations(database: DrizzleDb): void {
     DELETE FROM messages
     WHERE conversation_id IN (${PRIVATE_CONVERSATION_IDS})
   `);
+  database.run(/*sql*/ `
+    DELETE FROM attachments
+    WHERE NOT EXISTS (
+      SELECT 1
+      FROM message_attachments ma
+      WHERE ma.attachment_id = attachments.id
+    )
+  `);
   database.run(/*sql*/ `
     DELETE FROM memory_summaries
     WHERE scope_id LIKE 'private:%'

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/__tests__/244-provider-connection-status-label.test.ts

@@ -0,0 +1,84 @@
+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 { migrateCreateProviderConnections } from "../243-provider-connections.js";
+import { migrateProviderConnectionStatusLabel } from "../244-provider-connection-status-label.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 });
+}
+
+describe("migration 244 — provider_connection status + label", () => {
+  test("adds status (NOT NULL DEFAULT active) and label (nullable) columns", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    // Bootstrap provider_connections table via migration 243.
+    migrateCreateProviderConnections(db);
+
+    // Verify the new columns are absent before migration 244.
+    const colsBefore = raw.query(`PRAGMA table_info(provider_connections)`).all() as ColumnRow[];
+    const namesBefore = colsBefore.map((c) => c.name);
+    expect(namesBefore).not.toContain("status");
+    expect(namesBefore).not.toContain("label");
+
+    migrateProviderConnectionStatusLabel(db);
+
+    const cols = raw.query(`PRAGMA table_info(provider_connections)`).all() as ColumnRow[];
+    const colMap = Object.fromEntries(cols.map((c) => [c.name, c]));
+
+    // status: NOT NULL, default 'active'
+    expect(colMap["status"]).toBeDefined();
+    expect(colMap["status"].notnull).toBe(1);
+    expect(colMap["status"].dflt_value).toBe("'active'");
+
+    // label: nullable
+    expect(colMap["label"]).toBeDefined();
+    expect(colMap["label"].notnull).toBe(0);
+    expect(colMap["label"].dflt_value).toBeNull();
+  });
+
+  test("is idempotent — running twice does not throw", () => {
+    const db = createTestDb();
+    migrateCreateProviderConnections(db);
+    migrateProviderConnectionStatusLabel(db);
+    expect(() => migrateProviderConnectionStatusLabel(db)).not.toThrow();
+  });
+
+  test("existing rows get status=active from column default", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    // Seed a row before adding the status column.
+    migrateCreateProviderConnections(db);
+
+    // Verify canonical connections got the default.
+    migrateProviderConnectionStatusLabel(db);
+
+    const rows = raw.query(`SELECT name, status, label FROM provider_connections`).all() as Array<{
+      name: string;
+      status: string;
+      label: string | null;
+    }>;
+    expect(rows.length).toBeGreaterThan(0);
+    for (const row of rows) {
+      expect(row.status).toBe("active");
+      expect(row.label).toBeNull();
+    }
+  });
+});

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

@@ -0,0 +1,125 @@
+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 { migrateMemoryRetrospectiveState } from "../245-memory-retrospective-state.js";
+
+interface ColumnRow {
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: string | null;
+  pk: number;
+}
+
+interface ForeignKeyRow {
+  id: number;
+  seq: number;
+  table: string;
+  from: string;
+  to: string;
+  on_update: string;
+  on_delete: string;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  // `withCrashRecovery` (used by the migration) reads/writes a
+  // `memory_checkpoints` table. Seed a minimal version so the migration's
+  // structural setup can be exercised without booting the entire
+  // db-init pipeline.
+  sqlite.exec(`
+    CREATE TABLE memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  // The state table FK references `conversations(id)`, so the test DB needs
+  // that table to exist before we can apply the FK. Use a minimal table —
+  // we're only checking the migration's structural output, not exercising
+  // cascade behavior end-to-end.
+  sqlite.exec(`
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL
+    )
+  `);
+  return drizzle(sqlite, { schema });
+}
+
+describe("migration 245 — memory_retrospective_state", () => {
+  test("creates the table with the expected columns and primary key", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateMemoryRetrospectiveState(db);
+
+    const cols = raw
+      .query(`PRAGMA table_info(memory_retrospective_state)`)
+      .all() as ColumnRow[];
+    const colMap = Object.fromEntries(cols.map((c) => [c.name, c]));
+
+    expect(colMap["conversation_id"]).toBeDefined();
+    expect(colMap["conversation_id"].pk).toBe(1);
+
+    expect(colMap["last_processed_message_id"]).toBeDefined();
+    expect(colMap["last_processed_message_id"].notnull).toBe(1);
+
+    expect(colMap["last_run_at"]).toBeDefined();
+    expect(colMap["last_run_at"].notnull).toBe(1);
+  });
+
+  test("FK on conversation_id is ON DELETE CASCADE", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateMemoryRetrospectiveState(db);
+
+    const fks = raw
+      .query(`PRAGMA foreign_key_list(memory_retrospective_state)`)
+      .all() as ForeignKeyRow[];
+
+    expect(fks).toHaveLength(1);
+    expect(fks[0]!.from).toBe("conversation_id");
+    expect(fks[0]!.table).toBe("conversations");
+    expect(fks[0]!.to).toBe("id");
+    expect(fks[0]!.on_delete).toBe("CASCADE");
+  });
+
+  test("is idempotent — running twice does not throw", () => {
+    const db = createTestDb();
+
+    migrateMemoryRetrospectiveState(db);
+    expect(() => migrateMemoryRetrospectiveState(db)).not.toThrow();
+  });
+
+  test("deleting a conversation cascades to its state row", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateMemoryRetrospectiveState(db);
+
+    raw.exec(`INSERT INTO conversations (id, created_at) VALUES ('c1', 0)`);
+    raw.exec(
+      `INSERT INTO memory_retrospective_state (conversation_id, last_processed_message_id, last_run_at) VALUES ('c1', 'm1', 1000)`,
+    );
+
+    const before = raw
+      .query(`SELECT COUNT(*) AS c FROM memory_retrospective_state`)
+      .get() as { c: number };
+    expect(before.c).toBe(1);
+
+    raw.exec(`DELETE FROM conversations WHERE id = 'c1'`);
+
+    const after = raw
+      .query(`SELECT COUNT(*) AS c FROM memory_retrospective_state`)
+      .get() as { c: number };
+    expect(after.c).toBe(0);
+  });
+});