@vellumai/assistant 0.9.1-staging.1 → 0.10.0-staging.2

package/src/memory/migrations/295-drop-approval-prompt-ts-tracker.ts

@@ -0,0 +1,20 @@
+import { getLogger } from "../../util/logger.js";
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+const log = getLogger("migration-295");
+
+/**
+ * Drops the `approval_prompt_ts_tracker` table.
+ *
+ * Guardian approval-by-reaction no longer scopes reactions through a bespoke
+ * `(channel, chat, ts)` tracker. The canonical guardian delivery record
+ * (`canonical_guardian_deliveries.destination_message_id`) is now the single
+ * mapping from a delivered approval card to its request, so this table is dead.
+ *
+ * Idempotent: `DROP TABLE IF EXISTS` is a no-op once the table is gone.
+ */
+export function dropApprovalPromptTsTrackerTable(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  raw.run("DROP TABLE IF EXISTS approval_prompt_ts_tracker");
+  log.info("Dropped approval_prompt_ts_tracker table");
+}

package/src/memory/migrations/296-rewrite-balanced-economy-profile-pins.test.ts

@@ -0,0 +1,110 @@
+import { existsSync, rmSync, writeFileSync } from "node:fs";
+import { Database } from "bun:sqlite";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getWorkspaceConfigPath } from "../../util/platform.js";
+import * as schema from "../schema.js";
+import { migrateRewriteBalancedEconomyProfilePins } from "./296-rewrite-balanced-economy-profile-pins.js";
+
+function writeWorkspaceConfig(config: Record<string, unknown>): void {
+  writeFileSync(getWorkspaceConfigPath(), JSON.stringify(config));
+}
+
+afterEach(() => {
+  const path = getWorkspaceConfigPath();
+  if (existsSync(path)) rmSync(path);
+});
+
+function createTestDb(withColumns = true) {
+  const sqlite = new Database(":memory:");
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY
+      ${withColumns ? ", inference_profile TEXT" : ""}
+    )
+  `);
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE cron_jobs (
+      id TEXT PRIMARY KEY
+      ${withColumns ? ", inference_profile TEXT" : ""}
+    )
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function pin(sqlite: Database, table: string, id: string): string | null {
+  return (
+    sqlite
+      .query(`SELECT inference_profile FROM ${table} WHERE id = ?`)
+      .get(id) as { inference_profile: string | null }
+  ).inference_profile;
+}
+
+describe("migration 296: rewrite balanced-economy profile pins", () => {
+  test("rewrites balanced-economy pins to balanced on conversations and schedules", () => {
+    const { sqlite, db } = createTestDb();
+    sqlite.run(
+      `INSERT INTO conversations (id, inference_profile) VALUES ('c1', 'balanced-economy'), ('c2', 'quality-optimized'), ('c3', NULL)`,
+    );
+    sqlite.run(
+      `INSERT INTO cron_jobs (id, inference_profile) VALUES ('j1', 'balanced-economy'), ('j2', 'balanced')`,
+    );
+
+    migrateRewriteBalancedEconomyProfilePins(db);
+
+    expect(pin(sqlite, "conversations", "c1")).toBe("balanced");
+    // Unrelated pins and NULLs are left untouched.
+    expect(pin(sqlite, "conversations", "c2")).toBe("quality-optimized");
+    expect(pin(sqlite, "conversations", "c3")).toBeNull();
+    expect(pin(sqlite, "cron_jobs", "j1")).toBe("balanced");
+    expect(pin(sqlite, "cron_jobs", "j2")).toBe("balanced");
+  });
+
+  test("is idempotent — re-run is a no-op", () => {
+    const { sqlite, db } = createTestDb();
+    sqlite.run(
+      `INSERT INTO conversations (id, inference_profile) VALUES ('c1', 'balanced-economy')`,
+    );
+
+    migrateRewriteBalancedEconomyProfilePins(db);
+    expect(() => migrateRewriteBalancedEconomyProfilePins(db)).not.toThrow();
+    expect(pin(sqlite, "conversations", "c1")).toBe("balanced");
+  });
+
+  test("skips a table that has no inference_profile column", () => {
+    const { db } = createTestDb(false);
+    expect(() => migrateRewriteBalancedEconomyProfilePins(db)).not.toThrow();
+  });
+
+  test("leaves pins alone when balanced-economy is a user-owned profile", () => {
+    // The workspace migration keeps a user-owned profile of this name, so its
+    // pins still resolve and must not be switched to balanced.
+    writeWorkspaceConfig({
+      llm: { profiles: { "balanced-economy": { source: "user" } } },
+    });
+    const { sqlite, db } = createTestDb();
+    sqlite.run(
+      `INSERT INTO conversations (id, inference_profile) VALUES ('c1', 'balanced-economy')`,
+    );
+
+    migrateRewriteBalancedEconomyProfilePins(db);
+
+    expect(pin(sqlite, "conversations", "c1")).toBe("balanced-economy");
+  });
+
+  test("rewrites pins when balanced-economy is the managed profile in config", () => {
+    writeWorkspaceConfig({
+      llm: { profiles: { "balanced-economy": { source: "managed" } } },
+    });
+    const { sqlite, db } = createTestDb();
+    sqlite.run(
+      `INSERT INTO conversations (id, inference_profile) VALUES ('c1', 'balanced-economy')`,
+    );
+
+    migrateRewriteBalancedEconomyProfilePins(db);
+
+    expect(pin(sqlite, "conversations", "c1")).toBe("balanced");
+  });
+});

package/src/memory/migrations/296-rewrite-balanced-economy-profile-pins.ts

@@ -0,0 +1,68 @@
+import { loadRawConfig } from "../../config/loader.js";
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+const OLD_PROFILE = "balanced-economy";
+const NEW_PROFILE = "balanced";
+
+// Active inference-profile pin columns: the per-conversation override and the
+// per-schedule override. Audit/telemetry tables (tool_invocations,
+// llm_usage_events, skill_loaded_events) also carry an `inference_profile`, but
+// those record what actually ran and must keep their historical value.
+const PIN_TABLES = ["conversations", "cron_jobs"] as const;
+
+/**
+ * Rewrite persisted `balanced-economy` inference-profile pins to `balanced`.
+ *
+ * The managed `balanced-economy` profile folds into `balanced` (both resolve to
+ * MiniMax M3 on Fireworks). The workspace-config migration removes the profile
+ * definition, but a profile key can also be pinned outside config.json — on a
+ * conversation (`conversations.inference_profile`) or a schedule
+ * (`cron_jobs.inference_profile`). Left unrewritten those pins dangle, and
+ * `resolveCallSiteConfig` treats an unresolvable override as a silent
+ * fall-through to the active/default profile — dropping the user's intended
+ * MiniMax route. `balanced-economy` is a reserved managed-profile key, so every
+ * persisted pin refers to the now-folded profile.
+ *
+ * Ownership guard: the companion workspace migration keeps a `balanced-economy`
+ * profile the user owns (`source !== "managed"`) intact, so its pins still
+ * resolve and must not be touched. Memory migrations run before workspace
+ * migrations on boot, so the profile is still in config here either way; gate on
+ * its source rather than its presence. A reserved managed key (or no profile at
+ * all) means every pin is stale and safe to rewrite.
+ *
+ * Idempotent: the WHERE clause matches nothing once rewritten. The PRAGMA guard
+ * skips a table an install hasn't created the column on yet.
+ */
+export function migrateRewriteBalancedEconomyProfilePins(
+  database: DrizzleDb,
+): void {
+  if (isUserOwnedEconomyProfile()) return;
+
+  const raw = getSqliteFrom(database);
+
+  for (const table of PIN_TABLES) {
+    const cols = raw.prepare(`PRAGMA table_info(${table})`).all() as {
+      name: string;
+    }[];
+    if (!cols.some((c) => c.name === "inference_profile")) continue;
+
+    raw
+      .prepare(
+        `UPDATE ${table} SET inference_profile = ? WHERE inference_profile = ?`,
+      )
+      .run(NEW_PROFILE, OLD_PROFILE);
+  }
+}
+
+/** True when `balanced-economy` exists in config as a user-owned profile. */
+function isUserOwnedEconomyProfile(): boolean {
+  const llm = asObject(loadRawConfig().llm);
+  const profile = asObject(asObject(llm?.profiles)?.[OLD_PROFILE]);
+  return profile !== null && profile.source !== "managed";
+}
+
+function asObject(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}

package/src/memory/migrations/__tests__/131-drop-legacy-member-guardian-tables.test.ts

@@ -0,0 +1,154 @@
+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 { migrateDropLegacyMemberGuardianTables } from "../131-drop-legacy-member-guardian-tables.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  return drizzle(sqlite, { schema });
+}
+
+function bootstrap(db: ReturnType<typeof createTestDb>): void {
+  const raw = getSqliteFrom(db);
+  raw.exec(/*sql*/ `
+    CREATE TABLE contacts (
+      id TEXT PRIMARY KEY,
+      display_name TEXT NOT NULL,
+      role TEXT NOT NULL DEFAULT 'contact',
+      principal_id TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE TABLE contact_channels (
+      id TEXT PRIMARY KEY,
+      contact_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      address TEXT NOT NULL,
+      external_user_id TEXT,
+      external_chat_id TEXT,
+      status TEXT NOT NULL DEFAULT 'unverified',
+      policy TEXT NOT NULL DEFAULT 'allow',
+      invite_id TEXT,
+      revoked_reason TEXT,
+      blocked_reason TEXT,
+      last_seen_at INTEGER,
+      verified_at INTEGER,
+      verified_via TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE INDEX idx_contact_channels_type_ext_user
+      ON contact_channels(type, external_user_id)
+  `);
+}
+
+function createLegacyTables(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE channel_guardian_bindings (
+      id TEXT PRIMARY KEY,
+      channel TEXT NOT NULL,
+      status TEXT NOT NULL,
+      guardian_external_user_id TEXT,
+      guardian_principal_id TEXT,
+      guardian_delivery_chat_id TEXT,
+      metadata_json TEXT,
+      verified_at INTEGER,
+      verified_via TEXT,
+      created_at INTEGER NOT NULL
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE TABLE assistant_ingress_members (
+      id TEXT PRIMARY KEY,
+      source_channel TEXT NOT NULL,
+      external_user_id TEXT,
+      external_chat_id TEXT,
+      display_name TEXT,
+      username TEXT,
+      status TEXT NOT NULL,
+      policy TEXT,
+      invite_id TEXT,
+      revoked_reason TEXT,
+      blocked_reason TEXT,
+      last_seen_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER
+    )
+  `);
+}
+
+function tableExists(raw: Database, name: string): boolean {
+  return !!raw
+    .prepare(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+function seedLegacyRows(raw: Database): void {
+  raw.run(
+    `INSERT INTO channel_guardian_bindings
+       (id, channel, status, guardian_external_user_id, guardian_principal_id,
+        guardian_delivery_chat_id, metadata_json, verified_at, verified_via, created_at)
+     VALUES ('g1','telegram','active','U-guardian','prin-1','chat-1',NULL,1000,'telegram',1000)`,
+  );
+  raw.run(
+    `INSERT INTO assistant_ingress_members
+       (id, source_channel, external_user_id, external_chat_id, display_name,
+        username, status, policy, invite_id, revoked_reason, blocked_reason,
+        last_seen_at, created_at, updated_at)
+     VALUES ('m1','slack','U-member',NULL,'Member One','member1','active','allow',
+        NULL,NULL,NULL,2000,2000,2000)`,
+  );
+}
+
+describe("migration 131 — drop legacy member/guardian tables", () => {
+  test("syncs stragglers then drops the legacy tables when the column is present", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+    createLegacyTables(raw);
+    seedLegacyRows(raw);
+
+    migrateDropLegacyMemberGuardianTables(db);
+
+    // The straggler rows were synced into contact_channels.
+    const synced = raw
+      .prepare(`SELECT external_user_id FROM contact_channels ORDER BY id`)
+      .all() as { external_user_id: string | null }[];
+    expect(synced.map((r) => r.external_user_id).sort()).toEqual([
+      "U-guardian",
+      "U-member",
+    ]);
+
+    // The legacy tables were removed.
+    expect(tableExists(raw, "channel_guardian_bindings")).toBe(false);
+    expect(tableExists(raw, "assistant_ingress_members")).toBe(false);
+  });
+
+  test("drops the legacy tables without throwing when external_user_id is absent (re-run after migration 294)", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+    createLegacyTables(raw);
+    seedLegacyRows(raw);
+
+    // Simulate a later startup where migration 294 has already dropped the
+    // index + column. The sync references external_user_id, so 131 must skip it
+    // and still drop the tables rather than failing on every boot.
+    raw.run("DROP INDEX IF EXISTS idx_contact_channels_type_ext_user");
+    raw.run("ALTER TABLE contact_channels DROP COLUMN external_user_id");
+
+    expect(() => migrateDropLegacyMemberGuardianTables(db)).not.toThrow();
+
+    expect(tableExists(raw, "channel_guardian_bindings")).toBe(false);
+    expect(tableExists(raw, "assistant_ingress_members")).toBe(false);
+  });
+});

