@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/__tests__/voice-invite-redemption.test.ts

@@ -14,6 +14,14 @@ const gatewayIpc = {
     mirrored: boolean;
   },
   claimThrows: false,
+  // When set, contacts_get_rich throws (gateway read unreachable) so the
+  // gate-status fallback must fail open.
+  richThrows: false,
+  // When set, overrides the contacts_get_rich response (e.g. a gateway row
+  // under a divergent UUID for the same (type,address)).
+  richOverride: null as ((contactId: string | undefined) => unknown) | null,
+  // Drives the upsert_verified_channel relay verdict; false refuses the actor.
+  activationVerified: true,
   calls: [] as { method: string; params?: Record<string, unknown> }[],
 };
 
@@ -23,17 +31,112 @@ mock.module("../ipc/gateway-client.js", () => ({
     params?: Record<string, unknown>,
   ) => {
     gatewayIpc.calls.push({ method, params });
+    if (method === "contacts_get_rich") {
+      if (gatewayIpc.richThrows) throw new Error("gateway read unreachable");
+      if (gatewayIpc.richOverride) {
+        return gatewayIpc.richOverride(params?.contactId as string);
+      }
+      return richContactForId(params?.contactId as string);
+    }
     if (method === "record_invite_redemption") {
       if (gatewayIpc.claimThrows) throw new Error("gateway unreachable");
       return gatewayIpc.claim;
     }
+    if (method === "upsert_verified_channel") {
+      if (!gatewayIpc.activationVerified) {
+        return { ok: true, verified: false };
+      }
+      return { ok: true, verified: true };
+    }
     return undefined;
   },
 }));
 
+// Serves contacts_get_rich (the gateway ACL read backing the gate-status
+// fallback) from the seeded local contact, so gate resolution sources status
+// from the gateway path rather than the local channel column.
+function richContactForId(contactId: string | undefined) {
+  if (!contactId) return undefined;
+  const contact = getContact(contactId);
+  if (!contact) return undefined;
+  // ACL columns live on the still-present DB rows, not the slimmed interfaces;
+  // read them raw to build the gateway-rich response the production read parses.
+  const contactRole = (
+    getSqlite()
+      .query("SELECT role FROM contacts WHERE id = ?")
+      .get(contact.id) as { role: string } | undefined
+  )?.role;
+  return {
+    ok: true,
+    contact: {
+      id: contact.id,
+      displayName: contact.displayName,
+      role: contactRole ?? "contact",
+      interactionCount: contact.interactionCount,
+      createdAt: contact.createdAt,
+      updatedAt: contact.updatedAt,
+      channels: contact.channels.map((c) => {
+        const acl = rawChannelAcl(c.id);
+        return {
+          id: c.id,
+          contactId: c.contactId,
+          type: c.type,
+          address: c.address,
+          isPrimary: c.isPrimary,
+          externalUserId: c.externalChatId,
+          status: acl.status,
+          policy: acl.policy,
+          verifiedAt: acl.verifiedAt,
+          verifiedVia: acl.verifiedVia,
+          lastSeenAt: acl.lastSeenAt,
+          interactionCount: acl.interactionCount,
+          lastInteraction: acl.lastInteraction,
+          revokedReason: acl.revokedReason,
+          blockedReason: acl.blockedReason,
+        };
+      }),
+    },
+  };
+}
+
+/** Read a channel's ACL columns straight off the still-present DB row. */
+function rawChannelAcl(channelId: string) {
+  return getSqlite()
+    .query(
+      `SELECT status, policy, verified_at AS verifiedAt, verified_via AS verifiedVia,
+              last_seen_at AS lastSeenAt, interaction_count AS interactionCount,
+              last_interaction AS lastInteraction, revoked_reason AS revokedReason,
+              blocked_reason AS blockedReason
+         FROM contact_channels WHERE id = ?`,
+    )
+    .get(channelId) as {
+    status: string;
+    policy: string;
+    verifiedAt: number | null;
+    verifiedVia: string | null;
+    lastSeenAt: number | null;
+    interactionCount: number;
+    lastInteraction: number | null;
+    revokedReason: string | null;
+    blockedReason: string | null;
+  };
+}
+
+/** Read a contact's local role column (dropped from the Contact interface). */
+function localContactRole(contactId: string): string | undefined {
+  return (
+    getSqlite()
+      .query("SELECT role FROM contacts WHERE id = ?")
+      .get(contactId) as { role: string } | undefined
+  )?.role;
+}
+
 function resetGatewayIpc() {
   gatewayIpc.claim = { ok: true, updated: true, mirrored: true };
   gatewayIpc.claimThrows = false;
+  gatewayIpc.richThrows = false;
+  gatewayIpc.richOverride = null;
+  gatewayIpc.activationVerified = true;
   gatewayIpc.calls = [];
 }
 
