@vellumai/assistant 0.7.1 → 0.7.3

package/src/__tests__/workspace-migration-066-seed-heartbeat-callsite-cost-default.test.ts

@@ -0,0 +1,285 @@
+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 { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import { LLMSchema } from "../config/schemas/llm.js";
+import { seedHeartbeatCallsiteCostDefaultMigration } from "../workspace/migrations/066-seed-heartbeat-callsite-cost-default.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-066-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(configPath(), JSON.stringify(data, null, 2) + "\n");
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(configPath(), "utf-8"));
+}
+
+beforeEach(() => {
+  freshWorkspace();
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+});
+
+afterEach(() => {
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("066-seed-heartbeat-callsite-cost-default migration", () => {
+  test("has correct migration id and is registered", () => {
+    expect(seedHeartbeatCallsiteCostDefaultMigration.id).toBe(
+      "066-seed-heartbeat-callsite-cost-default",
+    );
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "066-seed-heartbeat-callsite-cost-default",
+    );
+  });
+
+  test("fresh config seeds explicit Anthropic cheap defaults", () => {
+    expect(existsSync(configPath())).toBe(false);
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    expect(existsSync(configPath())).toBe(true);
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      provider: "anthropic",
+      model: "claude-haiku-4-5-20251001",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("uses matching cost-optimized profile when present", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-sonnet-4-6" },
+        profiles: {
+          "cost-optimized": {
+            provider: "anthropic",
+            model: "claude-haiku-4-5-20251001",
+          },
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      profile: "cost-optimized",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("fills missing leaves on legacy heartbeat speed override", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          heartbeatAgent: { speed: "fast" },
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      speed: "fast",
+      provider: "anthropic",
+      model: "claude-haiku-4-5-20251001",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("preserves explicit user model selection unchanged", () => {
+    const heartbeatAgent = {
+      provider: "openai",
+      model: "gpt-5.4-mini",
+      effort: "medium",
+      thinking: { enabled: true },
+      contextWindow: { enabled: false },
+    };
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          heartbeatAgent,
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual(heartbeatAgent);
+  });
+
+  test("preserves explicit user profile selection unchanged", () => {
+    const heartbeatAgent = {
+      profile: "quality-optimized",
+    };
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        profiles: {
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-opus-4-7",
+            effort: "max",
+            thinking: { enabled: true, streamThinking: true },
+          },
+        },
+        callSites: {
+          heartbeatAgent,
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual(heartbeatAgent);
+  });
+
+  test("seeds provider-specific cheap model for OpenAI workspaces", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openai", model: "gpt-5.4" },
+        profiles: {
+          "cost-optimized": {
+            provider: "anthropic",
+            model: "claude-haiku-4-5-20251001",
+          },
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      provider: "openai",
+      model: "gpt-5.4-nano",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("seeds existing Gemini latency model for Gemini workspaces", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "gemini", model: "gemini-3.1-pro-preview" },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      provider: "gemini",
+      model: "gemini-3-flash",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("skips when VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH is set", () => {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, unknown> };
+    };
+    expect(config.llm.callSites).toBeUndefined();
+  });
+
+  test("resolved heartbeat config uses cheap model and bounded context", () => {
+    writeConfig({
+      llm: {
+        default: {
+          provider: "anthropic",
+          model: "claude-sonnet-4-6",
+          effort: "high",
+          thinking: { enabled: true, streamThinking: true },
+          contextWindow: { maxInputTokens: 200_000 },
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const onDisk = readConfig() as { llm: unknown };
+    const parsed = LLMSchema.parse(onDisk.llm);
+    const resolved = resolveCallSiteConfig("heartbeatAgent", parsed);
+    expect(resolved.provider).toBe("anthropic");
+    expect(resolved.model).toBe("claude-haiku-4-5-20251001");
+    expect(resolved.maxTokens).toBe(2048);
+    expect(resolved.effort).toBe("low");
+    expect(resolved.temperature).toBe(0);
+    expect(resolved.thinking).toEqual({
+      enabled: false,
+      streamThinking: false,
+    });
+    expect(resolved.contextWindow.maxInputTokens).toBe(16_000);
+  });
+});

package/src/__tests__/workspace-migration-068-release-notes-local-timezone.test.ts

@@ -0,0 +1,90 @@
+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 { releaseNotesLocalTimezoneMigration } from "../workspace/migrations/068-release-notes-local-timezone.js";
+
+const MIGRATION_ID = "068-release-notes-local-timezone";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-068-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function updatesPath(): string {
+  return join(workspaceDir, "UPDATES.md");
+}
+
+function markerCount(content: string): number {
+  return content.split(MARKER).length - 1;
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("workspace migration 068-release-notes-local-timezone", () => {
+  test("has the correct id", () => {
+    expect(releaseNotesLocalTimezoneMigration.id).toBe(MIGRATION_ID);
+  });
+
+  test("creates UPDATES.md with marker and key copy when file is absent", () => {
+    expect(existsSync(updatesPath())).toBe(false);
+
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content).toContain(MARKER);
+    expect(content).toContain("Local timezone grounding");
+    expect(content).toContain("device timezone");
+    expect(content).toContain("Manual timezone overrides still win");
+  });
+
+  test("is idempotent when run twice", () => {
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(markerCount(content)).toBe(1);
+    expect(content.match(/Local timezone grounding/g)?.length).toBe(1);
+  });
+
+  test("appends to existing UPDATES.md when marker is absent", () => {
+    const prior = "## Prior\n\nExisting release note.\n";
+    writeFileSync(updatesPath(), prior, "utf-8");
+
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(prior)).toBe(true);
+    expect(content).toContain(MARKER);
+  });
+
+  test("is a no-op when marker is already present", () => {
+    const seeded = `## Prior\n\n${MARKER}\nAlready announced.\n`;
+    writeFileSync(updatesPath(), seeded, "utf-8");
+
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(seeded);
+  });
+});

package/src/__tests__/workspace-migration-backfill-installation-id.test.ts

@@ -84,7 +84,6 @@ describe("011-backfill-installation-id migration", () => {
     getExternalAssistantIdFn.mockReturnValue("my-assistant");
     getMemoryCheckpointFn.mockReturnValue(null);
     randomUUIDFn.mockReturnValue("generated-uuid-1234");
-    delete process.env.BASE_DATA_DIR;
   });
 
   test("no-op when no lockfile exists", () => {
@@ -284,12 +283,9 @@ describe("011-backfill-installation-id migration", () => {
     expect(parsed.assistants[0].installationId).toBe("sqlite-id");
   });
 
-  test("ignores BASE_DATA_DIR and always reads lockfile from homedir", () => {
-    process.env.BASE_DATA_DIR = "/custom-base";
+  test("always reads lockfile from homedir (per-user, not per-instance)", () => {
     getMemoryCheckpointFn.mockReturnValue("sqlite-id");
 
-    // Lockfile under BASE_DATA_DIR should be ignored — the migration
-    // always reads from homedir() (per-user, not per-instance).
     setupFs({
       [LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
     });

package/src/__tests__/workspace-migration-down-functions.test.ts

@@ -32,7 +32,7 @@ mock.module("../security/credential-key.js", () => ({
   credentialKey: (...args: string[]) => args.join(":"),
 }));
 
-// Mock getRootDir for 016-extract-feature-flags-to-protected
+// Mutable root dir used by 016-extract-feature-flags-to-protected tests
 let mockRootDir: string = "/tmp/mock-root";
 // ---------------------------------------------------------------------------
 // Imports — after mocking
@@ -763,21 +763,21 @@ describe("014-migrate-to-workspace-volume down()", () => {
 // ---------------------------------------------------------------------------
 
 describe("016-extract-feature-flags-to-protected down()", () => {
-  let savedBaseDataDir: string | undefined;
+  let savedWorkspaceDir: string | undefined;
 
   beforeEach(() => {
-    // The migration has an inlined platform helpers that reads BASE_DATA_DIR,
-    // so we set that env var so the inlined function resolves to mockRootDir.
+    // getVellumRoot() resolves via dirname(VELLUM_WORKSPACE_DIR), so we set
+    // VELLUM_WORKSPACE_DIR to <mockRootDir>/workspace so dirname gives mockRootDir.
     const baseDir = freshWorkspace();
     mockRootDir = join(baseDir, ".vellum");
     mkdirSync(mockRootDir, { recursive: true });
-    savedBaseDataDir = process.env.BASE_DATA_DIR;
-    process.env.BASE_DATA_DIR = baseDir;
+    savedWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+    process.env.VELLUM_WORKSPACE_DIR = join(mockRootDir, "workspace");
   });
 
   afterEach(() => {
-    if (savedBaseDataDir === undefined) delete process.env.BASE_DATA_DIR;
-    else process.env.BASE_DATA_DIR = savedBaseDataDir;
+    if (savedWorkspaceDir === undefined) delete process.env.VELLUM_WORKSPACE_DIR;
+    else process.env.VELLUM_WORKSPACE_DIR = savedWorkspaceDir;
   });
 
   test("moves feature flags from protected dir back to config.json", () => {

package/src/__tests__/workspace-migration-safe-storage-limits-release.test.ts

@@ -0,0 +1,90 @@
+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 { releaseNotesSafeStorageLimitsMigration } from "../workspace/migrations/067-release-notes-safe-storage-limits.js";
+
+const MIGRATION_ID = "067-release-notes-safe-storage-limits";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-067-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function updatesPath(): string {
+  return join(workspaceDir, "UPDATES.md");
+}
+
+function markerCount(content: string): number {
+  return content.split(MARKER).length - 1;
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("workspace migration 067-release-notes-safe-storage-limits", () => {
+  test("has the correct id", () => {
+    expect(releaseNotesSafeStorageLimitsMigration.id).toBe(MIGRATION_ID);
+  });
+
+  test("creates UPDATES.md with marker and key copy when file is absent", () => {
+    expect(existsSync(updatesPath())).toBe(false);
+
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content).toContain(MARKER);
+    expect(content).toContain("safe-storage-limits");
+    expect(content).toContain("critical 95% threshold");
+    expect(content).toContain("trusted-contact messages");
+  });
+
+  test("is idempotent when run twice", () => {
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(markerCount(content)).toBe(1);
+    expect(content.match(/Safe storage limits/g)?.length).toBe(1);
+  });
+
+  test("appends to existing UPDATES.md when marker is absent", () => {
+    const prior = "## Prior\n\nExisting release note.\n";
+    writeFileSync(updatesPath(), prior, "utf-8");
+
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(prior)).toBe(true);
+    expect(content).toContain(MARKER);
+  });
+
+  test("is a no-op when marker is already present", () => {
+    const seeded = `## Prior\n\n${MARKER}\nAlready announced.\n`;
+    writeFileSync(updatesPath(), seeded, "utf-8");
+
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(seeded);
+  });
+});

package/src/__tests__/workspace-migration-unify-llm-callsite-configs.test.ts

@@ -119,15 +119,17 @@ describe("038-unify-llm-callsite-configs migration", () => {
   // ─── Schema-default-injection regression (the original bug) ────────────
 
   test("legacy services.inference.{provider,model} win over schema-default-injected llm.default", () => {
-    // Reproduces the production bug: between PR #26095 (added
-    // `LLMSchema.default(LLMSchema.parse({}))` to AssistantConfigSchema)
-    // and PR #26101 (this migration), any daemon boot caused the loader's
-    // `backfillConfigDefaults()` to write a schema-default `llm.default`
+    // Reproduces a production bug from a legacy-daemon era: between PR
+    // #26095 (added `LLMSchema.default(LLMSchema.parse({}))` to
+    // AssistantConfigSchema) and PR #26101 (this migration), any daemon
+    // boot caused the loader to write a schema-default `llm.default`
     // block to disk. Migration 038's old idempotency check (`return early
     // if llm.default exists`) then silently skipped, and migration 039
     // stripped `services.inference.{provider,model}` — losing the user's
     // actual configuration. The fix prefers legacy source keys over the
-    // injected schema defaults whenever both are present.
+    // injected schema defaults whenever both are present. (The loader
+    // no longer writes defaults to disk, but workspaces still on disk
+    // from that era can carry the bad state forward.)
     writeConfig({
       services: {
         inference: {
@@ -806,7 +808,9 @@ describe("038-unify-llm-callsite-configs migration", () => {
     // documented no-op — it leaves the config exactly as it found it,
     // whether the `llm` block is present or absent.
     const original = {
-      services: { inference: { mode: "your-own", provider: "openai", model: "gpt-5.4" } },
+      services: {
+        inference: { mode: "your-own", provider: "openai", model: "gpt-5.4" },
+      },
       maxTokens: 32000,
       llm: {
         default: {

package/src/approvals/guardian-decision-primitive.ts

@@ -355,6 +355,12 @@ export type CanonicalDecisionResult =
       resolverFailed?: boolean;
       resolverFailureReason?: string;
       resolverReplyText?: string;
+      activatedContact?: {
+        sourceChannel: string;
+        externalUserId: string;
+        externalChatId?: string;
+        displayName?: string;
+      };
     }
   | {
       applied: false;
@@ -521,6 +527,9 @@ export async function applyCanonicalGuardianDecision(
   let resolverFailed = false;
   let resolverFailureReason: string | undefined;
   let resolverReplyText: string | undefined;
+  let activatedContact:
+    | { sourceChannel: string; externalUserId: string; externalChatId?: string; displayName?: string }
+    | undefined;
   const resolver = getResolver(request.kind);
   if (resolver) {
     const resolverResult = await resolver.resolve({
@@ -549,6 +558,9 @@ export async function applyCanonicalGuardianDecision(
       resolverFailureReason = resolverResult.reason;
     } else {
       resolverReplyText = resolverResult.guardianReplyText;
+      if (resolverResult.activatedContact) {
+        activatedContact = resolverResult.activatedContact;
+      }
     }
   } else {
     log.info(
@@ -600,5 +612,6 @@ export async function applyCanonicalGuardianDecision(
     grantMinted,
     ...(resolverFailed ? { resolverFailed, resolverFailureReason } : {}),
     ...(resolverReplyText ? { resolverReplyText } : {}),
+    ...(activatedContact ? { activatedContact } : {}),
   };
 }

package/src/approvals/guardian-request-resolvers.ts

@@ -13,7 +13,6 @@
 
 import { answerCall } from "../calls/call-domain.js";
 import { findContactChannel } from "../contacts/contact-store.js";
-import { upsertContactChannel } from "../contacts/contacts-write.js";
 import { findConversation } from "../daemon/conversation-store.js";
 import { emitFeedEvent } from "../home/emit-feed-event.js";
 import {
@@ -120,6 +119,12 @@ export type ResolverResult =
       applied: true;
       grantMinted?: boolean;
       guardianReplyText?: string;
+      activatedContact?: {
+        sourceChannel: string;
+        externalUserId: string;
+        externalChatId?: string;
+        displayName?: string;
+      };
     }
   | { ok: false; reason: string };
 
@@ -510,21 +515,6 @@ const accessRequestResolver: GuardianRequestResolver = {
     // a verification session. The caller is already on the line and the
     // relay server's in-call wait loop will detect the approved status.
     if (channel === "phone") {
-      try {
-        upsertContactChannel({
-          sourceChannel: "phone",
-          externalUserId: requesterExternalUserId,
-          externalChatId: requesterChatId,
-          status: "active",
-          policy: "allow",
-        });
-      } catch (err) {
-        log.error(
-          { err, requesterExternalUserId },
-          "Access request resolver: failed to activate voice caller as trusted contact",
-        );
-      }
-
       log.info(
         {
           event: "resolver_access_request_voice_approved",
@@ -549,7 +539,16 @@ const accessRequestResolver: GuardianRequestResolver = {
         );
       });
 
-      return { ok: true, applied: true };
+      return {
+        ok: true,
+        applied: true,
+        activatedContact: {
+          sourceChannel: "phone",
+          externalUserId: requesterExternalUserId,
+          ...(requesterChatId ? { externalChatId: requesterChatId } : {}),
+          ...(requesterDisplayName ? { displayName: requesterDisplayName } : {}),
+        },
+      };
     }
 
     // Non-voice approvals: mint an identity-bound verification session so the