@vellumai/assistant 0.8.3 → 0.8.5

package/src/tools/acp/spawn.test.ts

@@ -82,6 +82,25 @@ mock.module("../../util/logger.js", () => ({
     }),
 }));
 
+// Stub secure-keys so the `prepareAgentEnv` preflight finds a token without
+// the test having to populate the real OS keyring. Driven via `secureKeyStore`
+// per test in beforeEach; the default seeds a vault token so existing tests
+// (which assume claude spawns succeed) keep passing.
+//
+// The real module's other exports are spread in so transitive importers
+// (e.g. session-manager → pending-interactions → credential-routes, which
+// imports `getSecureKeyResultAsync`) still resolve at parse time. Bun's
+// `mock.module` is process-global and returns *exactly* the keys the factory
+// returns — without the spread, any consumer pulling a non-`getSecureKeyAsync`
+// export errors with "Export named '<X>' not found".
+const secureKeyStore = new Map<string, string>();
+const realSecureKeys = await import("../../security/secure-keys.js");
+
+mock.module("../../security/secure-keys.js", () => ({
+  ...realSecureKeys,
+  getSecureKeyAsync: async (key: string) => secureKeyStore.get(key),
+}));
+
 // Stub session manager so we don't actually spawn child processes.
 const spawnMock = mock(
   async (
@@ -131,6 +150,14 @@ beforeEach(() => {
   _resetAdapterVersionCacheForTests();
   config.setConfig({ agents: DEFAULT_TEST_AGENTS });
   which.setWhich((cmd) => `/usr/local/bin/${cmd}`);
+  // Default: vault has a claude token so the preflight in `prepareAgentEnv`
+  // succeeds for tests that don't care about env injection. Env-injection
+  // tests below clear/override this explicitly.
+  secureKeyStore.clear();
+  secureKeyStore.set(
+    "credential/acp/claude_oauth_token",
+    "default-test-token",
+  );
 });
 
 // ---------------------------------------------------------------------------
@@ -376,3 +403,95 @@ describe("executeAcpSpawn — per-agent resume hint", () => {
     expect(payload.message).not.toContain("To resume this session later");
   });
 });
