github-router 0.3.45 → 0.3.66

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";
@@ -45,6 +45,8 @@ const state = {
 	showToken: false,
 	extendedBetas: false,
 	browseEnabled: false,
+	powerBrowseEnabled: false,
+	humanlikeForce: "auto",
 	sessionId: randomUUID(),
 	machineId: randomBytes(32).toString("hex")
 };
@@ -62,14 +64,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 +540,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 +1119,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 +2473,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 +2908,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 +3036,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,
@@ -2946,6 +3078,58 @@ function installRequiredToolResult(payload) {
 	};
 }
 
+//#endregion
+//#region src/lib/browser-mcp/humanlike.ts
+/**
+* Sample from a Beta(2, 5) distribution scaled to [minMs, maxMs].
+* The Beta(2, 5) shape has its mode near 0.2 of the range — humans
+* follow most actions quickly, with an occasional long pause. We do
+* NOT use uniform random because that would produce robotically-
+* even spacing detectable by behavioral analysis.
+*
+* Implementation: two gamma-distributed samples via the Marsaglia /
+* Tsang squeeze method (Box-Muller-style sufficiency for shape ≥ 2).
+*/
+function betaDelay(minMs, maxMs) {
+	const a = gammaSample(2);
+	const beta = a / (a + gammaSample(5));
+	return Math.round(minMs + beta * (maxMs - minMs));
+}
+function gammaSample(shape) {
+	const d = shape - 1 / 3;
+	const c = 1 / Math.sqrt(9 * d);
+	while (true) {
+		let x, v;
+		do {
+			x = normalSample();
+			v = 1 + c * x;
+		} while (v <= 0);
+		v = v * v * v;
+		const u = Math.random();
+		if (u < 1 - .0331 * x * x * x * x) return d * v;
+		if (Math.log(u) < .5 * x * x + d * (1 - v + Math.log(v))) return d * v;
+	}
+}
+function normalSample() {
+	let u = 0, v = 0;
+	while (u === 0) u = Math.random();
+	while (v === 0) v = Math.random();
+	return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+}
+/**
+* Inter-action delay when paced mode is on. Returns a Beta-shaped
+* randomized delay in [800, 4600] ms with a base of 600 ms so the
+* minimum is never "too fast." Humans take 800-2800 ms between
+* UI actions on average, with a tail of long pauses; this matches.
+*
+* Caller is expected to subtract the time already burned in the
+* compound pipeline (snapshot fetch + matcher cascade) so the user-
+* perceived delay isn't doubled.
+*/
+function interActionDelay() {
+	return betaDelay(800, 4600);
+}
+
 //#endregion
 //#region src/lib/browser-mcp/policy.ts
 const BLOCKED_URL_RE = /^(chrome|edge|brave|opera|vivaldi):\/\/(settings|preferences|extensions|policy|management|password|flags|flag-descriptions)/i;
