pi-browser-harness 0.10.2 → 0.12.0

package/src/domains/screenshot-capture.ts

@@ -0,0 +1,80 @@
+import { rename, writeFile } from "node:fs/promises";
+import type { BrowserClient } from "../client";
+import { type Result, ok } from "../util/result";
+import type { ToolErr } from "../util/tool";
+import { screenshotPath } from "../util/paths";
+import { loadSharp } from "../util/sharp-shim";
+import { safeJs } from "../util/js-template";
+import { cdpCall, evalJs } from "./cdp-call";
+
+export type CaptureArgs = {
+  readonly fullPage?: boolean;
+  readonly format?: "png" | "jpeg";
+  readonly quality?: number;
+};
+
+export const captureBase = async (
+  client: BrowserClient,
+  args: CaptureArgs,
+): Promise<Result<{ readonly path: string; readonly format: "png" | "jpeg" }, ToolErr>> => {
+  const format = args.format ?? "png";
+  const quality = args.quality ?? 80;
+  const path = screenshotPath(client.namespace, format);
+  const r = await cdpCall(client, "Page.captureScreenshot", {
+    format,
+    captureBeyondViewport: args.fullPage ?? false,
+    ...(format === "jpeg" ? { quality } : {}),
+  });
+  if (!r.success) return r;
+  await writeFile(path, Buffer.from(r.data.data, "base64"));
+  return ok({ path, format });
+};
+
+export const resizeIfNeeded = async (
+  path: string,
+  maxDim: number,
+): Promise<{ readonly note: string }> => {
+  const load = await loadSharp();
+  if (load.kind === "missing") return { note: " (maxDim ignored: install sharp for auto-resize)" };
+  if (load.kind === "error") return { note: ` (maxDim ignored: sharp failed to load: ${load.message})` };
+  try {
+    const meta = await load.sharp(path).metadata();
+    const w = meta.width ?? 0;
+    const h = meta.height ?? 0;
+    if (Math.max(w, h) <= maxDim) return { note: "" };
+    const tmp = `${path}.resized`;
+    await load.sharp(path).resize(maxDim, maxDim, { fit: "inside" }).toFile(tmp);
+    await rename(tmp, path);
+    return { note: ` (resized to fit ${maxDim}px)` };
+  } catch (e) {
+    return { note: ` (maxDim ignored: sharp threw: ${e instanceof Error ? e.message : String(e)})` };
+  }
+};
+
+export const captureWithCrosshair = async (
+  client: BrowserClient,
+  args: { readonly x: number; readonly y: number; readonly format?: "png" | "jpeg"; readonly quality?: number },
+): Promise<Result<{ readonly path: string }, ToolErr>> => {
+  const cap = await captureBase(client, args);
+  if (!cap.success) return cap;
+  const load = await loadSharp();
+  if (load.kind !== "ok") return ok({ path: cap.data.path });
+  try {
+    const dprR = await evalJs(client, safeJs`window.devicePixelRatio`);
+    const dpr = dprR.success && typeof dprR.data === "number" ? dprR.data : 1;
+    const meta = await load.sharp(cap.data.path).metadata();
+    const w = meta.width ?? 0;
+    const h = meta.height ?? 0;
+    const px = Math.round(args.x * dpr);
+    const py = Math.round(args.y * dpr);
+    const r = Math.round(15 * dpr);
+    const stroke = Math.max(2, Math.round(3 * dpr));
+    const svg = `<svg width="${w}" height="${h}"><circle cx="${px}" cy="${py}" r="${r}" fill="none" stroke="red" stroke-width="${stroke}" opacity="0.8"/><line x1="${px - r - 5}" y1="${py}" x2="${px + r + 5}" y2="${py}" stroke="red" stroke-width="${Math.max(1, stroke - 1)}" opacity="0.8"/><line x1="${px}" y1="${py - r - 5}" x2="${px}" y2="${py + r + 5}" stroke="red" stroke-width="${Math.max(1, stroke - 1)}" opacity="0.8"/></svg>`;
+    const tmp = `${cap.data.path}.debug`;
+    await load.sharp(cap.data.path).composite([{ input: Buffer.from(svg), top: 0, left: 0 }]).toFile(tmp);
+    await rename(tmp, cap.data.path);
+    return ok({ path: cap.data.path });
+  } catch {
+    return ok({ path: cap.data.path });
+  }
+};

package/src/domains/screenshot.ts