package/src/memory/migrations/__tests__/289-contact-channels-unique-ext-user.test.ts

@@ -568,4 +568,35 @@ describe("migration 287 — dedup case collisions + drop ext_user indexes", () =
     // Original casing preserved
     expect(channels[0]!.address).toBe("U999");
   });
+
+  test("no-op when external_user_id column is absent (re-run after migration 294)", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+    insertChannel(raw, {
+      id: "ch1",
+      contactId: "c1",
+      type: "slack",
+      address: "U999",
+      externalUserId: "U999",
+      status: "active",
+      updatedAt: 1000,
+    });
+
+    // Simulate a later startup where migration 294 has already dropped the
+    // index and column. Migration steps re-run on every startup, so this must
+    // tolerate the dropped column rather than throwing "no such column".
+    raw.run("DROP INDEX IF EXISTS idx_contact_channels_type_ext_user");
+    raw.run("ALTER TABLE contact_channels DROP COLUMN external_user_id");
+
+    expect(() => migrateContactChannelsUniqueExtUser(db)).not.toThrow();
+
+    const rows = raw
+      .prepare("SELECT id, address FROM contact_channels")
+      .all() as { id: string; address: string }[];
+    expect(rows).toHaveLength(1);
+    expect(rows[0]!.address).toBe("U999");
+  });
 });