@@ -2980,6 +3164,78 @@ function preflightUrlPolicy(toolName, args) {
 
 //#endregion
 //#region src/lib/browser-mcp/dispatch.ts
+/**
+* Tools whose dispatch counts as a mutating user action for pacing
+* purposes. Read-only tools (list_tabs, screenshot, read_page,
+* diagnostics, navigate-without-form-submit) skip the inter-action
+* delay because they don't look like a human clicking around.
+*/
+const PACED_TOOLS = new Set([
+	"browser_click",
+	"browser_fill",
+	"browser_type",
+	"browser_keyboard",
+	"browser_scroll",
+	"browser_mouse",
+	"browser_drag"
+]);
+let lastDispatchAt = 0;
+let humanlikeAutoCache = {
+	fetchedAt: 0,
+	tabs: /* @__PURE__ */ new Set()
+};
+const HUMANLIKE_PROBE_INTERVAL_MS = 5e3;
+async function isHumanlikeAutoOn(tabId, signal) {
+	if (state.humanlikeForce === "off") return false;
+	if (typeof tabId !== "number") return false;
+	const now = Date.now();
+	if (now - humanlikeAutoCache.fetchedAt > HUMANLIKE_PROBE_INTERVAL_MS) try {
+		const ready = await ensureBridgeReady();
+		if (ready.install_required) return false;
+		const res = await fetch(`http://127.0.0.1:${ready.port}/health`, {
+			headers: { authorization: `Bearer ${ready.token}` },
+			signal
+		});
+		if (res.ok) {
+			const body = await res.json();
+			const tabs = /* @__PURE__ */ new Set();
+			for (const t of body.humanlike_tabs ?? []) if (typeof t.tabId === "number") tabs.add(t.tabId);
+			humanlikeAutoCache = {
+				fetchedAt: now,
+				tabs
+			};
+		}
+	} catch {}
+	return humanlikeAutoCache.tabs.has(tabId);
+}
+async function maybeInjectHumanlikeDelay(tool, signal, tabId) {
+	if (!PACED_TOOLS.has(tool)) return;
+	let on = state.humanlikeForce === "on";
+	if (!on && state.humanlikeForce === "auto") on = await isHumanlikeAutoOn(tabId, signal);
+	if (!on) return;
+	const target = interActionDelay();
+	const sinceLast = Date.now() - lastDispatchAt;
+	const wait = Math.max(0, target - sinceLast);
+	if (wait > 0) await sleepAbortable(wait, signal);
+	lastDispatchAt = Date.now();
+}
+function sleepAbortable(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(/* @__PURE__ */ new Error("aborted"));
+			return;
+		}
+		const timer = setTimeout(() => {
+			if (signal) signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(/* @__PURE__ */ new Error("aborted"));
+		};
+		if (signal) signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
 const PER_TOOL_TIMEOUTS = {
 	browser_list_tabs: {
 		defaultMs: 5e3,
@@ -3145,6 +3401,7 @@ async function dispatchBrowserTool(tool, args, signal, opts = {}) {
 	};
 	const ready = await ensureBridgeReady();
 	if (ready.install_required) return installRequiredToolResult(ready);
+	await maybeInjectHumanlikeDelay(tool, signal, typeof args.tabId === "number" ? args.tabId : void 0);
 	const { defaultMs, maxMs } = pickTimeout(tool);
 	const callerTimeout = typeof opts.timeoutMs === "number" && opts.timeoutMs > 0 ? Math.min(opts.timeoutMs, maxMs) : defaultMs;
 	try {
@@ -3226,219 +3483,1563 @@ function logAudit$1(record) {
 }
 
 //#endregion
-//#region src/lib/browser-mcp/index.ts
+//#region src/lib/browser-mcp/matcher.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.
-*
-* 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`.
+* Resolve an intent to an action. Synchronous, no I/O, <5ms expected
+* on a 200-element snapshot.
 *
-* v1 surface: 19 tools (Phases 3 + 4a + 4b + humanlike input v2).
+* Returns `{source: "escalate"}` when no layer produced a single
+* confident candidate. Caller is expected to invoke the fast-model
+* fallback path with the returned `candidates` shortlist (smaller
+* than the full snapshot, so fast-model token cost drops 3-5×).
 */
-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);
+function deterministicResolve(snapshot, parsed, value) {
+	const v = value ?? parsed.valueFromIntent;
+	const allCandidates = [];
+	for (const layer of LAYERS) {
+		const found = layer.run(snapshot, parsed, v);
+		if (found.length === 0) continue;
+		allCandidates.push(...found);
+		const winners = applyTieBreakers(found, parsed);
+		const top = winners[0];
+		if (!top) continue;
+		const runnerUp = winners[1];
+		if (top.score >= layer.floor && (!runnerUp || top.score - runnerUp.score >= .15)) {
+			const action = inferActionLocal(top.el.role, parsed, v);
+			return {
+				ref: top.el.ref,
+				action,
+				...needsValue(action) && v !== void 0 ? { value: v } : {},
+				confidence: top.score,
+				source: layer.name,
+				reason: top.reason
+			};
 		}
-	},
-	{
-		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."
-				}
+	}
+	const shortlist = dedupeAndRank(allCandidates).slice(0, 8);
+	return {
+		ref: "",
+		action: parsed.verb ?? "click",
+		...v !== void 0 ? { value: v } : {},
+		confidence: 0,
+		source: "escalate",
+		reason: shortlist.length === 0 ? "no candidates from any cascade layer" : `${shortlist.length} ambiguous candidates`,
+		candidates: shortlist.map((c) => ({
+			ref: c.el.ref,
+			score: c.score,
+			layer: c.layer
+		}))
+	};
+}
+function applyTieBreakers(cands, parsed) {
+	const verb = parsed.verb ?? "click";
+	const dropDisabled = verb === "click" || verb === "fill" || verb === "type" || verb === "select";
+	return cands.filter((c) => {
+		if (c.el.hidden) return false;
+		if (c.el.bbox && (c.el.bbox[2] < 4 || c.el.bbox[3] < 4)) return false;
+		if (dropDisabled && c.el.disabled) return false;
+		return true;
+	}).map((c) => ({
+		...c,
+		score: c.score * weight(c, verb)
+	})).sort((a, b) => b.score - a.score);
+}
+function weight(c, verb) {
+	let w = 1;
+	const bbox = c.el.bbox;
+	if (bbox) {
+		if (!(bbox[0] >= 0 && bbox[1] >= 0)) w *= .92;
+	}
+	if (c.el.isInIframe) w *= .95;
+	if (verb === "click") {
+		const r = (c.el.role || "").toLowerCase();
+		if (r === "button") w *= 1;
+		else if (r === "link" || r === "a") w *= .98;
+		else if (r === "menuitem") w *= .96;
+		else if (r === "generic" || r === "div" || r === "span") w *= .9;
+	}
+	return Math.min(1, w);
+}
+function dedupeAndRank(cands) {
+	const byRef = /* @__PURE__ */ new Map();
+	for (const c of cands) {
+		const existing = byRef.get(c.el.ref);
+		if (!existing || existing.score < c.score) byRef.set(c.el.ref, c);
+	}
+	return [...byRef.values()].sort((a, b) => b.score - a.score);
+}
+function inferActionLocal(role, parsed, value) {
+	if (parsed.verb === "scroll_into_view") return "scroll_into_view";
+	const intentLower = parsed.rawTarget.toLowerCase();
+	if (/\bscroll\b/.test(intentLower)) return "scroll_into_view";
+	const r = (role || "").toLowerCase();
+	if (r === "select" || r === "combobox") return "select";
+	if (r === "textarea" || r === "input" || r === "textbox" || r === "searchbox" || r === "spinbutton") {
+		if (parsed.verb === "type") return "type";
+		if (parsed.verb === "fill") return "fill";
+		return value !== void 0 ? "fill" : "click";
+	}
+	return parsed.verb ?? "click";
+}
+function needsValue(action) {
+	return action === "fill" || action === "type" || action === "select";
+}
+function nameOf(el) {
+	return (el.name ?? "").trim();
+}
+function nameLowerOf(el) {
+	return nameOf(el).toLowerCase();
+}
+function isClickableRole(role) {
+	const r = role.toLowerCase();
+	return r === "button" || r === "link" || r === "a" || r === "menuitem" || r === "tab" || r === "checkbox" || r === "radio" || r === "switch" || r === "option" || r === "treeitem";
+}
+function isInputRole(role) {
+	const r = role.toLowerCase();
+	return r === "textbox" || r === "input" || r === "textarea" || r === "searchbox" || r === "spinbutton" || r === "combobox" || r === "select" || r === "checkbox" || r === "radio";
+}
+function verbCompatible(role, verb) {
+	if (!verb || verb === "click") return isClickableRole(role) || isInputRole(role);
+	if (verb === "fill" || verb === "type" || verb === "select") return isInputRole(role);
+	return true;
+}
+function wholeWordContains(haystack, needle) {
+	if (!haystack || !needle) return false;
+	return new RegExp(`\\b${needle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i").test(haystack);
+}
+const L0 = {
+	name: "L0",
+	floor: .95,
+	run: (snapshot, parsed) => {
+		const target = parsed.quotedName ?? parsed.normTarget;
+		if (!target) return [];
+		const out = [];
+		for (const el of snapshot.elements) {
+			if (!verbCompatible(el.role, parsed.verb)) continue;
+			const nm = nameLowerOf(el);
+			if (!nm) continue;
+			if (nm === target.toLowerCase()) out.push({
+				el,
+				score: 1,
+				layer: "L0",
+				reason: `L0 exact name "${el.name}"`
+			});
+		}
+		return out;
+	}
+};
+const L1 = {
+	name: "L1",
+	floor: .9,
+	run: (snapshot, parsed) => {
+		if (parsed.verb && parsed.verb !== "fill" && parsed.verb !== "type" && parsed.verb !== "select") return [];
+		const target = parsed.fieldHint ?? parsed.normTarget;
+		if (!target) return [];
+		const tgt = target.toLowerCase();
+		const out = [];
+		for (const el of snapshot.elements) {
+			if (!isInputRole(el.role)) continue;
+			const nm = nameLowerOf(el);
+			if (nm === tgt || nm === `${tgt} *` || nm === `${tgt} (required)` || nm.endsWith(tgt) && /^[\s*()required:_-]+/.test(nm.slice(0, nm.length - tgt.length))) out.push({
+				el,
+				score: .95,
+				layer: "L1",
+				reason: `L1 label "${el.name}"`
+			});
+		}
+		return out;
+	}
+};
+const L2 = {
+	name: "L2",
+	floor: .7,
+	run: (snapshot, parsed) => {
+		const target = parsed.fieldHint ?? parsed.normTarget;
+		if (!target) return [];
+		const tgt = target.toLowerCase();
+		const out = [];
+		for (const el of snapshot.elements) {
+			if (!isInputRole(el.role)) continue;
+			const ph = (el.placeholder ?? "").toLowerCase();
+			if (!ph) continue;
+			if (ph === tgt) out.push({
+				el,
+				score: .85,
+				layer: "L2",
+				reason: `L2 placeholder exact "${el.placeholder}"`
+			});
+			else if (wholeWordContains(ph, tgt)) out.push({
+				el,
+				score: .75,
+				layer: "L2",
+				reason: `L2 placeholder contains "${tgt}"`
+			});
+		}
+		return out;
+	}
+};
+const L3 = {
+	name: "L3",
+	floor: .65,
+	run: (snapshot, parsed) => {
+		const target = parsed.normTarget;
+		if (!target) return [];
+		const out = [];
+		for (const el of snapshot.elements) {
+			if (!verbCompatible(el.role, parsed.verb)) continue;
+			const nm = nameOf(el);
+			if (!nm) continue;
+			if (!wholeWordContains(nm, target)) continue;
+			const score = target.length / nm.length >= .8 ? .72 : .68;
+			out.push({
+				el,
+				score,
+				layer: "L3",
+				reason: `L3 fuzzy name "${nm}"`
+			});
+		}
+		return out;
+	}
+};
+const L4 = {
+	name: "L4",
+	floor: .6,
+	run: (snapshot, parsed) => {
+		const target = parsed.normTarget;
+		if (!target) return [];
+		const out = [];
+		for (const el of snapshot.elements) {
+			if (!isClickableRole(el.role)) continue;
+			const text = (el.value ?? "").toLowerCase().trim();
+			if (!text) continue;
+			const tgt = target.toLowerCase();
+			if (text === tgt) out.push({
+				el,
+				score: .65,
+				layer: "L4",
+				reason: `L4 text exact "${el.value}"`
+			});
+			else if (wholeWordContains(text, tgt)) out.push({
+				el,
+				score: .6,
+				layer: "L4",
+				reason: `L4 text contains "${tgt}"`
+			});
+		}
+		return out;
+	}
+};
+const L5 = {
+	name: "L5",
+	floor: .85,
+	run: (snapshot, parsed) => {
+		const target = parsed.normTarget;
+		if (!target) return [];
+		if (!/^[a-z][a-z0-9_-]{2,}$/i.test(target)) return [];
+		const norm = target.toLowerCase().replace(/[-_]/g, "");
+		const out = [];
+		for (const el of snapshot.elements) {
+			const attrs = el.attrs;
+			if (!attrs) continue;
+			if (attrs.testid && stripSep(attrs.testid).toLowerCase() === norm) {
+				out.push({
+					el,
+					score: .9,
+					layer: "L5",
+					reason: `L5 testid="${attrs.testid}"`
+				});
+				continue;
 			}
-		},
-		capability: "browser",
-		async handler(args, signal) {
-			return dispatchBrowserTool("browser_open_tab", args, signal);
+			if (attrs.id && stripSep(attrs.id).toLowerCase() === norm) {
+				out.push({
+					el,
+					score: .88,
+					layer: "L5",
+					reason: `L5 id="${attrs.id}"`
+				});
+				continue;
+			}
+			if (attrs.name_attr && stripSep(attrs.name_attr).toLowerCase() === norm) {
+				out.push({
+					el,
+					score: .86,
+					layer: "L5",
+					reason: `L5 name="${attrs.name_attr}"`
+				});
+				continue;
+			}
+			if (attrs.aria_label && stripSep(attrs.aria_label).toLowerCase() === norm) out.push({
+				el,
+				score: .86,
+				layer: "L5",
+				reason: `L5 aria-label="${attrs.aria_label}"`
+			});
 		}
-	},
+		return out;
+	}
+};
+function stripSep(s) {
+	return s.replace(/[-_\s]/g, "");
+}
+const LAYERS = [
+	L0,
+	L1,
+	L2,
+	L3,
+	L4,
+	L5,
 	{
-		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);
+		name: "L6",
+		floor: .75,
+		run: (snapshot, parsed) => {
+			if (!parsed.ordinal) return [];
+			const { n, kind } = parsed.ordinal;
+			const candidates = snapshot.elements.filter((el) => {
+				if (!kind) return true;
+				const role = el.role.toLowerCase();
+				return role === kind || role === `${kind}s` || (el.tag ?? "").toLowerCase() === kind;
+			});
+			if (candidates.length < Math.abs(n)) return [];
+			const sorted = [...candidates].sort((a, b) => {
+				const ay = Math.floor(a.bbox[1] / 24);
+				const by = Math.floor(b.bbox[1] / 24);
+				if (ay !== by) return ay - by;
+				return a.bbox[0] - b.bbox[0];
+			});
+			const idx = n === -1 ? sorted.length - 1 : n - 1;
+			if (idx < 0 || idx >= sorted.length) return [];
+			return [{
+				el: sorted[idx],
+				score: .8,
+				layer: "L6",
+				reason: `L6 ordinal pick #${n} of ${sorted.length} ${kind ?? "elements"}`
+			}];
 		}
 	},
 	{
-		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: [
-						"goto",
-						"back",
-						"forward",
-						"reload"
-					],
-					description: "The navigation action."
-				},
-				url: {
-					type: "string",
-					description: "Required when action=goto. Max 8 KB."
-				},
-				hard: {
-					type: "boolean",
-					description: "Reload only: bypass cache (Ctrl+Shift+R behavior). Default false."
-				}
+		name: "L7",
+		floor: .5,
+		run: (snapshot, parsed) => {
+			const hint = parsed.fieldHint ?? parsed.normTarget;
+			if (!hint) return [];
+			const h = hint.toLowerCase();
+			const out = [];
+			const inputRolePred = (el) => isInputRole(el.role);
+			if (h === "email") {
+				for (const el of snapshot.elements) if (el.inputType === "email" || inputRolePred(el) && (wholeWordContains(el.placeholder ?? "", "email") || wholeWordContains(el.name ?? "", "email"))) out.push({
+					el,
+					score: .55,
+					layer: "L7",
+					reason: "L7 email heuristic"
+				});
+			} else if (h === "password") {
+				for (const el of snapshot.elements) if (el.inputType === "password" || inputRolePred(el) && wholeWordContains(el.name ?? "", "password")) out.push({
+					el,
+					score: .55,
+					layer: "L7",
+					reason: "L7 password heuristic"
+				});
+			} else if (h === "search") {
+				for (const el of snapshot.elements) if (el.role === "searchbox" || el.inputType === "search" || inputRolePred(el) && wholeWordContains(el.name ?? "", "search")) out.push({
+					el,
+					score: .55,
+					layer: "L7",
+					reason: "L7 search heuristic"
+				});
+			} else if (h === "phone" || h === "tel") {
+				for (const el of snapshot.elements) if (el.inputType === "tel" || inputRolePred(el) && wholeWordContains(el.name ?? "", "phone")) out.push({
+					el,
+					score: .55,
+					layer: "L7",
+					reason: "L7 phone heuristic"
+				});
+			} else if (h === "submit" || h === "sign in" || h === "signin" || h === "log in" || h === "login") {
+				const sumRe = /^(submit|send|continue|next|save|sign[\s-]?in|sign[\s-]?up|log[\s-]?in)$/i;
+				for (const el of snapshot.elements) if (el.role === "button" && sumRe.test(el.name ?? "")) out.push({
+					el,
+					score: .55,
+					layer: "L7",
+					reason: "L7 submit heuristic"
+				});
+			} else if (h === "username" || h === "user") {
+				for (const el of snapshot.elements) if (inputRolePred(el) && (wholeWordContains(el.name ?? "", "user") || wholeWordContains(el.name ?? "", "login") || wholeWordContains(el.name ?? "", "account"))) out.push({
+					el,
+					score: .55,
+					layer: "L7",
+					reason: "L7 username heuristic"
+				});
 			}
-		},
-		capability: "browser",
-		async handler(args, signal) {
-			return dispatchBrowserTool("browser_navigate", args, signal);
+			return out;
 		}
-	},
-	{
-		toolNameHttp: "browser_screenshot",
-		description: "Capture a PNG screenshot of the visible area of a tab. Returns base64-encoded image bytes plus contentType. The tab must be active in its window; this tool auto-activates if needed.",
-		inputSchema: {
-			type: "object",
-			required: ["tabId"],
-			additionalProperties: false,
-			properties: {
-				tabId: {
-					type: "number",
-					description: "Tab id from browser_list_tabs / browser_open_tab."
-				},
-				format: {
+	}
+];
+
+//#endregion
+//#region src/lib/browser-mcp/parse-intent.ts
+const VERB_RE = /^\s*(click|press|tap|fill|enter|type|select|choose|scroll(?:[ -]?into[ -]?view)?|toggle|check|uncheck|open|focus|hover)\s+/i;
+const VALUE_RE = /\s+(?:with|to|=)\s+(.+?)\s*$/i;
+const QUOTED_RE = /["'`]([^"'`]+)["'`]/;
+const TITLE_CASE_RE = /\b([A-Z][\w]*(?:\s+[A-Z\d][\w]*){0,3})\b/;
+const ORDINAL_WORDS = {
+	first: 1,
+	second: 2,
+	third: 3,
+	fourth: 4,
+	fifth: 5,
+	sixth: 6,
+	seventh: 7,
+	eighth: 8,
+	ninth: 9,
+	tenth: 10,
+	last: -1
+};
+const ORDINAL_WORD_RE = /\b(first|second|third|fourth|fifth|sixth|seventh|eighth|ninth|tenth|last)\s+(\w+)/i;
+const ORDINAL_NUM_RE = /\b(\d+)(?:st|nd|rd|th)?\s+(\w+)/i;
+const FIELD_HINT_KINDS = [
+	"field",
+	"input",
+	"textbox",
+	"box",
+	"search",
+	"dropdown",
+	"select",
+	"menu",
+	"button",
+	"link",
+	"tab",
+	"checkbox",
+	"radio",
+	"switch"
+];
+const FIELD_HINT_RE = new RegExp(`\\b(\\w+)\\s+(?:${FIELD_HINT_KINDS.join("|")})\\b`, "i");
+const ARTICLES_RE = /\b(the|a|an|this|that)\b/gi;
+/**
+* Parse a natural-language intent into structured parts.
+*
+* Returns a fully-formed `ParsedIntent` even for unparseable inputs
+* (rawTarget = the trimmed intent, normTarget = its lowercased
+* normalization, every other field undefined). The matcher cascade
+* handles "I don't know what to do" by falling through layer-by-
+* layer until L7 or escalate; an unparseable intent simply has
+* less signal for the layers to key on.
+*/
+function parseIntent(intent) {
+	let work = String(intent ?? "").trim();
+	let verb;
+	const verbMatch = VERB_RE.exec(work);
+	if (verbMatch) {
+		verb = mapVerb(verbMatch[1]);
+		work = work.slice(verbMatch[0].length);
+	}
+	let valueFromIntent;
+	const valueMatch = VALUE_RE.exec(work);
+	if (valueMatch) {
+		valueFromIntent = valueMatch[1].trim();
+		work = work.slice(0, valueMatch.index).trim();
+	}
+	let quotedName;
+	const quotedMatch = QUOTED_RE.exec(work);
+	if (quotedMatch) quotedName = quotedMatch[1].trim();
+	else {
+		const titleMatch = TITLE_CASE_RE.exec(work);
+		if (titleMatch) quotedName = titleMatch[1].trim();
+	}
+	let ordinal;
+	const ordWordMatch = ORDINAL_WORD_RE.exec(work);
+	if (ordWordMatch) {
+		const n = ORDINAL_WORDS[ordWordMatch[1].toLowerCase()];
+		if (typeof n === "number") ordinal = {
+			n,
+			kind: ordWordMatch[2].toLowerCase()
+		};
+	} else {
+		const ordNumMatch = ORDINAL_NUM_RE.exec(work);
+		if (ordNumMatch) ordinal = {
+			n: Number.parseInt(ordNumMatch[1], 10),
+			kind: ordNumMatch[2].toLowerCase()
+		};
+	}
+	let fieldHint;
+	const fieldMatch = FIELD_HINT_RE.exec(work);
+	if (fieldMatch) fieldHint = fieldMatch[1].toLowerCase();
+	const rawTarget = work.trim();
+	let normTarget = rawTarget.toLowerCase().replace(ARTICLES_RE, "").replace(/\s+/g, " ").trim();
+	for (const kind of FIELD_HINT_KINDS) {
+		const tail = new RegExp(`\\s+${kind}$`, "i");
+		if (tail.test(normTarget)) {
+			normTarget = normTarget.replace(tail, "").trim();
+			break;
+		}
+	}
+	if (ordinal) normTarget = normTarget.replace(/^(\d+(?:st|nd|rd|th)?|first|second|third|fourth|fifth|sixth|seventh|eighth|ninth|tenth|last)\s+/i, "").trim();
+	const out = {
+		rawTarget,
+		normTarget
+	};
+	if (verb) out.verb = verb;
+	if (quotedName) out.quotedName = quotedName;
+	if (fieldHint) out.fieldHint = fieldHint;
+	if (ordinal) out.ordinal = ordinal;
+	if (valueFromIntent !== void 0) out.valueFromIntent = valueFromIntent;
+	return out;
+}
+function mapVerb(raw) {
+	const v = raw.toLowerCase();
+	if (v === "click" || v === "press" || v === "tap" || v === "toggle" || v === "check" || v === "uncheck" || v === "open") return "click";
+	if (v === "fill" || v === "enter") return "fill";
+	if (v === "type") return "type";
+	if (v === "select" || v === "choose") return "select";
+	if (v === "scroll" || v === "scrollintoview" || v === "scroll into view" || v === "scroll-into-view") return "scroll_into_view";
+	if (v === "hover" || v === "focus") return void 0;
+}
+
+//#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$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);
+		}
+	} 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/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();
+	}
+}
+/**
+* Public re-export of `callCompressor` for sibling modules that need
+* the same forced-tool-calling pipeline (slot acquisition, fallback-
+* chain backend, code-fence stripping). Used by `observe.ts` to drive
+* the natural-language describer through the same backend the matcher
+* cascade escalates to, and by `decompose-planner.ts` for the
+* fast-model compound-step replanner.
+*
+* Kept as a thin wrapper rather than re-exporting `callCompressor`
+* directly so the underlying function can change signature without
+* breaking the public surface.
+*/
+async function callCompressorPublic(systemPrompt, userMessage, tool, signal) {
+	return callCompressor(systemPrompt, userMessage, tool, signal);
+}
+/**
+* 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.
+*
+* Phase 2 short-circuits the common case through the deterministic
+* matcher cascade in `./matcher.ts` — pure-sync, no LLM round-trip,
+* <5ms on a 200-element snapshot. Only when the cascade returns
+* `source: "escalate"` (0 candidates or >1 ambiguous candidates) do
+* we fall through to the existing fast-model `pickMatchingElements`
+* path. When we DO escalate, we pass the cascade's pre-filtered
+* top-K shortlist along so the fast model sees ~8 candidates instead
+* of the full 200-element snapshot — 3-5× token-cost reduction even
+* on misses.
+*
+* 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 det = deterministicResolve(snapshot, parseIntent(intent), value);
+	if (det.source !== "escalate" && det.ref !== "") {
+		const out$1 = {
+			ref: det.ref,
+			action: det.action,
+			confidence: det.confidence
+		};
+		if (det.value !== void 0) out$1.value = det.value;
+		return out$1;
+	}
+	const matches = await pickMatchingElements(snapshot, intent, signal, det.candidates);
+	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.
+*
+* Phase 2 short-circuits via the deterministic matcher cascade when
+* possible. When the cascade finds a single confident match, we
+* synthesize a one-item `FindMatch[]` and skip the fast-model
+* round-trip. When the cascade's `candidates` shortlist is passed in
+* by `pickElement` (escalation path), we trim the snapshot to just
+* those refs before sending to the fast model — keeps tokens down on
+* misses too.
+*/
+async function pickMatchingElements(snapshot, intent, signal, shortlist) {
+	if (!shortlist) {
+		const det = deterministicResolve(snapshot, parseIntent(intent));
+		if (det.source !== "escalate" && det.ref !== "") {
+			if (snapshot.elements.find((e) => e.ref === det.ref)) return [{
+				ref: det.ref,
+				reason: `deterministic ${det.source}: ${det.reason}`
+			}];
+		}
+		shortlist = det.candidates;
+	}
+	const refSet = shortlist && shortlist.length > 0 ? new Set(shortlist.map((s) => s.ref)) : void 0;
+	const trimmed = (refSet ? snapshot.elements.filter((e) => refSet.has(e.ref)) : 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/decompose.ts
+const LOGIN_RE = /^log[ -]?in (?:to .+? )?with\s+([^\s/]+)\s*\/\s*(.+?)\s*$/i;
+const SEARCH_CLICK_RE = /^search\s+(?:for\s+)?(.+?)\s+and\s+click\s+(?:the\s+)?first\s+result\s*$/i;
+const CONJUNCTION_SPLIT_RE = /\s*(?:\s+and\s+then\s+|\s+then\s+|\s*;\s*|\s*,\s+and\s+)\s*/i;
+/**
+* Decompose a natural-language intent into atomic steps.
+*
+* The fallback path returns a single-step `[{intent: rawIntent}]` —
+* `browser_act` behaves identically to today's single-step dispatch
+* when no template matches.
+*/
+function decompose(intent, value) {
+	const raw = String(intent ?? "").trim();
+	if (!raw) return {
+		steps: [{
+			intent: "",
+			...value !== void 0 ? { value } : {}
+		}],
+		template: "fallback"
+	};
+	const loginMatch = LOGIN_RE.exec(raw);
+	if (loginMatch) {
+		const user = loginMatch[1].trim();
+		const pass = loginMatch[2].trim();
+		return {
+			steps: [
+				{
+					intent: "the email or username input",
+					value: user
+				},
+				{
+					intent: "the password input",
+					value: pass
+				},
+				{ intent: "the Sign in or Log in button" }
+			],
+			template: "login",
+			successSummary: "logged in"
+		};
+	}
+	const searchMatch = SEARCH_CLICK_RE.exec(raw);
+	if (searchMatch) {
+		const query = searchMatch[1].trim();
+		return {
+			steps: [
+				{
+					intent: "the search input",
+					value: query
+				},
+				{ intent: "the search button or submit" },
+				{ intent: "the first search result" }
+			],
+			template: "search_click",
+			successSummary: `searched for "${query}" and opened first result`
+		};
+	}
+	if (CONJUNCTION_SPLIT_RE.test(raw)) {
+		const parts = raw.split(CONJUNCTION_SPLIT_RE).map((p) => p.trim()).filter(Boolean);
+		if (parts.length >= 2) return {
+			steps: parts.map((p, i) => {
+				if (i === 0 && value !== void 0) return {
+					intent: p,
+					value
+				};
+				return { intent: p };
+			}),
+			template: "conjunction"
+		};
+	}
+	return {
+		steps: [{
+			intent: raw,
+			...value !== void 0 ? { value } : {}
+		}],
+		template: "fallback"
+	};
+}
+
+//#endregion
+//#region src/lib/browser-mcp/observe.ts
+const OBSERVE_SYSTEM = `You describe a web page for an AI assistant that cannot see the DOM.
+
+Write 2-4 sentences focused on user-actionable elements (forms, buttons, links) and the page's purpose. If 'intent' is provided, focus the description on the region most relevant to that intent.
+
+DO NOT mention DOM refs, selectors, bbox coordinates, or any internal identifiers. Plain prose only. Treat the reader as someone who will issue commands like "click the Sign In button" — describe what's there in terms they can act on.
+
+Call the describe_page tool with your description.`;
+const OBSERVE_TOOL = {
+	name: "describe_page",
+	description: "Report the natural-language description of the page.",
+	parameters: {
+		type: "object",
+		required: ["description"],
+		additionalProperties: false,
+		properties: { description: {
+			type: "string",
+			description: "2-4 sentence prose description of the visible page state."
+		} }
+	}
+};
+/**
+* Produce a natural-language description of the current page state.
+* The lead model never sees the underlying snapshot.
+*/
+async function observePage(snapshot, intent, signal) {
+	const trimmedElements = snapshot.elements.filter((e) => e.name && e.name.length > 0).slice(0, 80).map((e) => ({
+		role: e.role,
+		name: e.name
+	}));
+	const raw = await callCompressorPublic(OBSERVE_SYSTEM, JSON.stringify({
+		intent: intent ?? "",
+		url: snapshot.url ?? "",
+		title: snapshot.title ?? "",
+		visible_text: (snapshot.text ?? "").slice(0, 4e3),
+		actionable_elements: trimmedElements,
+		has_visual_surfaces: Boolean(snapshot.visualSurfaces && snapshot.visualSurfaces.length > 0)
+	}), OBSERVE_TOOL, signal);
+	const out = {
+		description: raw && typeof raw === "object" && typeof raw.description === "string" ? raw.description : "Page contents could not be described.",
+		hasVisualSurfaces: Boolean(snapshot.visualSurfaces && snapshot.visualSurfaces.length > 0)
+	};
+	if (snapshot.url) out.url = snapshot.url;
+	if (snapshot.title) out.title = snapshot.title;
+	return out;
+}
+
+//#endregion
+//#region src/lib/browser-mcp/planner.ts
+const PLANNER_SYSTEM = `You are a browser-automation replanner. A user issued a high-level intent that was decomposed into atomic steps. Several steps ran successfully, then one failed. You see the page state AFTER the failure and decide what to do next.
+
+Your job: produce a revised list of atomic steps that will accomplish the original intent given the current page. If you cannot — the page has changed in a way that makes the intent impossible (login form vanished, navigation moved elsewhere, captcha appeared) — return an empty list and explain why in reasoning.
+
+Each replanned step is a free-form natural-language intent ("the email input", "the Sign In button at the bottom of the form") plus an optional value for fill/type/select actions. Be SPECIFIC about element location ("at the bottom of the form", "in the top navigation") so the deterministic matcher cascade can resolve it without ambiguity. Do NOT reference element refs.
+
+Cost rule: you get ONE call per compound failure. Make every step count.
+
+Call the replan_compound tool with your answer.`;
+const PLANNER_TOOL = {
+	name: "replan_compound",
+	description: "Report the revised atomic steps to complete the original compound intent.",
+	parameters: {
+		type: "object",
+		required: ["steps", "reasoning"],
+		additionalProperties: false,
+		properties: {
+			steps: {
+				type: "array",
+				maxItems: 8,
+				items: {
+					type: "object",
+					required: ["intent"],
+					additionalProperties: false,
+					properties: {
+						intent: { type: "string" },
+						value: { type: "string" }
+					}
+				}
+			},
+			reasoning: {
+				type: "string",
+				description: "1-2 sentence explanation of the replanning decision."
+			}
+		}
+	}
+};
+/**
+* Run the fast-model planner on a failed compound. Returns the
+* revised step list (may be empty if the planner gives up).
+*
+* The snapshot is trimmed before sending to keep the round-trip
+* small: only element role + name + brief value/placeholder if
+* present. Bbox / state flags / frame ids would just inflate tokens
+* without helping the natural-language replanner.
+*/
+async function planCompoundReplan(input, signal) {
+	const trimmed = input.snapshot.elements.slice(0, 80).map((e) => {
+		const out = { role: e.role };
+		if (e.name) out.name = e.name;
+		if (e.placeholder) out.placeholder = e.placeholder;
+		if (e.value) out.value = e.value;
+		return out;
+	});
+	const raw = await callCompressorPublic(PLANNER_SYSTEM, JSON.stringify({
+		original_intent: input.originalIntent,
+		original_value: input.originalValue,
+		completed_steps: input.completedSteps.map((s) => ({
+			intent: s.intent,
+			...s.value !== void 0 ? { value: s.value } : {}
+		})),
+		failed_step: {
+			intent: input.failedStep.intent,
+			...input.failedStep.value !== void 0 ? { value: input.failedStep.value } : {}
+		},
+		failure_reason: input.failureReason,
+		page_now: {
+			url: input.snapshot.url ?? "",
+			title: input.snapshot.title ?? "",
+			visible_text: (input.snapshot.text ?? "").slice(0, 3e3),
+			actionable_elements: trimmed
+		}
+	}), PLANNER_TOOL, signal);
+	if (!raw || typeof raw !== "object") return {
+		steps: [],
+		reasoning: "planner returned empty response"
+	};
+	const obj = raw;
+	const reasoning = typeof obj.reasoning === "string" ? obj.reasoning : "";
+	if (!Array.isArray(obj.steps)) return {
+		steps: [],
+		reasoning
+	};
+	const steps = [];
+	for (const s of obj.steps.slice(0, 8)) {
+		if (!s || typeof s !== "object") continue;
+		const intent = s.intent;
+		const value = s.value;
+		if (typeof intent === "string" && intent.length > 0) {
+			const step = { intent };
+			if (typeof value === "string") step.value = value;
+			steps.push(step);
+		}
+	}
+	return {
+		steps,
+		reasoning
+	};
+}
+
+//#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_power",
+		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",
-					enum: ["png", "jpeg"],
-					description: "Image format. Default 'png'."
+					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_screenshot", args, signal);
+			return dispatchBrowserTool("browser_open_tab", args, signal);
 		}
 	},
 	{
-		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.",
+		toolNameHttp: "browser_close_tab",
+		description: "Close one or more tabs by tab id.",
 		inputSchema: {
 			type: "object",
-			required: ["tabId"],
+			required: ["tabIds"],
 			additionalProperties: false,
-			properties: { tabId: {
-				type: "number",
-				description: "Tab id from browser_list_tabs / browser_open_tab."
+			properties: { tabIds: {
+				type: "array",
+				items: { type: "number" },
+				description: "Array of tab ids to close (from browser_list_tabs)."
 			} }
 		},
-		capability: "browser",
+		capability: "browser_power",
 		async handler(args, signal) {
-			return dispatchBrowserTool("browser_read_page", args, signal);
+			return dispatchBrowserTool("browser_close_tab", 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.",
+		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"],
+			required: ["tabId", "action"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
-				ref: {
-					type: "string",
-					description: "Element ref from browser_read_page (preferred)."
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs / browser_open_tab."
 				},
-				selector: {
+				action: {
 					type: "string",
-					description: "CSS selector (fallback when no ref)."
+					enum: [
+						"goto",
+						"back",
+						"forward",
+						"reload"
+					],
+					description: "The navigation action."
 				},
-				button: {
+				url: {
 					type: "string",
-					enum: ["left", "right"],
-					description: "Mouse button. Default 'left'."
+					description: "Required when action=goto. Max 8 KB."
 				},
-				clickCount: {
-					type: "number",
-					description: "Number of times to click. Default 1."
+				hard: {
+					type: "boolean",
+					description: "Reload only: bypass cache (Ctrl+Shift+R behavior). Default false."
 				}
 			}
 		},
 		capability: "browser",
 		async handler(args, signal) {
-			return dispatchBrowserTool("browser_click", args, signal);
+			return dispatchBrowserTool("browser_navigate", 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.",
+		toolNameHttp: "browser_screenshot",
+		description: "Capture a PNG screenshot of the visible area of a tab. Returns base64-encoded image bytes plus contentType. The tab must be active in its window; this tool auto-activates if needed.",
 		inputSchema: {
 			type: "object",
-			required: ["tabId", "value"],
+			required: ["tabId"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
-				ref: {
-					type: "string",
-					description: "Element ref from browser_read_page (preferred)."
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs / browser_open_tab."
 				},
-				selector: {
+				format: {
 					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: ["png", "jpeg"],
+					description: "Image format. Default 'png'."
 				}
 			}
 		},
 		capability: "browser",
 		async handler(args, signal) {
-			return dispatchBrowserTool("browser_fill", args, signal);
+			return dispatchBrowserTool("browser_screenshot", args, signal);
+		}
+	},
+	{
+		toolNameHttp: "browser_read_page",
+		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",
+					description: "Tab id from browser_list_tabs / browser_open_tab."
+				},
+				mode: {
+					type: "string",
+					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_power",
+		async handler(args, signal) {
+			return dispatchBrowserTool("browser_read_page", args, signal);
 		}
 	},
 	{
@@ -3495,7 +5096,7 @@ const BROWSER_TOOLS = Object.freeze([
 				}
 			}
 		},
-		capability: "browser",
+		capability: "browser_power",
 		async handler(args, signal) {
 			return dispatchBrowserTool("browser_scroll", args, signal);
 		}
@@ -3515,7 +5116,7 @@ const BROWSER_TOOLS = Object.freeze([
 				}
 			}
 		},
-		capability: "browser",
+		capability: "browser_power",
 		async handler(args, signal) {
 			return dispatchBrowserTool("browser_keyboard", args, signal);
 		}
@@ -3552,7 +5153,7 @@ const BROWSER_TOOLS = Object.freeze([
 				}
 			}
 		},
-		capability: "browser",
+		capability: "browser_power",
 		async handler(args, signal) {
 			return dispatchBrowserTool("browser_wait", args, signal);
 		}
@@ -3576,7 +5177,7 @@ const BROWSER_TOOLS = Object.freeze([
 				}
 			}
 		},
-		capability: "browser",
+		capability: "browser_power",
 		async handler(args, signal) {
 			return dispatchBrowserTool("browser_eval_js", args, signal);
 		}
@@ -3608,53 +5209,11 @@ const BROWSER_TOOLS = Object.freeze([
 				}
 			}
 		},
-		capability: "browser",
+		capability: "browser_power",
 		async handler(args, signal) {
 			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.",
@@ -3714,7 +5273,7 @@ const BROWSER_TOOLS = Object.freeze([
 				}
 			}
 		},
-		capability: "browser",
+		capability: "browser_power",
 		async handler(args, signal) {
 			return dispatchBrowserTool("browser_mouse", args, signal);
 		}
@@ -3788,7 +5347,7 @@ const BROWSER_TOOLS = Object.freeze([
 				}
 			}
 		},
-		capability: "browser",
+		capability: "browser_power",
 		async handler(args, signal) {
 			return dispatchBrowserTool("browser_drag", args, signal);
 		}
@@ -3812,36 +5371,448 @@ const BROWSER_TOOLS = Object.freeze([
 				}
 			}
 		},
-		capability: "browser",
+		capability: "browser_power",
 		async handler(args, signal) {
 			return dispatchBrowserTool("browser_type", args, 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_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_power",
+		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_power",
+		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_read_page (preferred). Exactly one of ref / selector required."
+					description: "Element ref from browser_find / browser_read_page. Triggers REF mode (no compressor round-trip)."
 				},
-				selector: {
+				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) {
+			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 decomposed = decompose(intent, value);
+			if (decomposed.steps.length === 1) return runAtomicIntentStep(tabId, decomposed.steps[0].intent, decomposed.steps[0].value, signal);
+			const summaries = [];
+			let navigated = false;
+			const completedSteps = [];
+			for (let i = 0; i < decomposed.steps.length; i++) {
+				const step = decomposed.steps[i];
+				const env = await runAtomicIntentStep(tabId, step.intent, step.value, signal);
+				const stepText = env.content?.[0]?.text;
+				let stepResult = {};
+				if (typeof stepText === "string") try {
+					stepResult = JSON.parse(stepText);
+				} catch {}
+				if (env.isError || stepResult.ok === false) try {
+					const failureReason = String(stepResult.error ?? "unknown");
+					const replan = await planCompoundReplan({
+						originalIntent: intent,
+						originalValue: value,
+						completedSteps,
+						failedStep: step,
+						failureReason,
+						snapshot: await fetchSnapshot(tabId, signal)
+					}, signal);
+					if (replan.steps.length === 0) return toolEnvelope({
+						ok: false,
+						summary: `compound step ${i + 1}/${decomposed.steps.length} failed and planner declined: ${replan.reasoning || failureReason}`,
+						template: decomposed.template,
+						steps_completed: i,
+						failed_step: step.intent,
+						planner_reasoning: replan.reasoning
+					}, true);
+					const replanSummaries = [];
+					for (let j = 0; j < replan.steps.length; j++) {
+						const rstep = replan.steps[j];
+						const renv = await runAtomicIntentStep(tabId, rstep.intent, rstep.value, signal);
+						const rtext = renv.content?.[0]?.text;
+						let rresult = {};
+						if (typeof rtext === "string") try {
+							rresult = JSON.parse(rtext);
+						} catch {}
+						if (renv.isError || rresult.ok === false) return toolEnvelope({
+							ok: false,
+							summary: `compound failed at original step ${i + 1}, planner replan also failed at step ${j + 1}/${replan.steps.length}: ${String(rresult.error ?? "unknown")}`,
+							template: decomposed.template,
+							steps_completed: i,
+							failed_step: rstep.intent,
+							planner_reasoning: replan.reasoning
+						}, true);
+						if (typeof rresult.action_taken === "string") replanSummaries.push(`${rresult.action_taken} (${rstep.intent})`);
+						if (rresult.navigated === true) navigated = true;
+					}
+					return toolEnvelope({
+						ok: true,
+						summary: `compound recovered via planner (${replan.reasoning}): ${replanSummaries.join(" → ")}`,
+						template: decomposed.template,
+						steps_completed: i + replan.steps.length,
+						navigated,
+						planner_used: true,
+						planner_reasoning: replan.reasoning
+					});
+				} catch (replanErr) {
+					return toolEnvelope({
+						ok: false,
+						summary: `compound step ${i + 1}/${decomposed.steps.length} failed; planner errored: ${replanErr instanceof Error ? replanErr.message : String(replanErr)}`,
+						template: decomposed.template,
+						steps_completed: i,
+						failed_step: step.intent
+					}, true);
+				}
+				if (typeof stepResult.action_taken === "string") summaries.push(`${stepResult.action_taken} (${step.intent})`);
+				if (stepResult.navigated === true) navigated = true;
+				completedSteps.push(step);
+			}
+			return toolEnvelope({
+				ok: true,
+				summary: decomposed.successSummary ?? summaries.join(" → "),
+				template: decomposed.template,
+				steps_completed: decomposed.steps.length,
+				navigated
+			});
+		}
+	},
+	{
+		toolNameHttp: "browser_observe",
+		description: "Get a natural-language description of the current page's user-actionable state — what forms, buttons, links, and content sections are visible — in 2-4 sentences. Optional `intent` focuses the description on a region ('describe the login form', 'what's in the comments section'). Use this BEFORE browser_act when you don't know what's on the page, or AFTER navigation to confirm the page loaded. Cheaper than screenshots when text is enough. Does not include canvas/SVG content — those surface as a `hasVisualSurfaces` flag; switch to browser_screenshot for visuals.",
+		inputSchema: {
+			type: "object",
+			required: ["tabId"],
+			additionalProperties: false,
+			properties: {
+				tabId: { type: "number" },
+				intent: {
+					type: "string",
+					description: "Optional natural-language focus ('describe the form', 'what's in the sidebar')."
+				}
+			}
+		},
+		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 : void 0;
+			if (!tabId) return toolEnvelope({ error: "tabId required" }, true);
+			return toolEnvelope(await observePage(await fetchSnapshot(tabId, signal), intent, signal));
+		}
+	},
+	{
+		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",
+				"schema",
+				"instruction"
+			],
+			additionalProperties: false,
+			properties: {
+				tabId: { type: "number" },
+				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",
-		async handler(args, signal) {
-			return dispatchBrowserTool("browser_locate", args, signal);
+		},
+		capability: "browser_compound",
+		async handler(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;
+			}
+		}
+	}
+]);
+/**
+* Run a single atomic intent step: fetch snapshot, run matcher
+* cascade (via pickElement), visual fallback on no-match, dispatch
+* the resolved action. Returns the standard MCP envelope.
+*
+* Pulled out of `browser_act`'s handler so the compound-intent loop
+* (decompose path) can call it per-step without duplicating the
+* snapshot + visual-fallback logic.
+*/
+async function runAtomicIntentStep(tabId, intent, 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);
+}
+/**
+* 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 +7387,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 +7405,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 +7868,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 +8324,47 @@ 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();
+}
+/**
+* Gate for the L0/L1 power browser tools (`browser_read_page`,
+* `browser_mouse`, `browser_drag`, `browser_type`, `browser_keyboard`,
+* `browser_scroll`, `browser_eval_js`, `browser_diagnostics`,
+* `browser_find`, `browser_close_tab`, `browser_list_tabs`,
+* `browser_wait`, `browser_download`).
+*
+* Returns true iff `state.powerBrowseEnabled` (set by `--power-browse`
+* or `GH_ROUTER_ENABLE_POWER_BROWSE=1`). When off, the default
+* `--browse` surface exposes only the 6 lead-model tools (`act`,
+* `observe`, `extract`, `navigate`, `screenshot`, `open_tab`) that
+* hide DOM details behind intent. Power mode adds the raw primitives
+* for users who want direct coord/keystroke control.
+*
+* `handler.ts` filter chain ANDs this with `browserToolsEnabled()`
+* (defense-in-depth — power without basic is meaningless and the
+* setup path already forces basic on when power is on).
+*/
+function browserPowerToolsEnabled() {
+	return state.powerBrowseEnabled === true;
+}
 
 //#endregion
 //#region src/routes/mcp/handler.ts
@@ -6739,6 +8541,8 @@ 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();
+		if (t.capability === "browser_power") return browserToolsEnabled() && browserPowerToolsEnabled();
 		return true;
 	}).map((t) => ({
 		name: t.toolNameHttp,
@@ -7030,6 +8834,8 @@ 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}"`);
+	if (nonPersonaTool && nonPersonaTool.capability === "browser_power" && !(browserToolsEnabled() && browserPowerToolsEnabled())) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name$1}"`);
 	let personaPrompt;
 	let personaContext;
 	let personaEffort;
@@ -10583,6 +12389,10 @@ 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) {
+		const powerNote = opts.powerBrowseAvailable ? " Power mode is on: the L0/L1 primitives (`browser_mouse`, `browser_drag`, `browser_type`, `browser_keyboard`, `browser_scroll`, `browser_eval_js`, `browser_read_page`, `browser_diagnostics`, `browser_find`) are also available for direct DOM / coordinate control." : "";
+		para2Parts.push(`\`browser_*\` tools (under \`mcp__gh-router-peers__browser_*\`) drive a real Chrome / Edge browser via a local extension. Lead surface: \`browser_act(intent, value?)\` for any click / fill / type / scroll-to (an inner fast model resolves intent), \`browser_observe(intent?)\` for a 2-4 sentence natural-language page description, \`browser_extract(schema, instruction)\` for typed extraction, \`browser_navigate\` / \`browser_open_tab\` / \`browser_screenshot\` for state and visuals. The lead model never sees raw DOM: refs, bboxes, and role/name dumps stay internal.${powerNote}`);
+	}
 	return [
 		"## Peer review and advisor",
 		"",
@@ -12045,7 +13855,7 @@ function initProxyFromEnv() {
 //#endregion
 //#region package.json
 var name = "github-router";
-var version = "0.3.45";
+var version$1 = "0.3.66";
 
 //#endregion
 //#region src/lib/approval.ts
@@ -13716,7 +15526,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));
@@ -13767,6 +15577,11 @@ async function setupAndServe(options) {
 	state.showToken = options.showToken;
 	state.extendedBetas = options.extendedBetas;
 	state.browseEnabled = options.browseEnabled || process.env.GH_ROUTER_ENABLE_BROWSE === "1";
+	state.powerBrowseEnabled = options.powerBrowseEnabled || process.env.GH_ROUTER_ENABLE_POWER_BROWSE === "1";
+	if (state.powerBrowseEnabled) state.browseEnabled = true;
+	if (process.env.GH_ROUTER_BROWSER_NO_HUMANLIKE === "1") state.humanlikeForce = "off";
+	else if (options.humanlikeEnabled || process.env.GH_ROUTER_HUMANLIKE === "1") state.humanlikeForce = "on";
+	else state.humanlikeForce = "auto";
 	if (process.env.COPILOT_API_URL) state.copilotApiUrl = process.env.COPILOT_API_URL;
 	await ensurePaths();
 	await cacheVSCodeVersion();
@@ -13874,6 +15689,16 @@ const sharedServerArgs = {
 		type: "boolean",
 		default: false,
 		description: "Enable the browser-control MCP tools (browser_open_tab, browser_screenshot, browser_click, etc.) on /mcp. Requires Chrome or Edge installed; the bundled extension must be loaded on first tool call (the proxy returns install_required with Web Store URLs + a Load Unpacked fallback path). Off by default; can also be enabled with GH_ROUTER_ENABLE_BROWSE=1."
+	},
+	"power-browse": {
+		type: "boolean",
+		default: false,
+		description: "Expose the full ~18-tool browser MCP surface (raw read_page, mouse / drag / scroll / keyboard / type primitives, eval_js, diagnostics, find, locate). Default --browse exposes only the 6 lead-model tools (act, observe, extract, navigate, screenshot, open_tab) that hide DOM details behind intent. Implies --browse. Off by default; can also be enabled with GH_ROUTER_ENABLE_POWER_BROWSE=1."
+	},
+	humanlike: {
+		type: "boolean",
+		default: false,
+		description: "Force humanlike pacing on ALL browser tool dispatches: Beta-distributed inter-action delays (800-4600 ms), Bezier mouse trajectories with overshoot-and-correct, per-keystroke jitter with word-end pauses, scroll chunking. Use for known anti-bot sites (Cloudflare, Datadome). Off by default (auto mode); GH_ROUTER_HUMANLIKE=1 is the env equivalent. GH_ROUTER_BROWSER_NO_HUMANLIKE=1 hard-disables (wins over --humanlike, for tests)."
 	}
 };
 const allowedAccountTypes = new Set([
@@ -13911,7 +15736,9 @@ function parseSharedArgs(args) {
 		showToken: args["show-token"],
 		proxyEnv: args["proxy-env"],
 		extendedBetas: args["extended-betas"],
-		browseEnabled: args.browse
+		browseEnabled: args.browse,
+		powerBrowseEnabled: args["power-browse"],
+		humanlikeEnabled: args.humanlike
 	};
 }
 /**
@@ -14150,7 +15977,9 @@ const claude = defineCommand({
 				codexCli: backend === "cli",
 				geminiAvailable: geminiAvailable$1,
 				workerToolsAvailable: workerToolsEnabled(),
-				standInAvailable: standInToolEnabled()
+				standInAvailable: standInToolEnabled(),
+				browseAvailable: state.browseEnabled,
+				powerBrowseAvailable: state.powerBrowseEnabled
 			});
 			extraArgs.push("--append-system-prompt", peerSnippet);
 			try {
@@ -14247,7 +16076,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 +16102,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 +16426,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: {