github-router 0.3.45 → 0.3.52

package/dist/main.js

@@ -8,7 +8,7 @@ import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypt
 import fs, { readFile, stat } from "node:fs/promises";
 import os, { homedir, platform } from "node:os";
 import * as path$1 from "node:path";
-import path from "node:path";
+import path, { dirname, join } from "node:path";
 import process$1 from "node:process";
 import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
 import { promisify } from "node:util";
@@ -17,13 +17,13 @@ import { createInterface } from "node:readline";
 import Parser from "web-tree-sitter";
 import WebSocket from "ws";
 import { fileURLToPath } from "node:url";
+import { events } from "fetch-event-stream";
 import { Type } from "typebox";
 import "partial-json";
 import { Compile } from "typebox/compile";
 import { Value } from "typebox/value";
 import "yaml";
 import "ignore";
-import { events } from "fetch-event-stream";
 import { z } from "zod";
 import { Writable } from "node:stream";
 import { serve } from "srvx";
@@ -62,14 +62,14 @@ function copilotVersion(state$1) {
 const API_VERSION = "2026-01-09";
 const copilotBaseUrl = (state$1) => state$1.copilotApiUrl ?? "https://api.githubcopilot.com";
 const copilotHeaders = (state$1, vision = false, integrationId = "vscode-chat") => {
-	const version$1 = copilotVersion(state$1);
+	const version$2 = copilotVersion(state$1);
 	const headers = {
 		Authorization: `Bearer ${state$1.copilotToken}`,
 		"content-type": standardHeaders()["content-type"],
 		"copilot-integration-id": integrationId,
 		"editor-version": `vscode/${state$1.vsCodeVersion}`,
-		"editor-plugin-version": `copilot-chat/${version$1}`,
-		"user-agent": `GitHubCopilotChat/${version$1}`,
+		"editor-plugin-version": `copilot-chat/${version$2}`,
+		"user-agent": `GitHubCopilotChat/${version$2}`,
 		"openai-intent": "conversation-panel",
 		"x-interaction-type": "conversation-panel",
 		"x-github-api-version": API_VERSION,
@@ -538,9 +538,9 @@ const cacheVSCodeVersion = async () => {
 	consola.info(`Using VSCode version: ${response}`);
 };
 const cacheCopilotVersion = async () => {
-	const version$1 = await getCopilotChatVersion();
-	state.copilotVersion = version$1;
-	consola.info(`Using Copilot Chat version: ${version$1}`);
+	const version$2 = await getCopilotChatVersion();
+	state.copilotVersion = version$2;
+	consola.info(`Using Copilot Chat version: ${version$2}`);
 };
 
 //#endregion
@@ -1117,10 +1117,10 @@ function getCodexVersion() {
 	};
 	const major = Number.parseInt(m[1], 10);
 	const minor = Number.parseInt(m[2], 10);
-	const version$1 = `${m[1]}.${m[2]}.${m[3]}`;
+	const version$2 = `${m[1]}.${m[2]}.${m[3]}`;
 	return {
 		ok: major > 0 || major === 0 && minor >= 129,
-		version: version$1
+		version: version$2
 	};
 }
 /**
@@ -2471,6 +2471,33 @@ function round4(x) {
 	return Math.round(x * 1e4) / 1e4;
 }
 
+//#endregion
+//#region src/lib/version.ts
+/**
+* Read this binary's published version from package.json at runtime.
+*
+* Done at runtime (not baked at build time) because release.yml builds
+* BEFORE `npm version patch` bumps the version — a build-time inline
+* would always ship the pre-bump value. The npm tarball ships package.json
+* alongside `dist/`, so a sibling-up lookup from import.meta.url resolves
+* cleanly in both dev (`src/lib/`) and bundled (`dist/`) layouts.
+*
+* Returns `"unknown"` if package.json can't be located or parsed —
+* never throws, so the CLI never fails to start over version reporting.
+*/
+function getPackageVersion() {
+	try {
+		const here = dirname(fileURLToPath(import.meta.url));
+		const candidates = [join(here, "..", "..", "package.json"), join(here, "..", "package.json")];
+		for (const path$2 of candidates) try {
+			const raw = readFileSync(path$2, "utf8");
+			const parsed = JSON.parse(raw);
+			if (typeof parsed.version === "string" && (parsed.name === "github-router" || parsed.name === "@animeshkundu/github-router")) return parsed.version;
+		} catch {}
+	} catch {}
+	return "unknown";
+}
+
 //#endregion
 //#region src/lib/browser-mcp/browser-detect.ts
 let cached;
@@ -2879,16 +2906,94 @@ function loadStableExtensionId() {
 	} catch {}
 	return "unknown";
 }
-function buildInstallRequired(reason, autoInstalled) {
+/**
+* Reads the `version` field from the on-disk extension manifest in
+* extensionDir(). Returns undefined if the file is missing, unreadable,
+* or doesn't have a string version. Used to detect when the loaded
+* extension is stale relative to a freshly-updated package.
+*/
+function loadExpectedExtensionVersion() {
+	try {
+		const raw = readFileSync(path.join(extensionDir(), "manifest.json"), "utf8");
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.version === "string" && parsed.version.length > 0) return parsed.version;
+	} catch {}
+}
+/**
+* Source-checkout dev sentinel — see scripts/copy-browser-ext.ts. When
+* extensionDir() resolves to src/browser-ext/ (dev iteration via
+* GH_ROUTER_BROWSER_EXT_DIR, or the dist fallback when the package
+* isn't built), the version is "0.0.0" and the auto-reload check is a
+* no-op: both sides agree, no mismatch, no reload triggered.
+*/
+const DEV_VERSION_SENTINEL = "0.0.0";
+/**
+* Track which `(extensionId, expectedVersion)` pairs we've already
+* tried to auto-reload in this process. Prevents an infinite reload
+* loop if the on-disk version somehow stays ahead of what the browser
+* picks up (e.g. Chrome disabled the extension after reload because
+* a new permission was added — the loaded version stays stale).
+*/
+const attemptedReloads = /* @__PURE__ */ new Set();
+/**
+* Send POST /reload to the bridge — triggers __reload__ control frame
+* over native messaging, which the extension's handler dispatches into
+* chrome.runtime.reload(). After this returns, the OLD bridge process
+* may still be running (its WS clients haven't dropped); the NEW
+* bridge spawned by Chrome on extension reconnect will overwrite the
+* discovery file.
+*/
+async function postReload(port, token, timeoutMs = 1e3) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return (await fetch(`http://127.0.0.1:${port}/reload`, {
+			method: "POST",
+			headers: { authorization: `Bearer ${token}` },
+			signal: controller.signal
+		})).ok;
+	} catch {
+		return false;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* After triggering a reload, poll the discovery file + /health until
+* we see the expected extension version (success) or run out of time
+* (caller falls back to install_required). Re-reads the discovery file
+* each cycle because the bridge process changes — old bridge exits
+* after its grace window, new bridge writes a new discovery file with
+* new port/token/pid.
+*/
+async function pollUntilExtensionVersion(expectedVersion, maxWaitMs, intervalMs) {
+	const deadline = Date.now() + maxWaitMs;
+	while (Date.now() < deadline) {
+		await new Promise((r) => setTimeout(r, intervalMs));
+		const disc = readBridgeDiscovery();
+		if (!disc) continue;
+		const health = await probeHealth(disc.port, disc.token, 500);
+		if (health && health.ok && health.extension_connected && health.extension_loaded_version === expectedVersion) return disc;
+	}
+}
+function buildInstallRequired(reason, autoInstalled, versionMismatch) {
+	const instructions = (() => {
+		if (reason === "no_supported_browser") return "No Chrome or Edge installation was detected on this host. Install one and restart the github-router proxy.";
+		if (reason === "bridge_bundle_missing") return "The bridge bundle is missing. Run `bun run build` from the github-router checkout to produce dist/browser-bridge/index.js, then retry.";
+		if (reason === "extension_outdated" && versionMismatch) return `Your loaded github-router browser extension is version ${versionMismatch.loaded} but the github-router package shipped version ${versionMismatch.expected}. Auto-reload was attempted and did not converge — Chrome likely disabled the extension because the new manifest declares new permissions. Open chrome://extensions (or edge://extensions), find the github-router extension card, click "Enable" if it's disabled, then click the reload arrow. Retry this tool call afterwards.`;
+		return "Open chrome://extensions (or edge://extensions), enable Developer Mode, click 'Load unpacked', and select the load_unpacked_dir above. Then retry this tool call. If you just updated the github-router package, an extension already loaded may need to be reloaded — click the reload arrow on its card.";
+	})();
 	return {
 		install_required: true,
 		reason,
 		auto_installed: autoInstalled,
+		proxy_version: getPackageVersion(),
 		manual_steps: {
 			load_unpacked_dir: extensionDir(),
 			expected_extension_id: loadStableExtensionId(),
-			instructions: reason === "no_supported_browser" ? "No Chrome or Edge installation was detected on this host. Install one and restart the github-router proxy." : reason === "bridge_bundle_missing" ? "The bridge bundle is missing. Run `bun run build` from the github-router checkout to produce dist/browser-bridge/index.js, then retry." : "Open chrome://extensions (or edge://extensions), enable Developer Mode, click 'Load unpacked', and select the load_unpacked_dir above. Then retry this tool call."
-		}
+			instructions
+		},
+		...versionMismatch ? { version_mismatch: versionMismatch } : {}
 	};
 }
 /**
@@ -2929,6 +3034,31 @@ async function _ensureBridgeReadyImpl() {
 	const health = await probeHealth(discovery.port, discovery.token);
 	if (!health || !health.ok) return buildInstallRequired("bridge_not_running", autoInstalled);
 	if (!health.extension_connected) return buildInstallRequired("extension_not_loaded", autoInstalled);
+	const expectedVersion = loadExpectedExtensionVersion();
+	const loadedVersion = health.extension_loaded_version;
+	if (typeof expectedVersion === "string" && typeof loadedVersion === "string" && expectedVersion !== DEV_VERSION_SENTINEL && loadedVersion !== DEV_VERSION_SENTINEL && expectedVersion !== loadedVersion) {
+		const reloadKey = `${loadStableExtensionId()}::${expectedVersion}`;
+		if (attemptedReloads.has(reloadKey)) return buildInstallRequired("extension_outdated", autoInstalled, {
+			loaded: loadedVersion,
+			expected: expectedVersion
+		});
+		attemptedReloads.add(reloadKey);
+		if (!await postReload(discovery.port, discovery.token)) return buildInstallRequired("extension_outdated", autoInstalled, {
+			loaded: loadedVersion,
+			expected: expectedVersion
+		});
+		const newDiscovery = await pollUntilExtensionVersion(expectedVersion, 3e3, 150);
+		if (!newDiscovery) return buildInstallRequired("extension_outdated", autoInstalled, {
+			loaded: loadedVersion,
+			expected: expectedVersion
+		});
+		return {
+			install_required: false,
+			port: newDiscovery.port,
+			token: newDiscovery.token,
+			pid: newDiscovery.pid
+		};
+	}
 	return {
 		install_required: false,
 		port: discovery.port,
@@ -3226,89 +3356,698 @@ function logAudit$1(record) {
 }
 
 //#endregion
-//#region src/lib/browser-mcp/index.ts
+//#region src/lib/mcp-inflight.ts
 /**
-* Browser-control MCP tools (`browser_*`). All entries route through
-* `dispatchBrowserTool()` which (1) runs the bridge-layer URL policy
-* check, (2) runs the install-check pre-flight (returning structured
-* install_required JSON when the bridge or extension isn't ready),
-* and (3) opens a WS to the bridge, sends the tool call, awaits the
-* response with a per-tool timeout.
+* Shared concurrency cap for MCP `tools/call` dispatches.
 *
-* Each entry carries `capability: "browser"` so `browserToolsEnabled()`
-* in `src/routes/mcp/handler.ts` drops them at both list-time and
-* call-time when the operator hasn't opted in via `--browse` or
-* `GH_ROUTER_ENABLE_BROWSE=1`.
+* Originally lived as a module-private counter inside
+* `src/routes/mcp/handler.ts`. Extracted because the worker-agent's
+* `peer_review` and `advisor` tools (which dispatch to peer-model
+* personas / the advisor responses endpoint from inside a worker
+* subagent loop) must participate in the same backpressure budget;
+* otherwise a single worker can fan out unboundedly to peers and
+* starve the operator's own `tools/list` callers.
 *
-* v1 surface: 19 tools (Phases 3 + 4a + 4b + humanlike input v2).
+* The counter is a single process-wide integer — no per-route
+* partitioning. Persona calls at the MCP boundary (handler.ts),
+* peer/advisor calls nested inside a worker (tools.ts), and any
+* future MCP-adjacent dispatcher all increment the same number.
+*
+* Cap = `MAX_INFLIGHT_TOOLS_CALL = 8`. Justification lives at the
+* historical home (`src/routes/mcp/handler.ts` comment block); do not
+* change the value without re-reading
+* `docs/research/peer-mcp-investigation.md` § "Concurrency cap
+* investigation".
 */