package/src/memory/migrations/__tests__/291-contact-channels-renormalize-addresses.test.ts

@@ -308,4 +308,34 @@ describe("migration 291 — renormalize addresses", () => {
     expect(rows).toHaveLength(1);
     expect(rows[0].address).toBe("U12345ABC");
   });
+
+  test("no-op when external_user_id column is absent (re-run after migration 294)", () => {
+    const db = createTestDb();
+    bootstrap(db);
+    const raw = getSqliteFrom(db);
+
+    insertContact(raw, "c1");
+    insertChannel(raw, {
+      id: "ch1",
+      contactId: "c1",
+      type: "slack",
+      address: "u12345abc",
+      externalUserId: "U12345ABC",
+      status: "active",
+    });
+
+    // Simulate a later startup where migration 294 has already dropped the
+    // index and column. Migration steps re-run on every startup, so this must
+    // tolerate the dropped column rather than throwing "no such column".
+    raw.run("DROP INDEX IF EXISTS idx_contact_channels_type_ext_user");
+    raw.run("ALTER TABLE contact_channels DROP COLUMN external_user_id");
+
+    expect(() => migrateContactChannelsRenormalizeAddresses(db)).not.toThrow();
+
+    const rows = raw
+      .prepare("SELECT id, address FROM contact_channels")
+      .all() as { id: string; address: string }[];
+    expect(rows).toHaveLength(1);
+    expect(rows[0].address).toBe("u12345abc");
+  });
 });