@@ -1,13 +1,10 @@
 import { readFileSync } from "node:fs";
-import { writeFile, rename } from "node:fs/promises";
 import { Type } from "typebox";
 import { Image, type ImageTheme, Text, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
-import type { BrowserClient } from "../client";
-import { type Result, err, ok } from "../util/result";
+import { type Result, ok } from "../util/result";
 import { defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
-import { screenshotPath } from "../util/paths";
-import { loadSharp } from "../util/sharp-shim";
-import { safeJs } from "../util/js-template";
+import { asRecord, asString } from "../util/guards";
+import { captureBase, resizeIfNeeded } from "./screenshot-capture";
 
 const ScreenshotArgs = Type.Object({
   fullPage: Type.Optional(Type.Boolean({ default: false, description: "Capture beyond viewport" })),
@@ -16,50 +13,6 @@ const ScreenshotArgs = Type.Object({
   maxDim: Type.Optional(Type.Integer({ minimum: 100, maximum: 8000, description: "If max(w,h) exceeds this, resize via sharp." })),
 });
 
-type CaptureArgs = {
-  readonly fullPage?: boolean;
-  readonly format?: "png" | "jpeg";
-  readonly quality?: number;
-};
-
-const captureBase = async (
-  client: BrowserClient,
-  args: CaptureArgs,
-): Promise<Result<{ readonly path: string; readonly format: "png" | "jpeg" }, ToolErr>> => {
-  const format = args.format ?? "png";
-  const quality = args.quality ?? 80;
-  const path = screenshotPath(client.namespace, format);
-  const params: Record<string, unknown> = { format, captureBeyondViewport: args.fullPage ?? false };
-  if (format === "jpeg") params["quality"] = quality;
-  const r = await client.session().call("Page.captureScreenshot", params);
-  if (!r.success) return err({ kind: "cdp_error", message: r.error.message });
-  // Page.captureScreenshot returns { data: base64 }
-  const data = (r.data as { data: string }).data;
-  await writeFile(path, Buffer.from(data, "base64"));
-  return ok({ path, format });
-};
-
-const resizeIfNeeded = async (
-  path: string,
-  maxDim: number,
-): Promise<{ readonly note: string }> => {
-  const load = await loadSharp();
-  if (load.kind === "missing") return { note: " (maxDim ignored: install sharp for auto-resize)" };
-  if (load.kind === "error") return { note: ` (maxDim ignored: sharp failed to load: ${load.message})` };
-  try {
-    const meta = await load.sharp(path).metadata();
-    const w = meta.width ?? 0;
-    const h = meta.height ?? 0;
-    if (Math.max(w, h) <= maxDim) return { note: "" };
-    const tmp = `${path}.resized`;
-    await load.sharp(path).resize(maxDim, maxDim, { fit: "inside" }).toFile(tmp);
-    await rename(tmp, path);
-    return { note: ` (resized to fit ${maxDim}px)` };
-  } catch (e) {
-    return { note: ` (maxDim ignored: sharp threw: ${e instanceof Error ? e.message : String(e)})` };
-  }
-};
-
 export const screenshotTool = defineBrowserTool({
   name: "browser_screenshot",
   label: "Browser Screenshot",
@@ -67,13 +20,10 @@ export const screenshotTool = defineBrowserTool({
     "Capture the page as a JPEG/PNG image. NOT a default exploration tool. Use ONLY when (a) you need to verify visual properties (layout, color, spacing, rendered text legibility), or (b) browser_snapshot and browser_execute_js cannot answer your question. For understanding what's on the page use browser_snapshot. For specific element values use browser_execute_js. For click coordinates use the @(x,y) hints in browser_snapshot's outline.",
   promptSnippet: "Capture a screenshot — visual verification only",
   promptGuidelines: [
-    "DO NOT use as a default exploration tool. browser_snapshot is the default for understanding page structure — far cheaper and more reliable.",
-    "DO NOT use to find click coordinates. browser_snapshot already includes @(x,y) for every interactive element. If a target isn't there, use browser_execute_js with element.getBoundingClientRect().",
-    "DO use to verify visual rendering after an action: did the modal animate in correctly, did the chart render, are colors right, did the layout reflow as expected.",
-    "DO use as a debugging fallback when browser_execute_js or browser_snapshot return surprising results and you suspect the rendered page differs from the DOM.",
     "format='jpeg' with quality 60-90 keeps screenshots small for photo-heavy pages. Use maxDim if the page is huge.",
   ],
   parameters: ScreenshotArgs,
+  concurrency: "parallel",
   async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
     const cap = await captureBase(client, args);
     if (!cap.success) return cap;
@@ -89,15 +39,16 @@ export const screenshotTool = defineBrowserTool({
   },
 
   renderResult(result, _expanded, theme) {
-    const details = result.details as { path?: string; format?: string } | undefined;
-    const filePath = details?.path;
+    const raw = asRecord(result.details);
+    const filePath = raw === undefined ? undefined : asString(raw["path"]);
     if (!filePath) {
       return new Text(theme.fg("error", "Screenshot path missing"), 0, 0);
     }
+    const format = raw === undefined ? undefined : asString(raw["format"]);
     try {
       const buf = readFileSync(filePath);
       const b64 = buf.toString("base64");
-      const mimeType = details?.format === "jpeg" ? "image/jpeg" : "image/png";
+      const mimeType = format === "jpeg" ? "image/jpeg" : "image/png";
       const imageTheme: ImageTheme = {
         fallbackColor: (str: string) => theme.fg("dim", str),
       };
@@ -106,10 +57,7 @@ export const screenshotTool = defineBrowserTool({
         maxHeightCells: 24,
         filename: filePath,
       });
-      // Image's text fallback (when terminal lacks inline-image support) does
-      // not respect the rendered width, so a long file path can blow past the
-      // terminal width and crash the host TUI. Wrap the component to truncate
-      // each rendered line to fit.
+      // Image's text fallback does not respect the rendered width, so an unwrapped long path can blow past the terminal width and crash the host TUI.
       return {
         invalidate: () => image.invalidate(),
         render: (width: number) =>
@@ -122,32 +70,3 @@ export const screenshotTool = defineBrowserTool({
     }
   },
 });
-
-export const captureWithCrosshair = async (
-  client: BrowserClient,
-  args: { readonly x: number; readonly y: number; readonly format?: "png" | "jpeg"; readonly quality?: number },
-): Promise<Result<{ readonly path: string }, ToolErr>> => {
-  const cap = await captureBase(client, args);
-  if (!cap.success) return cap;
-  const load = await loadSharp();
-  if (load.kind !== "ok") return ok({ path: cap.data.path });
-  try {
-    const dprR = await client.evaluateJs(safeJs`window.devicePixelRatio`);
-    const dpr = dprR.success && typeof dprR.data === "number" ? dprR.data : 1;
-    const meta = await load.sharp(cap.data.path).metadata();
-    const w = meta.width ?? 0;
-    const h = meta.height ?? 0;
-    const px = Math.round(args.x * dpr);
-    const py = Math.round(args.y * dpr);
-    const r = Math.round(15 * dpr);
-    const stroke = Math.max(2, Math.round(3 * dpr));
-    const svg = `<svg width="${w}" height="${h}"><circle cx="${px}" cy="${py}" r="${r}" fill="none" stroke="red" stroke-width="${stroke}" opacity="0.8"/><line x1="${px - r - 5}" y1="${py}" x2="${px + r + 5}" y2="${py}" stroke="red" stroke-width="${Math.max(1, stroke - 1)}" opacity="0.8"/><line x1="${px}" y1="${py - r - 5}" x2="${px}" y2="${py + r + 5}" stroke="red" stroke-width="${Math.max(1, stroke - 1)}" opacity="0.8"/></svg>`;
-    const tmp = `${cap.data.path}.debug`;
-    await load.sharp(cap.data.path).composite([{ input: Buffer.from(svg), top: 0, left: 0 }]).toFile(tmp);
-    await rename(tmp, cap.data.path);
-    return ok({ path: cap.data.path });
-  } catch {
-    // Crosshair overlay is best-effort; on failure return the plain screenshot.
-    return ok({ path: cap.data.path });
-  }
-};

package/src/domains/scroll.ts

@@ -1,6 +1,7 @@
 import { Type } from "typebox";
 import { type Result, err, ok } from "../util/result";
 import { defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
+import { cdpCall } from "./cdp-call";
 
 const ScrollArgs = Type.Object({
   x: Type.Optional(Type.Number({ description: "X coordinate where to scroll. Default: viewport center" })),
@@ -19,10 +20,10 @@ export const scrollTool = defineBrowserTool({
     "Scroll the page at given coordinates. deltaY follows W3C wheel-event convention: positive = scroll down, negative = scroll up. Default scrolls down (deltaY = 300).",
   promptSnippet: "Scroll the page (deltaY positive=down, negative=up)",
   promptGuidelines: [
-    "Default behavior scrolls down 300px (deltaY=300). Pass a negative deltaY to scroll up.",
     "Pass x/y to target a specific scrollable region (e.g., a div with overflow); otherwise scrolls the page at viewport center.",
   ],
   parameters: ScrollArgs,
+  concurrency: "serialized",
   async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
     const info = await client.pageInfo();
     if (!info.success) return err({ kind: "cdp_error", message: info.error.message });
@@ -36,22 +37,19 @@ export const scrollTool = defineBrowserTool({
     const cy = args.y ?? Math.round(info.data.height / 2);
     const dx = args.deltaX ?? 0;
     const dy = args.deltaY ?? 300;
-    // The page target must be focused or Input events are dropped silently
-    // (mouseWheel hangs; synthesizeScrollGesture returns ok but no scroll).
-    // Page.bringToFront makes the target the active one in the browser.
-    const front = await client.session().call("Page.bringToFront", {});
-    if (!front.success) return err({ kind: "cdp_error", message: front.error.message });
-    // Establish compositor mouse position before mouseWheel; without this,
-    // CDP sometimes drops the wheel event with a timeout.
-    const moved = await client.session().call("Input.dispatchMouseEvent", {
+    // The page target must be focused or Input events are dropped silently: mouseWheel hangs and synthesizeScrollGesture returns ok without scrolling.
+    const front = await cdpCall(client, "Page.bringToFront", {});
+    if (!front.success) return front;
+    // Establish compositor mouse position first, or CDP sometimes drops the wheel event with a timeout.
+    const moved = await cdpCall(client, "Input.dispatchMouseEvent", {
       type: "mouseMoved", x: cx, y: cy, button: "none", buttons: 0,
     });
-    if (!moved.success) return err({ kind: "cdp_error", message: moved.error.message });
-    const wheel = await client.session().call("Input.dispatchMouseEvent", {
+    if (!moved.success) return moved;
+    const wheel = await cdpCall(client, "Input.dispatchMouseEvent", {
       type: "mouseWheel", x: cx, y: cy, deltaX: dx, deltaY: dy,
       button: "none", buttons: 0, pointerType: "mouse",
     });
-    if (!wheel.success) return err({ kind: "cdp_error", message: wheel.error.message });
+    if (!wheel.success) return wheel;
     return ok({
       text: `Scrolled at (${cx}, ${cy}) by (${dx}, ${dy})`,
       details: { x: cx, y: cy, deltaX: dx, deltaY: dy },

package/src/domains/search/google-serp.ts

@@ -1,27 +1,14 @@
-/**
- * Pure Google SERP parsing — no CDP, no browser. Everything here is a pure
- * function over data captured from the page, so it is unit-testable against
- * saved fixtures (see test/deep-research/serp-parser-test.ts).
- *
- * ADR-0001: results are extracted by structure/semantics (anchors carrying an
- * <h3> heading in the main results column), never by brittle Google CSS class
- * names, and Google redirect wrappers are unwound to the real target URL.
- */
-
-/** One raw anchor captured in-page: a link with a heading and nearby snippet. */
 export type SerpAnchor = {
   readonly href: string;
   readonly heading: string;
   readonly snippet: string;
 };
 
-/** The JSON payload the in-page extraction expression returns. */
 export type SerpExtraction = {
   readonly anchors: ReadonlyArray<SerpAnchor>;
   readonly pageText: string;
 };
 
-/** A parsed, ranked search result — the tool's public output shape. */
 export type SearchResult = {
   readonly title: string;
   readonly url: string;
@@ -29,7 +16,6 @@ export type SearchResult = {
   readonly rank: number;
 };
 
-/** Why a SERP yielded no usable results, or that it did. */
 export type SerpVerdict = "ok" | "captcha" | "no_results";
 
 const CAPTCHA_MARKERS: ReadonlyArray<string> = [
@@ -42,10 +28,6 @@ const CAPTCHA_MARKERS: ReadonlyArray<string> = [
   "our systems have detected unusual traffic",
 ];
 
-/**
- * Decode a Google redirect wrapper (`/url?q=<real>&sa=...`) to its target.
- * Returns the input unchanged when it is not a wrapper.
- */
 const unwrapRedirect = (href: string): string => {
   const wrapper = href.match(/^(?:https?:\/\/[^/]*google\.[^/]*)?\/url\?/i);
   if (!wrapper) return href;
@@ -66,7 +48,6 @@ const isExternalResult = (url: string): boolean => {
   }
 };
 
-/** Normalized key for dedupe: origin + pathname, trailing slash and hash removed. */
 const dedupeKey = (url: string): string => {
   try {
     const u = new URL(url);
@@ -76,11 +57,6 @@ const dedupeKey = (url: string): string => {
   }
 };
 
-/**
- * Parse captured anchors into ranked results: unwrap redirects, keep only
- * external http(s) links, dedupe by normalized url (first wins), rank by input
- * order, cap to `limit`.
- */
 export const parseGoogleSerp = (anchors: ReadonlyArray<SerpAnchor>, limit: number): ReadonlyArray<SearchResult> => {
   const seen = new Set<string>();
   const results: SearchResult[] = [];
@@ -101,11 +77,6 @@ export const parseGoogleSerp = (anchors: ReadonlyArray<SerpAnchor>, limit: numbe
   return results;
 };
 
-/**
- * Decide whether the SERP is usable, blocked by a CAPTCHA, or genuinely empty.
- * `resultCount` is the number of parsed results; `pageText` is a bounded slice
- * of the page's visible text.
- */
 export const classifySerp = (pageText: string, resultCount: number): SerpVerdict => {
   if (resultCount > 0) return "ok";
   const lower = pageText.toLowerCase();

package/src/domains/search/web-search.ts

@@ -1,16 +1,18 @@
 import { Type } from "typebox";
+import { Compile } from "typebox/compile";
+import { parseJson } from "../../schemas/parse";
 import { type Result, err, ok } from "../../util/result";
 import { applyTruncation } from "../../util/truncate";
 import { defineBrowserTool, type ToolErr, type ToolOk } from "../../util/tool";
 import {
   closeIsolatedTab,
   evalInIsolatedTab,
+  isJsonText,
   navigateIsolatedTab,
   openIsolatedTab,
   waitForIsolatedLoad,
 } from "../isolated-tab";
 import { renderExpandableText } from "../render";
-import { buildSerpExtractionExpr } from "./extract";
 import { classifySerp, parseGoogleSerp, type SearchResult, type SerpExtraction } from "./google-serp";
 
 const LOAD_TIMEOUT_MS = 15_000;
@@ -22,14 +24,46 @@ const WebSearchArgs = Type.Object({
   ),
 });
 
+const PAGE_TEXT_LIMIT = 4000;
+
+const buildSerpExtractionExpr = (): string => `
+  (() => {
+    const main = document.querySelector('#search, #rso, #main') || document.body;
+    const headings = Array.from(main.querySelectorAll('a h3'));
+    const seen = new Set();
+    const anchors = [];
+    for (const h3 of headings) {
+      const a = h3.closest('a[href]');
+      if (!a) continue;
+      const href = a.href;
+      if (!href || seen.has(href)) continue;
+      seen.add(href);
+      const container =
+        a.closest('div.g') ||
+        a.closest('div[data-hveid]') ||
+        a.parentElement?.parentElement ||
+        a.parentElement;
+      const containerText = container ? container.innerText || '' : '';
+      const heading = h3.innerText || h3.textContent || '';
+      const snippet = containerText.replace(heading, '').replace(/\\s+/g, ' ').trim().slice(0, 500);
+      anchors.push({ href, heading, snippet });
+    }
+    const pageText = (document.body.innerText || '').slice(0, ${PAGE_TEXT_LIMIT});
+    return JSON.stringify({ anchors, pageText });
+  })()
+`;
+
 const buildSerpUrl = (query: string, limit: number): string =>
   `https://www.google.com/search?q=${encodeURIComponent(query)}&num=${limit}&hl=en`;
 
-const isSerpExtraction = (value: unknown): value is SerpExtraction => {
-  if (typeof value !== "object" || value === null) return false;
-  const v = value as Record<string, unknown>;
-  return Array.isArray(v["anchors"]) && typeof v["pageText"] === "string";
-};
+const SerpExtractionSchema = Type.Object({
+  anchors: Type.Array(
+    Type.Object({ href: Type.String(), heading: Type.String(), snippet: Type.String() }),
+  ),
+  pageText: Type.String(),
+});
+
+const serpExtractionValidator = Compile(SerpExtractionSchema);
 
 const formatResults = (query: string, results: ReadonlyArray<SearchResult>): string => {
   const lines = results.map((r) => `${r.rank}. ${r.title}\n   ${r.url}\n   ${r.snippet}`);
@@ -43,12 +77,12 @@ export const webSearchTool = defineBrowserTool({
     "Search the web and return ranked results (title, url, snippet, rank). Scrapes a Google results page in the real Chrome — no API key. Returns links only; use browser_read_page to read a result's content.",
   promptSnippet: "Search the web for a query",
   promptGuidelines: [
-    "Returns ranked {title, url, snippet, rank} — links only, no page content. Follow up with browser_read_page.",
     "On a CAPTCHA / bot wall the call fails with kind:'invalid_state' and details.reason:'captcha' (plus serpUrl) — surface it to the user; do not retry in a tight loop.",
     "On zero results it fails with details.reason:'no_results' — rephrase the query and try again.",
     "Runs in its own isolated tab and never disturbs the user's current tab.",
   ],
   parameters: WebSearchArgs,
+  concurrency: "serialized",
   async handler(args, { client, signal }): Promise<Result<ToolOk, ToolErr>> {
     const limit = args.limit ?? 10;
     const serpUrl = buildSerpUrl(args.query, limit);
@@ -64,16 +98,17 @@ export const webSearchTool = defineBrowserTool({
       const loaded = await waitForIsolatedLoad(client, tab, LOAD_TIMEOUT_MS, signal);
       if (!loaded.success) return err(loaded.error);
 
-      const extracted = await evalInIsolatedTab(client, tab, buildSerpExtractionExpr());
+      const extracted = await evalInIsolatedTab(client, tab, buildSerpExtractionExpr(), isJsonText);
       if (!extracted.success) return err(extracted.error);
 
-      const parsedJson = typeof extracted.data === "string" ? safeParse(extracted.data) : extracted.data;
-      if (!isSerpExtraction(parsedJson)) {
-        return err({ kind: "internal", message: "SERP extraction returned an unexpected shape" });
+      const parsedJson = parseJson(extracted.data, serpExtractionValidator);
+      if (!parsedJson.success) {
+        return err({ kind: "internal", message: `SERP extraction returned an unexpected shape: ${parsedJson.error}` });
       }
+      const extraction: SerpExtraction = parsedJson.data;
 
-      const results = parseGoogleSerp(parsedJson.anchors, limit);
-      const verdict = classifySerp(parsedJson.pageText, results.length);
+      const results = parseGoogleSerp(extraction.anchors, limit);
+      const verdict = classifySerp(extraction.pageText, results.length);
       if (verdict !== "ok") {
         return err({
           kind: "invalid_state",
@@ -106,11 +141,3 @@ export const webSearchTool = defineBrowserTool({
     return renderExpandableText("web_search", result, expanded, theme);
   },
 });
-
-const safeParse = (text: string): unknown => {
-  try {
-    return JSON.parse(text) as unknown;
-  } catch {
-    return undefined;
-  }
-};

package/src/domains/setup.ts

@@ -1,11 +1,3 @@
-/**
- * browser_setup tool — agent-callable browser initialization.
- *
- * The agent can call this directly when browser tools fail with
- * "not initialized" instead of asking the user. Idempotent: safe
- * to call even when already connected.
- */
-
 import { Type } from "typebox";
 import { Text } from "@mariozechner/pi-tui";
 import type { Result } from "../util/result";
@@ -23,17 +15,13 @@ export const setupTool = defineBrowserTool({
     "Call when browser tools fail with 'Browser harness not initialized'. Idempotent.",
   promptSnippet: "Initialize browser connection",
   promptGuidelines: [
-    "Call browser_setup when you get a 'Browser harness not initialized' error from any browser tool.",
-    "This tool is idempotent — calling it when already connected is harmless.",
     "After browser_setup succeeds, retry the browser tool that failed.",
   ],
   parameters: SetupArgs,
-  // ensureAlive:false — this tool IS the setup; it must bypass the socket guard
+  concurrency: "parallel",
   ensureAlive: false,
   renderCall: () => new Text("🔧 Initializing browser...", 0, 0),
   async handler(_args, { client, extensionCtx }): Promise<Result<ToolOk, ToolErr>> {
-    // extensionCtx carries the UI, so the agent calling browser_setup gets the
-    // same first-run profile picker the user gets from /browser-setup.
     const result = await performSetup(client, extensionCtx);
     if (result.success) {
       return ok({ text: result.data });