@vellumai/assistant 0.11.4-staging.1 → 0.11.4-staging.3

package/src/__tests__/voice-config-update.test.ts

@@ -276,6 +276,46 @@ describe("voice_config_update — tts_voice_id (managed/vellum active)", () => {
     expect(result.content).not.toContain("broadcast");
   });
 
+  test("hints the inline picker for the next managed voice change", async () => {
+    makeVellumActive();
+
+    const result = await run(
+      { setting: "tts_voice_id", value: "aura-2-zeus-en" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toStartWith("Vellum managed voice updated to");
+    expect(result.content).toContain(
+      'ui_show { surface_type: "voice_picker", data: {} }',
+    );
+  });
+
+  test("does not hint the picker when the voice is not managed", async () => {
+    writeConfig({ services: { tts: { provider: "elevenlabs" } } });
+    invalidateConfigCache();
+
+    const result = await run(
+      { setting: "tts_voice_id", value: "abc123" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain("voice_picker");
+  });
+
+  test("does not hint the picker for a non-voice setting", async () => {
+    makeVellumActive();
+
+    const result = await run(
+      { setting: "conversation_timeout", value: 30 },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain("voice_picker");
+  });
+
   test("rejects a value with characters invalid for any voice id", async () => {
     makeVellumActive();
 

package/src/__tests__/voice-scoped-grant-consumer.test.ts

@@ -89,7 +89,8 @@ const CALL_SESSION_ID = "call-session-voice-grant-test";
 
 /**
  * Create a mock session that, when runAgentLoop is called, emits a
- * confirmation_request through the updateClient callback before completing.
+ * confirmation_request through the registered event observer before
+ * completing.
  */
 function createMockSession(opts?: {
   confirmationRequestId?: string;
@@ -118,8 +119,9 @@ function createMockSession(opts?: {
     currentRequestId: requestId,
     abort: () => {},
     persistUserMessage: async () => ({ id: "msg-1", deduplicated: false }),
-    updateClient: (cb: (msg: AssistantEvent) => void, _reset?: boolean) => {
+    addEventObserver: (cb: (msg: AssistantEvent) => void) => {
       clientCallback = cb;
+      return () => {};
     },
     handleConfirmationResponse: (
       reqId: string,
@@ -138,7 +140,7 @@ function createMockSession(opts?: {
       _messageId: string,
       options?: { onEvent?: (msg: AssistantEvent) => void },
     ) => {
-      // Emit a confirmation_request through the client callback
+      // Emit a confirmation_request through the event observer
       if (clientCallback) {
         clientCallback({
           type: "confirmation_request",

package/src/__tests__/voice-session-bridge.test.ts

@@ -61,7 +61,7 @@ function makeStreamingSession(events: AssistantEvent[]): Conversation {
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
     setVoiceCallControlPrompt: () => {},
-    updateClient: () => {},
+    addEventObserver: () => () => {},
     ensureActorScopedHistory: async () => {},
     runAgentLoop: async (
       _content: string,
@@ -116,7 +116,7 @@ function makePersistingStreamingSession(
       turnInterfaceContext = ctx;
     },
     setVoiceCallControlPrompt: () => {},
-    updateClient: () => {},
+    addEventObserver: () => () => {},
     ensureActorScopedHistory: async () => {},
     runAgentLoop: async (
       _content: string,
@@ -254,7 +254,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
         await new Promise((r) => setTimeout(r, 200));
@@ -321,6 +321,51 @@ describe("voice-session-bridge", () => {
     expect(capturedOptions?.callSite).toBe("callAgent");
   });
 
+  test("startVoiceTurn declares the turn interactive so approval prompts are raised for its observer", async () => {
+    // A caller is on the line. If the turn ran non-interactive the permission
+    // checker would deny an approval-gated tool before any prompt existed, and
+    // the bridge's approval observer (auto-resolve for a non-guardian caller, a
+    // real card for the guardian) would never get to decide. Presence is per
+    // turn, so the bridge has to say so.
+    const conversation = createConversation("voice bridge interactive test");
+    const events: AssistantEvent[] = [
+      { type: "message_complete", conversationId: conversation.id },
+    ];
+
+    let capturedOptions: Record<string, unknown> | undefined;
+    const session = {
+      ...makeStreamingSession(events),
+      runAgentLoop: async (
+        _content: string,
+        _messageId: string,
+        options?: Record<string, unknown>,
+      ) => {
+        capturedOptions = options;
+        const onEvent =
+          (options as { onEvent?: (msg: AssistantEvent) => void })?.onEvent ??
+          (() => {});
+        for (const event of events) {
+          onEvent(event);
+        }
+      },
+    } as unknown as Conversation;
+
+    injectDeps(() => session);
+
+    await startVoiceTurn({
+      conversationId: conversation.id,
+      content: "Hello",
+      isInbound: true,
+      onTextDelta: () => {},
+      onComplete: () => {},
+      onError: () => {},
+    });
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(capturedOptions?.isInteractive).toBe(true);
+  });
+
   test("external AbortSignal triggers turn abort", async () => {
     const conversation = createConversation("voice bridge signal test");
     let abortCalled = false;
@@ -339,7 +384,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
         await new Promise((r) => setTimeout(r, 200));
@@ -704,13 +749,14 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
-        // Simulate the prompter emitting a confirmation_request via the
-        // updateClient callback (this is how the real prompter works).
+        // Simulate the conversation emitting a confirmation_request to its
+        // event observer (this is how the real conversation fans out).
         clientHandler({
           type: "confirmation_request",
           requestId: "req-voice-1",
@@ -796,8 +842,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -879,8 +926,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -946,8 +994,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -1009,8 +1058,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -1061,13 +1111,20 @@ describe("voice-session-bridge", () => {
   // broadcast in voice-session-bridge.ts's confirmation_request branch. The
   // fake's handleConfirmationResponse mirrors production's synchronous
   // `interaction_resolved` broadcast so the wire order is observable through
-  // the event hub, which serializes publishes in call order.
+  // the event hub, which serializes publishes in call order. Its `emit`
+  // mirrors a real conversation's: the sink (the hub) delivers first, then
+  // observers run, so the bridge's resolution lands after the request.
   function makeConfirmationOrderingSession(
     conversationId: string,
     requestId: string,
   ): Conversation {
     let clientHandler: (msg: AssistantEvent) => void = () => {};
+    const emit = (msg: AssistantEvent) => {
+      broadcastMessage(msg);
+      clientHandler(msg);
+    };
     return {
+      emit,
       isProcessing: () => false,
       persistUserMessage: async () => ({
         id: "test-msg-id",
@@ -1080,12 +1137,13 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
-        clientHandler({
+        emit({
           type: "confirmation_request",
           requestId,
           toolName: "host_bash",
@@ -1222,8 +1280,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -1290,7 +1349,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {},
       handleConfirmationResponse: () => {},
@@ -1349,7 +1408,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: recordLast("setTurnChannelContext"),
       setTurnInterfaceContext: recordLast("setTurnInterfaceContext"),
       setVoiceCallControlPrompt: recordLast("setVoiceCallControlPrompt"),
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {},
       handleConfirmationResponse: () => {},
@@ -1391,15 +1450,12 @@ describe("voice-session-bridge", () => {
     expect(session.forcePromptSideEffects).toBe(false);
   });
 
-  test("cleanup on early persistUserMessage throw does not detach prior client sender", async () => {
+  test("cleanup on early persistUserMessage throw does not detach a prior turn's observer", async () => {
     const conversation = createConversation(
       "voice bridge sender detach guard test",
     );
 
-    const updateClientCalls: Array<{
-      callback: unknown;
-      replace: boolean | undefined;
-    }> = [];
+    const addEventObserverCalls: unknown[] = [];
 
     const session = {
       isProcessing: () => false,
@@ -1415,8 +1471,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (callback: unknown, replace?: boolean) => {
-        updateClientCalls.push({ callback, replace });
+      addEventObserver: (observer: unknown) => {
+        addEventObserverCalls.push(observer);
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {},
@@ -1451,10 +1508,9 @@ describe("voice-session-bridge", () => {
     expect(caught?.message).toBe(
       "persist failed before bridge installed callback",
     );
-    // The bridge never reached its `conversation.updateClient(...)` install
-    // site, so cleanup must not touch updateClient — otherwise it would
-    // detach a sender installed by a prior turn on the same conversation.
-    expect(updateClientCalls).toEqual([]);
+    // The bridge never reached its `conversation.addEventObserver(...)`
+    // install site, so no observer was registered for cleanup to detach.
+    expect(addEventObserverCalls).toEqual([]);
   });
 
   test("pre-aborted signal triggers immediate abort", async () => {
@@ -1475,7 +1531,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
         await new Promise((r) => setTimeout(r, 200));

package/src/__tests__/workspace-migration-146-repair-retired-fireworks-deepseek-flash-model-id.test.ts

@@ -0,0 +1,235 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repairRetiredFireworksDeepseekFlashModelIdMigration } from "../workspace/migrations/146-repair-retired-fireworks-deepseek-flash-model-id.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import { assertNotLiveDb } from "./assert-not-live-db.js";
+
+const STALE = "accounts/fireworks/models/deepseek-v4-flash";
+const REPLACEMENT = "accounts/fireworks/models/deepseek-v4-flash-0731";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-146-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+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 seedRows(rows: Array<{ name: string; provider: string }>): void {
+  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+  const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+  db.run(`CREATE TABLE IF NOT EXISTS provider_connections (
+    name TEXT PRIMARY KEY,
+    provider TEXT NOT NULL,
+    auth TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`);
+  for (const row of rows) {
+    db.query(
+      `INSERT INTO provider_connections (name, provider, auth, created_at, updated_at) VALUES (?, ?, '{"type":"api_key"}', 1, 1)`,
+    ).run(row.name, row.provider);
+  }
+  db.close();
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    assertNotLiveDb(workspaceDir);
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("146-repair-retired-fireworks-deepseek-flash-model-id migration", () => {
+  test("has correct migration id and is registered", () => {
+    expect(repairRetiredFireworksDeepseekFlashModelIdMigration.id).toBe(
+      "146-repair-retired-fireworks-deepseek-flash-model-id",
+    );
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "146-repair-retired-fireworks-deepseek-flash-model-id",
+    );
+  });
+
+  test("repairs the stale ID in default, call sites, and profiles", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        callSites: {
+          recall: { model: STALE, maxTokens: 4096 },
+          heartbeat: { model: `${STALE}-tuned` },
+          malformed: STALE,
+        },
+        profiles: {
+          "cost-optimized": { provider: "vellum", model: STALE },
+          legacy: { model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.maxTokens).toBe(4096);
+    // Non-exact matches and malformed leaves are untouched. The dated
+    // replacement itself extends the stale ID, so the exact match must not
+    // fire on already-repaired leaves.
+    expect(llm.callSites.heartbeat.model).toBe(`${STALE}-tuned`);
+    expect(llm.callSites.malformed).toBe(STALE);
+    // Managed profiles stamped provider "vellum" carry Fireworks model IDs.
+    expect(llm.profiles["cost-optimized"].model).toBe(REPLACEMENT);
+    expect(llm.profiles.legacy.model).toBe(REPLACEMENT);
+  });
+
+  test("repairs entry-bound fragments whose row kind is fireworks or vellum", () => {
+    seedRows([
+      { name: "my-fireworks", provider: "fireworks" },
+      { name: "managed-alt", provider: "vellum" },
+    ]);
+    writeConfig({
+      llm: {
+        profiles: {
+          bound: { provider: "my-fireworks", model: STALE },
+          managed: { provider: "managed-alt", model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(REPLACEMENT);
+    expect(llm.profiles.managed.model).toBe(REPLACEMENT);
+  });
+
+  test("leaves fragments with an explicit other provider untouched", () => {
+    seedRows([{ name: "byo-compat", provider: "openai-compatible" }]);
+    writeConfig({
+      llm: {
+        default: { provider: "openai-compatible", model: STALE },
+        profiles: {
+          byo: { provider: "openai-compatible", model: STALE },
+          // Entry-bound profile whose row kind is not repairable.
+          compatBound: { provider: "byo-compat", model: STALE },
+          // Entry name with no row: dangling, so nothing proves it is a
+          // fireworks-kind route.
+          dangling: { provider: "ghost", model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.default.model).toBe(STALE);
+    expect(llm.profiles.byo.model).toBe(STALE);
+    expect(llm.profiles.compatBound.model).toBe(STALE);
+    expect(llm.profiles.dangling.model).toBe(STALE);
+  });
+
+  test("leaves entry-name providers untouched when no DB file exists", () => {
+    writeConfig({
+      llm: {
+        profiles: { bound: { provider: "my-fireworks", model: STALE } },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(STALE);
+  });
+
+  test("throws when an entry-name provider needs rows and the DB is unreadable", () => {
+    // A DB file without the provider_connections table is unqueryable, so
+    // the run must fail (and retry later) instead of skipping the profile.
+    mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+    writeFileSync(join(workspaceDir, "data", "db", "assistant.db"), "");
+    writeConfig({
+      llm: {
+        profiles: { bound: { provider: "my-fireworks", model: STALE } },
+      },
+    });
+
+    expect(() =>
+      repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir),
+    ).toThrow();
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(STALE);
+
+    // Vendor and absent providers never need the rows, so the same broken
+    // DB does not block their repair.
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        profiles: { legacy: { model: STALE } },
+      },
+    });
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+    const repaired = readConfig().llm as Record<string, any>;
+    expect(repaired.default.model).toBe(REPLACEMENT);
+    expect(repaired.profiles.legacy.model).toBe(REPLACEMENT);
+  });
+
+  test("is idempotent and a no-op without the stale ID", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        profiles: { fine: { provider: "fireworks", model: REPLACEMENT } },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+    const first = readConfig();
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(first);
+
+    const llm = first.llm as Record<string, any>;
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.profiles.fine.model).toBe(REPLACEMENT);
+  });
+
+  test("handles missing config, missing llm block, and invalid JSON", () => {
+    // No config.json at all.
+    expect(() =>
+      repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    writeConfig({ theme: "dark" });
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+    expect(readConfig()).toEqual({ theme: "dark" });
+
+    writeFileSync(join(workspaceDir, "config.json"), "{not json");
+    expect(() =>
+      repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir),
+    ).not.toThrow();
+  });
+});

package/src/acp/session-manager.ts

@@ -1224,9 +1224,14 @@ export class AcpSessionManager {
       );
       return;
     }
+    // The notification turn streams to whoever is watching (the parent's sink is
+    // its client hub), but it is machine-injected with no human asserted to be
+    // present, so it runs non-interactive: a tool that would need approval is
+    // denied rather than left waiting on a prompt nobody may answer.
     const enqueueResult = parentConversation.enqueueMessage({
       content: message,
       metadata: { acpNotification },
+      isInteractive: false,
     });
     if (enqueueResult.queued || enqueueResult.rejected) {
       return;
@@ -1234,7 +1239,9 @@ export class AcpSessionManager {
     parentConversation
       .persistUserMessage({ content: message, metadata: { acpNotification } })
       .then(({ id: messageId }) =>
-        parentConversation.runAgentLoop(message, messageId),
+        parentConversation.runAgentLoop(message, messageId, {
+          isInteractive: false,
+        }),
       )
       .catch((err) => {
         log.error(

package/src/api/surfaces.ts

@@ -488,6 +488,11 @@ export const WorkResultItemSchema = z.object({
   status: tolerantString(),
   tone: WorkResultToneSchema.optional().catch(undefined),
   metadata: recordArray(WorkResultMetadataSchema).optional().catch(undefined),
+  /**
+   * Makes the item row a link. Clients follow an in-app path
+   * (`/assistant/skills/<skillId>?tab=history`) in place and open an http(s)
+   * URL externally; anything else renders as an unlinked row.
+   */
   href: tolerantString(),
 });
 export type WorkResultItem = z.infer<typeof WorkResultItemSchema>;
@@ -591,6 +596,7 @@ export const SURFACE_TYPES = [
   "skill_card",
   "call_summary",
   "visual",
+  "voice_picker",
 ] as const;
 
 export const SurfaceTypeSchema = z.enum(SURFACE_TYPES);
@@ -662,9 +668,10 @@ export type SurfaceData =
  * and serves verbatim but whose shape it does not model, which is why they
  * are absent from the renderable `SurfaceData` union: `channel_setup` (a
  * side-effect command forwarded to the setup panel), `task_preferences` (a
- * fixed grid that reads no data), and `skill_card` / `call_summary` (cards
- * the daemon appends to history directly — the memory retrospective and a
- * call summary — and whose data shape is owned by their client renderers).
+ * fixed grid that reads no data), `voice_picker` (a settings card that reads
+ * its own config), and `skill_card` / `call_summary` (cards the daemon appends
+ * to history directly, the memory retrospective and a call summary, whose
+ * data shape is owned by their client renderers).
  */
 export interface SurfaceDataByType {
   card: CardSurfaceData;
@@ -684,6 +691,7 @@ export interface SurfaceDataByType {
   skill_card: Record<string, unknown>;
   call_summary: Record<string, unknown>;
   visual: VisualSurfaceData;
+  voice_picker: Record<string, unknown>;
 }
 
 /** Any surface `data` payload, including the opaque (non-renderable) types. */
@@ -717,6 +725,7 @@ export const SURFACE_DATA_SCHEMAS: {
   skill_card: z.record(z.string(), z.unknown()),
   call_summary: z.record(z.string(), z.unknown()),
   visual: VisualSurfaceDataSchema,
+  voice_picker: z.record(z.string(), z.unknown()),
 };
 
 /**