-const BROWSER_TOOLS = Object.freeze([
-	{
-		toolNameHttp: "browser_list_tabs",
-		description: "List all open tabs across all browser windows. Returns each tab's id (used by other browser_* tools), URL, title, active flag, and window id.",
-		inputSchema: {
-			type: "object",
-			additionalProperties: false,
-			properties: {}
-		},
-		capability: "browser",
-		async handler(args, signal) {
-			return dispatchBrowserTool("browser_list_tabs", args, signal);
+const MAX_INFLIGHT_TOOLS_CALL = 8;
+let inFlight$1 = 0;
+/**
+* Acquire a slot if one is available. Returns a release function the
+* caller MUST invoke exactly once (typically from a `finally` block);
+* returns `null` if the cap is saturated. The release fn is idempotent
+* — calling it twice is a no-op so callers can release defensively
+* without worrying about double-decrementing the counter under unusual
+* unwind paths.
+*
+* Synchronous on purpose. Async semaphore acquisition would let callers
+* queue indefinitely; we want immediate "queue full" feedback so the
+* MCP client (or the model holding the nested tool call) can choose to
+* back off or retry.
+*/
+function acquireInFlightSlot() {
+	if (inFlight$1 >= MAX_INFLIGHT_TOOLS_CALL) return null;
+	inFlight$1++;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		inFlight$1--;
+	};
+}
+
+//#endregion
+//#region src/lib/diagnose-response.ts
+const PREVIEW_LIMIT = 200;
+async function parseJsonOrDiagnose(response, routePath) {
+	const cloned = response.clone();
+	try {
+		return await response.json();
+	} catch (error) {
+		const contentType = response.headers.get("content-type") ?? "(none)";
+		const bodyText = await cloned.text().catch(() => "(unreadable)");
+		const preview = bodyText.length > PREVIEW_LIMIT ? bodyText.slice(0, PREVIEW_LIMIT) + "...(truncated)" : bodyText;
+		consola.error(`Upstream JSON parse failed at ${routePath}: status=${response.status} content-type="${contentType}" body[0..${PREVIEW_LIMIT}]=${JSON.stringify(preview)}`);
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/lib/response-cap.ts
+/**
+* Hard byte cap for non-streaming upstream response bodies.
+*
+* Anthropic responses with large tool_use blocks can legitimately reach
+* several MB, but a multi-GB body is either a buggy upstream or a malicious
+* one. Buffering it would OOM the proxy and crash all in-flight requests.
+*
+* Applies to /v1/messages, /v1/chat/completions, and /v1/responses.
+*/
+const MAX_RESPONSE_BODY_BYTES = 10 * 1024 * 1024;
+/**
+* Read a Response body with a hard byte cap, then parse as JSON.
+*
+* Falls back to the fast path (response.json()) when Content-Length is
+* present and within the cap, avoiding the streaming-reader overhead for
+* the vast majority of normal responses.
+*
+* When the cap is hit:
+*   - the reader is cancelled to release the upstream socket
+*   - a structured Anthropic-format error is returned to the caller
+*     (the caller wraps it in c.json(), not throws — the client gets a
+*     clean 413 error, not an unhandled-rejection crash)
+*
+* Returns `{ ok: true, value }` on success or `{ ok: false, errorResponse, status }`
+* on cap exceeded.
+*/
+async function readResponseBodyCapped(response, routePath, capBytes = MAX_RESPONSE_BODY_BYTES) {
+	const contentLengthHeader = response.headers.get("content-length");
+	const contentLength = contentLengthHeader ? parseInt(contentLengthHeader, 10) : NaN;
+	if (!isNaN(contentLength) && contentLength <= capBytes) return {
+		ok: true,
+		value: await parseJsonOrDiagnose(response, routePath)
+	};
+	const reader = response.body?.getReader();
+	if (!reader) return {
+		ok: true,
+		value: await parseJsonOrDiagnose(response, routePath)
+	};
+	const chunks = [];
+	let totalBytes = 0;
+	let capped = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (!value) continue;
+			totalBytes += value.byteLength;
+			if (totalBytes > capBytes) {
+				capped = true;
+				try {
+					await reader.cancel("size_cap");
+				} catch {}
+				break;
+			}
+			chunks.push(value);
 		}
-	},
-	{
-		toolNameHttp: "browser_open_tab",
-		description: "Open a URL in a new browser tab and wait for the page to finish loading. Returns the new tab's id, final URL after redirects, and HTTP status. Refuses to navigate to browser-internal settings / preferences / extensions / flags pages (returns {blocked: true, reason}); devtools://* is allowed.",
-		inputSchema: {
-			type: "object",
-			required: ["url"],
-			additionalProperties: false,
-			properties: {
-				url: {
-					type: "string",
-					description: "The URL to load. Maximum 8 KB. Settings / preferences / extensions / flags pages are blocked."
-				},
-				reuseActive: {
-					type: "boolean",
-					description: "When true, navigate the currently active tab instead of opening a new one. Default false."
+	} catch (err) {
+		if (!capped) consola.warn(`readResponseBodyCapped: read error at ${routePath}:`, err);
+	}
+	if (capped) {
+		consola.warn(`Non-streaming upstream response at ${routePath} exceeded ${capBytes} bytes (10 MiB cap); dropping body to prevent OOM. Check upstream health.`);
+		return {
+			ok: false,
+			status: 502,
+			errorResponse: {
+				type: "error",
+				error: {
+					type: "api_error",
+					message: `Upstream response body exceeded the 10 MiB size cap for non-streaming ${routePath}. The upstream may be misbehaving. Try enabling streaming (stream: true) which handles large responses chunk-by-chunk.`
 				}
 			}
-		},
-		capability: "browser",
-		async handler(args, signal) {
-			return dispatchBrowserTool("browser_open_tab", args, signal);
-		}
-	},
-	{
-		toolNameHttp: "browser_close_tab",
-		description: "Close one or more tabs by tab id.",
-		inputSchema: {
-			type: "object",
-			required: ["tabIds"],
-			additionalProperties: false,
-			properties: { tabIds: {
-				type: "array",
-				items: { type: "number" },
-				description: "Array of tab ids to close (from browser_list_tabs)."
-			} }
-		},
-		capability: "browser",
-		async handler(args, signal) {
-			return dispatchBrowserTool("browser_close_tab", args, signal);
-		}
-	},
-	{
-		toolNameHttp: "browser_navigate",
-		description: "Navigate an existing tab: goto a URL, go back, go forward, or reload. Same URL-blocking policy as browser_open_tab.",
-		inputSchema: {
-			type: "object",
-			required: ["tabId", "action"],
-			additionalProperties: false,
-			properties: {
-				tabId: {
-					type: "number",
-					description: "Tab id from browser_list_tabs / browser_open_tab."
-				},
+		};
+	}
+	const merged = new Uint8Array(totalBytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		merged.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	const text = new TextDecoder().decode(merged);
+	try {
+		return {
+			ok: true,
+			value: JSON.parse(text)
+		};
+	} catch (err) {
+		const preview = text.slice(0, 200);
+		const contentType = response.headers.get("content-type") ?? "(none)";
+		consola.error(`Upstream JSON parse failed at ${routePath}: status=${response.status} content-type="${contentType}" body[0..200]=${JSON.stringify(preview)}`);
+		throw err;
+	}
+}
+
+//#endregion
+//#region src/services/copilot/create-chat-completions.ts
+const createChatCompletions = async (payload, modelHeaders, callerSignal) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const enableVision = payload.messages.some((x) => typeof x.content !== "string" && x.content?.some((x$1) => x$1.type === "image_url"));
+	const isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
+	const url = `${copilotBaseUrl(state)}/chat/completions`;
+	const doFetch = () => {
+		const fetchInit = {
+			method: "POST",
+			headers: {
+				...copilotHeaders(state, enableVision),
+				...modelHeaders,
+				"X-Initiator": isAgentCall ? "agent" : "user"
+			},
+			body: JSON.stringify(payload)
+		};
+		const signals = [];
+		if (UPSTREAM_FETCH_TIMEOUT_MS > 0) signals.push(AbortSignal.timeout(UPSTREAM_FETCH_TIMEOUT_MS));
+		if (callerSignal) signals.push(callerSignal);
+		if (signals.length === 1) fetchInit.signal = signals[0];
+		else if (signals.length > 1) fetchInit.signal = AbortSignal.any(signals);
+		return fetch(url, fetchInit);
+	};
+	const response = await tryRefreshAndRetry(doFetch, "/chat/completions");
+	if (!response.ok) {
+		let errorBody = "";
+		try {
+			errorBody = await response.text();
+		} catch {
+			errorBody = "(could not read error body)";
+		}
+		const claudeModels = state.models?.data.filter((m) => m.id.startsWith("claude")).map((m) => m.id).join(", ") ?? "(models not loaded)";
+		consola.error(`Copilot rejected model "${payload.model}": ${response.status} ${errorBody} (available Claude models: ${claudeModels})`);
+		throw new HTTPError("Failed to create chat completions", new Response(errorBody, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		}));
+	}
+	if (payload.stream) return events(response);
+	const cappedResult = await readResponseBodyCapped(response, "/v1/chat/completions", MAX_RESPONSE_BODY_BYTES);
+	if (!cappedResult.ok) throw new HTTPError("Upstream /v1/chat/completions response exceeded 10 MiB size cap", new Response(JSON.stringify(cappedResult.errorResponse), {
+		status: cappedResult.status,
+		headers: { "content-type": "application/json" }
+	}));
+	return cappedResult.value;
+};
+
+//#endregion
+//#region src/lib/browser-mcp/compressor.ts
+/**
+* Static fallback chain. Order is preference: faster + multimodal +
+* cheaper at the top. All three support `tool_calls` and image input
+* (the latter is required for Phase D visual fallback).
+*/
+const COMPRESSOR_FALLBACK_CHAIN = [
+	"gemini-3.5-flash",
+	"gpt-5.4-mini",
+	"claude-haiku-4-5"
+];
+let selectedBackend;
+/**
+* Walk the fallback chain against the live Copilot catalog. Returns
+* the first id present AND advertising `tool_calls` support, or
+* undefined when none match. Cached after first successful selection
+* so all compressor calls in a session hit the same backend; clear
+* the cache by calling `__resetCompressorBackendForTests`.
+*/
+function pickBackendFromCatalog() {
+	if (selectedBackend) return selectedBackend;
+	const models$1 = state.models?.data;
+	if (!models$1) return void 0;
+	for (const candidate of COMPRESSOR_FALLBACK_CHAIN) {
+		const found = models$1.find((m) => m.id === candidate);
+		if (!found) continue;
+		if (found.capabilities?.supports?.tool_calls !== true) continue;
+		selectedBackend = candidate;
+		consola.info(`[browser-mcp] compressor backend: ${candidate}`);
+		return candidate;
+	}
+}
+/**
+* True iff any compressor backend is available. Mirrors
+* `workerToolsEnabled()` / `standInToolEnabled()` — used by the
+* compound-tool capability gate so `browser_find` / `browser_act
+* (intent mode)` / `browser_extract` are dropped from `tools/list`
+* AND fail `tools/call` with -32601 when no backend is reachable.
+*/
+function compressorAvailable() {
+	return pickBackendFromCatalog() !== void 0;
+}
+/**
+* One round-trip to the picked backend. Wraps slot acquisition, payload
+* assembly, and JSON parsing. Forces structured output via tool-calling:
+* each caller supplies a tool schema and we set `tool_choice` so the
+* model has to emit a tool call whose `arguments` field is a
+* shape-validated JSON string. This eliminates a whole class of bug
+* where models wrap their JSON in markdown code fences despite
+* `response_format: { type: "json_object" }`. As a belt-and-suspenders
+* fallback for backends that ignore `tool_choice`, we ALSO accept
+* free-form `message.content` and strip a leading / trailing ```` ``` ````
+* code fence before parsing.
+*/
+async function callCompressor(systemPrompt, userMessage, tool, signal) {
+	const model = pickBackendFromCatalog();
+	if (!model) throw new Error(`browser-mcp compressor: no backend available in catalog. Checked: ${COMPRESSOR_FALLBACK_CHAIN.join(", ")}`);
+	const release = acquireInFlightSlot();
+	if (!release) throw new Error("browser-mcp compressor: inflight slot saturated (cap 8); try again shortly");
+	try {
+		const msg = ((await createChatCompletions({
+			model,
+			stream: false,
+			messages: [{
+				role: "system",
+				content: systemPrompt
+			}, {
+				role: "user",
+				content: userMessage
+			}],
+			tools: [{
+				type: "function",
+				function: {
+					name: tool.name,
+					description: tool.description,
+					parameters: tool.parameters
+				}
+			}],
+			tool_choice: {
+				type: "function",
+				function: { name: tool.name }
+			}
+		}, void 0, signal)).choices?.[0])?.message;
+		const toolArgs = msg?.tool_calls?.[0]?.function?.arguments;
+		if (typeof toolArgs === "string" && toolArgs.length > 0) return JSON.parse(toolArgs);
+		const text = typeof msg?.content === "string" ? msg.content : "";
+		if (text.length === 0) throw new Error("browser-mcp compressor: empty response from backend (no tool_calls and no content)");
+		return JSON.parse(stripCodeFence(text));
+	} finally {
+		release();
+	}
+}
+/**
+* Strip a single leading / trailing ``` (or ```json) code fence from a
+* model's free-form text reply so JSON.parse works. Idempotent on
+* fence-free input. Defensive against the failure mode caught in PR #55
+* smoke-test: some models wrap JSON output in ```json ... ``` even
+* with response_format: { type: "json_object" } set.
+*/
+function stripCodeFence(text) {
+	const t = text.trim();
+	const fenced = /^```(?:json)?\s*\n?([\s\S]*?)\n?```$/.exec(t);
+	if (fenced) return fenced[1].trim();
+	return t;
+}
+/**
+* Pick a single element matching the natural-language intent. Used by
+* `browser_act` in intent mode. Internally delegates the matching step
+* to `pickMatchingElements` (the same picker `browser_find` uses) so
+* `find` and `act` can't disagree on the same intent, then infers the
+* action verb deterministically from the picked element's role and
+* whether the intent supplied a value. Single source of truth for
+* element matching.
+*
+* Returns ref="" + confidence=0 when no element matches — caller
+* should escalate to visual fallback (when `visualSurfaces` is
+* present) or surface the miss to the lead model.
+*/
+async function pickElement(snapshot, intent, signal, value) {
+	const matches = await pickMatchingElements(snapshot, intent, signal);
+	if (matches.length === 0) return {
+		ref: "",
+		action: "click",
+		confidence: 0
+	};
+	const top = matches[0];
+	const el = snapshot.elements.find((e) => e.ref === top.ref);
+	if (!el) return {
+		ref: "",
+		action: "click",
+		confidence: 0
+	};
+	const action = inferAction(el.role, intent, value);
+	const out = {
+		ref: top.ref,
+		action,
+		confidence: .8
+	};
+	if (value !== void 0 && (action === "fill" || action === "type" || action === "select")) out.value = value;
+	return out;
+}
+/**
+* Deterministic action picker. Given an element role + the intent text
+* + an optional value, decide which primitive action to dispatch.
+* Pulled out of the compressor's responsibility so the compressor only
+* has to match elements (one prompt, one schema), and action selection
+* is a few small rules a future contributor can read at a glance.
+*/
+function inferAction(role, intent, value) {
+	const intentLower = intent.toLowerCase();
+	const r = role.toLowerCase();
+	if (/\bscroll\b/.test(intentLower) || /scroll[ -]?into[ -]?view/.test(intentLower)) return "scroll_into_view";
+	if (r === "select" || r === "combobox") return "select";
+	if (r === "textarea" || r === "input" || r === "textbox" || r === "searchbox" || r === "spinbutton") {
+		if (/\btype\b/.test(intentLower) && value !== void 0) return "type";
+		return "fill";
+	}
+	return "click";
+}
+const FIND_ELEMENTS_SYSTEM = `You match a natural-language intent to elements from a browser page snapshot.
+
+Snapshot elements look like: {ref: "e42", role: "button", name: "Sign in"}.
+
+Call the find_elements tool with up to 5 best matches ordered by relevance.`;
+const FIND_ELEMENTS_TOOL = {
+	name: "find_elements",
+	description: "Report ranked element matches for the intent.",
+	parameters: {
+		type: "object",
+		required: ["matches"],
+		additionalProperties: false,
+		properties: { matches: {
+			type: "array",
+			maxItems: 5,
+			items: {
+				type: "object",
+				required: ["ref", "reason"],
+				additionalProperties: false,
+				properties: {
+					ref: { type: "string" },
+					reason: { type: "string" }
+				}
+			}
+		} }
+	}
+};
+/**
+* Return up to 5 candidate matches for an intent. Used by
+* `browser_find` — the lead model gets a small ranked list rather than
+* a full element dump. Empty array when nothing matches.
+*/
+async function pickMatchingElements(snapshot, intent, signal) {
+	const trimmed = snapshot.elements.map((e) => ({
+		ref: e.ref,
+		role: e.role,
+		name: e.name
+	}));
+	const raw = await callCompressor(FIND_ELEMENTS_SYSTEM, JSON.stringify({
+		intent,
+		elements: trimmed
+	}), FIND_ELEMENTS_TOOL, signal);
+	if (!raw || typeof raw !== "object") return [];
+	const matches = raw.matches;
+	if (!Array.isArray(matches)) return [];
+	const out = [];
+	for (const m of matches.slice(0, 5)) {
+		if (!m || typeof m !== "object") continue;
+		const ref = m.ref;
+		const reason = m.reason;
+		if (typeof ref === "string" && ref.length > 0) out.push({
+			ref,
+			reason: typeof reason === "string" ? reason : ""
+		});
+	}
+	return out;
+}
+const EXTRACT_SYSTEM = `You extract structured data from a browser page snapshot into a JSON object matching the result schema you've been given.
+
+Use the snapshot's text + element list as your source. Be faithful to what's visible; do not invent values.
+
+Call the extract_result tool with your answer in the result field. The result field's schema is the caller's exact requested shape — fill it completely. If a field cannot be determined from the snapshot, omit it (when optional) or use a sensible empty value (when required).`;
+/**
+* Lightweight sanity check on a caller-supplied JSON Schema: the
+* schema must be a non-null object AND declare at least one of a
+* recognized `type` value, `properties`, `items`, `$ref`, or a
+* compound combinator (`oneOf` / `anyOf` / `allOf`). This catches the
+* two failure modes the prior smoke test surfaced — empty `{}` and
+* structurally-malformed schemas like `{type: "nonsense"}` — both of
+* which the permissive upstream silently accepts and the model then
+* fills with a useless primitive.
+*
+* Returns an error message string when the schema fails the check,
+* or undefined when the schema looks plausible.
+*/
+function validateExtractSchema(schema) {
+	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return "schema must be a non-null JSON object";
+	const obj = schema;
+	const validTypes = new Set([
+		"object",
+		"array",
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"null"
+	]);
+	const hasValidType = typeof obj.type === "string" && validTypes.has(obj.type);
+	const hasShape = "properties" in obj || "items" in obj || "$ref" in obj || "oneOf" in obj || "anyOf" in obj || "allOf" in obj;
+	if (!hasValidType && !hasShape) return `schema must declare a recognized type (one of ${Array.from(validTypes).join(", ")}) OR have properties / items / $ref / oneOf / anyOf / allOf`;
+	if ("type" in obj && !hasValidType) return `schema 'type' field must be one of: ${Array.from(validTypes).join(", ")}`;
+}
+/**
+* Structured extraction. The caller's JSON schema is injected directly
+* into the extract_result tool's `result` parameter so the model's
+* tool-call mechanism enforces shape — the model can't satisfy the
+* call without producing data of the requested shape.
+*
+* Schema is pre-validated by `validateExtractSchema` — bad schemas
+* fail loud with a clear `SchemaValidationError` instead of slipping
+* through to the upstream (which is permissive enough to accept
+* garbage and let the model return a useless primitive).
+*
+* Post-validation: if the model's `result` ended up as a primitive
+* (string / number / boolean) when the schema declared object / array,
+* surface the shape mismatch — the model returned the wrong type and
+* the caller should know rather than receive a confusing value.
+*/
+var SchemaValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SchemaValidationError";
+	}
+};
+var ResultShapeError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ResultShapeError";
+	}
+};
+async function extractStructured(snapshot, schema, instruction, signal) {
+	const schemaError = validateExtractSchema(schema);
+	if (schemaError) throw new SchemaValidationError(schemaError);
+	const raw = await callCompressor(EXTRACT_SYSTEM, JSON.stringify({
+		instruction,
+		snapshot: {
+			text: snapshot.text,
+			elements: snapshot.elements
+		}
+	}), {
+		name: "extract_result",
+		description: "Report the extracted object. The result field's schema is the caller's requested shape; fill it completely.",
+		parameters: {
+			type: "object",
+			required: ["result"],
+			additionalProperties: false,
+			properties: { result: schema }
+		}
+	}, signal);
+	const unwrapped = raw && typeof raw === "object" && "result" in raw ? raw.result : raw;
+	const declaredType = schema.type;
+	if (declaredType === "object" && (typeof unwrapped !== "object" || unwrapped === null || Array.isArray(unwrapped))) throw new ResultShapeError(`schema declared type "object" but model returned ${describeType(unwrapped)}`);
+	if (declaredType === "array" && !Array.isArray(unwrapped)) throw new ResultShapeError(`schema declared type "array" but model returned ${describeType(unwrapped)}`);
+	return unwrapped;
+}
+function describeType(v) {
+	if (v === null) return "null";
+	if (Array.isArray(v)) return "array";
+	return typeof v;
+}
+const PICK_VISUAL_SYSTEM = `You're given a browser screenshot, a natural-language intent, and a list of canvas / svg regions in CSS-pixel coordinates.
+
+Find the pixel coordinates in the screenshot where the intent points. Coordinates are CSS pixels (origin top-left of viewport).
+
+Call the pick_visual tool with the coordinates. If no clear target is visible, call with x=0, y=0, confidence=0.`;
+const PICK_VISUAL_TOOL = {
+	name: "pick_visual",
+	description: "Report the pixel coordinates the intent points at.",
+	parameters: {
+		type: "object",
+		required: [
+			"x",
+			"y",
+			"confidence",
+			"reason"
+		],
+		additionalProperties: false,
+		properties: {
+			x: { type: "number" },
+			y: { type: "number" },
+			confidence: { type: "number" },
+			reason: { type: "string" }
+		}
+	}
+};
+/**
+* Visual fallback for Phase D — used when text-based `pickElement`
+* misses AND the snapshot reported `visualSurfaces` in the viewport
+* (a canvas / svg blackhole the a11y tree can't see into). Takes the
+* base64-encoded screenshot, the original intent, and the surfaces
+* list; returns CSS-pixel coordinates the caller dispatches to
+* `browser_mouse {x, y}`.
+*/
+async function pickElementVisual(screenshotB64, contentType, intent, visualSurfaces, signal) {
+	const raw = await callCompressor(PICK_VISUAL_SYSTEM, [{
+		type: "text",
+		text: JSON.stringify({
+			intent,
+			visual_surfaces: visualSurfaces
+		})
+	}, {
+		type: "image_url",
+		image_url: { url: `data:${contentType};base64,${screenshotB64}` }
+	}], PICK_VISUAL_TOOL, signal);
+	if (!raw || typeof raw !== "object") return {
+		x: 0,
+		y: 0,
+		confidence: 0,
+		reason: "empty backend response"
+	};
+	const obj = raw;
+	return {
+		x: typeof obj.x === "number" ? Math.round(obj.x) : 0,
+		y: typeof obj.y === "number" ? Math.round(obj.y) : 0,
+		confidence: typeof obj.confidence === "number" ? Math.max(0, Math.min(1, obj.confidence)) : 0,
+		reason: typeof obj.reason === "string" ? obj.reason : ""
+	};
+}
+
+//#endregion
+//#region src/lib/browser-mcp/index.ts
+/**
+* Helper for compound tools (`browser_find` / `browser_act` /
+* `browser_extract`): fetch the page snapshot via the existing
+* primitive dispatcher and unwrap the JSON text envelope. Compound
+* tools all start from a snapshot, so a single helper keeps the
+* unwrap logic in one place.
+*/
+async function fetchSnapshot(tabId, signal) {
+	const env = await dispatchBrowserTool("browser_read_page", {
+		tabId,
+		mode: "summary"
+	}, signal);
+	if (env.isError) throw new Error("browser_read_page returned an error envelope; bridge / extension not ready");
+	const text = env.content?.[0]?.text;
+	if (typeof text !== "string") throw new Error("browser_read_page returned no text content");
+	return JSON.parse(text);
+}
+function toolEnvelope(data, isError) {
+	const text = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+	return isError ? {
+		content: [{
+			type: "text",
+			text
+		}],
+		isError: true
+	} : { content: [{
+		type: "text",
+		text
+	}] };
+}
+/**
+* Browser-control MCP tools (`browser_*`). All entries route through
+* `dispatchBrowserTool()` which (1) runs the bridge-layer URL policy
+* check, (2) runs the install-check pre-flight (returning structured
+* install_required JSON when the bridge or extension isn't ready),
+* and (3) opens a WS to the bridge, sends the tool call, awaits the
+* response with a per-tool timeout.
+*
+* Each entry carries `capability: "browser"` so `browserToolsEnabled()`
+* in `src/routes/mcp/handler.ts` drops them at both list-time and
+* call-time when the operator hasn't opted in via `--browse` or
+* `GH_ROUTER_ENABLE_BROWSE=1`.
+*
+* v1 surface: 19 tools (Phases 3 + 4a + 4b + humanlike input v2).
+*/
+const BROWSER_TOOLS = Object.freeze([
+	{
+		toolNameHttp: "browser_list_tabs",
+		description: "List all open tabs across all browser windows. Returns each tab's id (used by other browser_* tools), URL, title, active flag, and window id.",
+		inputSchema: {
+			type: "object",
+			additionalProperties: false,
+			properties: {}
+		},
+		capability: "browser",
+		async handler(args, signal) {
+			return dispatchBrowserTool("browser_list_tabs", args, signal);
+		}
+	},
+	{
+		toolNameHttp: "browser_open_tab",
+		description: "Open a URL in a new browser tab and wait for the page to finish loading. Returns the new tab's id, final URL after redirects, and HTTP status. Refuses to navigate to browser-internal settings / preferences / extensions / flags pages (returns {blocked: true, reason}); devtools://* is allowed.",
+		inputSchema: {
+			type: "object",
+			required: ["url"],
+			additionalProperties: false,
+			properties: {
+				url: {
+					type: "string",
+					description: "The URL to load. Maximum 8 KB. Settings / preferences / extensions / flags pages are blocked."
+				},
+				reuseActive: {
+					type: "boolean",
+					description: "When true, navigate the currently active tab instead of opening a new one. Default false."
+				}
+			}
+		},
+		capability: "browser",
+		async handler(args, signal) {
+			return dispatchBrowserTool("browser_open_tab", args, signal);
+		}
+	},
+	{
+		toolNameHttp: "browser_close_tab",
+		description: "Close one or more tabs by tab id.",
+		inputSchema: {
+			type: "object",
+			required: ["tabIds"],
+			additionalProperties: false,
+			properties: { tabIds: {
+				type: "array",
+				items: { type: "number" },
+				description: "Array of tab ids to close (from browser_list_tabs)."
+			} }
+		},
+		capability: "browser",
+		async handler(args, signal) {
+			return dispatchBrowserTool("browser_close_tab", args, signal);
+		}
+	},
+	{
+		toolNameHttp: "browser_navigate",
+		description: "Navigate an existing tab: goto a URL, go back, go forward, or reload. Same URL-blocking policy as browser_open_tab.",
+		inputSchema: {
+			type: "object",
+			required: ["tabId", "action"],
+			additionalProperties: false,
+			properties: {
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs / browser_open_tab."
+				},
 				action: {
 					type: "string",
 					enum: [
@@ -3360,85 +4099,26 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_read_page",
-		description: "Extract rendered page text plus interactive elements (refs, roles, names, bounding boxes) plus viewport metadata. Each element entry carries bbox: [x, y, w, h] in CSS viewport pixels — the same coordinate space used by browser_mouse / browser_drag / browser_scroll(at-pointer). Element refs returned here are intended as the primary input to follow-up tool calls — preferred over CSS selectors because refs are stable across dynamic class names. The viewport block {width, height, devicePixelRatio, scrollX, scrollY} lets you map a CSS-px bbox to a device-px pixel in browser_screenshot (device_px = css_px * devicePixelRatio). Text is capped at 256 KiB; elements at the first 200 interactive nodes.",
-		inputSchema: {
-			type: "object",
-			required: ["tabId"],
-			additionalProperties: false,
-			properties: { tabId: {
-				type: "number",
-				description: "Tab id from browser_list_tabs / browser_open_tab."
-			} }
-		},
-		capability: "browser",
-		async handler(args, signal) {
-			return dispatchBrowserTool("browser_read_page", args, signal);
-		}
-	},
-	{
-		toolNameHttp: "browser_click",
-		description: "Click an element by ref (from a prior browser_read_page) or CSS selector. Returns {ok, navigated} where navigated=true if the URL changed within ~300ms of the click.",
+		description: "Compressed page snapshot for the model: visible text, interactive elements with stable refs, viewport metadata, and (when present) `visualSurfaces` listing canvas / svg regions that need vision. Each element entry carries `bbox: [x, y, w, h]` in CSS viewport pixels (same coord space as browser_mouse / drag / scroll-at-pointer). Refs (e.g. `e42`) are stable for the lifetime of one read_page snapshot and are the preferred input to follow-up actions over brittle CSS selectors. The `viewport` block (`width`, `height`, `devicePixelRatio`, `scrollX`, `scrollY`) lets you map CSS-px bbox to device-px pixels for browser_screenshot. Mode controls what ships back: `summary` (default, ~5-15 KB) returns only viewport-visible elements/text and drops nameless non-interactive nodes; `full` returns up to 200 elements + 256 KiB of innerText (the legacy behavior — use only when you need off-screen content unscrolled). PREFER browser_act / browser_find for intent-driven interaction; read_page is the lower-level snapshot when you need to enumerate.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
-				ref: {
-					type: "string",
-					description: "Element ref from browser_read_page (preferred)."
-				},
-				selector: {
-					type: "string",
-					description: "CSS selector (fallback when no ref)."
-				},
-				button: {
-					type: "string",
-					enum: ["left", "right"],
-					description: "Mouse button. Default 'left'."
-				},
-				clickCount: {
+				tabId: {
 					type: "number",
-					description: "Number of times to click. Default 1."
-				}
-			}
-		},
-		capability: "browser",
-		async handler(args, signal) {
-			return dispatchBrowserTool("browser_click", args, signal);
-		}
-	},
-	{
-		toolNameHttp: "browser_fill",
-		description: "Type into an input / textarea, select from a dropdown, or toggle a checkbox / radio. Dispatches native input and change events so React-style controlled inputs see the value.",
-		inputSchema: {
-			type: "object",
-			required: ["tabId", "value"],
-			additionalProperties: false,
-			properties: {
-				tabId: { type: "number" },
-				ref: {
-					type: "string",
-					description: "Element ref from browser_read_page (preferred)."
+					description: "Tab id from browser_list_tabs / browser_open_tab."
 				},
-				selector: {
+				mode: {
 					type: "string",
-					description: "CSS selector (fallback when no ref)."
-				},
-				value: { description: "The value to set. String for inputs / textareas / select option value. Boolean for checkbox / radio. Max 1 MB." },
-				clearFirst: {
-					type: "boolean",
-					description: "Clear the input before typing (default true). No effect on select / checkbox."
-				},
-				pressEnter: {
-					type: "boolean",
-					description: "After typing, dispatch Enter keydown / keyup and call form.requestSubmit if available. Default false."
+					enum: ["summary", "full"],
+					description: "Snapshot scope. Default 'summary' returns viewport-visible elements + text capped at 20 KiB. 'full' returns up to 200 interactive elements page-wide + 256 KiB of innerText."
 				}
 			}
 		},
 		capability: "browser",
 		async handler(args, signal) {
-			return dispatchBrowserTool("browser_fill", args, signal);
+			return dispatchBrowserTool("browser_read_page", args, signal);
 		}
 	},
 	{
@@ -3613,48 +4293,6 @@ const BROWSER_TOOLS = Object.freeze([
 			return dispatchBrowserTool("browser_download", args, signal);
 		}
 	},
-	{
-		toolNameHttp: "browser_console_logs",
-		description: "Drain console messages a tab has emitted since the last call. The first call for a tab attaches chrome.debugger and starts capturing, so very-early-load messages from before the first call are missed; subsequent calls return everything since the previous drain. Buffer is capped at 1000 entries per tab.",
-		inputSchema: {
-			type: "object",
-			required: ["tabId"],
-			additionalProperties: false,
-			properties: {
-				tabId: { type: "number" },
-				level: {
-					type: "string",
-					enum: [
-						"log",
-						"info",
-						"warn",
-						"error",
-						"debug",
-						"all"
-					],
-					description: "Filter by console level. Default 'all'."
-				}
-			}
-		},
-		capability: "browser",
-		async handler(args, signal) {
-			return dispatchBrowserTool("browser_console_logs", args, signal);
-		}
-	},
-	{
-		toolNameHttp: "browser_network_log",
-		description: "Drain network responses a tab has received since the last call. Same lazy-attach + cap-1000 behavior as browser_console_logs. Returns request URL, method, status, mime type, and timestamp per entry.",
-		inputSchema: {
-			type: "object",
-			required: ["tabId"],
-			additionalProperties: false,
-			properties: { tabId: { type: "number" } }
-		},
-		capability: "browser",
-		async handler(args, signal) {
-			return dispatchBrowserTool("browser_network_log", args, signal);
-		}
-	},
 	{
 		toolNameHttp: "browser_mouse",
 		description: "Move / click / hover / press / release the mouse via real CDP input events (Input.dispatchMouseEvent). Use this when you need behavior that synthetic .click() can't trigger: hover-to-reveal menus, canvas / map / image-map clicks, sites that check event.isTrusted, or precise coordinate targeting. Target with ref (from browser_read_page), CSS selector, or (x, y) in CSS viewport pixels — exactly one. action='move' is the hover (single mouseMoved fires :hover and pointerover reliably). action='dblclick' sends two press/release cycles with incrementing clickCount (a real double-click, not one cycle with clickCount=2). By default the target is hit-tested with elementFromPoint and the call fails with `target_obscured` if the topmost element isn't the target or a descendant — pass force:true to bypass when you know an overlay forwards events.",
@@ -3806,42 +4444,340 @@ const BROWSER_TOOLS = Object.freeze([
 					type: "string",
 					description: "The text to type. Max 4096 chars. Iterates as Unicode code points (surrogate pairs handled correctly)."
 				},
-				delayMs: {
-					type: "number",
-					description: "Pause between characters. Default 0. Clamped to [0, 50]. Set > 0 when typing into search-as-you-type inputs that debounce."
+				delayMs: {
+					type: "number",
+					description: "Pause between characters. Default 0. Clamped to [0, 50]. Set > 0 when typing into search-as-you-type inputs that debounce."
+				}
+			}
+		},
+		capability: "browser",
+		async handler(args, signal) {
+			return dispatchBrowserTool("browser_type", args, signal);
+		}
+	},
+	{
+		toolNameHttp: "browser_diagnostics",
+		description: "Drain console messages or network responses for a tab, with filtering. Replaces the prior browser_console_logs / browser_network_log primitives. `kind` selects the stream; remaining params filter the result before it ships to the model so the response carries only what the caller asked for instead of a raw 1000-entry array dump. Lazy-attach behavior: first call for a tab attaches chrome.debugger; very-early-load events from before the first call are missed.",
+		inputSchema: {
+			type: "object",
+			required: ["tabId", "kind"],
+			additionalProperties: false,
+			properties: {
+				tabId: { type: "number" },
+				kind: {
+					type: "string",
+					enum: ["console", "network"],
+					description: "Which stream to drain."
+				},
+				level: {
+					type: "string",
+					enum: [
+						"log",
+						"info",
+						"warn",
+						"error",
+						"debug",
+						"all"
+					],
+					description: "Console only. Default 'all'. Ignored when kind=network."
+				},
+				regex: {
+					type: "string",
+					description: "Optional JS-regex string. Console: matches the message body. Network: matches the request URL."
+				},
+				limit: {
+					type: "number",
+					description: "Max entries to return after filtering. Default 100. Hard cap 1000."
+				}
+			}
+		},
+		capability: "browser",
+		async handler(args, signal) {
+			const kind = args.kind === "network" ? "network" : "console";
+			const tool = kind === "network" ? "browser_network_log" : "browser_console_logs";
+			const tabId = typeof args.tabId === "number" ? args.tabId : void 0;
+			const level = typeof args.level === "string" ? args.level : "all";
+			const regexStr = typeof args.regex === "string" ? args.regex : void 0;
+			const limit = typeof args.limit === "number" ? Math.min(1e3, Math.max(1, args.limit)) : 100;
+			const env = await dispatchBrowserTool(tool, {
+				tabId,
+				level
+			}, signal);
+			if (env.isError) return env;
+			const text = env.content?.[0]?.text;
+			if (typeof text !== "string") return env;
+			let entries;
+			try {
+				const parsed = JSON.parse(text);
+				entries = (Array.isArray(parsed) ? parsed : Array.isArray(parsed?.entries) ? parsed.entries : []).filter((e) => typeof e === "object" && e !== null);
+			} catch {
+				return env;
+			}
+			let filtered = entries;
+			if (regexStr) try {
+				const re = new RegExp(regexStr);
+				const field = kind === "network" ? "url" : "text";
+				filtered = filtered.filter((e) => {
+					const v = e[field];
+					return typeof v === "string" && re.test(v);
+				});
+			} catch {
+				return toolEnvelope({ error: `invalid regex: ${regexStr}` }, true);
+			}
+			const out = filtered.slice(0, limit);
+			return toolEnvelope({
+				kind,
+				total: entries.length,
+				returned: out.length,
+				entries: out
+			});
+		}
+	},
+	{
+		toolNameHttp: "browser_find",
+		description: "Find up to 5 elements matching a natural-language intent ('the search box at the top', 'the Submit button at the bottom of the login form'). Returns ranked candidates with stable refs the model can pass to browser_act (ref mode) or browser_mouse. Cheaper than browser_read_page when you know what you're looking for — the inner compressor (Gemini Flash class) filters the snapshot for you instead of sending the full element list to the lead model.",
+		inputSchema: {
+			type: "object",
+			required: ["tabId", "intent"],
+			additionalProperties: false,
+			properties: {
+				tabId: { type: "number" },
+				intent: {
+					type: "string",
+					description: "Natural-language description of what to find."
+				}
+			}
+		},
+		capability: "browser_compound",
+		async handler(args, signal) {
+			const tabId = typeof args.tabId === "number" ? args.tabId : void 0;
+			const intent = typeof args.intent === "string" ? args.intent : "";
+			if (!tabId) return toolEnvelope({ error: "tabId required" }, true);
+			if (!intent) return toolEnvelope({ error: "intent required" }, true);
+			const snapshot = await fetchSnapshot(tabId, signal);
+			const matches = await pickMatchingElements(snapshot, intent, signal);
+			const indexed = new Map(snapshot.elements.map((e) => [e.ref, e]));
+			return toolEnvelope({ matches: matches.map((m) => {
+				const el = indexed.get(m.ref);
+				return el ? {
+					ref: m.ref,
+					role: el.role,
+					name: el.name,
+					bbox: el.bbox,
+					reason: m.reason
+				} : {
+					ref: m.ref,
+					reason: m.reason
+				};
+			}) });
+		}
+	},
+	{
+		toolNameHttp: "browser_act",
+		description: "Preferred for any click / fill / type / scroll-to action against a tab. Two modes: (1) INTENT mode — pass `intent` as natural language ('click the submit button'); the inner compressor (Gemini Flash class) maps it to an element + action. Auto-escalates to visual fallback (screenshot + multimodal model + pixel-coord click) when the intent points into a canvas / svg region the a11y tree can't see. (2) REF mode — pass `ref` (from a prior browser_find or browser_read_page) and optionally `value`; dispatches directly with zero compressor latency. This is the fold-in path for the now-removed browser_click and browser_fill. Returns {ok, action_taken, target_ref, navigated}.",
+		inputSchema: {
+			type: "object",
+			required: ["tabId"],
+			additionalProperties: false,
+			properties: {
+				tabId: { type: "number" },
+				intent: {
+					type: "string",
+					description: "Natural-language description of the action. Triggers INTENT mode. Mutually exclusive with `ref`."
+				},
+				ref: {
+					type: "string",
+					description: "Element ref from browser_find / browser_read_page. Triggers REF mode (no compressor round-trip)."
+				},
+				action: {
+					type: "string",
+					enum: [
+						"click",
+						"fill",
+						"type",
+						"select",
+						"scroll_into_view"
+					],
+					description: "REF mode only. Defaults to 'click'. In INTENT mode, the compressor picks the action."
+				},
+				value: {
+					type: "string",
+					description: "For fill / type / select: the string value to set. In INTENT mode the compressor uses this when an action requires a value."
 				}
 			}
 		},
 		capability: "browser",
 		async handler(args, signal) {
-			return dispatchBrowserTool("browser_type", args, signal);
+			const tabId = typeof args.tabId === "number" ? args.tabId : void 0;
+			if (!tabId) return toolEnvelope({ error: "tabId required" }, true);
+			const refIn = typeof args.ref === "string" ? args.ref : void 0;
+			const intent = typeof args.intent === "string" ? args.intent : void 0;
+			const value = typeof args.value === "string" ? args.value : void 0;
+			if (!refIn && !intent) return toolEnvelope({ error: "either `ref` (REF mode) or `intent` (INTENT mode) is required" }, true);
+			if (refIn) return dispatchActionByRef(tabId, refIn, typeof args.action === "string" ? args.action : "click", value, signal);
+			const snapshot = await fetchSnapshot(tabId, signal);
+			const picked = await pickElement(snapshot, intent, signal, value);
+			if (!picked.ref || picked.confidence < .5) {
+				const surfaces = snapshot.visualSurfaces;
+				if (surfaces && surfaces.length > 0) {
+					const shotEnv = await dispatchBrowserTool("browser_screenshot", {
+						tabId,
+						format: "png"
+					}, signal);
+					if (shotEnv.isError) return toolEnvelope({
+						ok: false,
+						error: "no text match; screenshot for visual fallback failed",
+						picked
+					}, true);
+					const shotText = shotEnv.content?.[0]?.text;
+					let shot = {};
+					try {
+						shot = shotText ? JSON.parse(shotText) : {};
+					} catch {
+						return toolEnvelope({
+							ok: false,
+							error: "no text match; screenshot envelope unparseable"
+						}, true);
+					}
+					if (!shot.contentType || !shot.dataBase64) return toolEnvelope({
+						ok: false,
+						error: "no text match; screenshot envelope missing fields"
+					}, true);
+					const visual = await pickElementVisual(shot.dataBase64, shot.contentType, intent, surfaces, signal);
+					if (visual.confidence < .5) return toolEnvelope({
+						ok: false,
+						error: "no element matched intent (text + visual)",
+						picked,
+						visual
+					}, true);
+					const clickEnv = await dispatchBrowserTool("browser_mouse", {
+						tabId,
+						action: "click",
+						x: visual.x,
+						y: visual.y,
+						force: true
+					}, signal);
+					if (clickEnv.isError) return clickEnv;
+					return toolEnvelope({
+						ok: true,
+						action_taken: "click_visual",
+						x: visual.x,
+						y: visual.y,
+						confidence: visual.confidence,
+						reason: visual.reason
+					});
+				}
+				return toolEnvelope({
+					ok: false,
+					error: "no element matched intent",
+					picked
+				}, true);
+			}
+			return dispatchActionByRef(tabId, picked.ref, picked.action, picked.value ?? value, signal);
 		}
 	},
 	{
-		toolNameHttp: "browser_locate",
-		description: "Resolve a single ref or selector to bounding box + hit-test metadata, without a full browser_read_page snapshot. Cheap — one in-page script call. Returns bbox (CSS viewport px), center, inView (bbox intersects viewport), visible (display/visibility/opacity > 0 and bbox > 0), computed pointer-events, viewport metadata, and topmostAtCenter (is the element at the bbox center actually this target, or is it occluded by an overlay?). Use this before browser_mouse / browser_drag to detect overlay-occluded targets, or to check whether something scrolled out of view.",
+		toolNameHttp: "browser_extract",
+		description: "Structured extraction from the current page into a JSON object matching the provided schema. The inner compressor reads the page snapshot (text + elements) and synthesizes the typed object. Use this instead of browser_read_page + lead-model parsing when you know the shape you want (e.g. a list of {title, author, url} rows from a PR list).",
 		inputSchema: {
 			type: "object",
-			required: ["tabId"],
+			required: [
+				"tabId",
+				"schema",
+				"instruction"
+			],
 			additionalProperties: false,
 			properties: {
 				tabId: { type: "number" },
-				ref: {
-					type: "string",
-					description: "Element ref from browser_read_page (preferred). Exactly one of ref / selector required."
-				},
-				selector: {
+				schema: { description: "JSON schema (or schema-shaped descriptor) for the desired output shape." },
+				instruction: {
 					type: "string",
-					description: "CSS selector (fallback)."
+					description: "What to extract, in plain language ('the visible PR list')."
 				}
 			}
 		},
-		capability: "browser",
+		capability: "browser_compound",
 		async handler(args, signal) {
-			return dispatchBrowserTool("browser_locate", args, signal);
+			const tabId = typeof args.tabId === "number" ? args.tabId : void 0;
+			const instruction = typeof args.instruction === "string" ? args.instruction : "";
+			const schema = args.schema;
+			if (!tabId) return toolEnvelope({ error: "tabId required" }, true);
+			if (!instruction) return toolEnvelope({ error: "instruction required" }, true);
+			if (!schema) return toolEnvelope({ error: "schema required" }, true);
+			const snapshot = await fetchSnapshot(tabId, signal);
+			try {
+				return toolEnvelope(await extractStructured(snapshot, schema, instruction, signal));
+			} catch (err) {
+				if (err instanceof SchemaValidationError) return toolEnvelope({ error: `invalid schema: ${err.message}` }, true);
+				if (err instanceof ResultShapeError) return toolEnvelope({ error: `extraction produced wrong shape: ${err.message}` }, true);
+				throw err;
+			}
 		}
 	}
 ]);
+/**
+* Dispatch an action against a known ref via the appropriate primitive.
+* Shared between REF mode and INTENT-mode-text-match in `browser_act`.
+* Returns an MCP envelope (text content + optional isError).
+*/
+async function dispatchActionByRef(tabId, ref, action, value, signal) {
+	let env;
+	switch (action) {
+		case "click":
+			env = await dispatchBrowserTool("browser_click", {
+				tabId,
+				ref
+			}, signal);
+			break;
+		case "fill":
+			env = await dispatchBrowserTool("browser_fill", {
+				tabId,
+				ref,
+				value
+			}, signal);
+			break;
+		case "type":
+			await dispatchBrowserTool("browser_click", {
+				tabId,
+				ref
+			}, signal);
+			env = await dispatchBrowserTool("browser_type", {
+				tabId,
+				text: value ?? ""
+			}, signal);
+			break;
+		case "select":
+			env = await dispatchBrowserTool("browser_fill", {
+				tabId,
+				ref,
+				value
+			}, signal);
+			break;
+		case "scroll_into_view":
+			env = await dispatchBrowserTool("browser_scroll", {
+				tabId,
+				target: "element",
+				ref
+			}, signal);
+			break;
+		default: return toolEnvelope({
+			ok: false,
+			error: `unknown action: ${action}`
+		}, true);
+	}
+	if (env.isError) return env;
+	const innerText = env.content?.[0]?.text;
+	let parsed = {};
+	if (typeof innerText === "string") try {
+		parsed = JSON.parse(innerText);
+	} catch {}
+	return toolEnvelope({
+		ok: true,
+		action_taken: action,
+		target_ref: ref,
+		navigated: typeof parsed.navigated === "boolean" ? parsed.navigated : void 0
+	});
+}
 
 //#endregion
 //#region src/vendor/pi/ai/api-registry.ts
@@ -5416,7 +6352,7 @@ const MAX_INFLIGHT_WORKER_CALLS = (() => {
 	if (!Number.isFinite(n) || n <= 0 || !Number.isInteger(n)) return 8;
 	return n;
 })();
-let inFlight$1 = 0;
+let inFlight = 0;
 /**
 * Acquire a worker slot.
 *
@@ -5434,176 +6370,16 @@ let inFlight$1 = 0;
 */
 async function acquireWorkerSlot(signal) {
 	if (signal?.aborted) return null;
-	if (inFlight$1 >= MAX_INFLIGHT_WORKER_CALLS) return null;
-	inFlight$1 += 1;
+	if (inFlight >= MAX_INFLIGHT_WORKER_CALLS) return null;
+	inFlight += 1;
 	let released = false;
 	return () => {
 		if (released) return;
 		released = true;
-		inFlight$1 = Math.max(0, inFlight$1 - 1);
-	};
-}
-
-//#endregion
-//#region src/lib/diagnose-response.ts
-const PREVIEW_LIMIT = 200;
-async function parseJsonOrDiagnose(response, routePath) {
-	const cloned = response.clone();
-	try {
-		return await response.json();
-	} catch (error) {
-		const contentType = response.headers.get("content-type") ?? "(none)";
-		const bodyText = await cloned.text().catch(() => "(unreadable)");
-		const preview = bodyText.length > PREVIEW_LIMIT ? bodyText.slice(0, PREVIEW_LIMIT) + "...(truncated)" : bodyText;
-		consola.error(`Upstream JSON parse failed at ${routePath}: status=${response.status} content-type="${contentType}" body[0..${PREVIEW_LIMIT}]=${JSON.stringify(preview)}`);
-		throw error;
-	}
-}
-
-//#endregion
-//#region src/lib/response-cap.ts
-/**
-* Hard byte cap for non-streaming upstream response bodies.
-*
-* Anthropic responses with large tool_use blocks can legitimately reach
-* several MB, but a multi-GB body is either a buggy upstream or a malicious
-* one. Buffering it would OOM the proxy and crash all in-flight requests.
-*
-* Applies to /v1/messages, /v1/chat/completions, and /v1/responses.
-*/
-const MAX_RESPONSE_BODY_BYTES = 10 * 1024 * 1024;
-/**
-* Read a Response body with a hard byte cap, then parse as JSON.
-*
-* Falls back to the fast path (response.json()) when Content-Length is
-* present and within the cap, avoiding the streaming-reader overhead for
-* the vast majority of normal responses.
-*
-* When the cap is hit:
-*   - the reader is cancelled to release the upstream socket
-*   - a structured Anthropic-format error is returned to the caller
-*     (the caller wraps it in c.json(), not throws — the client gets a
-*     clean 413 error, not an unhandled-rejection crash)
-*
-* Returns `{ ok: true, value }` on success or `{ ok: false, errorResponse, status }`
-* on cap exceeded.
-*/
-async function readResponseBodyCapped(response, routePath, capBytes = MAX_RESPONSE_BODY_BYTES) {
-	const contentLengthHeader = response.headers.get("content-length");
-	const contentLength = contentLengthHeader ? parseInt(contentLengthHeader, 10) : NaN;
-	if (!isNaN(contentLength) && contentLength <= capBytes) return {
-		ok: true,
-		value: await parseJsonOrDiagnose(response, routePath)
-	};
-	const reader = response.body?.getReader();
-	if (!reader) return {
-		ok: true,
-		value: await parseJsonOrDiagnose(response, routePath)
+		inFlight = Math.max(0, inFlight - 1);
 	};
-	const chunks = [];
-	let totalBytes = 0;
-	let capped = false;
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			if (!value) continue;
-			totalBytes += value.byteLength;
-			if (totalBytes > capBytes) {
-				capped = true;
-				try {
-					await reader.cancel("size_cap");
-				} catch {}
-				break;
-			}
-			chunks.push(value);
-		}
-	} catch (err) {
-		if (!capped) consola.warn(`readResponseBodyCapped: read error at ${routePath}:`, err);
-	}
-	if (capped) {
-		consola.warn(`Non-streaming upstream response at ${routePath} exceeded ${capBytes} bytes (10 MiB cap); dropping body to prevent OOM. Check upstream health.`);
-		return {
-			ok: false,
-			status: 502,
-			errorResponse: {
-				type: "error",
-				error: {
-					type: "api_error",
-					message: `Upstream response body exceeded the 10 MiB size cap for non-streaming ${routePath}. The upstream may be misbehaving. Try enabling streaming (stream: true) which handles large responses chunk-by-chunk.`
-				}
-			}
-		};
-	}
-	const merged = new Uint8Array(totalBytes);
-	let offset = 0;
-	for (const chunk of chunks) {
-		merged.set(chunk, offset);
-		offset += chunk.byteLength;
-	}
-	const text = new TextDecoder().decode(merged);
-	try {
-		return {
-			ok: true,
-			value: JSON.parse(text)
-		};
-	} catch (err) {
-		const preview = text.slice(0, 200);
-		const contentType = response.headers.get("content-type") ?? "(none)";
-		consola.error(`Upstream JSON parse failed at ${routePath}: status=${response.status} content-type="${contentType}" body[0..200]=${JSON.stringify(preview)}`);
-		throw err;
-	}
 }
 
-//#endregion
-//#region src/services/copilot/create-chat-completions.ts
-const createChatCompletions = async (payload, modelHeaders, callerSignal) => {
-	if (!state.copilotToken) throw new Error("Copilot token not found");
-	const enableVision = payload.messages.some((x) => typeof x.content !== "string" && x.content?.some((x$1) => x$1.type === "image_url"));
-	const isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
-	const url = `${copilotBaseUrl(state)}/chat/completions`;
-	const doFetch = () => {
-		const fetchInit = {
-			method: "POST",
-			headers: {
-				...copilotHeaders(state, enableVision),
-				...modelHeaders,
-				"X-Initiator": isAgentCall ? "agent" : "user"
-			},
-			body: JSON.stringify(payload)
-		};
-		const signals = [];
-		if (UPSTREAM_FETCH_TIMEOUT_MS > 0) signals.push(AbortSignal.timeout(UPSTREAM_FETCH_TIMEOUT_MS));
-		if (callerSignal) signals.push(callerSignal);
-		if (signals.length === 1) fetchInit.signal = signals[0];
-		else if (signals.length > 1) fetchInit.signal = AbortSignal.any(signals);
-		return fetch(url, fetchInit);
-	};
-	const response = await tryRefreshAndRetry(doFetch, "/chat/completions");
-	if (!response.ok) {
-		let errorBody = "";
-		try {
-			errorBody = await response.text();
-		} catch {
-			errorBody = "(could not read error body)";
-		}
-		const claudeModels = state.models?.data.filter((m) => m.id.startsWith("claude")).map((m) => m.id).join(", ") ?? "(models not loaded)";
-		consola.error(`Copilot rejected model "${payload.model}": ${response.status} ${errorBody} (available Claude models: ${claudeModels})`);
-		throw new HTTPError("Failed to create chat completions", new Response(errorBody, {
-			status: response.status,
-			statusText: response.statusText,
-			headers: response.headers
-		}));
-	}
-	if (payload.stream) return events(response);
-	const cappedResult = await readResponseBodyCapped(response, "/v1/chat/completions", MAX_RESPONSE_BODY_BYTES);
-	if (!cappedResult.ok) throw new HTTPError("Upstream /v1/chat/completions response exceeded 10 MiB size cap", new Response(JSON.stringify(cappedResult.errorResponse), {
-		status: cappedResult.status,
-		headers: { "content-type": "application/json" }
-	}));
-	return cappedResult.value;
-};
-
 //#endregion
 //#region src/lib/worker-agent/stream-fn.ts
 function createCopilotStreamFn(opts) {
@@ -6057,56 +6833,6 @@ function isAbortError(err) {
 	return false;
 }
 
-//#endregion
-//#region src/lib/mcp-inflight.ts
-/**
-* Shared concurrency cap for MCP `tools/call` dispatches.
-*
-* Originally lived as a module-private counter inside
-* `src/routes/mcp/handler.ts`. Extracted because the worker-agent's
-* `peer_review` and `advisor` tools (which dispatch to peer-model
-* personas / the advisor responses endpoint from inside a worker
-* subagent loop) must participate in the same backpressure budget;
-* otherwise a single worker can fan out unboundedly to peers and
-* starve the operator's own `tools/list` callers.
-*
-* The counter is a single process-wide integer — no per-route
-* partitioning. Persona calls at the MCP boundary (handler.ts),
-* peer/advisor calls nested inside a worker (tools.ts), and any
-* future MCP-adjacent dispatcher all increment the same number.
-*
-* Cap = `MAX_INFLIGHT_TOOLS_CALL = 8`. Justification lives at the
-* historical home (`src/routes/mcp/handler.ts` comment block); do not
-* change the value without re-reading
-* `docs/research/peer-mcp-investigation.md` § "Concurrency cap
-* investigation".
-*/
-const MAX_INFLIGHT_TOOLS_CALL = 8;
-let inFlight = 0;
-/**
-* Acquire a slot if one is available. Returns a release function the
-* caller MUST invoke exactly once (typically from a `finally` block);
-* returns `null` if the cap is saturated. The release fn is idempotent
-* — calling it twice is a no-op so callers can release defensively
-* without worrying about double-decrementing the counter under unusual
-* unwind paths.
-*
-* Synchronous on purpose. Async semaphore acquisition would let callers
-* queue indefinitely; we want immediate "queue full" feedback so the
-* MCP client (or the model holding the nested tool call) can choose to
-* back off or retry.
-*/
-function acquireInFlightSlot() {
-	if (inFlight >= MAX_INFLIGHT_TOOLS_CALL) return null;
-	inFlight++;
-	let released = false;
-	return () => {
-		if (released) return;
-		released = true;
-		inFlight--;
-	};
-}
-
 //#endregion
 //#region src/lib/tokenizer.ts
 const ENCODING_MAP = {
@@ -6563,6 +7289,26 @@ function workerToolsEnabled() {
 	if (!found) return false;
 	return found.capabilities?.supports?.tool_calls === true;
 }
+/**
+* Gate for the compound L2 browser tools (`browser_find`, `browser_act`
+* in intent mode, `browser_extract`).
+*
+* Returns true iff `compressorAvailable()` — i.e. at least one model in
+* the compressor fallback chain (`gemini-3.5-flash` → `gpt-5.4-mini` →
+* `claude-haiku-4-5`) is present in the live catalog with `tool_calls`
+* support. When none are reachable the compound tools are dropped from
+* `tools/list` AND fail `tools/call` with -32601.
+*
+* Note: this gate does NOT additionally re-check the `browser` opt-in.
+* The `handler.ts` filter chain runs `browser` and `browser_compound`
+* via separate `capability` tags; the compound tools' entries also
+* apply at the route level via the existing `--browse` enablement
+* because they live under the browser MCP surface that the route
+* only mounts when `state.browseEnabled`.
+*/
+function browserCompoundToolsEnabled() {
+	return compressorAvailable();
+}
 
 //#endregion
 //#region src/routes/mcp/handler.ts
@@ -6739,6 +7485,7 @@ function toolEntries() {
 		if (t.capability === "worker") return workerToolsEnabled();
 		if (t.capability === "stand_in") return standInToolEnabled();
 		if (t.capability === "browser") return browserToolsEnabled();
+		if (t.capability === "browser_compound") return browserToolsEnabled() && browserCompoundToolsEnabled();
 		return true;
 	}).map((t) => ({
 		name: t.toolNameHttp,
@@ -7030,6 +7777,7 @@ async function handleToolsCall(body) {
 	if (nonPersonaTool && nonPersonaTool.capability === "worker" && !workerToolsEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name$1}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "stand_in" && !standInToolEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name$1}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "browser" && !browserToolsEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name$1}"`);
+	if (nonPersonaTool && nonPersonaTool.capability === "browser_compound" && !(browserToolsEnabled() && browserCompoundToolsEnabled())) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name$1}"`);
 	let personaPrompt;
 	let personaContext;
 	let personaEffort;
@@ -10583,6 +11331,7 @@ function buildPeerAwarenessSnippet(opts) {
 	if (opts.workerToolsAvailable) para2Parts.push("`worker_explore` runs a Gemini-backed read-only worker that returns a summary, using its own context rather than yours; concurrent launches share the `MAX_INFLIGHT_TOOLS_CALL=8` cap with operator traffic.", "`worker_implement` is the same worker with edit/write/bash; `worktree: true` runs it in an isolated git worktree and returns the diff.", "Workers themselves have `code_search` in their toolset.");
 	para2Parts.push("`web_search` surfaces citable sources for docs, errors, and upstream issues.");
 	if (opts.standInAvailable) para2Parts.push("`stand_in` provides three-lab consensus for decision tiebreak when the user is unavailable.");
+	if (opts.browseAvailable) para2Parts.push("`browser_*` tools (under `mcp__gh-router-peers__browser_*`) drive a real Chrome / Edge browser via a local extension; prefer the L2 compound tools `browser_act(intent | ref, value?)` / `browser_find(intent)` / `browser_extract(schema, instruction)` over the L0/L1 primitives.");
 	return [
 		"## Peer review and advisor",
 		"",
@@ -12045,7 +12794,7 @@ function initProxyFromEnv() {
 //#endregion
 //#region package.json
 var name = "github-router";
-var version = "0.3.45";
+var version$1 = "0.3.52";
 
 //#endregion
 //#region src/lib/approval.ts
@@ -13716,7 +14465,7 @@ server.use(cors());
 server.get("/", (c) => c.text("Server running"));
 server.get("/version", (c) => c.json({
 	name,
-	version,
+	version: version$1,
 	gitSha: process.env.GITHUB_SHA ?? "unknown"
 }));
 server.on("HEAD", ["/"], (c) => c.body(null, 200));
@@ -14150,7 +14899,8 @@ const claude = defineCommand({
 				codexCli: backend === "cli",
 				geminiAvailable: geminiAvailable$1,
 				workerToolsAvailable: workerToolsEnabled(),
-				standInAvailable: standInToolEnabled()
+				standInAvailable: standInToolEnabled(),
+				browseAvailable: state.browseEnabled
 			});
 			extraArgs.push("--append-system-prompt", peerSnippet);
 			try {
@@ -14247,7 +14997,7 @@ const codex = defineCommand({
 
 //#endregion
 //#region src/debug.ts
-async function getPackageVersion() {
+async function getPackageVersion$1() {
 	try {
 		const packageJsonPath = new URL("../package.json", import.meta.url).pathname;
 		return JSON.parse(await fs.readFile(packageJsonPath)).version;
@@ -14273,9 +15023,9 @@ async function checkTokenExists() {
 	}
 }
 async function getDebugInfo() {
-	const [version$1, tokenExists] = await Promise.all([getPackageVersion(), checkTokenExists()]);
+	const [version$2, tokenExists] = await Promise.all([getPackageVersion$1(), checkTokenExists()]);
 	return {
-		version: version$1,
+		version: version$2,
 		runtime: getRuntimeInfo(),
 		paths: {
 			APP_DIR: PATHS.APP_DIR,
@@ -14597,9 +15347,12 @@ process.on("uncaughtException", (error) => {
 	consola.error("Uncaught exception:", error);
 	process.exit(1);
 });
+const version = getPackageVersion();
+if (!process.argv.slice(2).includes("--version")) consola.info(`github-router v${version}`);
 await runMain(defineCommand({
 	meta: {
 		name: "github-router",
+		version,
 		description: "A reverse proxy that exposes GitHub Copilot as OpenAI and Anthropic compatible API endpoints."
 	},
 	subCommands: {