@vellumai/assistant 0.8.12 → 0.9.0-staging.2

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

@@ -0,0 +1,571 @@
+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 { migrateContactChannelsUniqueExtUser } from "../289-contact-channels-unique-ext-user.js";
+
+interface IndexRow {
+  name: string;
+  unique: number;
+}
+
+interface ChannelRow {
+  id: string;
+  contact_id: string;
+  type: string;
+  address: string;
+  external_user_id: string | null;
+  status: string;
+  updated_at: number | null;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+/**
+ * Bootstrap minimal contact_channels + contacts tables with a case-sensitive
+ * unique index on (type, address) and a non-unique index on
+ * (type, external_user_id) — the pre-migration state.
+ */
+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,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      role TEXT NOT NULL DEFAULT 'contact',
+      contact_type TEXT NOT NULL DEFAULT 'human'
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE TABLE contact_channels (
+      id TEXT PRIMARY KEY,
+      contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+      type TEXT NOT NULL,
+      address TEXT NOT NULL,
+      is_primary INTEGER NOT NULL DEFAULT 0,
+      external_user_id TEXT,
+      external_chat_id TEXT,
+      status TEXT NOT NULL DEFAULT 'unverified',
+      policy TEXT NOT NULL DEFAULT 'allow',
+      interaction_count INTEGER NOT NULL DEFAULT 0,
+      updated_at INTEGER,
+      created_at INTEGER NOT NULL
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE UNIQUE INDEX idx_contact_channels_type_address
+      ON contact_channels(type, address)
+  `);
+  raw.exec(/*sql*/ `
+    CREATE INDEX idx_contact_channels_type_ext_user
+      ON contact_channels(type, external_user_id)
+  `);
+}
+
+function insertContact(raw: Database, id: string): void {
+  const now = Date.now();
+  raw
+    .query(
+      `INSERT INTO contacts (id, display_name, created_at, updated_at) VALUES (?, ?, ?, ?)`,
+    )
+    .run(id, `Contact ${id}`, now, now);
+}
+
+function insertChannel(
+  raw: Database,
+  opts: {
+    id: string;
+    contactId: string;
+    type: string;
+    address: string;
+    externalUserId: string | null;
+    status: string;
+    updatedAt: number;
+  },
+): void {
+  raw
+    .query(
+      `INSERT INTO contact_channels (id, contact_id, type, address, external_user_id, status, updated_at, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      opts.id,
+      opts.contactId,
+      opts.type,
+      opts.address,
+      opts.externalUserId,
+      opts.status,
+      opts.updatedAt,
+      opts.updatedAt,
+    );
+}
+
+function getAllChannels(raw: Database): ChannelRow[] {
+  return raw
+    .query<ChannelRow, []>(`SELECT * FROM contact_channels ORDER BY id`)
+    .all();
+}
+
+function getIndexes(raw: Database): IndexRow[] {
+  return raw
+    .query<
+      IndexRow,
+      []
+    >(`SELECT name, "unique" FROM pragma_index_list('contact_channels')`)
+    .all();
+}
+
+describe("migration 287 — dedup case collisions + drop ext_user indexes", () => {
+  test("no-op on clean database (no duplicates), preserves original casing", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+    insertChannel(raw, {
+      id: "ch1",
+      contactId: "c1",
+      type: "slack",
+      address: "U111",
+      externalUserId: "U111",
+      status: "active",
+      updatedAt: 1000,
+    });
+    insertChannel(raw, {
+      id: "ch2",
+      contactId: "c1",
+      type: "telegram",
+      address: "T222",
+      externalUserId: "T222",
+      status: "active",
+      updatedAt: 1000,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    const channels = getAllChannels(raw);
+    expect(channels).toHaveLength(2);
+    expect(channels.map((c) => c.id).sort()).toEqual(["ch1", "ch2"]);
+    // Addresses preserve original casing
+    expect(channels.find((c) => c.id === "ch1")!.address).toBe("U111");
+    expect(channels.find((c) => c.id === "ch2")!.address).toBe("T222");
+  });
+
+  test("preserves original Slack address casing", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+    insertChannel(raw, {
+      id: "ch1",
+      contactId: "c1",
+      type: "slack",
+      address: "U12345ABC",
+      externalUserId: "U12345ABC",
+      status: "active",
+      updatedAt: 1000,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    const channels = getAllChannels(raw);
+    expect(channels).toHaveLength(1);
+    expect(channels[0]!.address).toBe("U12345ABC");
+    expect(channels[0]!.external_user_id).toBe("U12345ABC");
+  });
+
+  test("deduplicates historical case collisions (active wins over unverified)", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+    insertContact(raw, "c2");
+
+    // Two Slack channels with different casing — historical inconsistency.
+    insertChannel(raw, {
+      id: "ch-upper",
+      contactId: "c1",
+      type: "slack",
+      address: "U12345",
+      externalUserId: "U12345",
+      status: "active",
+      updatedAt: 1000,
+    });
+    insertChannel(raw, {
+      id: "ch-lower",
+      contactId: "c2",
+      type: "slack",
+      address: "u12345",
+      externalUserId: "U12345",
+      status: "unverified",
+      updatedAt: 900,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    const channels = getAllChannels(raw);
+    // Only one survives — active wins over unverified
+    expect(channels).toHaveLength(1);
+    expect(channels[0]!.id).toBe("ch-upper");
+    expect(channels[0]!.address).toBe("U12345");
+  });
+
+  test("deduplicates rows keeping blocked over active (preserves deny state)", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+    insertContact(raw, "c2");
+
+    insertChannel(raw, {
+      id: "ch-active",
+      contactId: "c1",
+      type: "slack",
+      address: "U789",
+      externalUserId: "U789",
+      status: "active",
+      updatedAt: 1000,
+    });
+    insertChannel(raw, {
+      id: "ch-blocked",
+      contactId: "c2",
+      type: "slack",
+      address: "u789",
+      externalUserId: "U789",
+      status: "blocked",
+      updatedAt: 800,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    const channels = getAllChannels(raw);
+    expect(channels).toHaveLength(1);
+    expect(channels[0]!.id).toBe("ch-blocked");
+    expect(channels[0]!.status).toBe("blocked");
+  });
+
+  test("deduplicates rows keeping most recent when same status", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+    insertContact(raw, "c2");
+
+    insertChannel(raw, {
+      id: "ch-old",
+      contactId: "c1",
+      type: "slack",
+      address: "U456",
+      externalUserId: "U456",
+      status: "unverified",
+      updatedAt: 500,
+    });
+    insertChannel(raw, {
+      id: "ch-new",
+      contactId: "c2",
+      type: "slack",
+      address: "u456",
+      externalUserId: "U456",
+      status: "unverified",
+      updatedAt: 1000,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    const channels = getAllChannels(raw);
+    expect(channels).toHaveLength(1);
+    expect(channels[0]!.id).toBe("ch-new");
+  });
+
+  test("does not touch rows with different addresses on different types", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+
+    insertChannel(raw, {
+      id: "ch-email-1",
+      contactId: "c1",
+      type: "email",
+      address: "user@example.com",
+      externalUserId: null,
+      status: "active",
+      updatedAt: 1000,
+    });
+    insertChannel(raw, {
+      id: "ch-email-2",
+      contactId: "c1",
+      type: "email",
+      address: "user2@example.com",
+      externalUserId: null,
+      status: "active",
+      updatedAt: 1000,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    const channels = getAllChannels(raw);
+    expect(channels).toHaveLength(2);
+  });
+
+  test("preserves external_user_id index (dropped by follow-up migration)", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    const beforeIndexes = getIndexes(raw);
+    const oldIdx = beforeIndexes.find(
+      (i) => i.name === "idx_contact_channels_type_ext_user",
+    );
+    expect(oldIdx).toBeDefined();
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    const afterIndexes = getIndexes(raw);
+    // Index is preserved — lookups still use externalUserId until PR 2
+    expect(
+      afterIndexes.find((i) => i.name === "idx_contact_channels_type_ext_user"),
+    ).toBeDefined();
+  });
+
+  test("preserves existing case-sensitive UNIQUE(type, address) index", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+    insertChannel(raw, {
+      id: "ch1",
+      contactId: "c1",
+      type: "slack",
+      address: "U789",
+      externalUserId: "U789",
+      status: "active",
+      updatedAt: 1000,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    // The unique index on (type, address) still exists
+    const afterIndexes = getIndexes(raw);
+    const typeAddrIdx = afterIndexes.find(
+      (i) => i.name === "idx_contact_channels_type_address",
+    );
+    expect(typeAddrIdx).toBeDefined();
+    expect(typeAddrIdx!.unique).toBe(1);
+  });
+
+  test("same address on different channel types both survive", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+    insertChannel(raw, {
+      id: "ch1",
+      contactId: "c1",
+      type: "slack",
+      address: "U111",
+      externalUserId: "U111",
+      status: "active",
+      updatedAt: 1000,
+    });
+    insertChannel(raw, {
+      id: "ch2",
+      contactId: "c1",
+      type: "telegram",
+      address: "U111",
+      externalUserId: "U111",
+      status: "active",
+      updatedAt: 1000,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    const channels = getAllChannels(raw);
+    expect(channels).toHaveLength(2);
+  });
+
+  test("does not normalize address casing (deferred to follow-up migration)", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+    // Simulates old write path that lowercased the address
+    insertChannel(raw, {
+      id: "ch1",
+      contactId: "c1",
+      type: "slack",
+      address: "u12345abc",
+      externalUserId: "U12345ABC",
+      status: "active",
+      updatedAt: 1000,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    const channels = getAllChannels(raw);
+    expect(channels).toHaveLength(1);
+    // Address is NOT normalized — casing restoration deferred to later migration
+    expect(channels[0]!.address).toBe("u12345abc");
+  });
+
+  test("deduplicates rows sharing external_user_id but having different addresses", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+    insertContact(raw, "c2");
+
+    // Two rows with different addresses but same external_user_id.
+    // Step 1 (address dedup) keeps both since addresses differ.
+    // Step 2 (external_user_id dedup) must reduce to one row to prevent
+    // step 3 from creating an address collision.
+    insertChannel(raw, {
+      id: "ch-old-addr",
+      contactId: "c1",
+      type: "slack",
+      address: "alice-old",
+      externalUserId: "U12345",
+      status: "unverified",
+      updatedAt: 500,
+    });
+    insertChannel(raw, {
+      id: "ch-correct",
+      contactId: "c2",
+      type: "slack",
+      address: "U12345",
+      externalUserId: "U12345",
+      status: "active",
+      updatedAt: 1000,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    const channels = getAllChannels(raw);
+    // Only one survives — active wins over unverified
+    expect(channels).toHaveLength(1);
+    expect(channels[0]!.id).toBe("ch-correct");
+    expect(channels[0]!.address).toBe("U12345");
+  });
+
+  test("cross-column collision: row with NULL ext_user_id removed as blocker", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+    insertContact(raw, "c2");
+
+    // Row A: has external_user_id but stale lowercased address
+    insertChannel(raw, {
+      id: "ch-normalizer",
+      contactId: "c1",
+      type: "slack",
+      address: "old-handle",
+      externalUserId: "U12345",
+      status: "active",
+      updatedAt: 2000,
+    });
+
+    // Row B: occupies the target address with NULL external_user_id
+    insertChannel(raw, {
+      id: "ch-blocker",
+      contactId: "c2",
+      type: "slack",
+      address: "U12345",
+      externalUserId: null,
+      status: "unverified",
+      updatedAt: 1000,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    const channels = getAllChannels(raw);
+    // Blocker removed; normalizer keeps its address (normalization deferred)
+    expect(channels).toHaveLength(1);
+    expect(channels[0]!.id).toBe("ch-normalizer");
+    expect(channels[0]!.address).toBe("old-handle");
+  });
+
+  test("cross-column collision: case-insensitive match removes lowercased blocker", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(db);
+
+    insertContact(raw, "c1");
+    insertContact(raw, "c2");
+
+    // Row A: has external_user_id with original Slack casing
+    insertChannel(raw, {
+      id: "ch-normalizer",
+      contactId: "c1",
+      type: "slack",
+      address: "old-handle",
+      externalUserId: "U12345ABC",
+      status: "active",
+      updatedAt: 2000,
+    });
+
+    // Row B: occupies a lowercased variant of the target address (from old write paths)
+    insertChannel(raw, {
+      id: "ch-blocker",
+      contactId: "c2",
+      type: "slack",
+      address: "u12345abc",
+      externalUserId: null,
+      status: "unverified",
+      updatedAt: 1000,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+
+    const channels = getAllChannels(raw);
+    // Blocker removed despite case difference — COLLATE NOCASE catches it
+    expect(channels).toHaveLength(1);
+    expect(channels[0]!.id).toBe("ch-normalizer");
+    expect(channels[0]!.address).toBe("old-handle");
+  });
+
+  test("idempotent — safe to run twice", () => {
+    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,
+    });
+
+    migrateContactChannelsUniqueExtUser(db);
+    migrateContactChannelsUniqueExtUser(db);
+
+    const channels = getAllChannels(raw);
+    expect(channels).toHaveLength(1);
+    // Original casing preserved
+    expect(channels[0]!.address).toBe("U999");
+  });
+});

package/src/memory/migrations/index.ts

@@ -272,6 +272,16 @@ export { migrateAddMemoryV3EverInjected } from "./277-add-memory-v3-ever-injecte
 export { migrateToolInvocationsTelemetryColumns } from "./278-tool-invocations-telemetry-columns.js";
 export { createSkillLoadedEventsTable } from "./279-create-skill-loaded-events.js";
 export { migrateConversationsSurfacedAt } from "./280-conversations-surfaced-at.js";
+export { migrateMemoryRetrospectiveRememberedLog } from "./281-memory-retrospective-remembered-log.js";
+export { migrateScheduleInferenceProfile } from "./282-schedule-inference-profile.js";
+export { migrateMemoryV3SelectionsMessageIdAndSections } from "./283-memory-v3-selections-message-id-and-sections.js";
+export { migrateWorkflowRuns } from "./284-workflow-runs.js";
+export { migrateScheduleWorkflowMode } from "./285-schedule-workflow-mode.js";
+export { migrateWorkflowRunTrust } from "./286-workflow-run-trust.js";
+export { migrateConversationOriginChannelIndex } from "./287-conversation-origin-channel-index.js";
+export { migrateBackfillOriginChannelFromBindings } from "./288-backfill-origin-channel-from-bindings.js";
+export { migrateContactChannelsUniqueExtUser } from "./289-contact-channels-unique-ext-user.js";
+export { migrateScheduleCapabilities } from "./290-schedule-capabilities.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/preloaded-apps.ts

@@ -0,0 +1,116 @@
+/**
+ * Seeds preloaded apps into the workspace apps directory at daemon startup.
+ *
+ * A preloaded app ships as plain source files under
+ * `src/config/preloaded-apps/<dirName>/` and is copied into
+ * `data/apps/<dirName>/` with a fixed, well-known app id, then compiled.
+ * The assistant later populates it by overwriting designated content files
+ * (e.g. the personal page's `src/profile-data.ts`) and calling app_refresh —
+ * it never authors the layout itself.
+ *
+ * Seeding is idempotent and deliberately conservative: once the definition
+ * JSON exists the app is considered user-owned (its content may have been
+ * populated) and the template is never re-copied. A missing `dist/` triggers
+ * a recompile only.
+ *
+ * Seeding is gated on the activation-flow experiment: only assistants in the
+ * personal-page treatment arm get the app. The gate is evaluated once per
+ * daemon startup — an assistant moved into the arm later picks it up on its
+ * next restart, and an already-seeded app is never removed when the
+ * assistant leaves the arm (it is user-owned by then).
+ */
+
+import { cpSync, existsSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { compileApp } from "../bundler/app-compiler.js";
+import {
+  getAssistantFeatureFlagValue,
+  initFeatureFlagOverrides,
+} from "../config/assistant-feature-flags.js";
+import type { AssistantConfig } from "../config/schema.js";
+import { resolveBundledDir } from "../util/bundled-asset.js";
+import { getLogger } from "../util/logger.js";
+import { getAppsDir } from "./app-store.js";
+
+const log = getLogger("preloaded-apps");
+
+/** Well-known id (and dirName) of the personal landing page app. */
+export const PERSONAL_PAGE_APP_ID = "personal-page";
+
+/** Multivariate activation-flow experiment flag (scope "both"). */
+export const ACTIVATION_FLOW_FLAG = "experiment-activation-flow-2026-06-03";
+
+/** Arm of the activation-flow experiment that gets the preseeded page. */
+export const PERSONAL_PAGE_ARM = "personal-page";
+
+export async function seedPreloadedApps(
+  config: AssistantConfig,
+): Promise<void> {
+  // The lifecycle hook fires this early in startup, possibly before the
+  // gateway override fetch has completed. Await it here (no-op when already
+  // cached; bounded retries otherwise) so the arm read below sees the
+  // platform-assigned value rather than the registry default.
+  await initFeatureFlagOverrides();
+
+  const arm = getAssistantFeatureFlagValue(ACTIVATION_FLOW_FLAG, config);
+  if (arm !== PERSONAL_PAGE_ARM) return;
+
+  await seedPersonalPageApp();
+}
+
+async function seedPersonalPageApp(): Promise<void> {
+  const appsDir = getAppsDir();
+  const definitionPath = join(appsDir, `${PERSONAL_PAGE_APP_ID}.json`);
+  const appDir = join(appsDir, PERSONAL_PAGE_APP_ID);
+  const alreadySeeded = existsSync(definitionPath);
+
+  if (alreadySeeded && existsSync(join(appDir, "dist", "index.html"))) {
+    return;
+  }
+
+  if (!alreadySeeded) {
+    const templateDir = resolveBundledDir(
+      import.meta.dirname ?? __dirname,
+      "../config/preloaded-apps/personal-page",
+      "preloaded-apps/personal-page",
+    );
+    if (!existsSync(join(templateDir, "src"))) {
+      log.warn(
+        { templateDir },
+        "Personal page template not found — skipping preloaded app seeding",
+      );
+      return;
+    }
+
+    cpSync(join(templateDir, "src"), join(appDir, "src"), { recursive: true });
+    // Multifile (formatVersion 2) apps keep an empty root index.html; the
+    // real entrypoint is src/index.html compiled into dist/. Matches the
+    // on-disk shape produced by createApp().
+    writeFileSync(join(appDir, "index.html"), "", "utf-8");
+
+    const now = Date.now();
+    const definition = {
+      id: PERSONAL_PAGE_APP_ID,
+      name: "Your Page",
+      description:
+        "A personal landing page the assistant fills in with what it learns about you.",
+      icon: "✨",
+      schemaJson: "{}",
+      createdAt: now,
+      updatedAt: now,
+      formatVersion: 2,
+      dirName: PERSONAL_PAGE_APP_ID,
+    };
+    writeFileSync(definitionPath, JSON.stringify(definition, null, 2), "utf-8");
+    log.info({ appDir }, "Seeded personal page app");
+  }
+
+  const result = await compileApp(appDir);
+  if (!result.ok) {
+    log.warn(
+      { errors: result.errors },
+      "Personal page app failed to compile after seeding",
+    );
+  }
+}