@vellumai/assistant 0.7.0 → 0.7.2

package/src/tools/browser/cdp-client/__tests__/factory.test.ts

@@ -113,6 +113,30 @@ mock.module("../../../../util/logger.js", () => ({
   }),
 }));
 
+/** Mutable singleton proxy. Tests set this to control extension availability. */
+let mockSingletonProxy: HostBrowserProxy | null = null;
+
+/** Default proxy that reports unavailable — used when no test override is set. */
+const unavailableFallback: HostBrowserProxy = {
+  isAvailable: () => false,
+  hasExtensionClient: () => false,
+  request: () => Promise.reject(new Error("no extension")),
+  resolve: () => {},
+  hasPendingRequest: () => false,
+  dispose: () => {},
+} as unknown as HostBrowserProxy;
+
+mock.module("../../../../daemon/host-browser-proxy.js", () => ({
+  HostBrowserProxy: {
+    get instance() {
+      return mockSingletonProxy ?? unavailableFallback;
+    },
+    reset() {
+      mockSingletonProxy = null;
+    },
+  },
+}));
+
 // Import under test AFTER mock.module calls so that the factory's
 // top-level imports resolve to our fakes.
 const {
@@ -127,9 +151,9 @@ const {
 } = await import("../factory.js");
 
 /**
- * Minimal ToolContext suitable for factory tests. Only the fields the
- * factory reads (`conversationId` and `hostBrowserProxy`) need to be
- * populated; other required fields are cast away.
+ * Minimal ToolContext suitable for factory tests. Only `conversationId`
+ * needs to be populated; other required fields are cast away.
+ * Extension availability is controlled via `mockSingletonProxy`.
  */
 function makeContext(
   overrides: Partial<ToolContext> & { conversationId: string },
@@ -138,23 +162,38 @@ function makeContext(
 }
 
 /**
- * Create a fake HostBrowserProxy that reports as available.
+ * Create a fake HostBrowserProxy with a Chrome Extension client connected.
+ * Both isAvailable() and hasExtensionClient() return true.
  */
 function makeAvailableProxy(): HostBrowserProxy {
   return {
     request: mock(async () => ({})),
     isAvailable: () => true,
+    hasExtensionClient: () => true,
+  } as unknown as HostBrowserProxy;
+}
+
+/**
+ * Create a fake HostBrowserProxy where only the macOS SSE bridge is connected
+ * (no Chrome Extension). isAvailable() is true but hasExtensionClient() is false.
+ */
+function makeMacosBridgeOnlyProxy(): HostBrowserProxy {
+  return {
+    request: mock(async () => ({})),
+    isAvailable: () => true,
+    hasExtensionClient: () => false,
   } as unknown as HostBrowserProxy;
 }
 
 /**
  * Create a fake HostBrowserProxy that reports as unavailable
- * (proxy exists but client is disconnected).
+ * (proxy exists but no client of any kind is connected).
  */
 function makeUnavailableProxy(): HostBrowserProxy {
   return {
     request: mock(async () => ({})),
     isAvailable: () => false,
+    hasExtensionClient: () => false,
   } as unknown as HostBrowserProxy;
 }
 
@@ -171,15 +210,16 @@ describe("getCdpClient", () => {
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
     logDebugCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   // ── Candidate selection (kind reported before first send) ────────────
 
   test("routes to ExtensionCdpClient when hostBrowserProxy is set and available", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "test-convo",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -205,9 +245,9 @@ describe("getCdpClient", () => {
 
   test("skips extension when hostBrowserProxy is present but unavailable", async () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "disconnected-proxy",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -227,9 +267,9 @@ describe("getCdpClient", () => {
   test("skips extension but uses cdp-inspect when proxy unavailable and cdp-inspect enabled", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "disconnected-inspect",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -247,9 +287,9 @@ describe("getCdpClient", () => {
   test("extension wins even when cdpInspect is enabled", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "ext-wins",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -268,7 +308,6 @@ describe("getCdpClient", () => {
     cdpInspectEnabled = true;
     const ctx = makeContext({
       conversationId: "inspect-convo",
-      hostBrowserProxy: undefined,
     });
 
     const client = getCdpClient(ctx);
@@ -295,7 +334,6 @@ describe("getCdpClient", () => {
     cdpInspectEnabled = false;
     const ctx = makeContext({
       conversationId: "local-convo",
-      hostBrowserProxy: undefined,
     });
 
     const client = getCdpClient(ctx);
@@ -333,9 +371,9 @@ describe("getCdpClient", () => {
 
   test("getCdpClient without options behaves identically to auto mode", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "no-opts",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -361,9 +399,9 @@ describe("getCdpClient", () => {
 
   test("forwards send() through the manager to the extension-backed client", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "send-ext",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -507,9 +545,9 @@ describe("getCdpClient", () => {
 
   test("dispose() on an extension-backed client tears down the extension client", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "dispose-ext",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -576,9 +614,9 @@ describe("getCdpClient", () => {
 
   test("context with transportInterface set routes normally to extension backend", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-ext",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
     });
 
@@ -629,13 +667,14 @@ describe("buildCandidateList", () => {
     cdpInspectEnabled = false;
     desktopAutoConfig = { enabled: true, cooldownMs: 30_000 };
     _resetDesktopAutoCooldown();
+    mockSingletonProxy = null;
   });
 
   test("includes extension candidate when proxy is present and available", () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "candidates-ext",
-      hostBrowserProxy: fakeProxy,
     });
 
     const candidates = buildCandidateList(ctx);
@@ -648,9 +687,9 @@ describe("buildCandidateList", () => {
 
   test("excludes extension candidate when proxy is present but unavailable", () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "candidates-no-ext",
-      hostBrowserProxy: fakeProxy,
     });
 
     const candidates = buildCandidateList(ctx);
@@ -659,6 +698,22 @@ describe("buildCandidateList", () => {
     expect(candidates[0].kind).toBe("local");
   });
 
+  test("excludes extension candidate when only macOS SSE bridge is connected", () => {
+    // isAvailable() = true but hasExtensionClient() = false: only macOS bridge.
+    // The macOS bridge routes through localhost:9222 on the host, so it must
+    // NOT be included under the "extension" candidate kind.
+    const fakeProxy = makeMacosBridgeOnlyProxy();
+    mockSingletonProxy = fakeProxy;
+    const ctx = makeContext({
+      conversationId: "candidates-macos-bridge-only",
+    });
+
+    const candidates = buildCandidateList(ctx);
+
+    expect(candidates.every((c) => c.kind !== "extension")).toBe(true);
+    expect(candidates[candidates.length - 1].kind).toBe("local");
+  });
+
   test("includes cdp-inspect candidate when enabled in config", () => {
     cdpInspectEnabled = true;
     const ctx = makeContext({ conversationId: "candidates-inspect" });
@@ -672,9 +727,9 @@ describe("buildCandidateList", () => {
   test("candidate order: extension > cdp-inspect > local when all present", () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "candidates-all",
-      hostBrowserProxy: fakeProxy,
     });
 
     const candidates = buildCandidateList(ctx);
@@ -710,10 +765,12 @@ describe("buildChainedClient failover", () => {
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
     logDebugCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   test("fails over from extension to local on transport_error", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension client fail with transport_error
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -735,7 +792,6 @@ describe("buildChainedClient failover", () => {
 
     const ctx = makeContext({
       conversationId: "failover-ext-to-local",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -754,6 +810,7 @@ describe("buildChainedClient failover", () => {
   test("fails over from extension to cdp-inspect to local on transport errors", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail with transport_error
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -785,7 +842,6 @@ describe("buildChainedClient failover", () => {
 
     const ctx = makeContext({
       conversationId: "failover-chain",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -803,6 +859,7 @@ describe("buildChainedClient failover", () => {
   test("does NOT fail over on cdp_error -- propagates immediately", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail with cdp_error (not transport_error)
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -820,7 +877,6 @@ describe("buildChainedClient failover", () => {
 
     const ctx = makeContext({
       conversationId: "no-failover-cdp-error",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -868,6 +924,7 @@ describe("buildChainedClient failover", () => {
   test("backend becomes sticky after first successful command", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail on first call with transport_error
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -885,7 +942,6 @@ describe("buildChainedClient failover", () => {
 
     const ctx = makeContext({
       conversationId: "sticky-test",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -946,6 +1002,7 @@ describe("buildChainedClient failover", () => {
 
   test("kind reflects the active backend after failover", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -961,7 +1018,6 @@ describe("buildChainedClient failover", () => {
 
     const ctx = makeContext({
       conversationId: "kind-after-failover",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -976,6 +1032,7 @@ describe("buildChainedClient failover", () => {
 
   test("dispose cleans up failed backends from failover chain", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -991,7 +1048,6 @@ describe("buildChainedClient failover", () => {
 
     const ctx = makeContext({
       conversationId: "dispose-failover",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -1023,6 +1079,7 @@ describe("desktop-auto cdp-inspect (macOS)", () => {
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
     logDebugCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   // ── buildCandidateList with desktopAuto ─────────────────────────────
@@ -1043,9 +1100,9 @@ describe("desktop-auto cdp-inspect (macOS)", () => {
 
   test("macOS turn with extension available: extension > cdp-inspect > local", () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-all",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
     });
 
@@ -1060,38 +1117,33 @@ describe("desktop-auto cdp-inspect (macOS)", () => {
 
   test("macOS turn with registry-routed proxy unavailable skips desktop-auto cdp-inspect (extension intent)", () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-proxy-unavailable-no-inspect",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
-      hostBrowserRegistryRouted: true,
     });
 
     const candidates = buildCandidateList(ctx);
 
-    // Should only include local -- cdp-inspect is suppressed because extension
-    // transport is expected (registry-routed proxy) but temporarily unavailable.
-    expect(candidates.length).toBe(1);
-    expect(candidates[0].kind).toBe("local");
+    // Extension unavailable => cdp-inspect (desktop-auto) + local
+    expect(candidates.length).toBe(2);
+    expect(candidates[0].kind).toBe("cdp-inspect");
+    expect(candidates[1].kind).toBe("local");
   });
 
-  test("macOS turn with SSE-backed proxy unavailable still includes desktop-auto cdp-inspect", () => {
+  test("macOS turn with singleton proxy unavailable still includes desktop-auto cdp-inspect", () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
-      conversationId: "macos-sse-proxy-unavailable-inspect-allowed",
-      hostBrowserProxy: fakeProxy,
+      conversationId: "macos-proxy-unavailable-inspect-allowed",
       transportInterface: "macos",
-      // hostBrowserRegistryRouted is NOT set -- SSE-backed proxy
     });
 
     const candidates = buildCandidateList(ctx);
 
-    // SSE-backed proxy that is unavailable (non-interactive turn) should NOT
-    // suppress cdp-inspect -- the SSE proxy was never expected to service
-    // browser requests, so cdp-inspect remains available as a fallback.
+    // Extension unavailable => cdp-inspect (desktop-auto) + local
     expect(candidates.length).toBe(2);
     expect(candidates[0].kind).toBe("cdp-inspect");
-    expect(candidates[0].reason).toContain("desktopAuto");
     expect(candidates[1].kind).toBe("local");
   });
 
@@ -1112,9 +1164,9 @@ describe("desktop-auto cdp-inspect (macOS)", () => {
 
   test("macOS turn with extension available still includes cdp-inspect as fallback", () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-ext-available-inspect-fallback",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
     });
 
@@ -1263,43 +1315,41 @@ describe("desktop-auto cdp-inspect (macOS)", () => {
     expect(candidates[0].kind).toBe("local");
   });
 
-  test("macOS turn with registry-routed proxy unavailable routes to local without trying cdp-inspect", async () => {
+  test("macOS turn with registry-routed proxy unavailable still tries cdp-inspect (desktop-auto)", async () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-proxy-unavail-route",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
-      hostBrowserRegistryRouted: true,
     });
 
     const client = getCdpClient(ctx);
 
-    // Should go straight to local -- no cdp-inspect candidate inserted
-    // because the registry-routed extension was expected but is unavailable.
-    expect(client.kind).toBe("local");
+    // Extension unavailable no longer suppresses cdp-inspect — desktop-auto
+    // inserts it as a candidate and it succeeds.
+    expect(client.kind).toBe("cdp-inspect");
     const result = await client.send<{ ok: boolean; via: string }>(
       "Page.navigate",
     );
-    expect(result).toEqual({ ok: true, via: "local" });
-    expect(createCdpInspectClientMock).not.toHaveBeenCalled();
+    expect(result).toEqual({ ok: true, via: "cdp-inspect" });
+    expect(createCdpInspectClientMock).toHaveBeenCalledTimes(1);
     expect(createExtensionCdpClientMock).not.toHaveBeenCalled();
-    expect(createLocalCdpClientMock).toHaveBeenCalledTimes(1);
+    expect(createLocalCdpClientMock).not.toHaveBeenCalled();
     client.dispose();
   });
 
-  test("macOS turn with SSE-backed proxy unavailable falls through to cdp-inspect", async () => {
+  test("macOS turn with singleton proxy unavailable still tries cdp-inspect (desktop-auto)", async () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
-      conversationId: "macos-sse-proxy-unavail-inspect",
-      hostBrowserProxy: fakeProxy,
+      conversationId: "macos-proxy-unavail-local",
       transportInterface: "macos",
-      // hostBrowserRegistryRouted is NOT set -- SSE-backed proxy
     });
 
     const client = getCdpClient(ctx);
 
-    // SSE-backed proxy unavailable (non-interactive turn) should NOT
-    // suppress cdp-inspect -- it falls through to desktop-auto cdp-inspect.
+    // Extension unavailable no longer suppresses cdp-inspect — desktop-auto
+    // inserts it as a candidate and it succeeds.
     expect(client.kind).toBe("cdp-inspect");
     const result = await client.send<{ ok: boolean; via: string }>(
       "Page.navigate",
@@ -1307,6 +1357,7 @@ describe("desktop-auto cdp-inspect (macOS)", () => {
     expect(result).toEqual({ ok: true, via: "cdp-inspect" });
     expect(createExtensionCdpClientMock).not.toHaveBeenCalled();
     expect(createCdpInspectClientMock).toHaveBeenCalledTimes(1);
+    expect(createLocalCdpClientMock).not.toHaveBeenCalled();
     client.dispose();
   });
 
@@ -1380,15 +1431,16 @@ describe("pinned-mode selection", () => {
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
     logDebugCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   // ── Pinned extension ────────────────────────────────────────────────
 
   test("pinned extension mode routes to extension when proxy is available", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "pinned-ext",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx, { mode: "extension" });
@@ -1415,7 +1467,7 @@ describe("pinned-mode selection", () => {
       const cdpErr = err as CdpError;
       expect(cdpErr.code).toBe("transport_error");
       expect(cdpErr.message).toContain('Pinned mode "extension" unavailable');
-      expect(cdpErr.message).toContain("no host browser proxy provisioned");
+      expect(cdpErr.message).toContain("no Chrome Extension connected");
       expect(cdpErr.attemptDiagnostics).toBeDefined();
       expect(cdpErr.attemptDiagnostics).toHaveLength(1);
       expect(cdpErr.attemptDiagnostics![0].candidateKind).toBe("extension");
@@ -1425,9 +1477,9 @@ describe("pinned-mode selection", () => {
 
   test("pinned extension mode throws when proxy is present but unavailable", () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "pinned-ext-unavail",
-      hostBrowserProxy: fakeProxy,
     });
 
     expect(() => getCdpClient(ctx, { mode: "extension" })).toThrow(CdpError);
@@ -1437,13 +1489,14 @@ describe("pinned-mode selection", () => {
     } catch (err) {
       const cdpErr = err as CdpError;
       expect(cdpErr.code).toBe("transport_error");
-      expect(cdpErr.message).toContain("not connected");
+      expect(cdpErr.message).toContain("no Chrome Extension connected");
       expect(cdpErr.attemptDiagnostics![0].stage).toBe("candidate_selection");
     }
   });
 
   test("pinned extension mode does NOT fall back to local on transport error", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail with transport_error
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -1459,7 +1512,6 @@ describe("pinned-mode selection", () => {
 
     const ctx = makeContext({
       conversationId: "pinned-ext-no-fallback",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx, { mode: "extension" });
@@ -1535,9 +1587,9 @@ describe("pinned-mode selection", () => {
 
   test("pinned local mode routes to local", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "pinned-local",
-      hostBrowserProxy: fakeProxy,
     });
 
     // Even with proxy available, pinned local should skip extension
@@ -1591,13 +1643,14 @@ describe("buildPinnedCandidateList", () => {
     cdpInspectEnabled = false;
     desktopAutoConfig = { enabled: true, cooldownMs: 30_000 };
     _resetDesktopAutoCooldown();
+    mockSingletonProxy = null;
   });
 
   test("extension mode produces single extension candidate", () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "bpl-ext",
-      hostBrowserProxy: fakeProxy,
     });
 
     const candidates = buildPinnedCandidateList(ctx, "extension");
@@ -1646,6 +1699,25 @@ describe("buildPinnedCandidateList", () => {
       });
     }
   });
+
+  test("extension mode throws when only macOS SSE bridge is connected", () => {
+    // This is the bug case: isAvailable() = true but hasExtensionClient() = false.
+    // Before the fix, this would build an extension candidate that silently
+    // dispatched to the macOS bridge and failed with a misleading localhost:9222 error.
+    const fakeProxy = makeMacosBridgeOnlyProxy();
+    mockSingletonProxy = fakeProxy;
+    const ctx = makeContext({ conversationId: "bpl-ext-macos-bridge-only" });
+
+    try {
+      buildPinnedCandidateList(ctx, "extension");
+      expect(true).toBe(false); // should not reach
+    } catch (err) {
+      expect(err).toBeInstanceOf(CdpError);
+      const cdpErr = err as CdpError;
+      expect(cdpErr.code).toBe("transport_error");
+      expect(cdpErr.message).toContain("no Chrome Extension connected");
+    }
+  });
 });
 
 // ── Attempt diagnostics & fallback log tests ─────────────────────────────
@@ -1663,11 +1735,13 @@ describe("attempt diagnostics", () => {
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
     logDebugCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   test("exhausted candidates error includes full attempt diagnostics", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -1707,7 +1781,6 @@ describe("attempt diagnostics", () => {
 
     const ctx = makeContext({
       conversationId: "diag-all-fail",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -1750,6 +1823,7 @@ describe("attempt diagnostics", () => {
 
   test("successful fallback still records diagnostics for failed candidates", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -1765,7 +1839,6 @@ describe("attempt diagnostics", () => {
 
     const ctx = makeContext({
       conversationId: "diag-partial",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -1786,6 +1859,7 @@ describe("attempt diagnostics", () => {
   test("auto-mode fallback log includes candidate sequence and failure reasons", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -1813,7 +1887,6 @@ describe("attempt diagnostics", () => {
 
     const ctx = makeContext({
       conversationId: "diag-log-shape",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -1937,10 +2010,12 @@ describe("no-fallback guarantees", () => {
     desktopAutoConfig = { enabled: true, cooldownMs: 30_000 };
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   test("pinned extension: only one candidate is ever constructed", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -1956,7 +2031,6 @@ describe("no-fallback guarantees", () => {
 
     const ctx = makeContext({
       conversationId: "nofb-ext",
-      hostBrowserProxy: fakeProxy,
     });
     const client = getCdpClient(ctx, { mode: "extension" });
 
@@ -2043,7 +2117,7 @@ describe("no-fallback guarantees", () => {
 // Verify that macOS turns can use the host browser proxy without requiring
 // extension registry connectivity. When a HostBrowserProxy is provisioned
 // via the SSE sender path (no extension), the factory should select
-// extension as the top candidate (because hostBrowserProxy is available).
+// extension as the top candidate (because the singleton proxy is available).
 // When both proxy and fallback backends exist, selection is deterministic:
 // extension > cdp-inspect > local.
 
@@ -2060,15 +2134,16 @@ describe("macOS host-browser proxy without extension registry", () => {
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
     logDebugCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   test("macOS turn with SSE-provisioned hostBrowserProxy selects extension backend", async () => {
     // Simulates macOS provisioning a HostBrowserProxy via SSE (no extension
     // registry connection). The proxy is available so extension is selected.
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-sse-proxy",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
     });
 
@@ -2085,9 +2160,9 @@ describe("macOS host-browser proxy without extension registry", () => {
 
   test("macOS turn with both proxy and cdp-inspect produces deterministic 3-candidate chain", () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-deterministic",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
     });
 
@@ -2119,9 +2194,9 @@ describe("macOS host-browser proxy without extension registry", () => {
     // enablement — proxy presence drives extension selection regardless of
     // interface.
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "non-macos-proxy",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "cli",
     });