@@ -42,12 +145,12 @@ import {
   getContact,
   upsertContact,
 } from "../contacts/contact-store.js";
-import { upsertContactChannel } from "../contacts/contacts-write.js";
 import { getSqlite } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { createInvite, revokeInvite } from "../memory/invite-store.js";
 import { redeemVoiceInviteCode } from "../runtime/invite-redemption-service.js";
 import { generateVoiceCode, hashVoiceCode } from "../util/voice-code.js";
+import { seedContactChannel } from "./helpers/seed-contact-channel.js";
 
 await initializeDb();
 
@@ -204,6 +307,13 @@ describe("redeemVoiceInviteCode", () => {
     );
     expect(claim).toBeDefined();
     expect(claim!.params).toMatchObject({ redeemedByExternalUserId: phone });
+
+    // The activation is written to the gateway via upsert_verified_channel.
+    const upsert = gatewayIpc.calls.find(
+      (c) => c.method === "upsert_verified_channel",
+    );
+    expect(upsert).toBeDefined();
+    expect(upsert!.params).toMatchObject({ type: "phone", address: phone });
   });
 
   test("rejects voice redemption when the gateway claim is not consumable (no mutation)", async () => {
@@ -223,6 +333,23 @@ describe("redeemVoiceInviteCode", () => {
     expect(findContactChannel({ channelType: "phone", address: phone })).toBeNull();
   });
 
+  test("returns invalid_or_expired (no throw) when the gateway refuses the activation", async () => {
+    const phone = "+15551234567";
+    const { code } = createVoiceInvite({ callerPhone: phone });
+
+    // Gateway claim consumes the row, then refuses the channel activation
+    // (blocked/revoked actor). The branch returns its generic failure, not a 500.
+    gatewayIpc.activationVerified = false;
+
+    const result = await redeemVoiceInviteCode({
+      callerExternalUserId: phone,
+      sourceChannel: "phone",
+      code,
+    });
+
+    expect(result).toEqual({ ok: false, reason: "invalid_or_expired" });
+  });
+
   test("proceeds for a legacy voice invite the gateway has never seen (mirrored:false)", async () => {
     const phone = "+15551234567";
     const { code } = createVoiceInvite({ callerPhone: phone });
@@ -259,6 +386,83 @@ describe("redeemVoiceInviteCode", () => {
     ).not.toBeNull();
   });
 
+  test("matches an active member by (type,address) when the gateway row has a divergent uuid", async () => {
+    const phone = "+15551234567";
+    const member = seedContactChannel({
+      sourceChannel: "phone",
+      externalUserId: phone,
+      status: "active",
+    });
+    const { code } = createVoiceInvite({
+      callerPhone: phone,
+      contactId: member.contactId,
+    });
+
+    // Gateway row for the same (type,address) under a DIFFERENT id.
+    gatewayIpc.richOverride = () => ({
+      ok: true,
+      contact: {
+        id: member.contactId,
+        displayName: phone,
+        role: "contact",
+        interactionCount: 0,
+        createdAt: 1,
+        updatedAt: 1,
+        channels: [
+          {
+            id: "gateway-divergent-uuid",
+            contactId: member.contactId,
+            type: "phone",
+            address: phone,
+            isPrimary: false,
+            externalUserId: null,
+            status: "active",
+            policy: "allow",
+            verifiedAt: 1,
+            verifiedVia: "invite",
+            lastSeenAt: null,
+            interactionCount: 0,
+            lastInteraction: null,
+            revokedReason: null,
+            blockedReason: null,
+          },
+        ],
+      },
+    });
+
+    const result = await redeemVoiceInviteCode({
+      callerExternalUserId: phone,
+      sourceChannel: "phone",
+      code,
+    });
+
+    expect(result.ok).toBe(true);
+    expect((result as { type: string }).type).toBe("already_member");
+  });
+
+  test("fails open (no throw) when the gateway gate-status read is unreachable", async () => {
+    const phone = "+15551234567";
+    const member = seedContactChannel({
+      sourceChannel: "phone",
+      externalUserId: phone,
+      status: "revoked",
+    });
+    const { code } = createVoiceInvite({
+      callerPhone: phone,
+      contactId: member.contactId,
+    });
+
+    gatewayIpc.richThrows = true;
+
+    const result = await redeemVoiceInviteCode({
+      callerExternalUserId: phone,
+      sourceChannel: "phone",
+      code,
+    });
+
+    expect(result.ok).toBe(true);
+  });
+
   test("marks channel as verified via invite on voice redemption", async () => {
     const phone = "+15551234567";
     const { code } = createVoiceInvite({ callerPhone: phone });
@@ -271,15 +475,12 @@ describe("redeemVoiceInviteCode", () => {
 
     expect(result.ok).toBe(true);
 
+    // The gateway owns the verified ACL verdict; the local mirror is identity-only.
     const channelResult = findContactChannel({
       channelType: "phone",
       address: phone,
     });
-
     expect(channelResult).not.toBeNull();
-    expect(channelResult!.channel.verifiedAt).toBeGreaterThan(0);
-    expect(channelResult!.channel.verifiedVia).toBe("invite");
-    expect(channelResult!.channel.status).toBe("active");
   });
 
   test("wrong caller identity fails with generic error", async () => {
@@ -387,7 +588,7 @@ describe("redeemVoiceInviteCode", () => {
     const phone = "+15551234567";
 
     // Pre-create an active member for this phone on voice channel
-    const member = upsertContactChannel({
+    const member = seedContactChannel({
       sourceChannel: "phone",
       externalUserId: phone,
       status: "active",
@@ -397,7 +598,7 @@ describe("redeemVoiceInviteCode", () => {
     // Create a voice invite targeting the same contact that owns the channel
     const { code } = createVoiceInvite({
       callerPhone: phone,
-      contactId: member!.contact.id,
+      contactId: member.contactId,
     });
 
     const result = await redeemVoiceInviteCode({
@@ -423,7 +624,7 @@ describe("redeemVoiceInviteCode", () => {
     const phone = "+15551234567";
 
     // Pre-create a blocked member and find their contact
-    const member = upsertContactChannel({
+    const member = seedContactChannel({
       sourceChannel: "phone",
       externalUserId: phone,
       status: "blocked",
@@ -433,7 +634,7 @@ describe("redeemVoiceInviteCode", () => {
     // Create a voice invite targeting the same contact that owns the channel
     const { code } = createVoiceInvite({
       callerPhone: phone,
-      contactId: member!.contact.id,
+      contactId: member.contactId,
     });
 
     const result = await redeemVoiceInviteCode({
@@ -459,16 +660,12 @@ describe("redeemVoiceInviteCode", () => {
     const phone = "+15559998888";
 
     // Pre-create a guardian contact with a revoked phone channel
-    const guardianContact = upsertContact({
+    const guardianSeed = seedContactChannel({
+      sourceChannel: "phone",
+      externalUserId: phone,
       displayName: "Guardian",
       role: "guardian",
-      channels: [
-        {
-          type: "phone",
-          address: phone,
-          status: "revoked",
-        },
-      ],
+      status: "revoked",
     });
 
     // Create a separate target contact "Mom"
@@ -500,11 +697,10 @@ describe("redeemVoiceInviteCode", () => {
     });
     expect(contactResult).not.toBeNull();
     expect(contactResult!.contact.id).toBe(momContact.id);
-    expect(contactResult!.channel.status).toBe("active");
 
     // Verify the original guardian contact was NOT modified
-    const guardian = getContact(guardianContact.id);
+    const guardian = getContact(guardianSeed.contactId);
     expect(guardian).not.toBeNull();
-    expect(guardian!.role).toBe("guardian");
+    expect(localContactRole(guardianSeed.contactId)).toBe("guardian");
   });
 });

package/src/__tests__/web-search-backend-failure.test.ts

@@ -57,6 +57,8 @@ mock.module("../config/loader.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: () => ({ id: "mock-msg-id" }),
   getMessageById: () => null,
   updateMessageContent: () => {},

package/src/__tests__/workspace-migration-102-preserve-heartbeat-enabled-for-existing-workspaces.test.ts

@@ -55,11 +55,11 @@ describe("102-preserve-heartbeat-enabled-for-existing-workspaces migration", ()
     ).toContain("heartbeat.enabled");
   });
 
-  test("schema default is disabled (the flip this migration compensates for)", () => {
-    expect(HeartbeatConfigSchema.parse({}).enabled).toBe(false);
+  test("schema default is enabled", () => {
+    expect(HeartbeatConfigSchema.parse({}).enabled).toBe(true);
   });
 
-  test("skips fresh workspaces so new users get the opt-in default", () => {
+  test("skips fresh workspaces so new users inherit the schema default", () => {
     preserveHeartbeatEnabledForExistingWorkspacesMigration.run(
       workspaceDir,
       NEW_WORKSPACE_CTX,

package/src/__tests__/workspace-migration-111-prune-seeded-callsite-defaults.test.ts

@@ -0,0 +1,208 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { pruneSeededCallsiteDefaultsMigration } from "../workspace/migrations/111-prune-seeded-callsite-defaults.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+
+let workspaceDir: string;
+let previousOverlayPath: string | undefined;
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function readLlm(): Record<string, unknown> | undefined {
+  return readConfig().llm as Record<string, unknown> | undefined;
+}
+
+function latencySeed(): Record<string, unknown> {
+  return {
+    model: "claude-haiku-4-5-20251001",
+    effort: "low",
+    thinking: { enabled: false },
+  };
+}
+
+function fullSeededCallSites(): Record<string, Record<string, unknown>> {
+  return {
+    guardianQuestionCopy: latencySeed(),
+    interactionClassifier: latencySeed(),
+    skillCategoryInference: latencySeed(),
+    inviteInstructionGenerator: latencySeed(),
+    notificationDecision: latencySeed(),
+    preferenceExtraction: latencySeed(),
+    commitMessage: {
+      model: "claude-haiku-4-5-20251001",
+      maxTokens: 120,
+      temperature: 0.2,
+      effort: "low",
+      thinking: { enabled: false },
+    },
+    conversationStarters: latencySeed(),
+    conversationSummarization: {
+      model: "claude-opus-4-7",
+      effort: "low",
+      thinking: { enabled: false },
+    },
+    recall: {
+      profile: "cost-optimized",
+      maxTokens: 4096,
+      effort: "low",
+      thinking: { enabled: false, streamThinking: false },
+      temperature: 0,
+      disableCache: true,
+    },
+    heartbeatAgent: {
+      profile: "cost-optimized",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16000 },
+    },
+    replySuggestion: {
+      model: "claude-haiku-4-5-20251001",
+      effort: "low",
+      thinking: { enabled: false },
+      disableCache: true,
+    },
+    memoryRouter: {
+      profile: "cost-optimized",
+      contextWindow: { maxInputTokens: 1_000_000 },
+    },
+  };
+}
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-111-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+  previousOverlayPath = process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+});
+
+afterEach(() => {
+  if (previousOverlayPath === undefined) {
+    delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  } else {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = previousOverlayPath;
+  }
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("111-prune-seeded-callsite-defaults migration", () => {
+  test("is registered", () => {
+    expect(WORKSPACE_MIGRATIONS).toContain(
+      pruneSeededCallsiteDefaultsMigration,
+    );
+  });
+
+  test("no-op when config.json does not exist", () => {
+    pruneSeededCallsiteDefaultsMigration.run(workspaceDir);
+    expect(existsSync(join(workspaceDir, "config.json"))).toBe(false);
+  });
+
+  test("gracefully handles invalid JSON", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+    pruneSeededCallsiteDefaultsMigration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("removes exact system-owned call-site default materializations", () => {
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        advisorProfile: "frontier",
+        callSites: fullSeededCallSites(),
+      },
+    });
+
+    pruneSeededCallsiteDefaultsMigration.run(workspaceDir);
+
+    expect(readLlm()?.activeProfile).toBe("balanced");
+    expect(readLlm()?.advisorProfile).toBe("frontier");
+    expect(readLlm()?.callSites).toBeUndefined();
+  });
+
+  test("preserves user-customized call-site entries", () => {
+    writeConfig({
+      llm: {
+        callSites: {
+          ...fullSeededCallSites(),
+          commitMessage: {
+            model: "claude-haiku-4-5-20251001",
+            maxTokens: 256,
+            temperature: 0.2,
+            effort: "low",
+            thinking: { enabled: false },
+          },
+          recall: {
+            profile: "cost-optimized",
+            maxTokens: 4096,
+            effort: "low",
+            thinking: { enabled: false, streamThinking: false },
+            temperature: 0,
+            disableCache: false,
+          },
+          customSite: { profile: "frontier" },
+        },
+      },
+    });
+
+    pruneSeededCallsiteDefaultsMigration.run(workspaceDir);
+
+    const callSites = readLlm()?.callSites as Record<
+      string,
+      Record<string, unknown>
+    >;
+    expect(Object.keys(callSites).sort()).toEqual([
+      "commitMessage",
+      "customSite",
+      "recall",
+    ]);
+    expect(callSites.commitMessage?.maxTokens).toBe(256);
+    expect(callSites.recall?.disableCache).toBe(false);
+    expect(callSites.customSite).toEqual({ profile: "frontier" });
+  });
+
+  test("platform-style config keeps gateway settings while pruning seeded call sites", () => {
+    writeConfig({
+      gateway: {
+        unmappedPolicy: "default",
+        defaultAssistantId: "self",
+      },
+      llm: {
+        callSites: fullSeededCallSites(),
+      },
+    });
+
+    pruneSeededCallsiteDefaultsMigration.run(workspaceDir);
+
+    expect(readConfig().gateway).toEqual({
+      unmappedPolicy: "default",
+      defaultAssistantId: "self",
+    });
+    expect(readLlm()?.callSites).toBeUndefined();
+  });
+});