@vellumai/assistant 0.6.6 → 0.7.0

package/src/providers/speech-to-text/provider-catalog.ts

@@ -79,6 +79,20 @@ export interface TelephonyRouting {
   readonly twilioNativeMapping?: TwilioNativeMapping;
 }
 
+// ---------------------------------------------------------------------------
+// Client display metadata
+// ---------------------------------------------------------------------------
+
+/** How the provider's credentials are configured by the user. */
+export type SttSetupMode = "api-key" | "cli";
+
+/** Guide for obtaining API credentials from a provider. */
+export interface SttCredentialsGuide {
+  readonly description: string;
+  readonly url: string;
+  readonly linkLabel: string;
+}
+
 // ---------------------------------------------------------------------------
 // Catalog entry
 // ---------------------------------------------------------------------------
@@ -90,6 +104,18 @@ export interface SttProviderEntry {
   /** Canonical provider identifier (must match an {@link SttProviderId} variant). */
   readonly id: SttProviderId;
 
+  /** Human-readable name for display in settings UI. */
+  readonly displayName: string;
+
+  /** Short description shown below the provider selector. */
+  readonly subtitle: string;
+
+  /** How the provider's credentials are configured. */
+  readonly setupMode: SttSetupMode;
+
+  /** Brief help text guiding the user through setup. */
+  readonly setupHint: string;
+
   /**
    * Name of the credential provider used by `getProviderKeyAsync` to
    * retrieve the API key. Multiple STT providers may share a credential
@@ -141,6 +167,9 @@ export interface SttProviderEntry {
    * strategy selection and Twilio-native mapping details.
    */
   readonly telephonyRouting: TelephonyRouting;
+
+  /** Guide for obtaining API credentials from this provider. */
+  readonly credentialsGuide?: SttCredentialsGuide;
 }
 
 // ---------------------------------------------------------------------------