+
+// ---------------------------------------------------------------------------
+// executeAcpSpawn — CLAUDE_CODE_OAUTH_TOKEN env injection + preflight
+//
+// Mirrors the HTTP-route test block in
+// `runtime/routes/acp-routes.test.ts` — the skill tool calls into the same
+// `prepareAgentEnv` helper, and the contract must be identical so a
+// missing token fails the spawn at the tool boundary (`isError: true`)
+// instead of letting a token-less subprocess zombie out. PR-history
+// context: the inline env-injection used to live in the route only; this
+// tool path was bypassing it entirely, causing every skill-driven ACP
+// spawn to die on first prompt with "Authentication required". Pin both
+// the happy paths and the throw path here so future drift on either
+// caller fails the suite loudly.
+// ---------------------------------------------------------------------------
+
+describe("executeAcpSpawn — CLAUDE_CODE_OAUTH_TOKEN injection", () => {
+  test("injects CLAUDE_CODE_OAUTH_TOKEN from the secure store for the claude agent", async () => {
+    secureKeyStore.clear();
+    secureKeyStore.set(
+      "credential/acp/claude_oauth_token",
+      "tool-vault-token-abc",
+    );
+    execScripts.set("npm ls", { error: new Error("npm not installed") });
+    execScripts.set("npm view", { error: new Error("npm not installed") });
+
+    const result = await executeAcpSpawn(
+      { agent: "claude", task: "do something" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(spawnMock).toHaveBeenCalledTimes(1);
+    const agentConfigArg = spawnMock.mock.calls[0][1] as {
+      env?: Record<string, string>;
+    };
+    expect(agentConfigArg.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe(
+      "tool-vault-token-abc",
+    );
+  });
+
+  test("accepts CLAUDE_CODE_OAUTH_TOKEN from config.json agent.env without a vault entry", async () => {
+    // Mirrors the route-level precedence test: a config.json env override
+    // is the first-priority provisioning route. The resolver surfaces it
+    // on `resolved.agent.env`, which the helper preserves.
+    secureKeyStore.clear();
+    config.setConfig({
+      agents: {
+        claude: {
+          command: "claude-agent-acp",
+          args: [],
+          env: { CLAUDE_CODE_OAUTH_TOKEN: "tool-config-token-xyz" },
+        },
+        codex: { command: "codex-acp", args: [] },
+        "unknown-agent": { command: "some-other-binary", args: [] },
+      },
+    });
+    execScripts.set("npm ls", { error: new Error("npm not installed") });
+    execScripts.set("npm view", { error: new Error("npm not installed") });
+
+    const result = await executeAcpSpawn(
+      { agent: "claude", task: "do something" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    const agentConfigArg = spawnMock.mock.calls[0][1] as {
+      env?: Record<string, string>;
+    };
+    expect(agentConfigArg.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe(
+      "tool-config-token-xyz",
+    );
+  });
+
+  test("returns isError when no token is available from either route (preflight throw mapped to tool result)", async () => {
+    // Both routes empty. The helper throws `FailedDependencyError`; the
+    // tool catches it and returns `{ isError: true, content: <msg> }`
+    // rather than letting it propagate (the tool boundary is a sync
+    // ToolExecutionResult, not an HTTP response).
+    secureKeyStore.clear();
+
+    const result = await executeAcpSpawn(
+      { agent: "claude", task: "do something" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("CLAUDE_CODE_OAUTH_TOKEN");
+    // Spawn was NEVER called — preflight fired before the subprocess started.
+    expect(spawnMock).not.toHaveBeenCalled();
+  });
+});

package/src/tools/acp/spawn.ts

@@ -1,6 +1,7 @@
 import { execFile } from "node:child_process";
 
 import { getAcpSessionManager } from "../../acp/index.js";
+import { prepareAgentEnv } from "../../acp/prepare-agent-env.js";
 import { resolveAcpAgent } from "../../acp/resolve-agent.js";
 import { DEFAULT_AGENT_NPM_PACKAGES } from "../../config/acp-defaults.js";
 import { getLogger } from "../../util/logger.js";
@@ -159,8 +160,6 @@ export async function executeAcpSpawn(
       }
     }
   }
-  const agentConfig = resolved.agent;
-
   const sendToClient = context.sendToClient as
     | ((msg: { type: string; [key: string]: unknown }) => void)
     | undefined;
@@ -171,6 +170,20 @@ export async function executeAcpSpawn(
     };
   }
 
+  // Inject required env vars and preflight via the shared helper. Mirrors
+  // the HTTP route at `runtime/routes/acp-routes.ts:spawnSession` — both
+  // call sites MUST go through `prepareAgentEnv` before `manager.spawn`,
+  // otherwise the spawned subprocess starts with no auth and dies as a
+  // zombie after the first prompt. See `acp/prepare-agent-env.ts` for
+  // the full rationale.
+  let agentConfig;
+  try {
+    agentConfig = await prepareAgentEnv(resolved.agent);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: msg, isError: true };
+  }
+
   // Best-effort version check — never blocks the spawn. If outdated, we
   // append a non-blocking warning to the success payload.
   const versionInfo = await checkAdapterVersion(agentConfig.command);

package/src/tools/apps/definitions.ts

@@ -9,7 +9,6 @@
  */
 
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import type { Tool, ToolExecutionResult } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -33,12 +32,9 @@ const appOpenTool: Tool = {
   category: "apps",
   defaultRiskLevel: RiskLevel.Low,
   executionMode: "proxy",
+  executionTarget: "host",
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema: {
         type: "object",
         properties: {
           app_id: {
@@ -54,8 +50,6 @@ const appOpenTool: Tool = {
         },
         required: ["app_id"],
       },
-    };
-  },
 
   execute: proxyExecute,
 };

package/src/tools/ask-question/ask-question-tool.test.ts

@@ -51,7 +51,7 @@ const singleQ = {
 
 describe("AskQuestionTool definition", () => {
   test("exposes the expected schema shape and description language", () => {
-    const def = new AskQuestionTool().getDefinition();
+    const def = new AskQuestionTool();
     expect(def.name).toBe("ask_question");
     expect(def.description).toContain("free-text fallback is always added");
     expect(def.description).toContain("do not");
@@ -463,8 +463,8 @@ describe("AskQuestionTool batched input", () => {
 
 describe("AskQuestionTool definition (batched schema)", () => {
   test("exposes `questions[]` shape, keeps legacy fields, omits per-question id", () => {
-    const def = new AskQuestionTool().getDefinition();
-    const schema = def.input_schema as {
+    const def = new AskQuestionTool();
+    const schema = def.input_schema as unknown as {
       properties: Record<
         string,
         {

package/src/tools/ask-question/ask-question-tool.ts

@@ -2,13 +2,12 @@ import { z } from "zod";
 
 import { QuestionPrompter } from "../../permissions/question-prompter.js";
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
 // ── Input schema ────────────────────────────────────────────────────
 // Runtime validation lives in Zod; the wire-level definition surfaced
-// to the LLM is the hand-written JSON Schema in getDefinition() below.
+// to the LLM is the hand-written JSON Schema in `input_schema` below.
 // (The codebase does not currently use zod-to-json-schema for tool defs,
 // so the two are kept in sync manually.)
 
@@ -109,53 +108,37 @@ const DESCRIPTION = [
   "context shown beneath the label.",
 ].join("\n");
 
+// Shared option-schema fragment used by both the batched `questions[]`
+// shape and the legacy flat `options` field.
+const OPTION_ITEMS_SCHEMA = {
+  type: "object",
+  properties: {
+    id: {
+      type: "string",
+      description:
+        "Stable identifier for this option (returned verbatim in the response).",
+    },
+    label: {
+      type: "string",
+      description: "Short human-readable label.",
+    },
+    description: {
+      type: "string",
+      description: "Optional one-line context shown beneath the label.",
+    },
+  },
+  required: ["id", "label"],
+} as const;
+
 // ── Tool ────────────────────────────────────────────────────────────
 
 export class AskQuestionTool implements Tool {
   name = "ask_question";
   description = DESCRIPTION;
   category = "interaction";
+  executionTarget = "sandbox" as const;
   defaultRiskLevel = RiskLevel.Low;
-
-  // Override hook for tests: lets a test replace the prompter factory
-  // without monkey-patching the module. Default factory wires the real
-  // broadcastMessage so the question reaches every connected client.
-  private prompterFactory: () => Pick<QuestionPrompter, "prompt">;
-
-  constructor(
-    prompterFactory: () => Pick<QuestionPrompter, "prompt"> = () =>
-      new QuestionPrompter({ broadcastMessage }),
-  ) {
-    this.prompterFactory = prompterFactory;
-  }
-
-  getDefinition(): ToolDefinition {
-    // Shared option-schema fragment used by both the batched `questions[]`
-    // shape and the legacy flat `options` field.
-    const optionItemsSchema = {
-      type: "object",
-      properties: {
-        id: {
-          type: "string",
-          description:
-            "Stable identifier for this option (returned verbatim in the response).",
-        },
-        label: {
-          type: "string",
-          description: "Short human-readable label.",
-        },
-        description: {
-          type: "string",
-          description: "Optional one-line context shown beneath the label.",
-        },
-      },
-      required: ["id", "label"],
-    } as const;
-
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema = {
         type: "object",
         properties: {
           // ── Recommended shape ─────────────────────────────────────
@@ -182,7 +165,7 @@ export class AskQuestionTool implements Tool {
                   maxItems: 4,
                   description:
                     "2–4 structured options. The UI always appends a free-text fallback slot, so do not include a 'something else' option here.",
-                  items: optionItemsSchema,
+                  items: OPTION_ITEMS_SCHEMA,
                 },
                 freeTextPlaceholder: {
                   type: "string",
@@ -212,7 +195,7 @@ export class AskQuestionTool implements Tool {
             maxItems: 4,
             description:
               "Legacy: 2–4 structured options. Prefer `questions[].options`. The UI always appends a free-text fallback slot, so do not include a 'something else' option here.",
-            items: optionItemsSchema,
+            items: OPTION_ITEMS_SCHEMA,
           },
           freeTextPlaceholder: {
             type: "string",
@@ -222,8 +205,18 @@ export class AskQuestionTool implements Tool {
         },
         // No top-level `required` — caller must supply either `questions`
         // or the legacy flat trio (`question` + `options`). Enforced in Zod.
-      },
     };
+
+  // Override hook for tests: lets a test replace the prompter factory
+  // without monkey-patching the module. Default factory wires the real
+  // broadcastMessage so the question reaches every connected client.
+  private prompterFactory: () => Pick<QuestionPrompter, "prompt">;
+
+  constructor(
+    prompterFactory: () => Pick<QuestionPrompter, "prompt"> = () =>
+      new QuestionPrompter({ broadcastMessage }),
+  ) {
+    this.prompterFactory = prompterFactory;
   }
 
   async execute(

package/src/tools/browser/__tests__/pinned-tabs.test.ts

@@ -0,0 +1,150 @@
+import { afterEach, describe, expect, test } from "bun:test";
+
+import {
+  __resetPinnedTabsForTests,
+  clearPinnedTab,
+  clearPinnedTabByTabId,
+  getPinnedTab,
+  setPinnedTab,
+} from "../pinned-tabs.js";
+
+describe("pinned-tabs", () => {
+  afterEach(() => {
+    __resetPinnedTabsForTests();
+  });
+
+  test("setPinnedTab / getPinnedTab round-trips", () => {
+    setPinnedTab("conv-a", "42");
+    expect(getPinnedTab("conv-a")).toBe("42");
+  });
+
+  test("getPinnedTab returns undefined for unset conversation", () => {
+    expect(getPinnedTab("unset-conv")).toBeUndefined();
+  });
+
+  test("conversations have independent pins", () => {
+    setPinnedTab("conv-a", "42");
+    setPinnedTab("conv-b", "99");
+    expect(getPinnedTab("conv-a")).toBe("42");
+    expect(getPinnedTab("conv-b")).toBe("99");
+  });
+
+  test("setPinnedTab overwrites a prior pin for the same conversation", () => {
+    setPinnedTab("conv-a", "42");
+    setPinnedTab("conv-a", "100");
+    expect(getPinnedTab("conv-a")).toBe("100");
+  });
+
+  test("clearPinnedTab removes the pin", () => {
+    setPinnedTab("conv-a", "42");
+    clearPinnedTab("conv-a");
+    expect(getPinnedTab("conv-a")).toBeUndefined();
+  });
+
+  test("clearPinnedTab on a non-existent conversation is a no-op", () => {
+    // Should not throw or affect other conversations.
+    setPinnedTab("conv-a", "42");
+    clearPinnedTab("nonexistent");
+    expect(getPinnedTab("conv-a")).toBe("42");
+  });
+
+  test("clearPinnedTabByTabId clears every matching conversation", () => {
+    setPinnedTab("conv-a", "42");
+    setPinnedTab("conv-b", "42");
+    setPinnedTab("conv-c", "99");
+
+    const cleared = clearPinnedTabByTabId("42");
+
+    expect(cleared).toBe(2);
+    expect(getPinnedTab("conv-a")).toBeUndefined();
+    expect(getPinnedTab("conv-b")).toBeUndefined();
+    expect(getPinnedTab("conv-c")).toBe("99"); // unchanged
+  });
+
+  test("clearPinnedTabByTabId on a non-matching tab is a no-op returning 0", () => {
+    setPinnedTab("conv-a", "42");
+    const cleared = clearPinnedTabByTabId("999");
+    expect(cleared).toBe(0);
+    expect(getPinnedTab("conv-a")).toBe("42");
+  });
+
+  test("empty conversationId is rejected on set", () => {
+    setPinnedTab("", "42");
+    expect(getPinnedTab("")).toBeUndefined();
+  });
+
+  test("empty tabId is rejected on set", () => {
+    setPinnedTab("conv-a", "");
+    expect(getPinnedTab("conv-a")).toBeUndefined();
+  });
+
+  describe("cross-client isolation (#31361)", () => {
+    test("same tabId on different clients are stored independently", () => {
+      setPinnedTab("conv-a", "99", "clientA");
+      setPinnedTab("conv-a", "99", "clientB");
+      expect(getPinnedTab("conv-a", "clientA")).toBe("99");
+      expect(getPinnedTab("conv-a", "clientB")).toBe("99");
+    });
+
+    test("clearPinnedTabByTabId with clientId only clears that client", () => {
+      setPinnedTab("conv-a", "99", "clientA");
+      setPinnedTab("conv-b", "99", "clientB");
+
+      const cleared = clearPinnedTabByTabId("99", "clientA");
+
+      expect(cleared).toBe(1);
+      expect(getPinnedTab("conv-a", "clientA")).toBeUndefined();
+      expect(getPinnedTab("conv-b", "clientB")).toBe("99"); // clientB's pin survives
+    });
+
+    test("getPinnedTab with matching clientId returns correct tabId", () => {
+      setPinnedTab("conv-x", "42", "clientA");
+      setPinnedTab("conv-x", "77", "clientB");
+
+      expect(getPinnedTab("conv-x", "clientA")).toBe("42");
+      expect(getPinnedTab("conv-x", "clientB")).toBe("77");
+    });
+
+    test("clearPinnedTabByTabId without clientId clears all matching entries (backward compat)", () => {
+      setPinnedTab("conv-a", "99", "clientA");
+      setPinnedTab("conv-b", "99", "clientB");
+
+      const cleared = clearPinnedTabByTabId("99");
+
+      expect(cleared).toBe(2);
+      expect(getPinnedTab("conv-a", "clientA")).toBeUndefined();
+      expect(getPinnedTab("conv-b", "clientB")).toBeUndefined();
+    });
+
+    test("clearPinnedTab with clientId only removes that client slot", () => {
+      setPinnedTab("conv-a", "42", "clientA");
+      setPinnedTab("conv-a", "77", "clientB");
+
+      clearPinnedTab("conv-a", "clientA");
+
+      expect(getPinnedTab("conv-a", "clientA")).toBeUndefined();
+      expect(getPinnedTab("conv-a", "clientB")).toBe("77");
+    });
+
+    test("clearPinnedTab without clientId removes all slots", () => {
+      setPinnedTab("conv-a", "42", "clientA");
+      setPinnedTab("conv-a", "77", "clientB");
+
+      clearPinnedTab("conv-a");
+
+      expect(getPinnedTab("conv-a", "clientA")).toBeUndefined();
+      expect(getPinnedTab("conv-a", "clientB")).toBeUndefined();
+    });
+
+    test("getPinnedTab with unknown clientId falls back to __default__ slot", () => {
+      setPinnedTab("conv-a", "42"); // stored in __default__ slot
+      expect(getPinnedTab("conv-a", "clientA")).toBe("42");
+    });
+
+    test("getPinnedTab without clientId returns first entry", () => {
+      setPinnedTab("conv-a", "42", "clientA");
+      const result = getPinnedTab("conv-a");
+      expect(result).toBe("42");
+    });
+  });
+});

package/src/tools/browser/browser-execution.ts

@@ -70,6 +70,7 @@ import type {
   CdpClient,
   CdpClientKind,
 } from "./cdp-client/types.js";
+import { clearPinnedTab, setPinnedTab } from "./pinned-tabs.js";
 import { checkBrowserRuntime } from "./runtime-check.js";
 
 const log = getLogger("headless-browser");
@@ -471,6 +472,24 @@ function wrapWithKindMemo(
     dispose(): void {
       inner.dispose();
     },
+    // Proxy the optional setCdpSessionId through to the underlying
+    // client so the navigate executor's --new-tab path can pin the
+    // freshly-created tab onto the extension CDP client. We define
+    // the method unconditionally here (rather than only when the
+    // inner client implements it) so callers can use a simple optional
+    // chain on this wrapper without re-walking the inner reference.
+    setCdpSessionId(cdpSessionId: string): void {
+      inner.setCdpSessionId?.(cdpSessionId);
+    },
+    listTabs() {
+      return inner.listTabs();
+    },
+    selectTab(tabId: number) {
+      return inner.selectTab(tabId);
+    },
+    closeTab(tabId: number) {
+      return inner.closeTab(tabId);
+    },
   };
 }
 
@@ -624,6 +643,93 @@ export async function executeBrowserNavigate(
   if (acquired.errorResult) return acquired.errorResult;
   const { cdp, browserMode } = acquired;
 
+  // --new-tab: open a fresh tab via the extension's Vellum.createTab
+  // pseudo-CDP method, then pin this client (and the conversation) to
+  // the returned tabId so this Page.navigate and every subsequent
+  // command on the same conversation routes to the new tab instead of
+  // the user's currently-active tab. Extension backend only; the local
+  // (Playwright) backend manages its own isolated browser and the
+  // cdp-inspect backend connects to a single tab by URL pattern.
+  const newTab = input.new_tab === true;
+  if (newTab && cdp.kind === "extension") {
+    try {
+      const result = await cdp.send<{ tabId?: number | string; clientId?: string }>(
+        "Vellum.createTab",
+        {},
+        context.signal,
+      );
+      const tabId =
+        typeof result?.tabId === "number"
+          ? String(result.tabId)
+          : typeof result?.tabId === "string"
+            ? result.tabId
+            : undefined;
+      const clientId =
+        typeof result?.clientId === "string" && result.clientId.length > 0
+          ? result.clientId
+          : undefined;
+      if (!tabId) {
+        // Malformed createTab response (no tabId). We're nominally falling
+        // back to active-tab routing — but the live `cdp` instance was
+        // already constructed with whatever pin was in scope for this
+        // conversation, AND the pin store still holds it for future
+        // client construction. Clear both: the pin store (so the next
+        // executeBrowserNavigate builds a clean client) AND the current
+        // cdp instance's session (so the Page.navigate that runs in a
+        // few lines targets the active tab rather than the stale pin).
+        // Without the setCdpSessionId(undefined) call, the warn message
+        // is a lie: navigation would still route to the dead tab via the
+        // already-injected cdpSessionId and likely fail with
+        // cdp_session_not_found.
+        clearPinnedTab(context.conversationId);
+        cdp.setCdpSessionId?.(undefined);
+        log.warn(
+          { conversationId: context.conversationId, result },
+          "Vellum.createTab returned no tabId; cleared stale pin and live session, falling back to active-tab routing",
+        );
+      } else {
+        cdp.setCdpSessionId?.(tabId);
+        setPinnedTab(context.conversationId, tabId, clientId);
+        log.debug(
+          { conversationId: context.conversationId, tabId, clientId },
+          "Opened new tab via --new-tab; pinned subsequent ops to it",
+        );
+      }
+    } catch (err) {
+      // Surface the failure rather than silently clobbering the active
+      // tab — that's exactly the behavior --new-tab is supposed to
+      // avoid. Clear any stale pin so subsequent ops don't route to a
+      // dead tab. Note: an old extension build without Vellum.createTab
+      // support will land here (CDP returns an "unknown method" error).
+      // We're early-returning before the main try/finally block below,
+      // so we must dispose the cdp client manually to avoid leaking it.
+      clearPinnedTab(context.conversationId);
+      const message =
+        err instanceof Error ? err.message : String(err);
+      log.warn(
+        { conversationId: context.conversationId, err },
+        "Vellum.createTab failed; aborting --new-tab navigate",
+      );
+      try {
+        cdp.dispose();
+      } catch (disposeErr) {
+        log.warn(
+          { conversationId: context.conversationId, err: disposeErr },
+          "Failed to dispose CDP client after Vellum.createTab failure",
+        );
+      }
+      return {
+        content: `Error: Failed to open a new tab for navigation: ${message}. The Chrome extension may need an update to support --new-tab.`,
+        isError: true,
+      };
+    }
+  } else if (newTab && cdp.kind !== "extension") {
+    log.debug(
+      { conversationId: context.conversationId, backendKind: cdp.kind },
+      "--new-tab requested but backend does not support it; ignoring",
+    );
+  }
+
   // Screencast + handoff are Playwright-backed and only meaningful
   // for the local sacrificial-profile path. On the extension path the
   // user already has their own Chrome window, so both are no-ops.