pi-lean-dimension 0.1.0 → 0.2.0

package/node_modules/pi-lean-portal/__tests__/browser-data.test.ts

@@ -0,0 +1,124 @@
+/**
+ * Shared browser-data validation tests.
+ *
+ * Verifies that ``browser-data.json`` is well-formed and contains all
+ * expected keys with the correct types.  Both the TypeScript loader
+ * (browser-data.ts) and the Python bridge's JSON loader depend on this
+ * file, so a break here means both sides are broken in the same way.
+ *
+ * These tests are browser-free — no Chromium/Firefox needed.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+	BOT_SIGNALS,
+	ACCESSIBILITY,
+	NAV_SETTLE,
+} from "../core/shared/browser-data.js";
+
+// ─── Bot signals ─────────────────────────────────────────────────────
+
+describe("shared browser-data.json — bot signals", () => {
+	it("has all four signal categories as arrays of strings", () => {
+		expect(Array.isArray(BOT_SIGNALS.blockSignals)).toBe(true);
+		expect(BOT_SIGNALS.blockSignals.length).toBeGreaterThanOrEqual(10);
+		for (const s of BOT_SIGNALS.blockSignals) {
+			expect(typeof s).toBe("string");
+		}
+
+		expect(Array.isArray(BOT_SIGNALS.bodyOnlySignals)).toBe(true);
+		expect(BOT_SIGNALS.bodyOnlySignals.length).toBeGreaterThanOrEqual(1);
+		for (const s of BOT_SIGNALS.bodyOnlySignals) {
+			expect(typeof s).toBe("string");
+		}
+
+		expect(Array.isArray(BOT_SIGNALS.bodyOnlyPatterns)).toBe(true);
+		expect(BOT_SIGNALS.bodyOnlyPatterns.length).toBeGreaterThanOrEqual(1);
+		for (const s of BOT_SIGNALS.bodyOnlyPatterns) {
+			expect(typeof s).toBe("string");
+		}
+
+		expect(Array.isArray(BOT_SIGNALS.htmlSignals)).toBe(true);
+		expect(BOT_SIGNALS.htmlSignals.length).toBeGreaterThanOrEqual(4);
+		for (const s of BOT_SIGNALS.htmlSignals) {
+			expect(typeof s).toBe("string");
+		}
+	});
+
+	it("includes known block signals", () => {
+		expect(BOT_SIGNALS.blockSignals).toContain("please verify you are human");
+		expect(BOT_SIGNALS.blockSignals).toContain("cf-challenge");
+		expect(BOT_SIGNALS.blockSignals).toContain("cdn-cgi/challenge");
+	});
+
+	it("includes known body-only signals", () => {
+		expect(BOT_SIGNALS.bodyOnlySignals).toContain("errors.edgesuite.net");
+	});
+
+	it("includes known html signals", () => {
+		expect(BOT_SIGNALS.htmlSignals).toContain("recaptcha");
+		expect(BOT_SIGNALS.htmlSignals).toContain("hcaptcha");
+		expect(BOT_SIGNALS.htmlSignals).toContain("data-sitekey");
+	});
+});
+
+// ─── Accessibility ───────────────────────────────────────────────────
+
+describe("shared browser-data.json — accessibility", () => {
+	it("has interactiveRoles as a non-empty array of strings", () => {
+		expect(Array.isArray(ACCESSIBILITY.interactiveRoles)).toBe(true);
+		expect(ACCESSIBILITY.interactiveRoles.length).toBeGreaterThanOrEqual(40);
+		for (const r of ACCESSIBILITY.interactiveRoles) {
+			expect(typeof r).toBe("string");
+		}
+	});
+
+	it("has informationalRoles as a non-empty array of strings", () => {
+		expect(Array.isArray(ACCESSIBILITY.informationalRoles)).toBe(true);
+		expect(ACCESSIBILITY.informationalRoles.length).toBeGreaterThanOrEqual(15);
+		for (const r of ACCESSIBILITY.informationalRoles) {
+			expect(typeof r).toBe("string");
+		}
+	});
+
+	it("has roleIcons as a map with known entries", () => {
+		expect(typeof ACCESSIBILITY.roleIcons).toBe("object");
+		expect(ACCESSIBILITY.roleIcons).not.toBeNull();
+		expect(Object.keys(ACCESSIBILITY.roleIcons).length).toBeGreaterThanOrEqual(
+			60,
+		);
+		expect(ACCESSIBILITY.roleIcons["button"]).toBe("🔘 ");
+		expect(ACCESSIBILITY.roleIcons["link"]).toBe("🔗 ");
+	});
+
+	it("includes common interactive roles like button and link", () => {
+		expect(ACCESSIBILITY.interactiveRoles).toContain("button");
+		expect(ACCESSIBILITY.interactiveRoles).toContain("link");
+		expect(ACCESSIBILITY.interactiveRoles).toContain("textbox");
+		expect(ACCESSIBILITY.interactiveRoles).toContain("checkbox");
+	});
+
+	it("includes informational roles like paragraph and text", () => {
+		expect(ACCESSIBILITY.informationalRoles).toContain("paragraph");
+		expect(ACCESSIBILITY.informationalRoles).toContain("text");
+		expect(ACCESSIBILITY.informationalRoles).toContain("group");
+	});
+});
+
+// ─── Nav-settle ────────────────────────────────────────────────────
+
+describe("shared browser-data.json — nav-settle", () => {
+	it("has expected numeric timeout values", () => {
+		expect(NAV_SETTLE.navTimeoutMs).toBe(5000);
+		expect(NAV_SETTLE.settleTimeoutMs).toBe(400);
+		expect(NAV_SETTLE.settleRaceMs).toBe(150);
+	});
+
+	it("has a non-empty domStabilizationJs string", () => {
+		expect(typeof NAV_SETTLE.domStabilizationJs).toBe("string");
+		expect(NAV_SETTLE.domStabilizationJs.length).toBeGreaterThan(50);
+		expect(NAV_SETTLE.domStabilizationJs).toContain(
+			"document.querySelectorAll",
+		);
+	});
+});

package/node_modules/pi-lean-portal/__tests__/browser-inspect.test.ts

@@ -21,6 +21,7 @@ import {
 	queryElementCache,
 	formatElementList,
 	formatRoleCountSummary,
+	type QueryStatus,
 } from "../core/shared/dom-extractor.js";
 
 // ─── Helpers ───────────────────────────────────────────────────────
@@ -171,15 +172,16 @@ describe("runExtractor()", () => {
 			result: MOCK_EXTRACTOR_RESPONSE,
 		};
 
-		const result = await runExtractor("test-task", mockPlugin);
-		expect(result).not.toBeNull();
-		expect(result!.title).toBe("Test Page");
-		expect(result!.headings).toHaveLength(1);
-		expect(result!.headings[0]!.text).toBe("Heading One");
-		expect(result!.paragraphs).toHaveLength(1);
-		expect(result!.links).toHaveLength(1);
-		expect(result!.images).toHaveLength(1);
-		expect(result!.interactive).toHaveLength(1);
+		const outcome = await runExtractor("test-task", mockPlugin);
+		expect(outcome.ok).toBe(true);
+		if (!outcome.ok) return;
+		expect(outcome.result.title).toBe("Test Page");
+		expect(outcome.result.headings).toHaveLength(1);
+		expect(outcome.result.headings[0]!.text).toBe("Heading One");
+		expect(outcome.result.paragraphs).toHaveLength(1);
+		expect(outcome.result.links).toHaveLength(1);
+		expect(outcome.result.images).toHaveLength(1);
+		expect(outcome.result.interactive).toHaveLength(1);
 	});
 
 	it("returns null on evaluate failure", async () => {
@@ -189,8 +191,10 @@ describe("runExtractor()", () => {
 			error: "evaluate failed",
 		};
 
-		const result = await runExtractor("test-task", mockPlugin);
-		expect(result).toBeNull();
+		const outcome = await runExtractor("test-task", mockPlugin);
+		expect(outcome.ok).toBe(false);
+		if (outcome.ok) return;
+		expect(outcome.error).toContain("evaluate failed");
 	});
 
 	it("returns null on invalid JSON from evaluate", async () => {
@@ -200,8 +204,10 @@ describe("runExtractor()", () => {
 			result: "not valid json {{{",
 		};
 
-		const result = await runExtractor("test-task", mockPlugin);
-		expect(result).toBeNull();
+		const outcome = await runExtractor("test-task", mockPlugin);
+		expect(outcome.ok).toBe(false);
+		if (outcome.ok) return;
+		expect(outcome.error).toContain("invalid JSON");
 	});
 
 	it("returns null when script returns error field", async () => {
@@ -211,8 +217,26 @@ describe("runExtractor()", () => {
 			result: JSON.stringify({ error: "Something went wrong" }),
 		};
 
-		const result = await runExtractor("test-task", mockPlugin);
-		expect(result).toBeNull();
+		const outcome = await runExtractor("test-task", mockPlugin);
+		expect(outcome.ok).toBe(false);
+		if (outcome.ok) return;
+		expect(outcome.error).toBe("Something went wrong");
+	});
+
+	it("forwards readOnly: true to plugin.evaluate", async () => {
+		const mockPlugin = new MockPlugin("test");
+		mockPlugin.evalResult = {
+			success: true,
+			result: MOCK_EXTRACTOR_RESPONSE,
+		};
+
+		await runExtractor("test-task", mockPlugin);
+		const evaluateCalls = mockPlugin.calls.get("evaluate");
+		expect(evaluateCalls).toBeDefined();
+		expect(evaluateCalls!.length).toBe(1);
+		// Third arg must be true (readOnly)
+		const args = evaluateCalls![0] as unknown[];
+		expect(args[2]).toBe(true);
 	});
 });
 
@@ -491,6 +515,55 @@ describe("queryElementCache()", () => {
 		expect(results).toHaveLength(2); // Two Submit buttons
 		expect(results.every((n) => n.role === "button")).toBe(true);
 	});
+
+	describe("QueryStatus out-param", () => {
+		it("ref present + extra role filter that does not match", () => {
+			const status: QueryStatus = {};
+			const results = queryElementCache(
+				cache,
+				{ ref: "@e6", role: "button" },
+				status,
+			);
+			expect(results).toHaveLength(0);
+			expect(status.refFilteredOut).toBeDefined();
+			expect(status.refFilteredOut!.filter).toBe("role");
+			expect(status.refFilteredOut!.value).toBe("button");
+			expect(status.refFilteredOut!.node.role).toBe("dialog");
+		});
+
+		it("ref present + extra name filter that does not match", () => {
+			const status: QueryStatus = {};
+			const results = queryElementCache(
+				cache,
+				{ ref: "@e6", name: "close" },
+				status,
+			);
+			expect(results).toHaveLength(0);
+			expect(status.refFilteredOut).toBeDefined();
+			expect(status.refFilteredOut!.filter).toBe("name");
+			expect(status.refFilteredOut!.value).toBe("close");
+			expect(status.refFilteredOut!.node.name).toBe("Sign Up");
+		});
+
+		it("ref genuinely absent", () => {
+			const status: QueryStatus = {};
+			const results = queryElementCache(cache, { ref: "@e99" }, status);
+			expect(results).toHaveLength(0);
+			expect(status.refFilteredOut).toBeUndefined();
+		});
+
+		it("ref present + matching extra filter", () => {
+			const status: QueryStatus = {};
+			const results = queryElementCache(
+				cache,
+				{ ref: "@e6", role: "dialog" },
+				status,
+			);
+			expect(results).toHaveLength(1);
+			expect(results[0]!.ref).toBe("e6");
+			expect(status.refFilteredOut).toBeUndefined();
+		});
+	});
 });
 
 // ─── Router dispatch integration tests ─────────────────────────────
@@ -577,6 +650,41 @@ describe("router.browserInspect()", () => {
 		expect(result.content).toContain("Lexical Analysis");
 	});
 
+	it("ref + role mismatch shows found-but-filtered message", async () => {
+		await router.navigate("https://example.com", { taskId: "test-5b" });
+
+		const result = await router.browserInspect("test-5b", {
+			ref: "@e6",
+			role: "button",
+		});
+		expect(result.success).toBe(true);
+		expect(result.content).toContain("found in cache");
+		expect(result.content).toContain("does not match");
+		expect(result.content).toContain('filter role="button"');
+		expect(result.content).not.toContain("not found in cache");
+	});
+
+	it("ref genuinely absent keeps not-found message", async () => {
+		await router.navigate("https://example.com", { taskId: "test-5c" });
+
+		const result = await router.browserInspect("test-5c", { ref: "@e99" });
+		expect(result.success).toBe(true);
+		expect(result.content).toContain("not found in cache");
+	});
+
+	it("ref + role match returns element normally", async () => {
+		await router.navigate("https://example.com", { taskId: "test-5d" });
+
+		const result = await router.browserInspect("test-5d", {
+			ref: "@e6",
+			role: "dialog",
+		});
+		expect(result.success).toBe(true);
+		expect(result.content).toContain("@e6");
+		expect(result.content).toContain("Sign Up");
+		expect(result.content).not.toContain("found in cache");
+	});
+
 	it("empty element cache returns 'no elements cached' message", async () => {
 		const emptyMock = new MockPlugin("empty");
 		emptyMock.elementCache = new Map();
@@ -828,7 +936,75 @@ describe("router.browserInspect()", () => {
 
 		const result = await router.browserInspect("test-10", { text: true });
 		expect(result.success).toBe(false);
-		expect(result.error).toContain("returned no content");
+		expect(result.error).toContain(
+			"Text extraction failed: browser disconnected",
+		);
+		expect(result.error).toContain("browser-inspect with role=");
+		expect(result.error).not.toContain("browser-snapshot to inspect visually");
+		expect(result.error).toMatch(/\(8 elements\) is available/);
+	});
+
+	describe("Changes 3 & 4 — silent-empty guards", () => {
+		it("correlateElements valid-but-empty result appends notice", () => {
+			const cache = new Map<string, AriaCachedNode>();
+			const result = correlateElements(
+				{
+					title: "",
+					headings: [],
+					paragraphs: [],
+					links: [],
+					images: [],
+					interactive: [],
+				},
+				cache,
+				true,
+			);
+			expect(result.text).toContain("No extractable content");
+			expect(result.text.length).toBeGreaterThan(0);
+			expect(result.matchedRefs).toBe(0);
+			expect(result.staleCache).toBe(false);
+		});
+
+		it("text=true + empty extractor + populated cache returns notice", async () => {
+			mock.evalResult = {
+				success: true,
+				result: JSON.stringify({
+					title: "",
+					headings: [],
+					paragraphs: [],
+					links: [],
+					images: [],
+					interactive: [],
+				}),
+			};
+			await router.navigate("https://example.com", { taskId: "test-11" });
+
+			const result = await router.browserInspect("test-11", { text: true });
+			expect(result.success).toBe(true);
+			expect(result.content).toContain("No extractable content");
+		});
+
+		it("text=true + query + empty extractor input appends no-match notice", async () => {
+			mock.evalResult = {
+				success: true,
+				result: JSON.stringify({
+					title: "",
+					headings: [],
+					paragraphs: [],
+					links: [],
+					images: [],
+					interactive: [],
+				}),
+			};
+			await router.navigate("https://example.com", { taskId: "test-12" });
+
+			const result = await router.browserInspect("test-12", {
+				text: true,
+				query: "anything",
+			});
+			expect(result.success).toBe(true);
+			expect(result.content).toContain('No content matched "anything"');
+		});
 	});
 });
 

package/node_modules/pi-lean-portal/__tests__/browser-toggle-profile.test.ts

@@ -24,8 +24,8 @@ vi.mock("node:fs", () => ({
 	unlinkSync: vi.fn(),
 }));
 
-import browserToggle from "../browser-toggle";
-import { listProfiles, formatProfileList } from "../browser-profile";
+import browserToggle from "../browser-toggle.js";
+import { listProfiles, formatProfileList } from "../browser-profile.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────
 
@@ -113,7 +113,7 @@ describe("listProfiles()", () => {
 		(statSync as Mock).mockReturnValue({ size: 100 });
 
 		const profiles = listProfiles();
-		expect(profiles.map((p) => p.name)).toEqual([
+		expect(profiles.map((p: { name: string }) => p.name)).toEqual([
 			"default",
 			"shopping",
 			"work",

package/node_modules/pi-lean-portal/__tests__/browser-toggle.test.ts

@@ -3,7 +3,7 @@
  * /web on | off | status commands for toggling browser automation tools.
  *
  * Tests cover:
- * - Filtering logic (getRegisteredBrowserTools)
+ * - Filtering logic (getRegisteredIn)
  * - State queries (isBrowserEnabled)
  * - State mutations (applyBrowserState, persistState)
  * - Branch-aware restoration (restoreFromBranch)
@@ -19,7 +19,7 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import browserToggle, { getToggleState } from "../browser-toggle.js";
 import {
-	getRegisteredBrowserTools,
+	getRegisteredIn,
 	isBrowserEnabled,
 	applyBrowserState,
 	persistState,
@@ -27,12 +27,10 @@ import {
 	_resetToggleStateForTest,
 	readBrowserToggleConfig,
 	applyConfigDefault,
-	getRegisteredLearnTools,
-	getRegisteredSiblingTools,
 	isLearnEnabled,
 	applyLearnState,
 	type BrowserToggleState,
-} from "./helpers/toggle-test-utils.js";
+} from "../browser-toggle.js";
 
 // Mock node:fs so readBrowserToggleConfig and applyConfigDefault can be
 // tested without touching the real filesystem.
@@ -119,38 +117,52 @@ function mockContext(
 }
 
 // ==================================================================
-//  getRegisteredBrowserTools
+//  getRegisteredIn
 // ==================================================================
-describe("getRegisteredBrowserTools", () => {
+describe("getRegisteredIn", () => {
+	const BROWSER_NAMES = new Set([
+		"web-fetch",
+		"browser-navigate",
+		"browser-snapshot",
+		"browser-click",
+		"browser-type",
+		"browser-scroll",
+		"browser-back",
+		"browser-press",
+		"browser-console",
+		"browser-inspect",
+		"web-guide",
+	]);
+
 	it("returns empty array when no tools are registered", () => {
 		const pi = mockPi({ tools: [] });
-		expect(getRegisteredBrowserTools(pi)).toEqual([]);
+		expect(getRegisteredIn(pi, BROWSER_NAMES)).toEqual([]);
 	});
 
-	it("returns empty array when only non-browser tools are registered", () => {
+	it("returns empty array when only non-matching tools are registered", () => {
 		const pi = mockPi({ tools: NON_BROWSER_TOOLS });
-		expect(getRegisteredBrowserTools(pi)).toEqual([]);
+		expect(getRegisteredIn(pi, BROWSER_NAMES)).toEqual([]);
 	});
 
-	it("returns only browser tools when mixed with other tools", () => {
+	it("returns only matching tools when mixed with non-matching tools", () => {
 		const pi = mockPi({
 			tools: [...ALL_BROWSER_TOOLS, ...NON_BROWSER_TOOLS],
 		});
-		expect(getRegisteredBrowserTools(pi)).toEqual(
+		expect(getRegisteredIn(pi, BROWSER_NAMES)).toEqual(
 			ALL_BROWSER_TOOLS.map((t) => t.name),
 		);
 	});
 
-	it("returns all browser tools when fully loaded", () => {
+	it("returns all matching tools when all are present", () => {
 		const pi = mockPi({ tools: ALL_BROWSER_TOOLS });
-		expect(getRegisteredBrowserTools(pi)).toEqual(
+		expect(getRegisteredIn(pi, BROWSER_NAMES)).toEqual(
 			ALL_BROWSER_TOOLS.map((t) => t.name),
 		);
 	});
 
-	it("returns a subset when only some browser tools are registered", () => {
+	it("returns a subset when only some matching tools are registered", () => {
 		const pi = mockPi({ tools: SOME_BROWSER_TOOLS });
-		expect(getRegisteredBrowserTools(pi)).toEqual(
+		expect(getRegisteredIn(pi, BROWSER_NAMES)).toEqual(
 			SOME_BROWSER_TOOLS.map((t) => t.name),
 		);
 	});
@@ -164,7 +176,7 @@ describe("getRegisteredBrowserTools", () => {
 			],
 		});
 		// Only the exact-lowercase match should be returned
-		expect(getRegisteredBrowserTools(pi)).toEqual(["web-fetch"]);
+		expect(getRegisteredIn(pi, BROWSER_NAMES)).toEqual(["web-fetch"]);
 	});
 
 	it("ignores tool metadata beyond the name field", () => {
@@ -173,7 +185,7 @@ describe("getRegisteredBrowserTools", () => {
 			{ name: "browser-scroll", description: "b", promptGuidelines: [] },
 		];
 		const pi = mockPi({ tools: tools as any });
-		expect(getRegisteredBrowserTools(pi)).toEqual([
+		expect(getRegisteredIn(pi, BROWSER_NAMES)).toEqual([
 			"web-fetch",
 			"browser-scroll",
 		]);
@@ -208,12 +220,12 @@ describe("isBrowserEnabled", () => {
 		expect(isBrowserEnabled(pi)).toBe(true);
 	});
 
-	it("returns true when no browser tools exist (vacuously enabled)", () => {
+	it("returns false when no browser tools exist", () => {
 		const pi = mockPi({
 			tools: NON_BROWSER_TOOLS,
 			activeTools: NON_BROWSER_TOOLS.map((t) => t.name),
 		});
-		expect(isBrowserEnabled(pi)).toBe(true);
+		expect(isBrowserEnabled(pi)).toBe(false);
 	});
 
 	it("returns false when active set is empty and browser tools exist", () => {
@@ -825,12 +837,14 @@ describe("command handler dispatch (via factory closure)", () => {
 });
 
 // ==================================================================
-//  getRegisteredLearnTools / isLearnEnabled / applyLearnState
+//  getRegisteredIn (learn) / isLearnEnabled / applyLearnState
 // ==================================================================
-describe("getRegisteredLearnTools", () => {
+describe("getRegisteredIn with learn tool names", () => {
+	const LEARN_NAMES = new Set(["web-learn"]);
+
 	it("returns empty array when no learn tools registered", () => {
 		const pi = mockPi({ tools: ALL_BROWSER_TOOLS });
-		expect(getRegisteredLearnTools(pi)).toEqual([]);
+		expect(getRegisteredIn(pi, LEARN_NAMES)).toEqual([]);
 	});
 
 	it("returns web-learn when it's in the tool list", () => {
@@ -839,7 +853,7 @@ describe("getRegisteredLearnTools", () => {
 			{ name: "web-learn", description: "learn" },
 		];
 		const pi = mockPi({ tools });
-		expect(getRegisteredLearnTools(pi)).toEqual(["web-learn"]);
+		expect(getRegisteredIn(pi, LEARN_NAMES)).toEqual(["web-learn"]);
 	});
 
 	it("is case-sensitive (tool names are always lowercase)", () => {
@@ -849,7 +863,7 @@ describe("getRegisteredLearnTools", () => {
 			{ name: "web-learn" },
 		];
 		const pi = mockPi({ tools });
-		expect(getRegisteredLearnTools(pi)).toEqual(["web-learn"]);
+		expect(getRegisteredIn(pi, LEARN_NAMES)).toEqual(["web-learn"]);
 	});
 });
 
@@ -878,9 +892,9 @@ describe("isLearnEnabled", () => {
 		expect(isLearnEnabled(pi)).toBe(false);
 	});
 
-	it("returns true when no learn tools exist (vacuously enabled)", () => {
+	it("returns false when no learn tools exist", () => {
 		const pi = mockPi({ tools: ALL_BROWSER_TOOLS });
-		expect(isLearnEnabled(pi)).toBe(true);
+		expect(isLearnEnabled(pi)).toBe(false);
 	});
 });
 
@@ -924,28 +938,28 @@ describe("applyLearnState", () => {
 });
 
 // ==================================================================
-//  getRegisteredSiblingTools
+//  getRegisteredIn (sibling)
 // ==================================================================
-describe("getRegisteredSiblingTools", () => {
-	it("returns web-search when it's in the tool list (Sprint 4)", () => {
+describe("getRegisteredIn with sibling tool names", () => {
+	const SIBLING_NAMES = new Set(["web-search"]);
+
+	it("returns web-search when it's in the tool list", () => {
 		const tools = [
 			...ALL_BROWSER_TOOLS,
 			{ name: "web-search", description: "SearXNG search" },
 		];
 		const pi = mockPi({ tools });
-		expect(getRegisteredSiblingTools(pi)).toEqual(["web-search"]);
+		expect(getRegisteredIn(pi, SIBLING_NAMES)).toEqual(["web-search"]);
 	});
 
 	it("uses exact-name Set.has() membership — no regex false positives", () => {
-		// A tool named "web-search-news" should NOT match the "web-search" entry,
-		// confirming exact-name membership rather than a prefix regex.
 		const tools = [
 			...ALL_BROWSER_TOOLS,
 			{ name: "web-search-news", description: "news" },
 			{ name: "web-search-images", description: "images" },
 		];
 		const pi = mockPi({ tools });
-		expect(getRegisteredSiblingTools(pi)).toEqual([]);
+		expect(getRegisteredIn(pi, SIBLING_NAMES)).toEqual([]);
 	});
 
 	it("is case-sensitive — only exact lower-case matches", () => {
@@ -955,7 +969,7 @@ describe("getRegisteredSiblingTools", () => {
 			{ name: "web-search" },
 		];
 		const pi = mockPi({ tools });
-		expect(getRegisteredSiblingTools(pi)).toEqual(["web-search"]);
+		expect(getRegisteredIn(pi, SIBLING_NAMES)).toEqual(["web-search"]);
 	});
 });