@vellumai/assistant 0.6.2 → 0.6.4

package/src/__tests__/browser-fill-credential.test.ts

@@ -9,35 +9,93 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+/**
+ * Fake CDP session driven by the real `LocalCdpClient` via the mocked
+ * `browserManager.getOrCreateSessionPage` below. `sendCalls` records
+ * every `session.send(method, params)` so tests can assert the exact
+ * sequence of CDP commands issued by `executeBrowserFillCredential`.
+ * `sendHandler` is replaced per test to shape responses or throw.
+ */
+interface SendCall {
+  method: string;
+  params: Record<string, unknown> | undefined;
+}
+
+let sendCalls: SendCall[];
+let sendHandler: (
+  method: string,
+  params: Record<string, unknown> | undefined,
+) => unknown;
+let detachCalls: number;
+
+function resetCdpMock() {
+  sendCalls = [];
+  detachCalls = 0;
+  sendHandler = defaultCdpHandler;
+}
+
+const fakeCdpSession = {
+  send: async (method: string, params?: Record<string, unknown>) => {
+    sendCalls.push({ method, params });
+    const value = sendHandler(method, params);
+    if (value instanceof Error) throw value;
+    return value;
+  },
+  detach: async () => {
+    detachCalls += 1;
+  },
+};
+
+/**
+ * Fake Playwright page that LocalCdpClient drives. Only the
+ * `context().newCDPSession()` surface is needed — all credential-fill
+ * work now flows through CDP.
+ */
 let mockPage: {
-  click: ReturnType<typeof mock>;
-  fill: ReturnType<typeof mock>;
-  press: ReturnType<typeof mock>;
-  evaluate: ReturnType<typeof mock>;
-  title: ReturnType<typeof mock>;
-  url: ReturnType<typeof mock>;
-  goto: ReturnType<typeof mock>;
   close: () => Promise<void>;
   isClosed: () => boolean;
+  context: () => {
+    newCDPSession: (page: unknown) => Promise<typeof fakeCdpSession>;
+  };
 };
 