package/src/memory/migrations/index.ts

@@ -283,6 +283,11 @@ export { migrateBackfillOriginChannelFromBindings } from "./288-backfill-origin-
 export { migrateContactChannelsUniqueExtUser } from "./289-contact-channels-unique-ext-user.js";
 export { migrateScheduleCapabilities } from "./290-schedule-capabilities.js";
 export { migrateContactChannelsRenormalizeAddresses } from "./291-contact-channels-renormalize-addresses.js";
+export { migrateScheduleDefaultNoReuseConversation } from "./292-schedule-default-no-reuse-conversation.js";
+export { migrateWorkflowJournalLeafTokens } from "./293-workflow-journal-leaf-tokens.js";
+export { migrateDropExternalUserId } from "./294-drop-external-user-id.js";
+export { dropApprovalPromptTsTrackerTable } from "./295-drop-approval-prompt-ts-tracker.js";
+export { migrateRewriteBalancedEconomyProfilePins } from "./296-rewrite-balanced-economy-profile-pins.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

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

@@ -1,7 +1,7 @@
 import { and, asc, eq, gt, or } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getConfig } from "../config/loader.js";
+import { getCachedShareAnalytics } from "../platform/consent-cache.js";
 import {
   ACTIVATION_AB_VARIANT,
   ACTIVATION_FUNNEL_VERSION,
@@ -58,7 +58,7 @@ function insertOnboardingEvent(event: OnboardingEvent): OnboardingEvent {
 export function recordOnboardingEvent(
   params: RecordOnboardingEventParams,
 ): OnboardingEvent | null {
-  if (!getConfig().collectUsageData) return null;
+  if (!getCachedShareAnalytics()) return null;
   return insertOnboardingEvent({
     id: uuid(),
     createdAt: Date.now(),
@@ -93,7 +93,7 @@ export function recordActivationEvent(params: {
   userId?: string | null;
   abVariant?: string;
 }): OnboardingEvent | null {
-  if (!getConfig().collectUsageData) return null;
+  if (!getCachedShareAnalytics()) return null;
   const createdAt = Date.now();
   return insertOnboardingEvent({
     id: uuid(),

package/src/memory/schema/contacts.ts

@@ -26,7 +26,6 @@ export const contactChannels = sqliteTable(
     isPrimary: integer("is_primary", { mode: "boolean" })
       .notNull()
       .default(false),
-    externalUserId: text("external_user_id"), // channel-native user ID (e.g., Telegram numeric ID, E.164 phone)
     externalChatId: text("external_chat_id"), // delivery/notification routing address (e.g., Telegram chat ID)
     status: text("status").notNull().default("unverified"), // 'active' | 'pending' | 'revoked' | 'blocked' | 'unverified'
     policy: text("policy").notNull().default("allow"), // 'allow' | 'deny' | 'escalate'

package/src/memory/skill-loaded-events-store.test.ts

@@ -8,18 +8,10 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-let collectUsageData = true;
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-    secretDetection: { enabled: false },
-    collectUsageData,
-  }),
+let shareAnalytics = true;
+
+mock.module("../platform/consent-cache.js", () => ({
+  getCachedShareAnalytics: () => shareAnalytics,
 }));
 
 import { getDb } from "./db-connection.js";
@@ -42,12 +34,12 @@ function insertEvent(
 
 describe("skill-loaded-events-store", () => {
   beforeEach(() => {
-    collectUsageData = true;
+    shareAnalytics = true;
     getDb().delete(skillLoadedEvents).run();
   });
 
-  test("honors the collectUsageData opt-out (records nothing)", () => {
-    collectUsageData = false;
+  test("honors the share_analytics opt-out (records nothing)", () => {
+    shareAnalytics = false;
     recordSkillLoadedEvent({ skillName: "web-research" });
     expect(queryUnreportedSkillLoadedEvents(0, undefined, 10)).toHaveLength(0);
   });

package/src/memory/skill-loaded-events-store.ts

@@ -1,7 +1,7 @@
 import { and, asc, eq, gt, or } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getConfig } from "../config/loader.js";
+import { getCachedShareAnalytics } from "../platform/consent-cache.js";
 import type { UsageAttributionColumns } from "../usage/attribution.js";
 import { getDb } from "./db-connection.js";
 import { skillLoadedEvents } from "./schema.js";
@@ -38,7 +38,7 @@ export interface SkillLoadedEvent {
  * opt-out, matching the rest of telemetry).
  */
 export function recordSkillLoadedEvent(record: SkillLoadedEventRecord): void {
-  if (!getConfig().collectUsageData) return;
+  if (!getCachedShareAnalytics()) return;
   const db = getDb();
   db.insert(skillLoadedEvents)
     .values({

package/src/memory/tool-executed-events-store.test.ts

@@ -8,12 +8,12 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-// Toggle for the collectUsageData opt-out gate the audit listener consults
+// Toggle for the share_analytics opt-out gate the audit listener consults
 // when populating the telemetry columns.
-let collectUsageData = true;
+let shareAnalytics = true;
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({ collectUsageData }),
+mock.module("../platform/consent-cache.js", () => ({
+  getCachedShareAnalytics: () => shareAnalytics,
 }));
 
 import {
@@ -43,7 +43,7 @@ function insertInvocation(
 
 describe("tool-executed-events-store", () => {
   beforeEach(() => {
-    collectUsageData = true;
+    shareAnalytics = true;
     getDb().delete(toolInvocations).run();
   });
 
@@ -136,10 +136,10 @@ describe("tool-executed-events-store", () => {
 
     listener(executedEvent("t-opted-in-before"));
 
-    collectUsageData = false;
+    shareAnalytics = false;
     listener(executedEvent("t-opted-out"));
 
-    collectUsageData = true;
+    shareAnalytics = true;
     listener(executedEvent("t-opted-in-after"));
 
     // Mid-session opt-out flip: only rows recorded while opted in project.