@vellumai/assistant 0.12.2-staging.2 → 0.12.2-staging.4

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

@@ -2146,6 +2146,68 @@ describe("front-door leg tool suppression", () => {
   });
 });
 
+describe("desktop skill preactivation", () => {
+  async function preactivatedFor(turn: Record<string, unknown>): Promise<{
+    skillIds: string[];
+    proxyInterfaces: unknown[];
+    skillIdsDuringLoop: string[];
+  }> {
+    const skillIds: string[] = [];
+    const proxyInterfaces: unknown[] = [];
+    let skillIdsDuringLoop: string[] = [];
+    const fake = makeFakeConversation({
+      processing: false,
+      runAgentLoop: async () => {
+        skillIdsDuringLoop = [...skillIds];
+      },
+    });
+    Object.assign(fake.conversation, {
+      addPreactivatedSkillId: (id: string) => {
+        skillIds.push(id);
+      },
+      ensureHostProxiesForTurn: (sourceInterface: unknown) => {
+        proxyInterfaces.push(sourceInterface);
+      },
+    });
+    fakeConversation = fake.conversation;
+
+    await startVoiceTurn({
+      ...makeTurnOptions(undefined, "conv-desktop-skills"),
+      userMessageInterface: "macos",
+      ...turn,
+    });
+    await flushMicrotasks();
+    return { skillIds, proxyInterfaces, skillIdsDuringLoop };
+  }
+
+  test("an escalated leg of a macOS desktop session starts with computer use active", async () => {
+    const result = await preactivatedFor({
+      routingLeg: "escalated",
+      macosDesktopSession: true,
+    });
+
+    expect(result.skillIdsDuringLoop).toContain("computer-use");
+    expect(result.proxyInterfaces).toEqual(["macos"]);
+  });
+
+  test("a session from any other client leaves the desktop skills to be loaded", async () => {
+    const result = await preactivatedFor({ routingLeg: "escalated" });
+
+    expect(result.skillIds).toEqual([]);
+    expect(result.proxyInterfaces).toEqual([]);
+  });
+
+  test("the toolless front-door leg is never preactivated", async () => {
+    const result = await preactivatedFor({
+      routingLeg: "front-door",
+      macosDesktopSession: true,
+    });
+
+    expect(result.skillIds).toEqual([]);
+    expect(result.proxyInterfaces).toEqual([]);
+  });
+});
+
 describe("cutFrontDoorContentAtVerdict", () => {
   test("null when the content carries no verdict token (committed answer)", () => {
     expect(

package/src/calls/progress-narration.ts

@@ -16,7 +16,7 @@ import type {
   ProviderResponse,
   ToolDefinition,
 } from "../providers/types.js";
-import { createAbortReason } from "../util/abort-reasons.js";
+import { createAbortReason, isAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("voice-progress-narration");
@@ -164,7 +164,10 @@ async function requestBoundedResponse(args: {
   const timeoutTimer = setTimeout(
     () =>
       timeoutController.abort(
-        createAbortReason("voice_session_aborted", "voice-progress-narration"),
+        createAbortReason(
+          "voice_progress_narration_timeout",
+          "voice-progress-narration",
+        ),
       ),
     args.timeoutMs,
   );
@@ -260,9 +263,19 @@ export function createVoiceProgressNarrator(options: {
         }
         return trimmed;
       } catch (error) {
+        // Why the beat went unspoken, as one greppable field. A narrator whose
+        // budget is below the model's real roundtrip drops every update at the
+        // deadline and reads in the logs as a run of unrelated failures; naming
+        // the outcome is what makes that run legible as "the feature is off".
+        const outcome = isAbortReason(error)
+          ? error.kind === "voice_progress_narration_timeout"
+            ? "timed_out"
+            : "session_ended"
+          : "error";
         log.info(
           {
             error,
+            outcome,
             providerResolveMs,
             totalMs: Math.round(performance.now() - startedAt),
             timeoutMs: options.config.generationTimeoutMs,

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

@@ -60,6 +60,18 @@ export const FEWER_UPDATES_MARKER = "[UPDATES:FEWER]";
 export const NORMAL_UPDATES_MARKER = "[UPDATES:NORMAL]";
 const UPDATES_MARKER_PREFIX = "[UPDATES:";
 
+/**
+ * Look session controls for live voice: turn on a screen share
+ * ({@link LOOK_SCREEN_MARKER}) or the camera ({@link LOOK_CAMERA_MARKER}) so
+ * the call can see what the user means by "take a look". Carried out by the
+ * client, like mute and end.
+ */
+export const LOOK_SCREEN_MARKER = "[LOOK:SCREEN]";
+export const LOOK_CAMERA_MARKER = "[LOOK:CAMERA]";
+/** Stop showing the call the screen and the camera, whichever is on. */
+export const LOOK_STOP_MARKER = "[LOOK:STOP]";
+const LOOK_MARKER_PREFIX = "[LOOK:";
+
 // ---------------------------------------------------------------------------
 // Regexes
 // ---------------------------------------------------------------------------
@@ -82,6 +94,7 @@ const ESCALATE_VERDICT_TOKEN_REGEX = /\[1\]/g;
 const MINIMIZE_ROOM_MARKER_REGEX = /\[-1\]/g;
 const MUTE_MARKER_REGEX = /\[MUTE(?::\s*[^\]]*)?\]/g;
 const UPDATES_MARKER_REGEX = /\[UPDATES:\s*[^\]]*\]/g;
+const LOOK_MARKER_REGEX = /\[LOOK:\s*[^\]]*\]/g;
 const GUARDIAN_TIMEOUT_MARKER_REGEX = /\[GUARDIAN_TIMEOUT\]/g;
 const GUARDIAN_UNAVAILABLE_MARKER_REGEX = /\[GUARDIAN_UNAVAILABLE\]/g;
 
@@ -209,6 +222,7 @@ export function stripInternalSpeechMarkers(text: string): string {
     .replace(MINIMIZE_ROOM_MARKER_REGEX, "")
     .replace(MUTE_MARKER_REGEX, "")
     .replace(UPDATES_MARKER_REGEX, "")
+    .replace(LOOK_MARKER_REGEX, "")
     .replace(GUARDIAN_TIMEOUT_MARKER_REGEX, "")
     .replace(GUARDIAN_UNAVAILABLE_MARKER_REGEX, "");
   return result;
@@ -237,6 +251,7 @@ const CONTROL_MARKER_STRINGS = [
   MUTE_MARKER,
   MUTE_MARKER_PREFIX,
   UPDATES_MARKER_PREFIX,
+  LOOK_MARKER_PREFIX,
   "[GUARDIAN_TIMEOUT]",
   "[GUARDIAN_UNAVAILABLE]",
 ];
@@ -252,6 +267,7 @@ const FIRST_BRACKET_TERMINATED_PREFIXES = [
   "[USER_INSTRUCTION:",
   MUTE_MARKER_PREFIX,
   UPDATES_MARKER_PREFIX,
+  LOOK_MARKER_PREFIX,
 ];
 
 const GUARDIAN_APPROVAL_PREFIX = "[ASK_GUARDIAN_APPROVAL:";
@@ -339,15 +355,19 @@ export function createControlMarkerHoldback(
 /**
  * A session control a live-voice reply asked for with a terminal marker:
  * `end` from {@link END_CALL_MARKER}, `mute` from {@link MUTE_MARKER} or its
- * timed form, `updates` from the progress-cadence markers.
+ * timed form, `updates` from the progress-cadence markers, `look_screen` and
+ * `look_camera` and `look_stop` from the look markers.
  */
 export type SessionControlRequest =
   | { readonly action: "end" }
   | { readonly action: "mute"; readonly durationMs?: number }
-  | { readonly action: "updates"; readonly cadence: "fewer" | "normal" };
+  | { readonly action: "updates"; readonly cadence: "fewer" | "normal" }
+  | { readonly action: "look_screen" }
+  | { readonly action: "look_camera" }
+  | { readonly action: "look_stop" };
 
 const TERMINAL_SESSION_CONTROL_REGEX =
-  /(\[END_CALL\]|\[UPDATES:(FEWER|NORMAL)\]|\[MUTE\]|\[MUTE:\s*([^\]]*)\])\s*$/;
+  /(\[END_CALL\]|\[UPDATES:(FEWER|NORMAL)\]|\[LOOK:(SCREEN|CAMERA|STOP)\]|\[MUTE\]|\[MUTE:\s*([^\]]*)\])\s*$/;
 
 /**
  * The session control a reply ends with, or null.
@@ -378,7 +398,17 @@ export function parseTerminalSessionControl(
       cadence: match[2] === "FEWER" ? "fewer" : "normal",
     };
   }
-  const seconds = match[3] === undefined ? NaN : Number(match[3].trim());
+  if (match[3] !== undefined) {
+    return {
+      action:
+        match[3] === "SCREEN"
+          ? "look_screen"
+          : match[3] === "CAMERA"
+            ? "look_camera"
+            : "look_stop",
+    };
+  }
+  const seconds = match[4] === undefined ? NaN : Number(match[4].trim());
   if (
     Number.isFinite(seconds) &&
     seconds > 0 &&

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

@@ -31,6 +31,7 @@ import {
 import { CONVERSATION_BUSY_MESSAGE } from "../daemon/conversation-messaging.js";
 import { resolveChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
 import { getOrCreateConversation } from "../daemon/conversation-store.js";
+import { preactivateHostProxySkills } from "../daemon/host-proxy-preactivation.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import {
   newestPersistedSightFrame,
@@ -464,6 +465,14 @@ export interface VoiceTurnOptions {
    * path has always used.
    */
   actorFallbackSuppressed?: boolean;
+  /**
+   * Whether the session was opened from the macOS desktop client. A leg that
+   * can run tools then starts with the desktop skills (computer use, app
+   * control, screen annotation) already active, as a typed turn from that
+   * client does. The turn interface cannot answer this: every live-voice
+   * session reports `macos` for its channel capabilities, iOS included.
+   */
+  macosDesktopSession?: boolean;
   /** Whether this is an inbound call (no outbound task). */
   isInbound: boolean;
   /** The outbound call task, if any. */
@@ -2016,6 +2025,20 @@ export async function startVoiceTurn(
         (needsImagePin
           ? VOICE_IMAGE_PROFILE
           : (conversationProfile?.profile ?? null));
+      if (opts.macosDesktopSession === true && !frontDoorToolsSuppressed) {
+        const sourceInterface = turnInterfaceContext.userMessageInterface;
+        const sourceActorPrincipalId =
+          voiceTurnValues.actorPrincipalId ?? undefined;
+        conversation.ensureHostProxiesForTurn(
+          sourceInterface,
+          sourceActorPrincipalId,
+        );
+        preactivateHostProxySkills(
+          conversation,
+          sourceInterface,
+          sourceActorPrincipalId,
+        );
+      }
       await conversation.runAgentLoop(persistedContent, messageId, {
         onEvent: (msg: AssistantEvent) => {
           if (msg.type === "assistant_turn_start") {

package/src/cli/commands/__tests__/browser.test.ts

@@ -67,9 +67,8 @@ mock.module("../../../util/logger.js", () => ({
 // Import module under test (after mocks)
 // ---------------------------------------------------------------------------
 
-const { formatBrowserStatusLines, registerBrowserCommand } = await import(
-  "../browser.js"
-);
+const { formatBrowserStatusLines, registerBrowserCommand } =
+  await import("../browser.js");
 
 // ---------------------------------------------------------------------------
 // Test helper
@@ -641,3 +640,85 @@ describe("error exit codes", () => {
     expect(exitCode).toBe(0);
   });
 });
+
+for (const desktopFlag of ["--virtual-desktop", "--desktop"]) {
+  describe(`virtual desktop routing via ${desktopFlag}`, () => {
+    test("routes semantic actions through IPC with conversation and element identity", async () => {
+      process.env.__CONVERSATION_ID = "conv-desktop";
+      const result = await runCommand([
+        "browser",
+        desktopFlag,
+        "--json",
+        "click",
+        "--element-id",
+        "e7",
+      ]);
+      expect(result.exitCode).toBe(0);
+      expect(lastIpcCall?.method).toBe("browser_execute");
+      expect(lastBody()).toMatchObject({
+        desktop: true,
+        conversationId: "conv-desktop",
+        operation: "click",
+        input: { element_id: "e7" },
+      });
+      expect(
+        (lastBody().input as Record<string, unknown>).desktop,
+      ).toBeUndefined();
+    });
+
+    test.each([
+      { args: ["list"] },
+      { args: ["select", "--tab-id", "7"] },
+      { args: ["new"] },
+      { args: ["close", "--tab-id", "7"] },
+    ])("routes desktop tabs $args through IPC", async ({ args }) => {
+      mockIpcResult = { ok: true, result: { ok: true, tabs: [] } };
+      const result = await runCommand([
+        "browser",
+        desktopFlag,
+        "--json",
+        "tabs",
+        ...args,
+      ]);
+      expect(result.exitCode).toBe(0);
+      expect(lastIpcCall?.method).toBe("browser_tabs");
+      expect(lastBody()).toMatchObject({ desktop: true, command: args[0] });
+    });
+
+    test.each([
+      { flags: ["--browser-mode", "extension"] },
+      { flags: ["--target-client-id", "client-123"] },
+    ])("rejects conflicting desktop targets before IPC", async ({ flags }) => {
+      const result = await runCommand([
+        "browser",
+        desktopFlag,
+        ...flags,
+        "tabs",
+        "list",
+      ]);
+      expect(result.exitCode).not.toBe(0);
+      expect(lastIpcCall).toBeNull();
+    });
+  });
+}
+
+test.each([
+  { args: ["list"] },
+  { args: ["select", "--tab-id", "1"] },
+  { args: ["new", "--url", "https://example.com"] },
+  { args: ["close", "--tab-id", "1"] },
+])(
+  "tab command $args forwards an explicit backend override",
+  async ({ args }) => {
+    mockIpcResult = { ok: true, result: { ok: true, tabs: [] } };
+    await runCommand([
+      "browser",
+      "--browser-mode",
+      "extension",
+      "tabs",
+      ...args,
+    ]);
+    expect(lastIpcCall?.method).toBe("browser_tabs");
+    expect(lastBody().browserMode).toBe("extension");
+  },
+);

package/src/cli/commands/browser.help.ts

@@ -96,6 +96,15 @@ export const browserHelp: CliCommandHelp = {
   name: "browser",
   description: "Control the browser via the running assistant.",
   options: [
+    {
+      flags: "--desktop",
+      description: "Compatibility alias for --virtual-desktop.",
+    },
+    {
+      flags: "--virtual-desktop",
+      description:
+        "Use Chrome in the platform-hosted virtual desktop with visible cursor feedback.",
+    },
     {
       flags: "--session <id>",
       description: "Session ID to preserve browser state across invocations.",
@@ -118,6 +127,38 @@ export const browserHelp: CliCommandHelp = {
   ],
   helpText: `
 Browser operations are executed through the running assistant.
+Virtual desktop is available only for platform-hosted assistants.
+In the web client, automatic selection prefers virtual desktop Chrome when
+its feature is enabled and the conversation has an
+identified guardian. The macOS and Windows apps keep their existing browser
+selection and fallback behavior; use --virtual-desktop to select it there.
+Existing sessions and explicit backend/client choices take priority.
+--browser-mode local (alias playwright) means the assistant's Playwright browser,
+not the user's Chrome. --desktop remains an alias for --virtual-desktop.
+Use --virtual-desktop for Chrome in the Desktop panel.
+Run navigate --url <url> directly to open a page.
+The assistant-desktop feature flag and completed installation are required.
+The first browser command installs missing components, starts Chrome, and completes
+the requested action in one call. Allow up to 600 seconds for this command when
+using bash (timeout_seconds: 600). Opening the Desktop panel also starts
+the same installation and shows progress. No separate setup command is needed.
+Report other availability errors without switching to a personal computer.
+The assistant manages Chrome startup. Do not launch a separate desktop stack,
+install desktop packages, or drive webpages with shell-level xdotool.
+With --virtual-desktop, screenshot captures the page directly from Chrome over CDP
+as a color JPEG. Use --output to save it and file_read to view it. Do not use
+shell-level xwd or custom screenshot conversion scripts.
+Use snapshot for current element IDs and tabs list for current tab IDs.
+Refresh the snapshot after navigation, tab changes or stale-element errors.
+Inspect the result before retrying a failed action; it may have happened.
+A purple page pointer shows CDP mouse movement in the stream. Browser toolbar
+controls, native dialogs and other apps are outside this CLI's page controls.
+Do not combine --virtual-desktop with personal browser targets, other browser modes
+or --use-active-tab. Download waiting is unavailable on this target.
+Users can interact directly with the expanded desktop. If they ask you to pause,
+stop and wait. Take a fresh snapshot before resuming. Closing the viewer does not
+end automation. Run assistant browser --virtual-desktop detach when finished or
+blocked, including before asking a question. Chrome stays running.
 Each subcommand maps to a browser operation and communicates
 with the assistant process.
 
@@ -131,6 +172,8 @@ local. Useful for debugging or when deterministic backend selection
 is required.
 
 Examples:
+  $ assistant browser --virtual-desktop status
+  $ assistant browser --virtual-desktop screenshot --output /tmp/desktop-page.jpg
   $ assistant browser navigate --url https://example.com
   $ assistant browser snapshot
   $ assistant browser click --selector "#login"

package/src/cli/commands/browser.ts

@@ -28,6 +28,8 @@ import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
 import { browserHelp, toKebab } from "./browser.help.js";
 
+const BROWSER_REQUEST_TIMEOUT_MS = 10 * 60_000;
+
 // ── Naming helpers ───────────────────────────────────────────────────
 
 /**
@@ -116,6 +118,7 @@ function attachOperationAction(
 
   subcmd.action(async (opts: Record<string, unknown>) => {
     const parentOpts = browser.opts() as {
+      desktop?: boolean;
       session?: string;
       json?: boolean;
       browserMode?: string;
@@ -130,6 +133,8 @@ function attachOperationAction(
     // targetClientId) and screenshot ergonomics (output).
     const input: Record<string, unknown> = {};
     const excludeKeys = new Set([
+      "desktop",
+      "virtualDesktop",
       "session",
       "json",
       "output",
@@ -163,9 +168,7 @@ function attachOperationAction(
       }
     }
 
-    // Browser operations can be long-running (page loads, auth
-    // challenges, downloads up to 120s, etc.), so use a generous
-    // IPC timeout that exceeds any server-side operation timeout.
+    // First use can include virtual desktop installation and Chrome startup.
     const ipcResult = await cliIpcCall<BrowserExecuteResult>(
       "browser_execute",
       {
@@ -173,10 +176,11 @@ function attachOperationAction(
           operation: meta.operation,
           input,
           sessionId,
+          ...(parentOpts.desktop ? { desktop: true } : {}),
           ...(conversationId ? { conversationId } : {}),
         },
       },
-      { timeoutMs: 180_000 },
+      { timeoutMs: BROWSER_REQUEST_TIMEOUT_MS, cancelOnDisconnect: true },
     );
 
     if (!ipcResult.ok) {
@@ -328,6 +332,22 @@ export function registerBrowserCommand(program: Command): void {
     description: browserHelp.description,
     build: (browser) => {
       applyCommandHelp(browser, browserHelp);
+      browser.hook("preAction", () => {
+        if (browser.opts().virtualDesktop) {
+          browser.setOptionValue("desktop", true);
+        }
+        const options = browser.opts();
+        if (
+          options.desktop &&
+          (options.targetClientId ||
+            (options.browserMode &&
+              !["auto", "cdp-inspect"].includes(options.browserMode)))
+        ) {
+          throw new Error(
+            "--virtual-desktop cannot be combined with a personal browser target or another browser mode",
+          );
+        }
+      });
 
       // Attach one action per browser operation
       for (const meta of BROWSER_OPERATION_META) {
@@ -339,6 +359,8 @@ export function registerBrowserCommand(program: Command): void {
 
       subcommand(tabs, "list").action(async (opts: { pretty?: boolean }) => {
         const parentOpts = browser.opts() as {
+          desktop?: boolean;
+          browserMode?: string;
           session?: string;
           json?: boolean;
           targetClientId?: string;
@@ -364,11 +386,15 @@ export function registerBrowserCommand(program: Command): void {
             body: {
               command: "list",
               sessionId,
+              ...(parentOpts.desktop ? { desktop: true } : {}),
+              ...(parentOpts.browserMode
+                ? { browserMode: parentOpts.browserMode }
+                : {}),
               ...(conversationId ? { conversationId } : {}),
               ...(targetClientId ? { targetClientId } : {}),
             },
           },
-          { timeoutMs: 30_000 },
+          { timeoutMs: BROWSER_REQUEST_TIMEOUT_MS, cancelOnDisconnect: true },
         );
 
         if (!ipcResult.ok) {
@@ -409,6 +435,8 @@ export function registerBrowserCommand(program: Command): void {
 
       subcommand(tabs, "select").action(async (opts: { tabId: string }) => {
         const parentOpts = browser.opts() as {
+          desktop?: boolean;
+          browserMode?: string;
           session?: string;
           json?: boolean;
           targetClientId?: string;
@@ -425,12 +453,16 @@ export function registerBrowserCommand(program: Command): void {
             body: {
               command: "select",
               sessionId,
+              ...(parentOpts.desktop ? { desktop: true } : {}),
+              ...(parentOpts.browserMode
+                ? { browserMode: parentOpts.browserMode }
+                : {}),
               tabId,
               ...(conversationId ? { conversationId } : {}),
               ...(targetClientId ? { targetClientId } : {}),
             },
           },
-          { timeoutMs: 30_000 },
+          { timeoutMs: BROWSER_REQUEST_TIMEOUT_MS, cancelOnDisconnect: true },
         );
 
         if (!ipcResult.ok) {
@@ -456,6 +488,8 @@ export function registerBrowserCommand(program: Command): void {
 
       subcommand(tabs, "new").action(async (opts: { url?: string }) => {
         const parentOpts = browser.opts() as {
+          desktop?: boolean;
+          browserMode?: string;
           session?: string;
           json?: boolean;
           targetClientId?: string;
@@ -475,12 +509,16 @@ export function registerBrowserCommand(program: Command): void {
             body: {
               command: "new",
               sessionId,
+              ...(parentOpts.desktop ? { desktop: true } : {}),
+              ...(parentOpts.browserMode
+                ? { browserMode: parentOpts.browserMode }
+                : {}),
               ...(opts.url ? { url: opts.url } : {}),
               ...(conversationId ? { conversationId } : {}),
               ...(targetClientId ? { targetClientId } : {}),
             },
           },
-          { timeoutMs: 30_000 },
+          { timeoutMs: BROWSER_REQUEST_TIMEOUT_MS, cancelOnDisconnect: true },
         );
 
         if (!ipcResult.ok) {
@@ -512,6 +550,8 @@ export function registerBrowserCommand(program: Command): void {
 
       subcommand(tabs, "close").action(async (opts: { tabId: string }) => {
         const parentOpts = browser.opts() as {
+          desktop?: boolean;
+          browserMode?: string;
           session?: string;
           json?: boolean;
           targetClientId?: string;
@@ -532,12 +572,16 @@ export function registerBrowserCommand(program: Command): void {
             body: {
               command: "close",
               sessionId,
+              ...(parentOpts.desktop ? { desktop: true } : {}),
+              ...(parentOpts.browserMode
+                ? { browserMode: parentOpts.browserMode }
+                : {}),
               tabId,
               ...(conversationId ? { conversationId } : {}),
               ...(targetClientId ? { targetClientId } : {}),
             },
           },
-          { timeoutMs: 30_000 },
+          { timeoutMs: BROWSER_REQUEST_TIMEOUT_MS, cancelOnDisconnect: true },
         );
 
         if (!ipcResult.ok) {

package/src/cli/commands/plugins.ts

@@ -53,6 +53,7 @@ import {
   PluginAlreadyInStateException,
   PluginDirectoryNotFoundError,
 } from "../lib/toggle-plugin.js";
+import type { PluginUninstallWarningKey } from "../lib/uninstall-plugin.js";
 import type { PluginUpgradeResult } from "../lib/upgrade-plugin.js";
 import { getCliLogger } from "../logger.js";
 import { PLUGINS_SEARCH_INSTALL_HINT, pluginsHelp } from "./plugins.help.js";
@@ -666,11 +667,16 @@ export function registerPluginsCommand(program: Command): void {
             // when the daemon is unreachable (a transport error carries no
             // `statusCode`); an operator can still uninstall while it's stopped,
             // and `shutdown` then runs in this process, the only one available.
-            const daemon = await cliIpcCall<{ name: string; target: string }>(
-              "plugins_uninstall",
-              { pathParams: { name } },
-            );
-            let result: { name: string; target: string };
+            const daemon = await cliIpcCall<{
+              name: string;
+              target: string;
+              warnings?: PluginUninstallWarningKey[];
+            }>("plugins_uninstall", { pathParams: { name } });
+            let result: {
+              name: string;
+              target: string;
+              warnings?: PluginUninstallWarningKey[];
+            };
             if (daemon.ok && daemon.result) {
               result = daemon.result;
             } else if (daemon.statusCode === undefined) {
@@ -693,6 +699,11 @@ export function registerPluginsCommand(program: Command): void {
             console.log(
               `Uninstalled plugin "${result.name}" from ${result.target}`,
             );
+            for (const warning of result.warnings ?? []) {
+              console.warn(
+                `Warning: ${libs.uninstall.resolvePluginUninstallWarning(warning)}`,
+              );
+            }
           } catch (err) {
             if (err instanceof libs.installGitHub.InvalidPluginNameError) {
               console.error(err.message);