-let snapshotMaps: Map<string, Map<string, string>>;
+let snapshotBackendNodeMaps: Map<string, Map<string, number>>;
+
+const preferredBackendKinds = new Map<string, string>();
 
 mock.module("../tools/browser/browser-manager.js", () => {
-  snapshotMaps = new Map();
+  snapshotBackendNodeMaps = new Map();
+  preferredBackendKinds.clear();
   return {
     browserManager: {
       getOrCreateSessionPage: async () => mockPage,
       closeSessionPage: async () => {},
       closeAllPages: async () => {},
-      storeSnapshotMap: (conversationId: string, map: Map<string, string>) => {
-        snapshotMaps.set(conversationId, map);
+      storeSnapshotBackendNodeMap: (
+        conversationId: string,
+        map: Map<string, number>,
+      ) => {
+        snapshotBackendNodeMaps.set(conversationId, map);
       },
-      resolveSnapshotSelector: (conversationId: string, elementId: string) => {
-        const map = snapshotMaps.get(conversationId);
+      resolveSnapshotBackendNodeId: (
+        conversationId: string,
+        elementId: string,
+      ) => {
+        const map = snapshotBackendNodeMaps.get(conversationId);
         if (!map) return null;
         return map.get(elementId) ?? null;
       },
+      clearSnapshotBackendNodeMap: (conversationId: string) => {
+        snapshotBackendNodeMaps.delete(conversationId);
+      },
+      getPreferredBackendKind: (conversationId: string) =>
+        preferredBackendKinds.get(conversationId) ?? null,
+      setPreferredBackendKind: (conversationId: string, kind: string) => {
+        preferredBackendKinds.set(conversationId, kind);
+      },
+      clearPreferredBackendKind: (conversationId: string) => {
+        preferredBackendKinds.delete(conversationId);
+      },
     },
   };
 });
@@ -82,21 +140,50 @@ const ctx: ToolContext = {
 
 function resetMockPage() {
   mockPage = {
-    click: mock(async () => {}),
-    fill: mock(async () => {}),
-    press: mock(async () => {}),
-    evaluate: mock(async () => ""),
-    title: mock(async () => "Test Page"),
-    url: mock(() => "https://example.com/"),
-    goto: mock(async () => ({
-      status: () => 200,
-      url: () => "https://example.com/",
-    })),
     close: async () => {},
     isClosed: () => false,
+    context: () => ({
+      newCDPSession: async (_page: unknown) => fakeCdpSession,
+    }),
   };
 }
 
+/**
+ * Default CDP handler used by every test unless overridden. Returns
+ * the minimum plumbing needed for:
+ *   - `getCurrentUrl` via Runtime.evaluate (for the broker domain check)
+ *   - `querySelectorBackendNodeId` via DOM.getDocument / querySelector / describeNode
+ *   - `focusElement` via DOM.focus
+ *   - `clearAndInsertText` via DOM.resolveNode + Runtime.callFunctionOn + Input.insertText
+ *   - `dispatchKeyPress` via Input.dispatchKeyEvent
+ */
+function defaultCdpHandler(
+  method: string,
+  _params: Record<string, unknown> | undefined,
+): unknown {
+  switch (method) {
+    case "Runtime.evaluate":
+      // getCurrentUrl() reads document.location.href via Runtime.evaluate
+      return { result: { value: "https://example.com/" } };
+    case "DOM.getDocument":
+      return { root: { nodeId: 1 } };
+    case "DOM.querySelector":
+      return { nodeId: 42 };
+    case "DOM.describeNode":
+      return { node: { backendNodeId: 100 } };
+    case "DOM.resolveNode":
+      // Used by clearAndInsertText to obtain a remote object on the
+      // target element so it can run the value-clearing function.
+      return { object: { objectId: "obj-1" } };
+    case "Runtime.callFunctionOn":
+      // The clear-helper function returns undefined; tests don't
+      // depend on the return value.
+      return { result: { value: undefined } };
+    default:
+      return {};
+  }
+}
+
 function defaultMetadata(service: string, field: string) {
   return {
     credentialId: `${service}:${field}`,
@@ -114,7 +201,8 @@ function defaultMetadata(service: string, field: string) {
 describe("executeBrowserFillCredential", () => {
   beforeEach(() => {
     resetMockPage();
-    snapshotMaps.clear();
+    resetCdpMock();
+    snapshotBackendNodeMaps.clear();
     mockGetSecureKey = mock(() => "super-secret-password");
     mockGetCredentialMetadata = mock((service: string, field: string) =>
       defaultMetadata(service, field),
@@ -122,23 +210,79 @@ describe("executeBrowserFillCredential", () => {
   });
 
   test("fills credential into element by element_id", async () => {
-    snapshotMaps.set(
-      "test-conversation",
-      new Map([["e1", '[data-vellum-eid="e1"]']]),
-    );
+    snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
     const result = await executeBrowserFillCredential(
       { service: "gmail", field: "password", element_id: "e1" },
       ctx,
     );
     expect(result.isError).toBe(false);
     expect(result.content).toContain("Filled password for gmail");
-    expect(mockPage.fill).toHaveBeenCalledWith(
-      '[data-vellum-eid="e1"]',
-      "super-secret-password",
-    );
+
+    // Backend path now goes through clearAndInsertText:
+    //   Runtime.evaluate (getCurrentUrl)
+    //   → DOM.focus
+    //   → DOM.resolveNode
+    //   → Runtime.callFunctionOn (clear)
+    //   → DOM.focus (re-focus)
+    //   → Input.insertText
+    const methods = sendCalls.map((c) => c.method);
+    expect(methods).toContain("DOM.focus");
+    expect(methods).toContain("DOM.resolveNode");
+    expect(methods).toContain("Runtime.callFunctionOn");
+    expect(methods).toContain("Input.insertText");
+    expect(methods).not.toContain("DOM.querySelector");
+
+    const focusCall = sendCalls.find((c) => c.method === "DOM.focus")!;
+    expect(focusCall.params).toEqual({ backendNodeId: 555 });
+
+    const insertCall = sendCalls.find((c) => c.method === "Input.insertText")!;
+    expect(insertCall.params).toEqual({ text: "super-secret-password" });
+
     expect(mockGetSecureKey).toHaveBeenCalledWith(
       credentialKey("gmail", "password"),
     );
+
+    // CdpClient disposed in finally → session.detach called.
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(detachCalls).toBe(1);
+  });
+
+  test("clears pre-populated field BEFORE inserting credential text", async () => {
+    // Regression: previously, fillCredential called focus + insertText
+    // directly, which APPENDED the credential to any existing value
+    // (autofill, prior typing, etc.) — corrupting the password and
+    // leaking partial state. The fix routes through the shared
+    // clearAndInsertText helper.
+    snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
+    await executeBrowserFillCredential(
+      { service: "gmail", field: "password", element_id: "e1" },
+      ctx,
+    );
+
+    // The clear must happen BEFORE the insertText. Specifically, the
+    // Runtime.callFunctionOn that runs the clearing function declaration
+    // must precede Input.insertText.
+    const methodSeq = sendCalls.map((c) => c.method);
+    const clearIdx = methodSeq.indexOf("Runtime.callFunctionOn");
+    const insertIdx = methodSeq.indexOf("Input.insertText");
+    expect(clearIdx).toBeGreaterThanOrEqual(0);
+    expect(insertIdx).toBeGreaterThan(clearIdx);
+
+    // The clearing function must reset both `value` and
+    // `textContent` so input/textarea AND contenteditable targets
+    // are handled.
+    const clearCall = sendCalls[clearIdx]!;
+    const fnDecl = (clearCall.params as { functionDeclaration: string })
+      .functionDeclaration;
+    expect(fnDecl).toContain('this.value = ""');
+    expect(fnDecl).toContain("this.textContent");
+    expect(fnDecl).toContain('new Event("input"');
+
+    // After the clear, the helper re-focuses the element (some sites
+    // blur on programmatic value reset) before inserting text — so we
+    // expect at least 2 DOM.focus calls in total.
+    const focusCount = methodSeq.filter((m) => m === "DOM.focus").length;
+    expect(focusCount).toBeGreaterThanOrEqual(2);
   });
 
   test("fills credential by CSS selector", async () => {
@@ -148,18 +292,27 @@ describe("executeBrowserFillCredential", () => {
     );
     expect(result.isError).toBe(false);
     expect(result.content).toContain("Filled token for github");
-    expect(mockPage.fill).toHaveBeenCalledWith(
-      'input[name="password"]',
-      "super-secret-password",
-    );
+
+    // Selector path must resolve the backendNodeId via DOM.querySelector
+    // before focusing + inserting text.
+    const methods = sendCalls.map((c) => c.method);
+    expect(methods).toContain("DOM.getDocument");
+    expect(methods).toContain("DOM.querySelector");
+    expect(methods).toContain("DOM.describeNode");
+    expect(methods).toContain("DOM.focus");
+    expect(methods).toContain("Input.insertText");
+
+    // DOM.focus uses the backendNodeId (100) returned by DOM.describeNode
+    const focusCall = sendCalls.find((c) => c.method === "DOM.focus")!;
+    expect(focusCall.params).toEqual({ backendNodeId: 100 });
+
+    const insertCall = sendCalls.find((c) => c.method === "Input.insertText")!;
+    expect(insertCall.params).toEqual({ text: "super-secret-password" });
   });
 
   test("returns error when credential not found", async () => {
     mockGetCredentialMetadata = mock(() => undefined);
-    snapshotMaps.set(
-      "test-conversation",
-      new Map([["e1", '[data-vellum-eid="e1"]']]),
-    );
+    snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
     const result = await executeBrowserFillCredential(
       { service: "slack", field: "api_key", element_id: "e1" },
       ctx,
@@ -167,15 +320,15 @@ describe("executeBrowserFillCredential", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("No credential stored for slack/api_key");
     expect(result.content).toContain("credential_store");
-    expect(mockPage.fill).not.toHaveBeenCalled();
+    // The broker short-circuits before DOM.focus is dispatched.
+    const methods = sendCalls.map((c) => c.method);
+    expect(methods).not.toContain("DOM.focus");
+    expect(methods).not.toContain("Input.insertText");
   });
 
   test("returns error when metadata exists but no stored value", async () => {
     mockGetSecureKey = mock(() => undefined);
-    snapshotMaps.set(
-      "test-conversation",
-      new Map([["e1", '[data-vellum-eid="e1"]']]),
-    );
+    snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
     const result = await executeBrowserFillCredential(
       { service: "slack", field: "api_key", element_id: "e1" },
       ctx,
@@ -183,7 +336,8 @@ describe("executeBrowserFillCredential", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("No credential stored for slack/api_key");
     expect(result.content).toContain("credential_store");
-    expect(mockPage.fill).not.toHaveBeenCalled();
+    const methods = sendCalls.map((c) => c.method);
+    expect(methods).not.toContain("Input.insertText");
   });
 
   test("returns error when element not found", async () => {
@@ -194,13 +348,13 @@ describe("executeBrowserFillCredential", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain('element_id "e99" not found');
     expect(result.content).toContain("browser_snapshot");
+    // Element resolution fails before any CDP session is opened.
+    expect(sendCalls).toHaveLength(0);
+    expect(detachCalls).toBe(0);
   });
 
   test("presses Enter after fill when press_enter is true", async () => {
-    snapshotMaps.set(
-      "test-conversation",
-      new Map([["e2", '[data-vellum-eid="e2"]']]),
-    );
+    snapshotBackendNodeMaps.set("test-conversation", new Map([["e2", 222]]));
     const result = await executeBrowserFillCredential(
       {
         service: "gmail",
@@ -211,21 +365,34 @@ describe("executeBrowserFillCredential", () => {
       ctx,
     );
     expect(result.isError).toBe(false);
-    expect(mockPage.fill).toHaveBeenCalledWith(
-      '[data-vellum-eid="e2"]',
-      "super-secret-password",
+    const methods = sendCalls.map((c) => c.method);
+    expect(methods).toContain("Input.insertText");
+    // dispatchKeyPress for "Enter" dispatches keyDown + char + keyUp
+    // (Enter has text "\r" so it now produces a char event too).
+    const keyEvents = sendCalls.filter(
+      (c) => c.method === "Input.dispatchKeyEvent",
     );
-    expect(mockPage.press).toHaveBeenCalledWith(
-      '[data-vellum-eid="e2"]',
+    expect(keyEvents).toHaveLength(3);
+    expect((keyEvents[0]!.params as { type: string; key: string }).type).toBe(
+      "keyDown",
+    );
+    expect((keyEvents[0]!.params as { type: string; key: string }).key).toBe(
       "Enter",
     );
+    expect((keyEvents[1]!.params as { type: string }).type).toBe("char");
+    expect((keyEvents[2]!.params as { type: string }).type).toBe("keyUp");
+    // Enter must come AFTER Input.insertText.
+    const insertIdx = sendCalls.findIndex(
+      (c) => c.method === "Input.insertText",
+    );
+    const firstKeyIdx = sendCalls.findIndex(
+      (c) => c.method === "Input.dispatchKeyEvent",
+    );
+    expect(firstKeyIdx).toBeGreaterThan(insertIdx);
   });
 
   test("credential value NEVER appears in result content", async () => {
-    snapshotMaps.set(
-      "test-conversation",
-      new Map([["e1", '[data-vellum-eid="e1"]']]),
-    );
+    snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
     const result = await executeBrowserFillCredential(
       { service: "gmail", field: "password", element_id: "e1" },
       ctx,
@@ -235,10 +402,7 @@ describe("executeBrowserFillCredential", () => {
   });
 
   test("returns error when service is missing", async () => {
-    snapshotMaps.set(
-      "test-conversation",
-      new Map([["e1", '[data-vellum-eid="e1"]']]),
-    );
+    snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
     const result = await executeBrowserFillCredential(
       { field: "password", element_id: "e1" },
       ctx,
@@ -248,10 +412,7 @@ describe("executeBrowserFillCredential", () => {
   });
 
   test("returns error when field is missing", async () => {
-    snapshotMaps.set(
-      "test-conversation",
-      new Map([["e1", '[data-vellum-eid="e1"]']]),
-    );
+    snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
     const result = await executeBrowserFillCredential(
       { service: "gmail", element_id: "e1" },
       ctx,
@@ -265,10 +426,7 @@ describe("executeBrowserFillCredential", () => {
   // -----------------------------------------------------------------------
   describe("broker integration", () => {
     test("fill succeeds with no domain or tool-policy checks", async () => {
-      snapshotMaps.set(
-        "test-conversation",
-        new Map([["e1", '[data-vellum-eid="e1"]']]),
-      );
+      snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
       const result = await executeBrowserFillCredential(
         { service: "gmail", field: "password", element_id: "e1" },
         ctx,
@@ -279,10 +437,7 @@ describe("executeBrowserFillCredential", () => {
     });
 
     test("credential access goes through broker (metadata + value checked)", async () => {
-      snapshotMaps.set(
-        "test-conversation",
-        new Map([["e1", '[data-vellum-eid="e1"]']]),
-      );
+      snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
       await executeBrowserFillCredential(
         { service: "gmail", field: "password", element_id: "e1" },
         ctx,
@@ -302,10 +457,7 @@ describe("executeBrowserFillCredential", () => {
         ...defaultMetadata(service, field),
         allowedTools: ["some_other_tool"],
       }));
-      snapshotMaps.set(
-        "test-conversation",
-        new Map([["e1", '[data-vellum-eid="e1"]']]),
-      );
+      snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
       const result = await executeBrowserFillCredential(
         { service: "gmail", field: "password", element_id: "e1" },
         ctx,
@@ -314,7 +466,9 @@ describe("executeBrowserFillCredential", () => {
       expect(result.content).toContain("Policy denied");
       expect(result.content).toContain("not allowed to use credential");
       expect(result.content).toContain("credential_store");
-      expect(mockPage.fill).not.toHaveBeenCalled();
+      // The broker short-circuits before Input.insertText fires.
+      const methods = sendCalls.map((c) => c.method);
+      expect(methods).not.toContain("Input.insertText");
     });
 
     test("returns domain policy denial with actionable message", async () => {
@@ -322,10 +476,7 @@ describe("executeBrowserFillCredential", () => {
         ...defaultMetadata(service, field),
         allowedDomains: ["other-site.com"],
       }));
-      snapshotMaps.set(
-        "test-conversation",
-        new Map([["e1", '[data-vellum-eid="e1"]']]),
-      );
+      snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
       const result = await executeBrowserFillCredential(
         { service: "gmail", field: "password", element_id: "e1" },
         ctx,
@@ -333,7 +484,8 @@ describe("executeBrowserFillCredential", () => {
       expect(result.isError).toBe(true);
       expect(result.content).toContain("Domain policy denied");
       expect(result.content).toContain("Navigate to an allowed domain");
-      expect(mockPage.fill).not.toHaveBeenCalled();
+      const methods = sendCalls.map((c) => c.method);
+      expect(methods).not.toContain("Input.insertText");
     });
 
     test("passes current page domain to broker", async () => {
@@ -341,15 +493,12 @@ describe("executeBrowserFillCredential", () => {
         ...defaultMetadata(service, field),
         allowedDomains: ["example.com"],
       }));
-      snapshotMaps.set(
-        "test-conversation",
-        new Map([["e1", '[data-vellum-eid="e1"]']]),
-      );
+      snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
       const result = await executeBrowserFillCredential(
         { service: "gmail", field: "password", element_id: "e1" },
         ctx,
       );
-      // Page URL is https://example.com/ which matches allowedDomains
+      // Default handler returns https://example.com/ → matches allowedDomains
       expect(result.isError).toBe(false);
       expect(result.content).toContain("Filled password for gmail");
     });
@@ -359,10 +508,7 @@ describe("executeBrowserFillCredential", () => {
         ...defaultMetadata(service, field),
         allowedTools: ["other_tool"],
       }));
-      snapshotMaps.set(
-        "test-conversation",
-        new Map([["e1", '[data-vellum-eid="e1"]']]),
-      );
+      snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
       const result = await executeBrowserFillCredential(
         { service: "gmail", field: "password", element_id: "e1" },
         ctx,

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

@@ -165,13 +165,15 @@ describe("BrowserManager", () => {
       // Should not throw
     });
 
-    test("clears snapshot map for the session", async () => {
+    test("clears snapshot backendNodeId map for the session", async () => {
       await browserManager.getOrCreateSessionPage("s1");
-      browserManager.storeSnapshotMap("s1", new Map([["e1", "#btn"]]));
-      expect(browserManager.resolveSnapshotSelector("s1", "e1")).toBe("#btn");
+      browserManager.storeSnapshotBackendNodeMap("s1", new Map([["e1", 42]]));
+      expect(browserManager.resolveSnapshotBackendNodeId("s1", "e1")).toBe(42);
 
       await browserManager.closeSessionPage("s1");
-      expect(browserManager.resolveSnapshotSelector("s1", "e1")).toBeNull();
+      expect(
+        browserManager.resolveSnapshotBackendNodeId("s1", "e1"),
+      ).toBeNull();
     });
   });
 
@@ -195,52 +197,63 @@ describe("BrowserManager", () => {
       // Should not throw
     });
 
-    test("clears all snapshot maps", async () => {
+    test("clears all snapshot backendNodeId maps", async () => {
       await browserManager.getOrCreateSessionPage("s1");
       await browserManager.getOrCreateSessionPage("s2");
-      browserManager.storeSnapshotMap("s1", new Map([["e1", "#a"]]));
-      browserManager.storeSnapshotMap("s2", new Map([["e2", "#b"]]));
+      browserManager.storeSnapshotBackendNodeMap("s1", new Map([["e1", 11]]));
+      browserManager.storeSnapshotBackendNodeMap("s2", new Map([["e2", 22]]));
 
       await browserManager.closeAllPages();
 
-      expect(browserManager.resolveSnapshotSelector("s1", "e1")).toBeNull();
-      expect(browserManager.resolveSnapshotSelector("s2", "e2")).toBeNull();
+      expect(
+        browserManager.resolveSnapshotBackendNodeId("s1", "e1"),
+      ).toBeNull();
+      expect(
+        browserManager.resolveSnapshotBackendNodeId("s2", "e2"),
+      ).toBeNull();
     });
   });
 
-  // ── snapshot map ─────────────────────────────────────────────
+  // ── snapshot backendNodeId map ───────────────────────────────
 
-  describe("snapshot map", () => {
-    test("stores and resolves element selectors", () => {
+  describe("snapshot backendNodeId map", () => {
+    test("stores and resolves element backendNodeIds", () => {
       const map = new Map([
-        ["e1", "#submit-btn"],
-        ["e2", 'input[name="email"]'],
+        ["e1", 101],
+        ["e2", 202],
       ]);
-      browserManager.storeSnapshotMap("s1", map);
+      browserManager.storeSnapshotBackendNodeMap("s1", map);
 
-      expect(browserManager.resolveSnapshotSelector("s1", "e1")).toBe(
-        "#submit-btn",
-      );
-      expect(browserManager.resolveSnapshotSelector("s1", "e2")).toBe(
-        'input[name="email"]',
-      );
+      expect(browserManager.resolveSnapshotBackendNodeId("s1", "e1")).toBe(101);
+      expect(browserManager.resolveSnapshotBackendNodeId("s1", "e2")).toBe(202);
     });
 
     test("returns null for unknown element id", () => {
-      browserManager.storeSnapshotMap("s1", new Map([["e1", "#btn"]]));
-      expect(browserManager.resolveSnapshotSelector("s1", "e999")).toBeNull();
+      browserManager.storeSnapshotBackendNodeMap("s1", new Map([["e1", 42]]));
+      expect(
+        browserManager.resolveSnapshotBackendNodeId("s1", "e999"),
+      ).toBeNull();
     });
 
     test("returns null for unknown session", () => {
       expect(
-        browserManager.resolveSnapshotSelector("unknown", "e1"),
+        browserManager.resolveSnapshotBackendNodeId("unknown", "e1"),
       ).toBeNull();
     });
 
     test("overwrites previous snapshot map for same session", () => {
-      browserManager.storeSnapshotMap("s1", new Map([["e1", "#old"]]));
-      browserManager.storeSnapshotMap("s1", new Map([["e1", "#new"]]));
-      expect(browserManager.resolveSnapshotSelector("s1", "e1")).toBe("#new");
+      browserManager.storeSnapshotBackendNodeMap("s1", new Map([["e1", 1]]));
+      browserManager.storeSnapshotBackendNodeMap("s1", new Map([["e1", 999]]));
+      expect(browserManager.resolveSnapshotBackendNodeId("s1", "e1")).toBe(999);
+    });
+
+    test("clearSnapshotBackendNodeMap drops the map for a session", () => {
+      browserManager.storeSnapshotBackendNodeMap("s1", new Map([["e1", 42]]));
+      expect(browserManager.resolveSnapshotBackendNodeId("s1", "e1")).toBe(42);
+      browserManager.clearSnapshotBackendNodeMap("s1");
+      expect(
+        browserManager.resolveSnapshotBackendNodeId("s1", "e1"),
+      ).toBeNull();
     });
   });
 });

package/src/__tests__/browser-skill-baseline-tool-payload.test.ts

@@ -41,12 +41,12 @@ describe("browser skill cutover — startup tool payload", () => {
     }
   });
 
-  test("total tool definition count reflects removal of 14 browser tools", () => {
+  test("total tool definition count reflects removal of browser tools", () => {
     const definitions = getAllToolDefinitions();
     // Startup has ~20 definitions after moving scaffold/settings/skill-management
     // tools to bundled skills (no browser tools).
     // Allow wider drift for unrelated tool additions while still failing if
-    // browser tools are reintroduced at startup (+14 definitions).
+    // browser tools are reintroduced at startup (+many definitions).
     expect(definitions.length).toBeGreaterThanOrEqual(15);
     expect(definitions.length).toBeLessThanOrEqual(50);
   });