@@ -164,6 +193,11 @@ const CATALOG: ReadonlyMap<SttProviderId, SttProviderEntry> = new Map<
     "deepgram",
     {
       id: "deepgram",
+      displayName: "Deepgram",
+      subtitle:
+        "Fast, real-time speech-to-text with streaming support. Requires a Deepgram API key.",
+      setupMode: "api-key",
+      setupHint: "Enter your Deepgram API key to enable speech-to-text.",
       credentialProvider: "deepgram",
       supportedBoundaries: new Set<SttBoundaryId>([
         "daemon-batch",
@@ -179,12 +213,24 @@ const CATALOG: ReadonlyMap<SttProviderId, SttProviderEntry> = new Map<
           defaultSpeechModel: "nova-3",
         },
       },
+      credentialsGuide: {
+        description:
+          "Sign in to the Deepgram console, navigate to API Keys, and create a new key.",
+        url: "https://console.deepgram.com/",
+        linkLabel: "Open Deepgram Console",
+      },
     },
   ],
   [
     "google-gemini",
     {
       id: "google-gemini",
+      displayName: "Google Gemini",
+      subtitle:
+        "Multimodal speech-to-text powered by Google Gemini. Requires a Gemini API key.",
+      setupMode: "api-key",
+      setupHint:
+        "Enter your Gemini API key to enable Google Gemini transcription.",
       credentialProvider: "gemini",
       supportedBoundaries: new Set<SttBoundaryId>([
         "daemon-batch",
@@ -200,12 +246,24 @@ const CATALOG: ReadonlyMap<SttProviderId, SttProviderEntry> = new Map<
           defaultSpeechModel: undefined,
         },
       },
+      credentialsGuide: {
+        description:
+          "Visit Google AI Studio, sign in with your Google account, and create an API key.",
+        url: "https://aistudio.google.com/apikey",
+        linkLabel: "Open Google AI Studio",
+      },
     },
   ],
   [
     "openai-whisper",
     {
       id: "openai-whisper",
+      displayName: "OpenAI Whisper",
+      subtitle:
+        "High-accuracy speech-to-text powered by OpenAI Whisper. Requires an OpenAI API key.",
+      setupMode: "api-key",
+      setupHint:
+        "Enter your OpenAI API key to enable Whisper transcription.",
       credentialProvider: "openai",
       supportedBoundaries: new Set<SttBoundaryId>([
         "daemon-batch",
@@ -217,12 +275,23 @@ const CATALOG: ReadonlyMap<SttProviderId, SttProviderEntry> = new Map<
       telephonyRouting: {
         strategyKind: "media-stream-custom",
       },
+      credentialsGuide: {
+        description:
+          "Log in to the OpenAI platform, go to API Keys, and generate a new secret key.",
+        url: "https://platform.openai.com/api-keys",
+        linkLabel: "Open OpenAI Platform",
+      },
     },
   ],
   [
     "xai",
     {
       id: "xai",
+      displayName: "xAI",
+      subtitle:
+        "Real-time speech-to-text powered by xAI. Requires an xAI API key.",
+      setupMode: "api-key",
+      setupHint: "Enter your xAI API key to enable xAI transcription.",
       credentialProvider: "xai",
       supportedBoundaries: new Set<SttBoundaryId>([
         "daemon-batch",
@@ -234,6 +303,12 @@ const CATALOG: ReadonlyMap<SttProviderId, SttProviderEntry> = new Map<
       telephonyRouting: {
         strategyKind: "media-stream-custom",
       },
+      credentialsGuide: {
+        description:
+          "Sign in to the xAI console, navigate to API Keys, and create a new key.",
+        url: "https://console.x.ai/",
+        linkLabel: "Open xAI Console",
+      },
     },
   ],
 ]);

package/src/providers/speech-to-text/xai.ts

@@ -1,13 +1,13 @@
 import type { SttTranscribeResult } from "../../stt/types.js";
 
-export const XAI_STT_URL = "https://api.x.ai/v1/stt";
-export const DEFAULT_TIMEOUT_MS = 60_000;
+const XAI_STT_URL = "https://api.x.ai/v1/stt";
+const DEFAULT_TIMEOUT_MS = 60_000;
 
 /**
  * Derive a filename extension from a MIME type so the xAI STT API can detect
  * the audio format. Falls back to "audio" when the MIME type is unrecognised.
  */
-export function extensionFromMime(mimeType: string): string {
+function extensionFromMime(mimeType: string): string {
   const map: Record<string, string> = {
     "audio/wav": "wav",
     "audio/x-wav": "wav",
@@ -31,7 +31,7 @@ export function extensionFromMime(mimeType: string): string {
  * `file` field to be appended LAST in the multipart body, so we only append
  * the file here (no other fields in v1).
  */
-export function buildXaiFormData(audio: Buffer, mimeType: string): FormData {
+function buildXaiFormData(audio: Buffer, mimeType: string): FormData {
   const ext = extensionFromMime(mimeType);
 
   const formData = new FormData();
@@ -51,7 +51,7 @@ export function buildXaiFormData(audio: Buffer, mimeType: string): FormData {
  * xAI returns a richer shape (`{ text, language, duration, words }`) — we only
  * consume `text`.
  */
-export async function xaiTranscribe(
+async function xaiTranscribe(
   apiKey: string,
   audio: Buffer,
   mimeType: string,

package/src/providers/thinking-config.ts

@@ -0,0 +1,34 @@
+type ThinkingConfigRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is ThinkingConfigRecord {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function normalizeThinkingConfigForWire(
+  thinking: unknown,
+): ThinkingConfigRecord | undefined {
+  if (!isRecord(thinking)) return undefined;
+
+  if (typeof thinking.type === "string") {
+    return thinking;
+  }
+
+  if (thinking.enabled === true) {
+    return { type: "adaptive" };
+  }
+
+  if (thinking.enabled === false) {
+    return { type: "disabled" };
+  }
+
+  return undefined;
+}
+
+export function isThinkingConfigDisabled(thinking: unknown): boolean {
+  return normalizeThinkingConfigForWire(thinking)?.type === "disabled";
+}
+
+export function isThinkingConfigEnabled(thinking: unknown): boolean {
+  const normalized = normalizeThinkingConfigForWire(thinking);
+  return normalized !== undefined && normalized.type !== "disabled";
+}

package/src/providers/types.ts

@@ -1,3 +1,6 @@
+import type { ToolDefinition } from "@vellumai/skill-host-contracts";
+export type { ToolDefinition };
+
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { ProviderError } from "../util/errors.js";
 
@@ -31,6 +34,11 @@ export interface ToolUseContent {
   id: string;
   name: string;
   input: Record<string, unknown>;
+  providerMetadata?: {
+    gemini?: {
+      thoughtSignature?: string;
+    };
+  };
 }
 
 export interface ThinkingContent {
@@ -82,12 +90,6 @@ export interface Message {
   content: ContentBlock[];
 }
 
-export interface ToolDefinition {
-  name: string;
-  description: string;
-  input_schema: object;
-}
-
 export type ModelIntent =
   | "latency-optimized"
   | "quality-optimized"
@@ -140,13 +142,23 @@ export interface SendMessageConfig {
   model?: string;
   /**
    * LLM call-site identifier. `RetryProvider` resolves
-   * provider/model/maxTokens/effort/speed/temperature/thinking/contextWindow
-   * via `resolveCallSiteConfig(callSite, config.llm)`, falling back to
-   * `llm.default` when no callSite-specific entry is present.
+   * provider/model/maxTokens/effort/speed/verbosity/temperature/thinking/
+   * contextWindow via `resolveCallSiteConfig(callSite, config.llm)`, falling
+   * back to `llm.default` when no callSite-specific entry is present.
    */
   callSite?: LLMCallSite;
-  effort?: "low" | "medium" | "high" | "xhigh" | "max";
+  /**
+   * Optional ad-hoc profile override applied per request. When set, the
+   * resolver layers `llm.profiles[overrideProfile]` between the workspace's
+   * `activeProfile` and the call-site's named profile (see
+   * `resolveCallSiteConfig`). Used by per-conversation pinned profiles to
+   * override the workspace default for a single send. Missing profile names
+   * silently fall through.
+   */
+  overrideProfile?: string;
+  effort?: "none" | "low" | "medium" | "high" | "xhigh" | "max";
   speed?: "standard" | "fast";
+  verbosity?: "low" | "medium" | "high";
   [key: string]: unknown;
 }
 

package/src/runtime/AGENTS.md

@@ -65,13 +65,13 @@ Host browser allows the assistant to proxy CDP (Chrome DevTools Protocol) JSON-R
 
 The `chrome-extension` interface in `INTERFACE_IDS` is a non-interactive transport that supports only the `host_browser` capability — it does NOT support `host_bash`, `host_file`, or `host_cu`. This is encoded in `supportsHostProxy(id, capability)`: passing a capability argument returns `true` for `chrome-extension` only when the capability is `host_browser`; the no-arg form returns `false` for `chrome-extension` (so legacy desktop-only call sites that assume full-desktop proxy availability continue to gate correctly).
 
-For the chrome-extension interface, `host_browser_request` frames do NOT travel through `assistantEventHub`. Instead they are routed through the `ChromeExtensionRegistry` singleton (`runtime/chrome-extension-registry.ts`), which tracks active chrome-extension WebSocket connections keyed by `(guardianId, clientInstanceId)`. The registry is populated on WebSocket `open` and drained on `close` inside `http-server.ts`'s `/v1/browser-relay` handlers — see the `wsType === "browser-relay"` branches. For macOS, `host_browser_request` frames travel through `assistantEventHub` (SSE) by default; when the guardian also has an active extension connection, the registry-routed WebSocket sender takes precedence.
+For **self-hosted** deployments, `host_browser_request` frames are routed through the `ChromeExtensionRegistry` singleton (`runtime/chrome-extension-registry.ts`), which tracks active chrome-extension WebSocket connections keyed by `(guardianId, clientInstanceId)`. The registry is populated on WebSocket `open` and drained on `close` inside `http-server.ts`'s `/v1/browser-relay` handlers — see the `wsType === "browser-relay"` branches. For **cloud/platform-hosted** deployments, the chrome extension connects via SSE (`GET /v1/events` with `X-Vellum-Interface-Id: chrome-extension`) and `host_browser_request` frames travel through `assistantEventHub` to the SSE stream. The extension POSTs results back to `POST /v1/host-browser-result`. Transport selection is handled by `resolveHostBrowserSender()` which checks the `ChromeExtensionRegistry` first (WS), then the `ClientRegistry` for an SSE-connected chrome-extension client. For macOS, `host_browser_request` frames travel through `assistantEventHub` (SSE) by default; when the guardian also has an active extension connection, the registry-routed WebSocket sender takes precedence.
 
 A single guardian may have multiple parallel extension installs connected at once (two Chrome profiles, two desktops sharing a sync identity). Each install generates a stable `clientInstanceId` on first run, persists it in `chrome.storage.local`, and sends it on every WebSocket handshake as a query param (`clientInstanceId=...`) or header (`x-client-instance-id`). The registry keys inner entries by that id so sibling installs don't evict each other on register/unregister. The default `send(guardianId, msg)` path routes to whichever instance has the most recent activity (`lastActiveAt`); `sendToInstance(guardianId, clientInstanceId, msg)` pins a specific install. Older extension builds that omit the id get a connection-scoped `legacy:<connectionId>` fallback key so they degrade gracefully to single-instance semantics.
 
 `Conversation.hostBrowserSenderOverride` is the integration point between the turn layer and the registry. When any turn enters the routes layer and the guardian has an active extension connection in the `ChromeExtensionRegistry`, `conversation-routes.ts` resolves the registry entry and sets the override to a sender that writes to that WebSocket. This applies to chrome-extension turns (where the registry is the only transport) and macOS turns (where the extension connection lets browser tools route through the user's real Chrome session instead of cdp-inspect/local). `Conversation.restoreBrowserProxyAvailability()` re-threads the override on queue drain — without this, the drain path would clobber the registry-routed sender with the default `sendToClient` (pointed at the SSE hub) and `host_browser_request` frames would stop reaching the extension mid-queue.
 
-Capability token bootstrap for self-hosted deployments is handled by `routes/browser-extension-pair-routes.ts` (loopback-only; mints a guardian-bound HMAC capability token via `capability-tokens.ts`). Cloud deployments issue guardian-bound JWTs via the gateway's WorkOS-backed flow — `browser-extension-pair-routes.ts` is not involved.
+Capability token bootstrap for self-hosted deployments is handled by the gateway (`gateway/src/http/routes/browser-extension-pair.ts`) which mints a guardian-bound HMAC capability token. The daemon delegates token verification to the gateway via IPC (`verify_capability_token`) — it must never read secrets from `GATEWAY_SECURITY_DIR` or any other gateway-owned directory. Cloud deployments issue guardian-bound JWTs via the gateway's WorkOS-backed flow.
 
 See `docs/browser-use-architecture-phase2.md` for the full wire diagram and component inventory.
 
@@ -79,20 +79,21 @@ See `docs/browser-use-architecture-phase2.md` for the full wire diagram and comp
 
 On macOS-originated turns, the CDP factory (`tools/browser/cdp-client/factory.ts`) evaluates three browser backends in strict priority order. Each candidate is tried lazily; if the first command fails with a transport-level error, the factory falls over to the next candidate. CDP protocol errors (the browser understood the command but rejected it) do NOT trigger failover.
 
-| Priority | Backend                    | Condition                                                                                                                                                                                           | Transport                                                                                              |
-| -------- | -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
-| 1        | **Extension / host proxy** | `hostBrowserProxy` present AND `isAvailable()` returns `true`. On macOS, the proxy is always provisioned (SSE sender when no extension is present, registry-routed when extension is connected)     | WS via `ChromeExtensionRegistry` (extension present) or SSE via `assistantEventHub` (macOS host proxy) |
-| 2        | **cdp-inspect**            | (a) `hostBrowser.cdpInspect.enabled` is `true` in config, OR (b) `transportInterface === "macos"` AND `desktopAuto.enabled` is `true` (default) AND the cooldown from a prior failure is not active | Direct CDP WebSocket to `localhost:9222`                                                               |
-| 3        | **Local**                  | Always present as the final fallback                                                                                                                                                                | In-process Playwright CDP via `browserManager`                                                         |
+| Priority | Backend                    | Condition                                                                                                                                                                                                | Transport                                                                                              |
+| -------- | -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| 1        | **Extension / host proxy** | `hostBrowserProxy` present AND `isAvailable()` returns `true`. On macOS, the proxy is always provisioned. On other interfaces, requires an active transport (WS registry or SSE chrome-extension client) | WS via `ChromeExtensionRegistry` (self-hosted), SSE via `assistantEventHub` (cloud extension or macOS) |
+| 2        | **cdp-inspect**            | (a) `hostBrowser.cdpInspect.enabled` is `true` in config, OR (b) `transportInterface === "macos"` AND `desktopAuto.enabled` is `true` (default) AND the cooldown from a prior failure is not active      | Direct CDP WebSocket to `localhost:9222`                                                               |
+| 3        | **Local**                  | Always present as the final fallback                                                                                                                                                                     | In-process Playwright CDP via `browserManager`                                                         |
 
 **Transport selection for the extension/host-proxy backend:**
 
 The "extension" backend label is a misnomer inherited from the original Phase 2 design where only the Chrome Extension provided host-browser access. In the current architecture, two transports can power this backend:
 
-- **Extension WebSocket**: When the `ChromeExtensionRegistry` has an active entry for the guardian, `resolveHostBrowserSender()` returns a registry-routed sender. `host_browser_request` frames travel over the `/v1/browser-relay` WebSocket to the Chrome extension, which executes CDP commands via `chrome.debugger`.
+- **Extension WebSocket** (self-hosted): When the `ChromeExtensionRegistry` has an active entry for the guardian, `resolveHostBrowserSender()` returns a registry-routed sender. `host_browser_request` frames travel over the `/v1/browser-relay` WebSocket to the Chrome extension, which executes CDP commands via `chrome.debugger`.
+- **Extension SSE** (cloud/platform): When no WebSocket entry exists but a `chrome-extension` client is registered in the `ClientRegistry` (connected via `GET /v1/events`), `resolveHostBrowserSender()` returns the `onEvent` SSE hub sender and sets `hasSseExtension = true`. `host_browser_request` frames travel through `assistantEventHub` to the extension's SSE stream. The extension POSTs results back to `/v1/host-browser-result`. This path is used for any `canServiceSseBrowser()` interface (`web`, `chrome-extension`, `macos`).
 - **macOS SSE bridge**: When the macOS desktop client is connected but no extension is present, `resolveHostBrowserSender()` returns the `onEvent` SSE hub sender. `host_browser_request` frames travel through `assistantEventHub` to the desktop client's SSE connection. The desktop client executes CDP commands against the local Chrome and POSTs results back to `/v1/host-browser-result`.
 
-Both transports use the same `HostBrowserProxy` → `ExtensionCdpClient` pipeline. The `browser_status` output distinguishes the transport via the `details.transport` field: `"extension-ws"` or `"macos-sse"`.
+All three transports use the same `HostBrowserProxy` → `ExtensionCdpClient` pipeline. The `browser_status` output distinguishes the transport via the `details.transport` field: `"extension-ws"` or `"macos-sse"`.
 
 **Fallback criteria for cdp-inspect (desktop-auto):**
 

package/src/runtime/__tests__/agent-wake.test.ts

@@ -15,7 +15,14 @@
  * `memory/conversation-crud.js`.
  */
 
-import { beforeEach, describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Stub the DB-backed override-profile read so unit tests don't need a
+// real SQLite database. The wake helper calls this on every invocation
+// to honor the conversation's pinned inference profile.
+mock.module("../../memory/conversation-crud.js", () => ({
+  getConversationOverrideProfile: () => undefined,
+}));
 
 import type { AgentEvent } from "../../agent/loop.js";
 import type { Message } from "../../providers/types.js";
@@ -195,11 +202,32 @@ describe("wakeAgentForOpportunity", () => {
     // Hint was included in the run input, but baseline is unchanged.
     expect(target.runCalls).toHaveLength(1);
     const input = target.runCalls[0]!.input;
-    expect(input).toHaveLength(3); // 2 baseline + 1 hint
+    expect(input).toHaveLength(5); // 2 baseline + 3 hint (user + assistant + user)
     expect(input[2]).toEqual({
       role: "user",
       content: [
-        { type: "text", text: "[opportunity:unit-test] someone asked a question" },
+        {
+          type: "text",
+          text: "[system] The following assistant message comes from an external system.",
+        },
+      ],
+    });
+    expect(input[3]).toEqual({
+      role: "assistant",
+      content: [
+        {
+          type: "text",
+          text: "[opportunity:unit-test] someone asked a question",
+        },
+      ],
+    });
+    expect(input[4]).toEqual({
+      role: "user",
+      content: [
+        {
+          type: "text",
+          text: "[system] End of message from external system, continue the conversation.",
+        },
       ],
     });
   });
@@ -723,9 +751,7 @@ describe("wakeAgentForOpportunity", () => {
     };
     const toolResultUserMsg: Message = {
       role: "user",
-      content: [
-        { type: "tool_result", tool_use_id: "tu-1", content: "ok" },
-      ],
+      content: [{ type: "tool_result", tool_use_id: "tu-1", content: "ok" }],
     };
     const followup: Message = {
       role: "assistant",
@@ -776,9 +802,7 @@ describe("wakeAgentForOpportunity", () => {
       };
       const toolResultUserMsg: Message = {
         role: "user",
-        content: [
-          { type: "tool_result", tool_use_id: "tu-1", content: "ok" },
-        ],
+        content: [{ type: "tool_result", tool_use_id: "tu-1", content: "ok" }],
       };
       const followup: Message = {
         role: "assistant",

package/src/runtime/__tests__/client-registry.test.ts

@@ -18,8 +18,6 @@ describe("ClientRegistry", () => {
     const entry = registry.register({
       clientId: "mac-1",
       interfaceId: "macos",
-      hostHomeDir: "/Users/alice",
-      hostUsername: "alice",
     });
 
     expect(entry.clientId).toBe("mac-1");
@@ -28,16 +26,14 @@ describe("ClientRegistry", () => {
     expect(entry.capabilities).toContain("host_file");
     expect(entry.capabilities).toContain("host_cu");
     expect(entry.capabilities).toContain("host_browser");
-    expect(entry.hostHomeDir).toBe("/Users/alice");
-    expect(entry.hostUsername).toBe("alice");
     expect(entry.connectedAt).toBeGreaterThan(0);
     expect(entry.lastActiveAt).toBeGreaterThanOrEqual(entry.connectedAt);
   });
 
-  test("register derives empty capabilities for web interface", () => {
+  test("register derives empty capabilities for cli interface", () => {
     const registry = new ClientRegistry();
     const entry = registry.register({
-      clientId: "web-1",
+      clientId: "cli-1",
       interfaceId: "cli",
     });
 
@@ -66,13 +62,11 @@ describe("ClientRegistry", () => {
     const second = registry.register({
       clientId: "mac-1",
       interfaceId: "macos",
-      hostHomeDir: "/Users/bob",
     });
 
     // Same object reference — refreshed in place
     expect(second).toBe(first);
     expect(second.lastActiveAt).toBeGreaterThanOrEqual(firstActive);
-    expect(second.hostHomeDir).toBe("/Users/bob");
     // connectedAt should NOT change on refresh
     expect(second.connectedAt).toBe(first.connectedAt);
   });
@@ -161,7 +155,7 @@ describe("ClientRegistry", () => {
   test("listByCapability filters to clients with matching capability", () => {
     const registry = new ClientRegistry();
     registry.register({ clientId: "mac-1", interfaceId: "macos" });
-    registry.register({ clientId: "web-1", interfaceId: "cli" });
+    registry.register({ clientId: "cli-1", interfaceId: "cli" });
     registry.register({ clientId: "ext-1", interfaceId: "chrome-extension" });
 
     const bashCapable = registry.listByCapability("host_bash");
@@ -177,7 +171,7 @@ describe("ClientRegistry", () => {
 
   test("listByCapability returns empty when no clients match", () => {
     const registry = new ClientRegistry();
-    registry.register({ clientId: "web-1", interfaceId: "cli" });
+    registry.register({ clientId: "cli-1", interfaceId: "cli" });
     expect(registry.listByCapability("host_bash")).toEqual([]);
   });
 
@@ -199,7 +193,7 @@ describe("ClientRegistry", () => {
 
   test("getMostRecentByCapability returns undefined when no clients match", () => {
     const registry = new ClientRegistry();
-    registry.register({ clientId: "web-1", interfaceId: "cli" });
+    registry.register({ clientId: "cli-1", interfaceId: "cli" });
     expect(registry.getMostRecentByCapability("host_bash")).toBeUndefined();
   });
 
@@ -210,8 +204,6 @@ describe("ClientRegistry", () => {
     const entry = registry.register({
       clientId: "mac-1",
       interfaceId: "macos",
-      hostHomeDir: "/Users/alice",
-      hostUsername: "alice",
     });
 
     const json = ClientRegistry.toJSON(entry);
@@ -220,20 +212,6 @@ describe("ClientRegistry", () => {
     expect(json.capabilities).toContain("host_bash");
     expect(json.connectedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
     expect(json.lastActiveAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-    expect(json.hostHomeDir).toBe("/Users/alice");
-    expect(json.hostUsername).toBe("alice");
-  });
-
-  test("toJSON omits host fields when not present", () => {
-    const registry = new ClientRegistry();
-    const entry = registry.register({
-      clientId: "web-1",
-      interfaceId: "cli",
-    });
-
-    const json = ClientRegistry.toJSON(entry);
-    expect(json.hostHomeDir).toBeUndefined();
-    expect(json.hostUsername).toBeUndefined();
   });
 
   // ── evictStale ─────────────────────────────────────────────────────────────