@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/desktop/desktop-window-theme.ts

@@ -13,24 +13,7 @@ const BUTTON_MASKS = {
   iconify: [0, 0, 0, 0, 0x3ff, 0x3ff, 0, 0, 0, 0],
 };
 
-function windowTheme(accentHex: string | null): string {
-  const tint = (base: string, amount: number): string => {
-    if (!accentHex || !/^#[\da-f]{6}$/i.test(accentHex)) {
-      return base;
-    }
-    return (
-      "#" +
-      [1, 3, 5]
-        .map((offset) => {
-          const from = parseInt(base.slice(offset, offset + 2), 16);
-          const to = parseInt(accentHex.slice(offset, offset + 2), 16);
-          return Math.round(from + (to - from) * amount)
-            .toString(16)
-            .padStart(2, "0");
-        })
-        .join("")
-    );
-  };
+function windowTheme(): string {
   return `
 border.width: 1
 padding.width: 8
@@ -47,17 +30,15 @@ window.*.grip.bg: Flat Solid
 window.*.button.*.bg: Parentrelative
 window.*.button.*.hover.bg: Flat Solid
 window.*.button.*.pressed.bg: Flat Solid
-window.active.title.bg: Flat Gradient Horizontal
-window.active.title.bg.color: ${tint("#292930", 0.28)}
-window.active.title.bg.colorTo: #292930
+window.active.title.bg.color: #292930
 window.active.border.color: #4a4a54
 window.active.title.separator.color: #202026
 window.active.label.text.color: #f0f0f4
 window.active.handle.bg.color: #292930
 window.active.grip.bg.color: #292930
 window.active.button.*.image.color: #d4d4dc
-window.active.button.*.hover.bg.color: ${tint("#45454f", 0.22)}
-window.active.button.*.pressed.bg.color: ${tint("#555561", 0.18)}
+window.active.button.*.hover.bg.color: #45454f
+window.active.button.*.pressed.bg.color: #555561
 window.active.button.*.disabled.image.color: #62626e
 window.active.button.close.hover.bg.color: #b64150
 window.active.button.close.pressed.bg.color: #963442
@@ -97,7 +78,6 @@ osd.label.text.color: #f0f0f4
 export function writeDesktopWindowTheme(
   configDir: string,
   home?: string,
-  accentHex: string | null = null,
 ): string {
   let source: string | undefined;
   let sourcePath = "";
@@ -134,7 +114,7 @@ export function writeDesktopWindowTheme(
   mkdirSync(join(themeDir, "openbox-3"), { recursive: true });
   writeFileSync(
     join(themeDir, "openbox-3", "themerc"),
-    windowTheme(accentHex).trimStart(),
+    windowTheme().trimStart(),
   );
   for (const [name, rows] of Object.entries(BUTTON_MASKS)) {
     const bytes = rows.flatMap((row) => [row & 0xff, row >> 8]);

package/src/desktop/virtual-desktop-feature.ts

@@ -1,9 +1,17 @@
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getIsContainerized, getIsPlatform } from "../config/env-registry.js";
 import type { AssistantConfig } from "../config/schema.js";
+import type { ToolContext } from "../tools/types.js";
 
 const VIRTUAL_DESKTOP_FLAG = "assistant-desktop" as const;
 
+export function isVirtualDesktopPlatform(
+  containerized: boolean = getIsContainerized(),
+  platformHosted: boolean = getIsPlatform(),
+): boolean {
+  return platformHosted && containerized;
+}
+
 /** Gates desktop streaming and control to enabled, platform-hosted containers. */
 export function isVirtualDesktopEnabled(
   config?: AssistantConfig,
@@ -11,8 +19,50 @@ export function isVirtualDesktopEnabled(
   platformHosted: boolean = getIsPlatform(),
 ): boolean {
   return (
-    platformHosted &&
-    containerized &&
+    isVirtualDesktopPlatform(containerized, platformHosted) &&
     isAssistantFeatureFlagEnabled(VIRTUAL_DESKTOP_FLAG, config)
   );
 }
+
+export function canUseVirtualDesktop(
+  context: Pick<ToolContext, "trustClass" | "sourceActorPrincipalId">,
+  enabled: boolean = isVirtualDesktopEnabled(),
+): boolean {
+  return (
+    context.trustClass === "guardian" &&
+    !!context.sourceActorPrincipalId &&
+    enabled
+  );
+}
+
+/** Web browser turns default to the streamed desktop; native apps keep their host. */
+export function shouldUseVirtualDesktop(
+  context: Pick<
+    ToolContext,
+    "transportInterface" | "clientOs" | "trustClass" | "sourceActorPrincipalId"
+  >,
+  enabled: boolean = isVirtualDesktopEnabled(),
+): boolean {
+  return (
+    context.transportInterface === "web" &&
+    context.clientOs !== "macos" &&
+    context.clientOs !== "windows" &&
+    context.clientOs !== "linux" &&
+    canUseVirtualDesktop(context, enabled)
+  );
+}
+
+export function supportsVirtualDesktopComputerUse(toolName: string): boolean {
+  return [
+    "computer_use_observe",
+    "computer_use_click",
+    "computer_use_type_text",
+    "computer_use_key",
+    "computer_use_scroll",
+    "computer_use_drag",
+    "computer_use_wait",
+    "computer_use_sequence",
+    "computer_use_done",
+    "computer_use_respond",
+  ].includes(toolName);
+}

package/src/desktop/virtual-desktop-platform.test.ts

@@ -3,7 +3,7 @@ import { afterEach, beforeEach, expect, spyOn, test } from "bun:test";
 import { setOverridesForTesting } from "../__tests__/feature-flag-test-helpers.js";
 import { shouldUseVirtualDesktopBrowser } from "../browser/virtual-desktop-target.js";
 import { executeDesktopBrowserOperation } from "./desktop-browser-operations.js";
-import { desktopDependencyInstaller } from "./desktop-dependencies.js";
+import { desktopDependencies } from "./desktop-dependencies.js";
 
 const originalPlatform = process.env.IS_PLATFORM;
 const originalContainerized = process.env.IS_CONTAINERIZED;
@@ -15,15 +15,13 @@ const context = {
   transportInterface: "web" as const,
   clientOs: "web" as const,
 };
-let status: ReturnType<
-  typeof spyOn<typeof desktopDependencyInstaller, "getStatus">
->;
+let status: ReturnType<typeof spyOn<typeof desktopDependencies, "getStatus">>;
 
 beforeEach(() => {
   process.env.IS_CONTAINERIZED = "true";
   process.env.IS_PLATFORM = "false";
   setOverridesForTesting({ "assistant-desktop": true });
-  status = spyOn(desktopDependencyInstaller, "getStatus").mockReturnValue({
+  status = spyOn(desktopDependencies, "getStatus").mockReturnValue({
     state: "ready",
   });
 });
@@ -51,11 +49,9 @@ test("self-hosted Docker cannot automatically select or explicitly control virtu
   expect(status).not.toHaveBeenCalled();
 });
 
-test("platform web conversations select virtual Chrome before and during installation", () => {
+test("platform web conversations select virtual Chrome even when image components are missing", () => {
   process.env.IS_PLATFORM = "true";
   expect(shouldUseVirtualDesktopBrowser(undefined, {}, context)).toBe(true);
-  status.mockReturnValue({ state: "installing" });
-  expect(shouldUseVirtualDesktopBrowser(undefined, {}, context)).toBe(true);
-  status.mockReturnValue({ state: "required" });
+  status.mockReturnValue({ state: "failed" });
   expect(shouldUseVirtualDesktopBrowser(undefined, {}, context)).toBe(true);
 });

package/src/documents/document-store.ts

@@ -5,6 +5,8 @@
  * background jobs (e.g. proactive artifact generation) can persist documents
  * without going through the HTTP layer.
  */
+import { randomUUID } from "node:crypto";
+
 import { rawAll, rawGet, rawRun } from "../persistence/raw-query.js";
 import { getLogger } from "../util/logger.js";
 
@@ -456,6 +458,27 @@ export function saveDocument(params: {
   }
 }
 
+export const DEFAULT_DOCUMENT_TITLE = "Untitled Document";
+
+/**
+ * Create a new document owned by `conversationId` under a freshly minted
+ * surface ID. A missing or empty title falls back to `DEFAULT_DOCUMENT_TITLE`.
+ */
+export function createDocument(params: {
+  conversationId: string;
+  title?: string;
+  content?: string;
+}): ReturnType<typeof saveDocument> {
+  const content = params.content ?? "";
+  return saveDocument({
+    surfaceId: `doc-${randomUUID()}`,
+    conversationId: params.conversationId,
+    title: params.title || DEFAULT_DOCUMENT_TITLE,
+    content,
+    wordCount: countWords(content),
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Find-and-replace
 // ---------------------------------------------------------------------------

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -179,10 +179,20 @@ mock.module("../../credential-health/credential-health-service.js", () => ({
 let heartbeatRunIdCounter = 0;
 let lastRunAtFromHistory: number | null = null;
 const skipHeartbeatRunCalls: Array<{ runId: string; reason: string }> = [];
+const completeHeartbeatRunCalls: Array<{
+  runId: string;
+  result: { status: string; error?: string };
+}> = [];
 mock.module("../heartbeat-run-store.js", () => ({
   insertPendingHeartbeatRun: () => `heartbeat-run-${++heartbeatRunIdCounter}`,
   startHeartbeatRun: () => true,
-  completeHeartbeatRun: () => true,
+  completeHeartbeatRun: (
+    runId: string,
+    result: { status: string; error?: string },
+  ) => {
+    completeHeartbeatRunCalls.push({ runId, result });
+    return true;
+  },
   skipHeartbeatRun: (runId: string, reason: string) => {
     skipHeartbeatRunCalls.push({ runId, reason });
   },
@@ -226,6 +236,7 @@ beforeEach(() => {
   onBroadcast = null;
   runBackgroundJobCalls.length = 0;
   skipHeartbeatRunCalls.length = 0;
+  completeHeartbeatRunCalls.length = 0;
   lastRunAtFromHistory = null;
   preFirstMessageGateOpen = true;
   seedHeartbeat();
@@ -340,14 +351,9 @@ describe("HeartbeatService", () => {
     await service.runOnce({ force: true });
 
     expect(runnerCompleted).toBe(true);
-    // No heartbeat_alert broadcast because the runner returned ok=true and
-    // there was no outer-timeout failure to surface.
-    expect(
-      broadcastedMessages.filter((m) => m.type === "heartbeat_alert"),
-    ).toHaveLength(0);
   });
 
-  test("calls alerter with the failure message when the runner reports ok=false", async () => {
+  test("records the failure on the run when the runner reports ok=false", async () => {
     runBackgroundJobImpl = async () => ({
       conversationId: STUB_CONVERSATION_ID,
       ok: false,
@@ -359,25 +365,15 @@ describe("HeartbeatService", () => {
 
     await service.runOnce({ force: true });
 
-    const alerts = broadcastedMessages.filter(
-      (m) => m.type === "heartbeat_alert",
-    );
-    expect(alerts).toHaveLength(1);
-    expect(alerts[0]).toMatchObject({
-      type: "heartbeat_alert",
-      title: "Heartbeat Failed",
-      body: "LLM call failed",
-    });
-  });
-
-  test("does not call alerter when the runner reports ok=true", async () => {
-    const service = new HeartbeatService();
-
-    await service.runOnce({ force: true });
-
-    expect(
-      broadcastedMessages.filter((m) => m.type === "heartbeat_alert"),
-    ).toHaveLength(0);
+    expect(completeHeartbeatRunCalls).toEqual([
+      {
+        runId: expect.any(String),
+        result: expect.objectContaining({
+          status: "error",
+          error: "LLM call failed",
+        }),
+      },
+    ]);
   });
 
   test("scheduled run skips with reason 'pre_first_user_message' when the user has not yet interacted", async () => {

package/src/heartbeat/heartbeat-service.ts

@@ -3,7 +3,6 @@ import { join } from "node:path";
 
 import { channelForBotProvider } from "@vellumai/service-contracts/channels";
 
-import type { HeartbeatAlertEvent } from "../api/events/heartbeat-alert.js";
 import { getConfig } from "../config/loader.js";
 import type { HeartbeatConfig } from "../config/schemas/heartbeat.js";
 import { warmGuardianBindings } from "../contacts/guardian-delivery-reader.js";
@@ -737,17 +736,6 @@ export class HeartbeatService {
       }
     } catch (err) {
       log.error({ err }, "Credential health check failed");
-      try {
-        broadcastMessage({
-          type: "heartbeat_alert",
-          title: "Credential Health Check Failed",
-          body:
-            "Could not verify OAuth credential health. " +
-            (err instanceof Error ? err.message : String(err)),
-        } satisfies HeartbeatAlertEvent);
-      } catch {
-        // Last resort — alerter itself failed. Already logged above.
-      }
     }
     return [];
   }
@@ -912,32 +900,16 @@ export class HeartbeatService {
       "Heartbeat failed",
     );
 
-    // The runner has already emitted `activity.failed` for the failure;
-    // we still record the run-level error and broadcast the in-app
-    // heartbeat alert so the existing surfacing keeps working.
-    // Map the runner's error classification onto the run-store's status
-    // enum so the run history preserves the timeout / error distinction.
+    // The runner has already emitted `activity.failed` for the failure, so
+    // this only records the run-level error. Map the runner's error
+    // classification onto the run-store's status enum so the run history
+    // preserves the timeout / error distinction.
     const runStatus = result.errorKind === "timeout" ? "timeout" : "error";
-    const transitioned = completeHeartbeatRun(runId, {
+    completeHeartbeatRun(runId, {
       status: runStatus,
       conversationId: conversationId ?? result.conversationId,
       error: result.error?.message ?? "Unknown error",
     });
-
-    // Only fire the in-app alerter when our completion is the one that
-    // actually wrote — otherwise a parallel finalizer (e.g. a startup
-    // recovery sweep) already alerted for this run.
-    if (transitioned) {
-      try {
-        broadcastMessage({
-          type: "heartbeat_alert",
-          title: "Heartbeat Failed",
-          body: result.error?.message ?? "Unknown error",
-        } satisfies HeartbeatAlertEvent);
-      } catch (alertErr) {
-        log.error({ alertErr }, "Failed to broadcast heartbeat alert");
-      }
-    }
   }
 
   private readChecklist(): string {

package/src/ipc/__tests__/browser-ipc.test.ts

@@ -16,7 +16,11 @@ import {
   test,
 } from "bun:test";
 
-import { desktopDependencyInstaller } from "../../desktop/desktop-dependencies.js";
+import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
+import { isSessionGroupsEnabled } from "../../config/session-groups-gate.js";
+import type { BrowserOperationToken } from "../../daemon/browser-mode-session.js";
+import { BrowserModeSessionProducer } from "../../daemon/browser-mode-session.js";
+import { desktopDependencies } from "../../desktop/desktop-dependencies.js";
 import * as desktopFeature from "../../desktop/virtual-desktop-feature.js";
 import { browserManager } from "../../tools/browser/browser-manager.js";
 import type { ToolExecutionResult } from "../../tools/types.js";
@@ -46,11 +50,69 @@ let mockConversation: {
   clientOs?: string;
   getTurnActorPrincipalId?: () => string | undefined;
   abortController?: AbortController;
+  currentRequestId?: string;
+  browserModeSessions?: {
+    beginOperation: (input: {
+      turnId: string;
+      lifecycle: "action" | "terminal" | "status";
+      at: number;
+    }) => BrowserOperationToken | undefined;
+    finishOperation: (
+      token: BrowserOperationToken | undefined,
+      outcome: {
+        at: number;
+        isError: boolean;
+        cancelled: boolean;
+        terminalReason?: "browser_closed" | "browser_detached";
+      },
+    ) => boolean;
+  };
 } | null = null;
 
+const lifecycleBegins: Array<{
+  turnId: string;
+  lifecycle: "action" | "terminal" | "status";
+  at: number;
+}> = [];
+const lifecycleFinishes: Array<{
+  token: BrowserOperationToken | undefined;
+  outcome: {
+    at: number;
+    isError: boolean;
+    cancelled: boolean;
+    terminalReason?: "browser_closed" | "browser_detached";
+  };
+}> = [];
+
+function browserLifecycle() {
+  return {
+    beginOperation(input: (typeof lifecycleBegins)[number]) {
+      lifecycleBegins.push(input);
+      return {
+        turnId: input.turnId,
+        lifecycle: input.lifecycle === "status" ? "action" : input.lifecycle,
+        owner: { id: "browser-session", mode: "browser" as const },
+      } as BrowserOperationToken;
+    },
+    finishOperation(
+      token: BrowserOperationToken | undefined,
+      outcome: (typeof lifecycleFinishes)[number]["outcome"],
+    ) {
+      lifecycleFinishes.push({ token, outcome });
+      return true;
+    },
+  };
+}
+
 let mockFindConversationCalls: string[] = [];
 
 mock.module("../../browser/operations.js", () => ({
+  browserOperationLifecycle: (operation: string) =>
+    operation === "status"
+      ? "status"
+      : operation === "close" || operation === "detach"
+        ? "terminal"
+        : "action",
   executeBrowserOperation: async (
     operation: string,
     input: Record<string, unknown>,
@@ -78,6 +140,7 @@ mock.module("../../daemon/conversation-registry.js", () => ({
     mockFindConversationCalls.push(conversationId);
     return mockConversation ?? undefined;
   },
+  findConversationOrSubagent: () => mockConversation ?? undefined,
 }));
 
 let desktopEnabled = false;
@@ -87,10 +150,9 @@ const enabledSpy = spyOn(
   desktopFeature,
   "isVirtualDesktopEnabled",
 ).mockImplementation(() => desktopEnabled);
-const readySpy = spyOn(
-  desktopDependencyInstaller,
-  "getStatus",
-).mockImplementation(() => ({ state: desktopReady ? "ready" : "required" }));
+const readySpy = spyOn(desktopDependencies, "getStatus").mockImplementation(
+  () => ({ state: desktopReady ? "ready" : "failed" }),
+);
 afterAll(() => {
   enabledSpy.mockRestore();
   readySpy.mockRestore();
@@ -147,6 +209,7 @@ function callHandler(
 // ---------------------------------------------------------------------------
 
 afterEach(() => {
+  setOverridesForTesting({});
   desktopEnabled = false;
   desktopReady = false;
   desktopFailure = false;
@@ -156,6 +219,8 @@ afterEach(() => {
   mockOperationCalls = [];
   mockConversation = null;
   mockFindConversationCalls = [];
+  lifecycleBegins.length = 0;
+  lifecycleFinishes.length = 0;
 });
 
 // ---------------------------------------------------------------------------
@@ -471,6 +536,150 @@ describe("browser_execute route", () => {
     });
   });
 
+  test("brackets a typed live-turn action with browser lifecycle", async () => {
+    mockConversation = {
+      currentRequestId: "turn-123",
+      browserModeSessions: browserLifecycle(),
+      getTurnActorPrincipalId: () => undefined,
+    };
+
+    await callHandler({
+      operation: "navigate",
+      input: { url: "https://example.com" },
+      conversationId: "conv-live",
+    });
+
+    expect(lifecycleBegins).toEqual([
+      expect.objectContaining({ turnId: "turn-123", lifecycle: "action" }),
+    ]);
+    expect(lifecycleFinishes).toEqual([
+      expect.objectContaining({
+        token: expect.objectContaining({ turnId: "turn-123" }),
+        outcome: expect.objectContaining({
+          isError: false,
+          cancelled: false,
+        }),
+      }),
+    ]);
+  });
+
+  test("executes a live-turn action without tracking while session groups are disabled", async () => {
+    setOverridesForTesting({ "session-groups": false });
+    const activateSource = mock(() => {
+      throw new Error("disabled tracking must not activate a source");
+    });
+    mockConversation = {
+      currentRequestId: "turn-123",
+      browserModeSessions: new BrowserModeSessionProducer(
+        {
+          activateSource,
+          claimTurn: mock(() => undefined),
+          getTurnOwner: mock(() => undefined),
+          recordActivity: mock(() => false),
+          retireSource: mock(() => false),
+        },
+        1,
+        isSessionGroupsEnabled,
+      ),
+      getTurnActorPrincipalId: () => undefined,
+    };
+
+    const result = await callHandler({
+      operation: "navigate",
+      input: { url: "https://example.com" },
+      conversationId: "conv-live",
+    });
+
+    expect(result).toEqual({ content: "ok", isError: false });
+    expect(mockOperationCalls).toHaveLength(1);
+    expect(activateSource).not.toHaveBeenCalled();
+  });
+
+  test.each(["navigate", "close"] as const)(
+    "executes %s once after tracking admission throws",
+    async (operation) => {
+      mockConversation = {
+        currentRequestId: "turn-123",
+        browserModeSessions: {
+          ...browserLifecycle(),
+          beginOperation() {
+            throw new Error("tracking unavailable");
+          },
+        },
+        getTurnActorPrincipalId: () => undefined,
+      };
+      const result = await callHandler({
+        operation,
+        conversationId: "conv-live",
+      });
+      expect(result).toEqual({ content: "ok", isError: false });
+      expect(mockOperationCalls).toHaveLength(1);
+    },
+  );
+
+  test("passes typed terminal success and failure outcomes", async () => {
+    mockConversation = {
+      currentRequestId: "turn-123",
+      browserModeSessions: browserLifecycle(),
+      getTurnActorPrincipalId: () => undefined,
+    };
+
+    await callHandler({ operation: "detach", conversationId: "conv-live" });
+    expect(lifecycleBegins[0]).toMatchObject({ lifecycle: "terminal" });
+    expect(lifecycleFinishes[0]?.outcome).toMatchObject({
+      isError: false,
+      terminalReason: "browser_detached",
+    });
+
+    mockOperationResult = { content: "close failed", isError: true };
+    await callHandler({ operation: "close", conversationId: "conv-live" });
+    expect(lifecycleFinishes[1]?.outcome).toMatchObject({
+      isError: true,
+      terminalReason: "browser_closed",
+    });
+  });
+
+  test.each(["navigate", "close"] as const)(
+    "preserves a successful %s result when session tracking fails",
+    async (operation) => {
+      mockOperationResult = {
+        content: `${operation} completed`,
+        isError: false,
+      };
+      const lifecycle = browserLifecycle();
+      mockConversation = {
+        currentRequestId: "turn-123",
+        browserModeSessions: {
+          ...lifecycle,
+          finishOperation(token, outcome) {
+            lifecycle.finishOperation(token, outcome);
+            throw new Error("session tracking unavailable");
+          },
+        },
+        getTurnActorPrincipalId: () => undefined,
+      };
+
+      const result = await callHandler({
+        operation,
+        input: operation === "navigate" ? { url: "https://example.com" } : {},
+        conversationId: "conv-live",
+      });
+
+      expect(result).toEqual({
+        content: `${operation} completed`,
+        isError: false,
+      });
+      expect(mockOperationCalls).toHaveLength(1);
+      expect(lifecycleFinishes).toHaveLength(1);
+    },
+  );
+
+  test("does not observe lifecycle for a standalone CLI operation", async () => {
+    await callHandler({ operation: "navigate", sessionId: "standalone" });
+    expect(lifecycleBegins).toEqual([]);
+    expect(lifecycleFinishes).toEqual([]);
+  });
+
   // ── Input defaults ─────────────────────────────────────────────────
 
   test("defaults input to empty object when omitted", async () => {
@@ -639,7 +848,7 @@ test("a streamed browser failure does not switch to Playwright or personal Chrom
   expect(mockOperationCalls).toHaveLength(0);
 });
 
-test("first web browser use routes to virtual desktop setup before installation", async () => {
+test("missing image components do not redirect web browser use to a personal browser", async () => {
   webConversation();
   desktopReady = false;
   await callHandler({

package/src/ipc/assistant-server.ts

@@ -59,6 +59,7 @@ import { RouteResponse } from "../runtime/routes/types.js";
 import { getLogger } from "../util/logger.js";
 import { mapGatewayIpcConnectError } from "./gateway-ipc-errors.js";
 import { ACTIVATION_SYNC_IPC_METHODS } from "./routes/activation-sync-ipc-routes.js";
+import { CHANNEL_REPLY_IPC_METHODS } from "./routes/channel-reply-ipc-routes.js";
 import { CONTACTS_INFO_IPC_METHODS } from "./routes/contacts-info-ipc-routes.js";
 import { CONTACTS_MIRROR_IPC_METHODS } from "./routes/contacts-mirror-ipc-routes.js";
 import { CONVERSATION_SYNC_IPC_METHODS } from "./routes/conversation-sync-ipc-routes.js";
@@ -216,6 +217,7 @@ export class AssistantIpcServer {
     // never in ROUTES.
     for (const methodMap of [
       INVITE_IPC_METHODS,
+      CHANNEL_REPLY_IPC_METHODS,
       CONTACTS_INFO_IPC_METHODS,
       CONTACTS_MIRROR_IPC_METHODS,
       GUARDIAN_LABEL_IPC_METHODS,