@vellumai/assistant 0.6.6 → 0.7.0

package/src/calls/voice-control-protocol.ts

@@ -19,20 +19,20 @@ export const END_CALL_MARKER = "[END_CALL]";
 // ---------------------------------------------------------------------------
 
 export const ASK_GUARDIAN_CAPTURE_REGEX = /\[ASK_GUARDIAN:\s*(.+?)\]/;
-export const ASK_GUARDIAN_MARKER_REGEX = /\[ASK_GUARDIAN:\s*.+?\]/g;
+const ASK_GUARDIAN_MARKER_REGEX = /\[ASK_GUARDIAN:\s*.+?\]/g;
 
 // Flexible prefix for ASK_GUARDIAN_APPROVAL — tolerates variable whitespace
 // after the colon so the marker is recognized even if the model omits the
 // space or inserts a newline.
-export const ASK_GUARDIAN_APPROVAL_PREFIX_RE = /\[ASK_GUARDIAN_APPROVAL:\s*/;
+const ASK_GUARDIAN_APPROVAL_PREFIX_RE = /\[ASK_GUARDIAN_APPROVAL:\s*/;
 
-export const USER_ANSWERED_MARKER_REGEX = /\[USER_ANSWERED:\s*.+?\]/g;
-export const USER_INSTRUCTION_MARKER_REGEX = /\[USER_INSTRUCTION:\s*.+?\]/g;
-export const CALL_OPENING_MARKER_REGEX = /\[CALL_OPENING\]/g;
-export const CALL_OPENING_ACK_MARKER_REGEX = /\[CALL_OPENING_ACK\]/g;
-export const END_CALL_MARKER_REGEX = /\[END_CALL\]/g;
-export const GUARDIAN_TIMEOUT_MARKER_REGEX = /\[GUARDIAN_TIMEOUT\]/g;
-export const GUARDIAN_UNAVAILABLE_MARKER_REGEX = /\[GUARDIAN_UNAVAILABLE\]/g;
+const USER_ANSWERED_MARKER_REGEX = /\[USER_ANSWERED:\s*.+?\]/g;
+const USER_INSTRUCTION_MARKER_REGEX = /\[USER_INSTRUCTION:\s*.+?\]/g;
+const CALL_OPENING_MARKER_REGEX = /\[CALL_OPENING\]/g;
+const CALL_OPENING_ACK_MARKER_REGEX = /\[CALL_OPENING_ACK\]/g;
+const END_CALL_MARKER_REGEX = /\[END_CALL\]/g;
+const GUARDIAN_TIMEOUT_MARKER_REGEX = /\[GUARDIAN_TIMEOUT\]/g;
+const GUARDIAN_UNAVAILABLE_MARKER_REGEX = /\[GUARDIAN_UNAVAILABLE\]/g;
 
 // ---------------------------------------------------------------------------
 // Balanced JSON extraction (used by stripGuardianApprovalMarkers)
@@ -124,7 +124,7 @@ export function extractBalancedJson(
  * nested braces, string literals, and flexible whitespace correctly.
  * Only strips complete markers (prefix + balanced JSON + closing `]`).
  */
-export function stripGuardianApprovalMarkers(text: string): string {
+function stripGuardianApprovalMarkers(text: string): string {
   let result = text;
   for (;;) {
     const match = extractBalancedJson(result);

package/src/calls/voice-ingress-preflight.ts

@@ -1,6 +1,6 @@
+import { getIsPlatform } from "../config/env-registry.js";
 import { loadConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/types.js";
-import { shouldUsePlatformCallbacks } from "../inbound/platform-callback-registration.js";
 import { getPublicBaseUrl } from "../inbound/public-ingress-urls.js";
 
 const SERVICE_UNAVAILABLE_STATUS = 503 as const;
@@ -34,7 +34,7 @@ export async function preflightVoiceIngress(): Promise<VoiceIngressPreflightResu
 
   // Platform-callback deployments register routes with the platform and receive
   // stable callback URLs. No public ingress URL or local gateway is involved.
-  if (shouldUsePlatformCallbacks()) {
+  if (getIsPlatform()) {
     return {
       ok: true,
       ingressConfig,

package/src/calls/voice-session-bridge.ts

@@ -11,15 +11,21 @@
  */
 
 import { consumeGrantForInvocation } from "../approvals/approval-primitive.js";
-import type { ChannelId } from "../channels/types.js";
+import type {
+  ChannelId,
+  InterfaceId,
+  TurnChannelContext,
+  TurnInterfaceContext,
+} from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
 import type { Conversation } from "../daemon/conversation.js";
-import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
 import { resolveChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { TrustContext } from "../daemon/trust-context.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
@@ -50,7 +56,6 @@ export interface VoiceBridgeDeps {
     data: string;
     filePath?: string;
   }>;
-  deriveDefaultStrictSideEffects: (conversationId: string) => boolean;
 }
 
 let deps: VoiceBridgeDeps | undefined;
@@ -73,23 +78,58 @@ export function setVoiceBridgeDeps(d: VoiceBridgeDeps): void {
  * standard channel path.
  */
 export interface VoiceRunEventSink {
-  onTextDelta(text: string): void;
-  onMessageComplete(): void;
+  onTextDelta(
+    msg: Extract<ServerMessage, { type: "assistant_text_delta" }>,
+  ): void;
+  onMessageComplete(
+    msg: Extract<
+      ServerMessage,
+      { type: "message_complete" } | { type: "generation_cancelled" }
+    >,
+  ): void;
   onError(message: string): void;
   onToolUse(toolName: string, input: Record<string, unknown>): void;
 }
 
+export interface VoiceTurnCallbacks {
+  assistant_text_delta?: (
+    msg: Extract<ServerMessage, { type: "assistant_text_delta" }>,
+  ) => void;
+  message_complete?: (
+    msg: Extract<
+      ServerMessage,
+      { type: "message_complete" } | { type: "generation_cancelled" }
+    >,
+  ) => void;
+  persisted_user_message_id?: (messageId: string) => void;
+  persisted_assistant_message_id?: (messageId: string) => void;
+}
+
 export interface VoiceTurnOptions {
   /** The conversation ID for this voice call's session. */
   conversationId: string;
+  /** Voice session ID for scoped grant matching. Defaults to callSessionId. */
+  voiceSessionId?: string;
   /** The call session ID for scoped grant matching. */
   callSessionId?: string;
+  /** Source channel for persisted user messages. Defaults to phone. */
+  userMessageChannel?: ChannelId;
+  /** Source channel for persisted assistant messages. Defaults to userMessageChannel. */
+  assistantMessageChannel?: ChannelId;
+  /** Source interface for persisted user messages. Defaults to phone. */
+  userMessageInterface?: InterfaceId;
+  /** Source interface for persisted assistant messages. Defaults to userMessageInterface. */
+  assistantMessageInterface?: InterfaceId;
+  /** Per-turn control prompt. Undefined uses the phone prompt; null disables it. */
+  voiceControlPrompt?: string | null;
   /** The transcribed caller utterance or synthetic marker. */
   content: string;
   /** Assistant scope for multi-assistant channels. */
   assistantId?: string;
   /** Guardian trust context for the caller. */
   trustContext?: TrustContext;
+  /** Permission handling mode. Defaults to phone-call auto policy. */
+  approvalMode?: "phone-call" | "local-live-voice";
   /** Whether this is an inbound call (no outbound task). */
   isInbound: boolean;
   /** The outbound call task, if any. */
@@ -97,11 +137,13 @@ export interface VoiceTurnOptions {
   /** When true, skip the disclosure announcement for this call. */
   skipDisclosure?: boolean;
   /** Called for each streaming text token from the agent loop. */
-  onTextDelta: (text: string) => void;
+  onTextDelta?: (text: string) => void;
   /** Called when the agent loop completes a full response. */
-  onComplete: () => void;
+  onComplete?: () => void;
   /** Called when the agent loop encounters an error. */
-  onError: (message: string) => void;
+  onError?: (message: string) => void;
+  /** Event-name callbacks used by non-phone voice clients. */
+  callbacks?: VoiceTurnCallbacks;
   /** Optional AbortSignal for external cancellation (e.g. barge-in). */
   signal?: AbortSignal;
 }
@@ -245,22 +287,50 @@ export async function startVoiceTurn(
   }
 
   const eventSink: VoiceRunEventSink = {
-    onTextDelta: opts.onTextDelta,
-    onMessageComplete: opts.onComplete,
-    onError: opts.onError,
+    onTextDelta: (msg) => {
+      opts.onTextDelta?.(msg.text);
+      opts.callbacks?.assistant_text_delta?.(msg);
+    },
+    onMessageComplete: (msg) => {
+      opts.onComplete?.();
+      opts.callbacks?.message_complete?.(msg);
+      if (msg.type === "message_complete" && msg.messageId) {
+        try {
+          opts.callbacks?.persisted_assistant_message_id?.(msg.messageId);
+        } catch (err) {
+          log.warn(
+            { err, messageId: msg.messageId },
+            "Voice turn assistant-message callback threw",
+          );
+        }
+      }
+    },
+    onError: (message) => {
+      opts.onError?.(message);
+    },
     onToolUse: (toolName, input) => {
       log.debug({ toolName, input }, "Voice turn tool_use event");
     },
   };
 
-  // Voice has no interactive permission/secret UI, so apply explicit
-  // per-role policies:
-  // - guardian: permission prompts auto-allow (parity with guardian chat)
-  // - everyone else (including unknown): fail-closed strict side-effects
-  //   with auto-deny confirmations.
+  // Phone voice has no interactive permission/secret UI, so apply explicit
+  // per-role policies by default. Local live voice opts into the normal
+  // client approval path instead.
   const trustClass = opts.trustContext?.trustClass;
   const isGuardian = trustClass === "guardian";
-  const forceStrictSideEffects = isGuardian ? undefined : true;
+  const approvalMode = opts.approvalMode ?? "phone-call";
+  const usesLocalInteractiveApprovals = approvalMode === "local-live-voice";
+  const voiceSessionId = opts.voiceSessionId ?? opts.callSessionId;
+  const turnChannelContext: TurnChannelContext = {
+    userMessageChannel: opts.userMessageChannel ?? "phone",
+    assistantMessageChannel:
+      opts.assistantMessageChannel ?? opts.userMessageChannel ?? "phone",
+  };
+  const turnInterfaceContext: TurnInterfaceContext = {
+    userMessageInterface: opts.userMessageInterface ?? "phone",
+    assistantMessageInterface:
+      opts.assistantMessageInterface ?? opts.userMessageInterface ?? "phone",
+  };
 
   // Replace the [CALL_OPENING] marker with a neutral instruction before
   // persisting. The marker must not appear as a user message in conversation
@@ -277,16 +347,19 @@ export async function startVoiceTurn(
   // control markers (ASK_GUARDIAN, END_CALL, etc.) and recognize opener turns.
   const isCallerGuardian = opts.trustContext?.trustClass === "guardian";
 
-  const voiceCallControlPrompt = buildVoiceCallControlPrompt({
-    isInbound: opts.isInbound,
-    task: opts.task,
-    isCallerGuardian,
-    skipDisclosure: opts.skipDisclosure,
-  });
+  const voiceCallControlPrompt =
+    opts.voiceControlPrompt === undefined
+      ? buildVoiceCallControlPrompt({
+          isInbound: opts.isInbound,
+          task: opts.task,
+          isCallerGuardian,
+          skipDisclosure: opts.skipDisclosure,
+        })
+      : opts.voiceControlPrompt;
 
   // Get or create the conversation
   const transport = {
-    channelId: "phone" as ChannelId,
+    channelId: turnChannelContext.userMessageChannel,
   };
   const conversation = await deps.getOrCreateConversation(
     opts.conversationId,
@@ -315,23 +388,17 @@ export async function startVoiceTurn(
   }
 
   // Configure conversation for this voice turn
-  const strictSideEffects =
-    forceStrictSideEffects ??
-    deps.deriveDefaultStrictSideEffects(opts.conversationId);
-  conversation.memoryPolicy = {
-    ...conversation.memoryPolicy,
-    strictSideEffects,
-  };
   conversation.setAssistantId(opts.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID);
-  conversation.callSessionId = opts.callSessionId;
+  conversation.callSessionId = voiceSessionId;
   conversation.setTrustContext(opts.trustContext ?? null);
   conversation.setCommandIntent(null);
-  conversation.setTurnChannelContext({
-    userMessageChannel: "phone",
-    assistantMessageChannel: "phone",
-  });
+  conversation.setTurnChannelContext(turnChannelContext);
+  conversation.setTurnInterfaceContext?.(turnInterfaceContext);
   conversation.setChannelCapabilities(
-    resolveChannelCapabilities("phone", undefined),
+    resolveChannelCapabilities(
+      turnChannelContext.userMessageChannel,
+      turnInterfaceContext.userMessageInterface,
+    ),
   );
   conversation.setVoiceCallControlPrompt(voiceCallControlPrompt);
 
@@ -342,6 +409,14 @@ export async function startVoiceTurn(
     [],
     requestId,
   );
+  try {
+    opts.callbacks?.persisted_user_message_id?.(messageId);
+  } catch (err) {
+    log.warn(
+      { err, turnId, messageId },
+      "Voice turn persisted-message callback threw",
+    );
+  }
 
   // Serialized publish chain so hub subscribers observe events in order.
   let hubChain: Promise<void> = Promise.resolve();
@@ -378,6 +453,26 @@ export async function startVoiceTurn(
   let lastError: string | null = null;
   conversation.updateClient(async (msg: ServerMessage) => {
     if (msg.type === "confirmation_request") {
+      if (usesLocalInteractiveApprovals) {
+        pendingInteractions.register(msg.requestId, {
+          conversation,
+          conversationId: opts.conversationId,
+          kind: "confirmation",
+          confirmationDetails: {
+            toolName: msg.toolName,
+            input: msg.input,
+            riskLevel: msg.riskLevel,
+            executionTarget: msg.executionTarget,
+            allowlistOptions: msg.allowlistOptions,
+            scopeOptions: msg.scopeOptions,
+            persistentDecisionsAllowed: msg.persistentDecisionsAllowed,
+            acpToolKind: msg.acpToolKind,
+            acpOptions: msg.acpOptions,
+          },
+        });
+        publishToHub(msg);
+        return;
+      }
       if (autoDeny) {
         // Non-guardian voice callers have no interactive approval UI.
         // The pre-exec gate (tool-approval-handler.ts) handles grant
@@ -398,9 +493,9 @@ export async function startVoiceTurn(
               toolName: msg.toolName,
               inputDigest,
               consumingRequestId: msg.requestId,
-              executionChannel: "phone",
+              executionChannel: turnChannelContext.userMessageChannel,
               conversationId: opts.conversationId,
-              callSessionId: opts.callSessionId,
+              callSessionId: voiceSessionId,
               requesterExternalUserId:
                 opts.trustContext?.requesterExternalUserId,
             },
@@ -505,13 +600,13 @@ export async function startVoiceTurn(
 
           // Forward voice-relevant events to the real-time event sink
           if (msg.type === "assistant_text_delta") {
-            eventSink.onTextDelta(msg.text);
+            eventSink.onTextDelta(msg);
           } else if (msg.type === "message_complete") {
-            eventSink.onMessageComplete();
+            eventSink.onMessageComplete(msg);
           } else if (msg.type === "generation_cancelled") {
             // Treat cancellation as a completed turn so the voice
             // turnComplete promise settles instead of hanging forever.
-            eventSink.onMessageComplete();
+            eventSink.onMessageComplete(msg);
           } else if (msg.type === "error") {
             eventSink.onError(msg.message);
           } else if (msg.type === "conversation_error") {

package/src/channels/__tests__/types.test.ts

@@ -4,6 +4,7 @@ import {
   INTERACTIVE_INTERFACES,
   INTERFACE_IDS,
   isInterfaceId,
+  parseInterfaceId,
   supportsHostProxy,
 } from "../types.js";
 
@@ -21,7 +22,7 @@ describe("INTERFACE_IDS", () => {
       "cli",
       "telegram",
       "phone",
-      "vellum",
+      "web",
       "whatsapp",
       "slack",
       "email",
@@ -55,6 +56,27 @@ describe("isInterfaceId", () => {
   test("returns false for unknown interface", () => {
     expect(isInterfaceId("safari-extension")).toBe(false);
   });
+
+  test("returns false for legacy alias 'vellum' (use parseInterfaceId to normalize)", () => {
+    expect(isInterfaceId("vellum")).toBe(false);
+  });
+});
+
+describe("parseInterfaceId", () => {
+  test("returns canonical ID for valid interface", () => {
+    expect(parseInterfaceId("web")).toBe("web");
+    expect(parseInterfaceId("macos")).toBe("macos");
+  });
+
+  test("normalizes legacy 'vellum' alias to 'web'", () => {
+    expect(parseInterfaceId("vellum")).toBe("web");
+  });
+
+  test("returns null for unknown interface", () => {
+    expect(parseInterfaceId("safari-extension")).toBeNull();
+    expect(parseInterfaceId(42)).toBeNull();
+    expect(parseInterfaceId(null)).toBeNull();
+  });
 });
 
 describe("supportsHostProxy", () => {
@@ -124,8 +146,8 @@ describe("supportsHostProxy", () => {
     expect(supportsHostProxy("telegram", "host_browser")).toBe(false);
   });
 
-  test("vellum returns false (no capability)", () => {
-    expect(supportsHostProxy("vellum")).toBe(false);
+  test("web returns false (no capability)", () => {
+    expect(supportsHostProxy("web")).toBe(false);
   });
 
   test("email returns false for host_browser", () => {

package/src/channels/permission-profiles.ts

@@ -11,7 +11,7 @@
  * Each entry maps a channel ID to a ChannelPermissionProfile.
  */
 
-import { getConfig, saveConfig } from "../config/loader.js";
+import { getConfig } from "../config/loader.js";
 
 // ── Types ───────────────────────────────────────────────────────────
 
@@ -35,7 +35,7 @@ export type ChannelPermissionMap = Record<string, ChannelPermissionProfile>;
 /**
  * Get all channel permission mappings from config.
  */
-export function getChannelPermissions(): ChannelPermissionMap {
+function getChannelPermissions(): ChannelPermissionMap {
   const config = getConfig();
   const perms = config.skills?.entries?.slack?.config?.channelPermissions;
   if (perms && typeof perms === "object" && !Array.isArray(perms)) {
@@ -55,65 +55,6 @@ export function getChannelPermissionProfile(
   return perms[channelId] ?? null;
 }
 
-/**
- * Set the permission profile for a specific channel.
- */
-export function setChannelPermissionProfile(
-  channelId: string,
-  profile: ChannelPermissionProfile,
-): void {
-  const config = getConfig();
-  if (!config.skills) config.skills = {} as typeof config.skills;
-  if (!config.skills.entries) config.skills.entries = {};
-  if (!config.skills.entries.slack)
-    config.skills.entries.slack = { enabled: true };
-  if (!config.skills.entries.slack.config)
-    config.skills.entries.slack.config = {};
-
-  const existing =
-    (config.skills.entries.slack.config.channelPermissions as
-      | ChannelPermissionMap
-      | undefined) ?? {};
-  existing[channelId] = profile;
-  config.skills.entries.slack.config.channelPermissions = existing;
-  saveConfig(config);
-}
-
-/**
- * Remove the permission profile for a specific channel.
- * Returns true if a profile was removed, false if none existed.
- */
-export function removeChannelPermissionProfile(channelId: string): boolean {
-  const config = getConfig();
-  const perms = config.skills?.entries?.slack?.config?.channelPermissions as
-    | ChannelPermissionMap
-    | undefined;
-  if (!perms || !(channelId in perms)) return false;
-
-  delete perms[channelId];
-  config.skills!.entries!.slack!.config!.channelPermissions = perms;
-  saveConfig(config);
-  return true;
-}
-
-/**
- * Replace all channel permission profiles at once.
- */
-export function setAllChannelPermissions(
-  permissions: ChannelPermissionMap,
-): void {
-  const config = getConfig();
-  if (!config.skills) config.skills = {} as typeof config.skills;
-  if (!config.skills.entries) config.skills.entries = {};
-  if (!config.skills.entries.slack)
-    config.skills.entries.slack = { enabled: true };
-  if (!config.skills.entries.slack.config)
-    config.skills.entries.slack.config = {};
-
-  config.skills.entries.slack.config.channelPermissions = permissions;
-  saveConfig(config);
-}
-
 // ── Permission resolution ───────────────────────────────────────────
 
 /**
@@ -142,14 +83,3 @@ export function isToolAllowedInChannel(
 
   return true;
 }
-
-/**
- * Get the effective trust level for a channel.
- * Returns "standard" if no profile or no override is configured.
- */
-export function getChannelTrustLevel(
-  channelId: string,
-): "restricted" | "standard" {
-  const profile = getChannelPermissionProfile(channelId);
-  return profile?.trustLevel ?? "standard";
-}

package/src/channels/types.ts

@@ -21,18 +21,6 @@ export function parseChannelId(value: unknown): ChannelId | null {
   return null;
 }
 
-export function assertChannelId(value: unknown, field: string): ChannelId {
-  const parsed = parseChannelId(value);
-  if (!parsed) {
-    throw new Error(
-      `Invalid channel ID for ${field}: ${String(
-        value,
-      )}. Valid values: ${CHANNEL_IDS.join(", ")}`,
-    );
-  }
-  return parsed;
-}
-
 export interface TurnChannelContext {
   userMessageChannel: ChannelId;
   assistantMessageChannel: ChannelId;
@@ -44,7 +32,7 @@ export const INTERFACE_IDS = [
   "cli",
   "telegram",
   "phone",
-  "vellum",
+  "web",
   "whatsapp",
   "slack",
   "email",
@@ -53,6 +41,22 @@ export const INTERFACE_IDS = [
 
 export type InterfaceId = (typeof INTERFACE_IDS)[number];
 
+/**
+ * Interface IDs that older clients or persisted data may still use.
+ * `normalizeInterfaceId` maps these to their canonical replacements.
+ */
+const LEGACY_INTERFACE_ALIASES: Record<string, InterfaceId> = {
+  // The web client used to report "vellum" as its interface ID. Older
+  // conversation records and in-flight SSE connections may still carry this
+  // value. Normalize to "web" so downstream logic only needs one branch.
+  vellum: "web",
+};
+
+/**
+ * Strict type guard — returns `true` only for canonical `InterfaceId`
+ * values. Legacy aliases like `"vellum"` return `false`; use
+ * `parseInterfaceId` to accept and normalize those.
+ */
 export function isInterfaceId(value: unknown): value is InterfaceId {
   return (
     typeof value === "string" &&
@@ -61,18 +65,12 @@ export function isInterfaceId(value: unknown): value is InterfaceId {
 }
 
 export function parseInterfaceId(value: unknown): InterfaceId | null {
-  return isInterfaceId(value) ? value : null;
-}
-
-export function assertInterfaceId(value: unknown, field: string): InterfaceId {
-  if (!isInterfaceId(value)) {
-    throw new Error(
-      `Invalid interface ID for ${field}: ${String(
-        value,
-      )}. Valid values: ${INTERFACE_IDS.join(", ")}`,
-    );
-  }
-  return value;
+  if (typeof value !== "string") return null;
+  if ((INTERFACE_IDS as readonly string[]).includes(value))
+    return value as InterfaceId;
+  const alias = LEGACY_INTERFACE_ALIASES[value];
+  if (alias) return alias;
+  return null;
 }
 
 /**
@@ -84,7 +82,7 @@ export const INTERACTIVE_INTERFACES: ReadonlySet<InterfaceId> = new Set([
   "macos",
   "ios",
   "cli",
-  "vellum",
+  "web",
 ]);
 
 export function isInteractiveInterface(id: InterfaceId): boolean {
@@ -163,6 +161,24 @@ export function canServiceRegistryBrowser(id: InterfaceId): boolean {
   return id === "chrome-extension" || id === "macos";
 }
 
+/**
+ * Whether the interface can service host_browser frames via the SSE event
+ * hub when a chrome-extension client is connected over SSE (cloud mode).
+ *
+ * In cloud/platform-hosted deployments the chrome extension connects via
+ * SSE (`GET /v1/events`) instead of a direct WebSocket. There is no
+ * ChromeExtensionRegistry entry, but the extension is a valid SSE consumer
+ * for `host_browser_request` frames and can POST results back to
+ * `/v1/host-browser-result`.
+ *
+ * Returns `true` for interfaces that should provision a `HostBrowserProxy`
+ * with the SSE hub sender when a chrome-extension SSE client is present in
+ * the ClientRegistry.
+ */
+export function canServiceSseBrowser(id: InterfaceId): boolean {
+  return id === "web" || id === "chrome-extension" || id === "macos";
+}
+
 export interface TurnInterfaceContext {
   userMessageInterface: InterfaceId;
   assistantMessageInterface: InterfaceId;

package/src/cli/AGENTS.md

@@ -20,6 +20,7 @@ Examples: `config`, `contacts`, `memory`, `autonomy`, `conversations` belong her
 - Each command module exports a registration function that attaches subcommands to the program.
 - Register new commands in `assistant/src/cli/program.ts` inside the `buildCliProgram()` function by importing and calling the registration function.
 - Use `getCliLogger("cli")` for output (not raw `console.log`).
+- When adding/removing/renaming assistant CLI commands or subcommands, update the gateway bash risk registry coverage in `gateway/src/risk/command-registry/commands/assistant.ts` (supported command paths + risk overrides) so permission prompts stay correct.
 
 ## Service calls — no gateway proxying
 

package/src/cli/__tests__/notifications.test.ts

@@ -135,9 +135,10 @@ describe("notifications send", () => {
     expect(ipcCalls).toHaveLength(1);
     const call = ipcCalls[0];
     expect(call.method).toBe("emit_notification_signal");
-    expect(call.params?.sourceChannel).toBe("assistant_tool");
-    expect(call.params?.sourceEventName).toBe("user.send_notification");
-    const payload = call.params?.contextPayload as Record<string, unknown>;
+    const callBody = call.params?.body as Record<string, unknown>;
+    expect(callBody?.sourceChannel).toBe("assistant_tool");
+    expect(callBody?.sourceEventName).toBe("user.send_notification");
+    const payload = callBody?.contextPayload as Record<string, unknown>;
     expect(payload.requestedMessage).toBe("Hello");
   });
 
@@ -160,7 +161,8 @@ describe("notifications send", () => {
     expect(parsed.ok).toBe(true);
 
     expect(ipcCalls).toHaveLength(1);
-    const hints = ipcCalls[0].params?.attentionHints as Record<string, unknown>;
+    const emitBody = ipcCalls[0].params?.body as Record<string, unknown>;
+    const hints = emitBody?.attentionHints as Record<string, unknown>;
     expect(hints.urgency).toBe("high");
     expect(hints.requiresAction).toBe(true);
     expect(hints.isAsyncBackground).toBe(true);
@@ -183,10 +185,8 @@ describe("notifications send", () => {
     expect(parsed.ok).toBe(true);
 
     expect(ipcCalls).toHaveLength(1);
-    const payload = ipcCalls[0].params?.contextPayload as Record<
-      string,
-      unknown
-    >;
+    const dlBody = ipcCalls[0].params?.body as Record<string, unknown>;
+    const payload = dlBody?.contextPayload as Record<string, unknown>;
     expect(payload.preferredChannels).toEqual(["telegram", "slack"]);
   });
 
@@ -288,7 +288,7 @@ describe("notifications list", () => {
     expect(parsed.ok).toBe(true);
 
     expect(ipcCalls).toHaveLength(1);
-    expect(ipcCalls[0].params?.limit).toBe(5);
+    expect((ipcCalls[0].params?.body as Record<string, unknown>)?.limit).toBe(5);
   });
 
   test("list passes --source-event-name to IPC", async () => {
@@ -304,7 +304,9 @@ describe("notifications list", () => {
     expect(parsed.ok).toBe(true);
 
     expect(ipcCalls).toHaveLength(1);
-    expect(ipcCalls[0].params?.sourceEventName).toBe("schedule.notify");
+    expect(
+      (ipcCalls[0].params?.body as Record<string, unknown>)?.sourceEventName,
+    ).toBe("schedule.notify");
   });
 
   test("list surfaces IPC error response", async () => {