github-router 0.3.121 → 0.3.126

package/dist/{peer-mcp-personas-CoeEliOe.js → peer-mcp-personas-Be4SAgm0.js}

@@ -40,6 +40,7 @@ const state = {
 	showToken: false,
 	extendedBetas: false,
 	browseEnabled: false,
+	fleetEnabled: false,
 	powerBrowseEnabled: false,
 	humanlikeForce: "auto",
 	sessionId: randomUUID(),
@@ -306,12 +307,12 @@ async function fetchWithTransientRetry(doFetch, opts = {}) {
 			await res.body.cancel();
 		} catch {}
 		const expCap = Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
-		const delay = Math.min(maxDelayMs, retryAfterMs ?? Math.round(Math.random() * expCap));
+		const delay$1 = Math.min(maxDelayMs, retryAfterMs ?? Math.round(Math.random() * expCap));
 		if (label) {
 			const why = res ? `HTTP ${res.status}` : caught?.name ?? "error";
-			consola.debug(`[upstream-retry] ${label}: attempt ${attempt}/${attempts} failed (${why}); retrying in ${delay}ms`);
+			consola.debug(`[upstream-retry] ${label}: attempt ${attempt}/${attempts} failed (${why}); retrying in ${delay$1}ms`);
 		}
-		await abortableSleep(delay, signal);
+		await abortableSleep(delay$1, signal);
 	}
 }
 /** Extract an HTTP status from a thrown error (HTTPError carries
@@ -352,9 +353,9 @@ async function withTransientRetry(fn, opts = {}) {
 			if (!(status !== void 0 && retryStatuses.includes(status) || isTransientNetworkError(err)) || attempt >= attempts) throw err;
 			const retryAfterMs = parseRetryAfter(err?.response?.headers?.get?.("retry-after") ?? null);
 			const expCap = Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
-			const delay = Math.min(maxDelayMs, retryAfterMs ?? Math.round(Math.random() * expCap));
-			if (label) consola.debug(`[upstream-retry] ${label}: attempt ${attempt}/${attempts} threw (${status !== void 0 ? `HTTP ${status}` : err?.name ?? "error"}); retrying in ${delay}ms`);
-			await abortableSleep(delay, signal);
+			const delay$1 = Math.min(maxDelayMs, retryAfterMs ?? Math.round(Math.random() * expCap));
+			if (label) consola.debug(`[upstream-retry] ${label}: attempt ${attempt}/${attempts} threw (${status !== void 0 ? `HTTP ${status}` : err?.name ?? "error"}); retrying in ${delay$1}ms`);
+			await abortableSleep(delay$1, signal);
 		}
 	}
 }
@@ -1045,6 +1046,1886 @@ function collapsePathKeys(env) {
 	return env;
 }
 
+//#endregion
+//#region src/lib/artifact/client.ts
+var ArtifactError = class extends Error {
+	code;
+	retryable;
+	status;
+	detail;
+	constructor(args) {
+		super(args.message);
+		this.name = "ArtifactError";
+		this.code = args.code;
+		this.retryable = args.retryable;
+		this.status = args.status;
+		this.detail = args.detail;
+	}
+};
+var ArtifactClient = class {
+	baseUrl;
+	token;
+	sessionId;
+	fetchFn;
+	constructor(options) {
+		this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+		this.token = options.token;
+		this.sessionId = options.sessionId;
+		this.fetchFn = options.fetchFn ?? globalThis.fetch.bind(globalThis);
+	}
+	open(file, signal) {
+		return this.request("POST", `/api/artifact/${encodeURIComponent(this.sessionId)}/open`, { file }, signal);
+	}
+	poll(timeoutMsHint, signal) {
+		return this.request("GET", `/api/artifact/${encodeURIComponent(this.sessionId)}/poll`, void 0, signal, timeoutMsHint);
+	}
+	agentReply(text, signal) {
+		return this.request("POST", `/api/artifact/${encodeURIComponent(this.sessionId)}/agent-reply`, { text }, signal, void 0, true);
+	}
+	async request(method, pathname, body, signal, timeoutMsHint, allowEmptyJson = false) {
+		let url;
+		try {
+			url = new URL(pathname, `${this.baseUrl}/`);
+		} catch (err) {
+			throw new ArtifactError({
+				code: "UNREACHABLE",
+				message: "artifact API base URL is invalid",
+				retryable: false,
+				detail: err
+			});
+		}
+		const timeout = combineSignalAndTimeout(signal, timeoutMsHint);
+		let response;
+		try {
+			response = await this.fetchFn(url.toString(), {
+				method,
+				headers: {
+					Authorization: `Bearer ${this.token}`,
+					...body === void 0 ? {} : { "Content-Type": "application/json" }
+				},
+				body: body === void 0 ? void 0 : JSON.stringify(body),
+				redirect: "error",
+				signal: timeout.signal
+			});
+		} catch (err) {
+			throw mapNetworkError$1(err);
+		} finally {
+			timeout.cleanup();
+		}
+		if (!response.ok) throw await mapHttpError$1(response);
+		const text = await response.text().catch((err) => {
+			throw new ArtifactError({
+				code: "INVALID_RESPONSE",
+				message: "artifact API response body could not be read",
+				retryable: false,
+				detail: err
+			});
+		});
+		if (!text && allowEmptyJson) return {};
+		try {
+			return JSON.parse(text);
+		} catch (err) {
+			throw new ArtifactError({
+				code: "INVALID_RESPONSE",
+				message: "artifact API returned a non-JSON response",
+				retryable: false,
+				detail: err
+			});
+		}
+	}
+};
+function combineSignalAndTimeout(signal, timeoutMsHint) {
+	const timeoutMs = typeof timeoutMsHint === "number" && Number.isFinite(timeoutMsHint) && timeoutMsHint > 0 ? timeoutMsHint : void 0;
+	if (timeoutMs === void 0) return {
+		signal,
+		cleanup: () => {}
+	};
+	const controller = new AbortController();
+	const abortFromCaller = () => {
+		try {
+			controller.abort(signal?.reason);
+		} catch {
+			controller.abort();
+		}
+	};
+	if (signal?.aborted) abortFromCaller();
+	signal?.addEventListener("abort", abortFromCaller, { once: true });
+	const timer = setTimeout(() => {
+		try {
+			controller.abort(new DOMException("artifact API request timed out", "TimeoutError"));
+		} catch {
+			controller.abort();
+		}
+	}, timeoutMs);
+	return {
+		signal: controller.signal,
+		cleanup: () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", abortFromCaller);
+		}
+	};
+}
+async function mapHttpError$1(response) {
+	const detail = await readErrorDetail$1(response);
+	const upstreamMessage = detailToMessage$1(detail);
+	const suffix = upstreamMessage ? `: ${upstreamMessage}` : "";
+	if (response.status === 401 || response.status === 403) return new ArtifactError({
+		code: "AUTH_FAILED",
+		message: `artifact API authentication failed (${response.status})${suffix}`,
+		retryable: false,
+		status: response.status,
+		detail
+	});
+	if (response.status === 404) return new ArtifactError({
+		code: "NOT_FOUND",
+		message: `artifact session or resource not found (404)${suffix}`,
+		retryable: false,
+		status: response.status,
+		detail
+	});
+	if (response.status === 408 || response.status === 504) return new ArtifactError({
+		code: "TIMEOUT",
+		message: `artifact API request timed out (${response.status})${suffix}`,
+		retryable: true,
+		status: response.status,
+		detail
+	});
+	return new ArtifactError({
+		code: "UPSTREAM_ERROR",
+		message: `artifact API returned HTTP ${response.status}${suffix}`,
+		retryable: response.status === 429 || response.status >= 500,
+		status: response.status,
+		detail
+	});
+}
+function mapNetworkError$1(err) {
+	if (isAbortLike$2(err)) return new ArtifactError({
+		code: "TIMEOUT",
+		message: "artifact API request timed out or was aborted",
+		retryable: true,
+		detail: err
+	});
+	return new ArtifactError({
+		code: "UNREACHABLE",
+		message: `artifact API unreachable: ${err instanceof Error ? err.message : String(err)}`,
+		retryable: true,
+		detail: err
+	});
+}
+async function readErrorDetail$1(response) {
+	const text = await response.text().catch(() => "");
+	if (!text) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+function detailToMessage$1(detail) {
+	if (typeof detail === "string") return detail;
+	if (typeof detail !== "object" || detail === null) return void 0;
+	const record = detail;
+	const error = record.error;
+	if (typeof error === "string") return error;
+	if (typeof error === "object" && error !== null) {
+		const errorRecord = error;
+		if (typeof errorRecord.message === "string") return errorRecord.message;
+		if (typeof errorRecord.code === "string") return errorRecord.code;
+	}
+	if (typeof record.message === "string") return record.message;
+}
+function isAbortLike$2(err) {
+	return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+}
+
+//#endregion
+//#region src/lib/artifact/tools.ts
+const ARTIFACT_GROUP = "peers";
+const ARTIFACT_POLL_TOOL_BUDGET_MS = 5e4;
+const ARTIFACT_SINGLE_POLL_TIMEOUT_MS = 25e3;
+const ARTIFACT_POLL_RETURN_MARGIN_MS = 1e3;
+const ARTIFACT_MAX_POLLS_PER_TOOL_CALL = 2;
+function tool(toolNameHttp, description, inputSchema, handler) {
+	return {
+		toolNameHttp,
+		group: ARTIFACT_GROUP,
+		capability: "artifact",
+		description,
+		inputSchema,
+		async handler(args, signal) {
+			try {
+				return await handler(args, signal);
+			} catch (err) {
+				return errorResult$1(err);
+			}
+		}
+	};
+}
+const ARTIFACT_TOOLS = Object.freeze([
+	tool("artifact_open", "Open a workspace file in ai-or-die's Artifact review panel for human review. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$1({ file: stringProp$1("Workspace-relative or absolute file path to show in the Artifact panel.") }, ["file"]), async (args, signal) => {
+		const env = readArtifactEnv();
+		if (!env) return missingEnvResult();
+		const file = requiredString$1(args, "file");
+		return ok$1({
+			viewUrl: (await clientFromEnv(env).open(file, signal)).viewUrl,
+			next_step: "Tell the user to review at the Artifact panel, then call artifact_poll."
+		});
+	}),
+	tool("artifact_poll", "Wait for human Artifact review feedback from ai-or-die and return the prompts/layout warnings/DOM snapshot for the agent to act on. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$1({}, []), async (_args, signal) => {
+		const env = readArtifactEnv();
+		if (!env) return missingEnvResult();
+		return ok$1(formatPollResponse(await pollUntilReady(clientFromEnv(env), signal)));
+	}),
+	tool("artifact_reply", "Send the agent's reply back to the ai-or-die Artifact review panel after applying or responding to human feedback. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$1({ text: stringProp$1("Agent reply text to deliver to the human Artifact review panel.") }, ["text"]), async (args, signal) => {
+		const env = readArtifactEnv();
+		if (!env) return missingEnvResult();
+		const text = requiredString$1(args, "text");
+		return ok$1({
+			ok: true,
+			...await clientFromEnv(env).agentReply(text, signal),
+			next_step: "Wait for further human review, or continue if the review loop is complete."
+		});
+	})
+]);
+function readArtifactEnv() {
+	const baseUrl = process.env.AIORDIE_BASE_URL;
+	const token = process.env.AIORDIE_TOKEN;
+	const sessionId = process.env.AIORDIE_SESSION_ID;
+	if (!baseUrl || !token || !sessionId) return void 0;
+	return {
+		baseUrl,
+		token,
+		sessionId
+	};
+}
+function clientFromEnv(env) {
+	return new ArtifactClient(env);
+}
+async function pollUntilReady(client, signal) {
+	const deadline = Date.now() + ARTIFACT_POLL_TOOL_BUDGET_MS;
+	let last;
+	let attempts = 0;
+	while (!signal?.aborted && attempts < ARTIFACT_MAX_POLLS_PER_TOOL_CALL) {
+		attempts += 1;
+		const remaining = deadline - Date.now();
+		if (remaining <= ARTIFACT_POLL_RETURN_MARGIN_MS) break;
+		const timeoutMsHint = Math.min(ARTIFACT_SINGLE_POLL_TIMEOUT_MS, Math.max(1, remaining - ARTIFACT_POLL_RETURN_MARGIN_MS));
+		last = await client.poll(timeoutMsHint, signal);
+		if (!isWaitingPoll(last)) return last;
+		if (deadline - Date.now() <= ARTIFACT_POLL_RETURN_MARGIN_MS) break;
+	}
+	return {
+		...last ?? { status: "waiting" },
+		status: "waiting",
+		next_step: "No human feedback is ready yet. Call artifact_poll again."
+	};
+}
+function isWaitingPoll(response) {
+	if (hasFeedback(response.prompts)) return false;
+	const status = response.status.toLowerCase();
+	return status === "waiting" || status === "pending" || status === "open" || status === "idle" || status === "timeout" || status === "no_feedback";
+}
+function hasFeedback(prompts) {
+	if (Array.isArray(prompts)) return prompts.length > 0;
+	if (typeof prompts === "string") return prompts.trim() !== "";
+	if (typeof prompts === "object" && prompts !== null) return Object.keys(prompts).length > 0;
+	return prompts !== void 0 && prompts !== null;
+}
+function formatPollResponse(response) {
+	return definedObject$1({
+		status: response.status,
+		prompts: response.prompts,
+		layout_warnings: response.layout_warnings,
+		dom_snapshot: response.dom_snapshot,
+		next_step: response.next_step ?? defaultPollNextStep(response.status)
+	});
+}
+function defaultPollNextStep(status) {
+	return isWaitingStatus(status) ? "No human feedback is ready yet. Call artifact_poll again." : "Apply the human Artifact review feedback, then call artifact_reply with a concise summary.";
+}
+function isWaitingStatus(status) {
+	const normalized = status.toLowerCase();
+	return normalized === "waiting" || normalized === "pending" || normalized === "open" || normalized === "idle" || normalized === "timeout" || normalized === "no_feedback";
+}
+function requiredString$1(args, key) {
+	const value = args[key];
+	if (typeof value !== "string" || value.trim() === "") throw new ArtifactToolInputError("INVALID_ARGUMENT", `arguments.${key} is required and must be a non-empty string`);
+	return value;
+}
+var ArtifactToolInputError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "ArtifactToolInputError";
+		this.code = code;
+	}
+};
+function missingEnvResult() {
+	return jsonResult$1({ error: {
+		code: "NOT_IN_AIORDIE_TAB",
+		message: "artifact tools only work inside an ai-or-die tab-backed Claude session. Missing AIORDIE_BASE_URL, AIORDIE_TOKEN, or AIORDIE_SESSION_ID."
+	} }, true);
+}
+function ok$1(value) {
+	return jsonResult$1(value, false);
+}
+function jsonResult$1(value, isError) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(value)
+		}],
+		...isError ? { isError: true } : {}
+	};
+}
+function errorResult$1(err) {
+	if (err instanceof ArtifactError) return jsonResult$1({ error: definedObject$1({
+		code: err.code,
+		message: err.message,
+		retryable: err.retryable,
+		status: err.status
+	}) }, true);
+	return jsonResult$1({ error: {
+		code: errorCode$1(err),
+		message: err instanceof Error ? err.message : String(err)
+	} }, true);
+}
+function errorCode$1(err) {
+	if (typeof err === "object" && err !== null && "code" in err) {
+		const code = err.code;
+		if (typeof code === "string") return code;
+	}
+	return "ARTIFACT_ERROR";
+}
+function definedObject$1(input) {
+	const result = {};
+	for (const [key, value] of Object.entries(input)) if (value !== void 0) result[key] = value;
+	return result;
+}
+function objectSchema$1(properties, required) {
+	return {
+		type: "object",
+		required,
+		additionalProperties: false,
+		properties
+	};
+}
+function stringProp$1(description) {
+	return {
+		type: "string",
+		description
+	};
+}
+
+//#endregion
+//#region src/lib/fleet/tunnel-auth.ts
+var TunnelAuthError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "TunnelAuthError";
+		this.code = code;
+	}
+};
+const REFRESH_MARGIN_MS = 5 * 6e4;
+const MIN_REMINT_INTERVAL_MS = 3e4;
+const DEVTUNNEL_TIMEOUT_MS = 1e4;
+const MINT_FAILURE_BACKOFF_MS = 3e4;
+const MAX_PLAUSIBLE_TTL_MS = 2880 * 6e4;
+const MAX_STDOUT_BYTES$2 = 256 * 1024;
+const TUNNEL_ID_RE$1 = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const JWT_REDACT_RE = /eyJ[A-Za-z0-9._-]{20,}/g;
+const SCHEME_TOKEN_RE = /(bearer|tunnel) +[!-~]+/gi;
+/** Strip credential-shaped substrings from any string before it is logged or surfaced. */
+function redactTunnelSecrets(s) {
+	return s.replace(JWT_REDACT_RE, "<redacted-token>").replace(SCHEME_TOKEN_RE, "$1 <redacted-token>");
+}
+function safeRealpath(p) {
+	try {
+		return realpathSync(p);
+	} catch {
+		return nodePath.resolve(p);
+	}
+}
+/**
+* Guard the resolved `devtunnel` path: it must be a trusted ABSOLUTE path that
+* is not the current working directory's own binary. `resolveExecutable` already
+* excludes cwd; this is defense-in-depth against a cwd-local / relative
+* resolution ever reaching a child-process spawn. Both paths are canonicalized
+* (realpath, resolving `..` and symlinks) before the cwd-containment check, so a
+* non-canonical path like `/safe/../cwd/devtunnel` or a symlink cannot evade it.
+* Returns the (original) path to spawn, or throws.
+*/
+function assertTrustedDevtunnelPath(resolved, cwd = typeof process.cwd === "function" ? nodePath.resolve(process.cwd()) : null) {
+	if (!resolved) throw new TunnelAuthError("NOT_INSTALLED", "the devtunnel CLI was not found on PATH; install it and run `devtunnel user login` on this (control-plane) machine");
+	if (!nodePath.isAbsolute(resolved)) throw new TunnelAuthError("NOT_INSTALLED", "refusing to run a non-absolute devtunnel binary");
+	const ext = nodePath.extname(resolved).toLowerCase();
+	if (ext === ".cmd" || ext === ".bat" || ext === ".ps1") throw new TunnelAuthError("NOT_INSTALLED", "resolved devtunnel is a script shim (.cmd/.bat/.ps1); github-router runs the native devtunnel(.exe) — ensure the native binary precedes any shim on PATH");
+	const realResolved = safeRealpath(resolved);
+	const realCwd = cwd ? safeRealpath(cwd) : null;
+	if (realCwd && (realResolved === realCwd || realResolved.startsWith(realCwd + nodePath.sep))) throw new TunnelAuthError("NOT_INSTALLED", "refusing to run a cwd-local devtunnel binary");
+	return resolved;
+}
+/**
+* The real runner: resolve `devtunnel` to a trusted absolute path (PATH-resolved,
+* cwd-excluded) and run it with `shell:false` (native binary).
+*/
+function realDevtunnelRunner() {
+	return async (args) => {
+		const res = await runManagedExeCapture(assertTrustedDevtunnelPath(resolveExecutable("devtunnel")), args, {
+			timeoutMs: DEVTUNNEL_TIMEOUT_MS,
+			maxStdoutBytes: MAX_STDOUT_BYTES$2
+		});
+		return {
+			stdout: res.stdout,
+			stderr: res.stderr,
+			code: res.code,
+			timedOut: res.timedOut
+		};
+	};
+}
+function looksLikeJwt(s) {
+	const parts = s.split(".");
+	if (parts.length !== 3) return false;
+	return parts.every((p) => p.length > 0 && /^[A-Za-z0-9_-]+$/.test(p));
+}
+/** Recursively collect JWT-shaped strings from arbitrary parsed JSON. */
+function collectJwts(value, out) {
+	if (typeof value === "string") {
+		if (value.startsWith("eyJ") && looksLikeJwt(value)) out.add(value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const v of value) collectJwts(v, out);
+		return;
+	}
+	if (value && typeof value === "object") for (const v of Object.values(value)) collectJwts(v, out);
+}
+/**
+* Extract the single access token from `devtunnel token --json` output. Prefers
+* structured JSON; falls back to a token-shaped scan. Refuses to guess when zero
+* or more-than-one distinct tokens are present (so we never send a wrong JWT).
+*/
+function extractToken(stdout) {
+	const found = /* @__PURE__ */ new Set();
+	try {
+		collectJwts(JSON.parse(stdout), found);
+	} catch {}
+	if (found.size === 0) {
+		for (const tok of stdout.split(/[^A-Za-z0-9._-]+/)) if (tok.startsWith("eyJ") && looksLikeJwt(tok)) found.add(tok);
+	}
+	if (found.size === 0) throw new TunnelAuthError("PARSE", "no tunnel access token found in devtunnel output");
+	if (found.size > 1) throw new TunnelAuthError("PARSE", "devtunnel output contained more than one token; refusing to guess");
+	return [...found][0];
+}
+/** Parse a JWT `exp` claim (seconds) into epoch milliseconds. Throws on a missing/non-numeric exp. */
+function parseJwtExpMs(jwt) {
+	const parts = jwt.split(".");
+	if (parts.length !== 3) throw new TunnelAuthError("PARSE", "tunnel token is not a JWT");
+	let payload;
+	try {
+		payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+	} catch {
+		throw new TunnelAuthError("PARSE", "tunnel token payload was not decodable");
+	}
+	const exp = payload?.exp;
+	if (typeof exp !== "number" || !Number.isFinite(exp)) throw new TunnelAuthError("PARSE", "tunnel token has no numeric exp claim");
+	return exp * 1e3;
+}
+function classifyMintFailure(res) {
+	if (res.timedOut) return new TunnelAuthError("TIMEOUT", "devtunnel token request timed out");
+	const stderr = (res.stderr || "").toLowerCase();
+	const tail = redactTunnelSecrets((res.stderr || "").trim()).slice(-300);
+	const suffix = tail ? ` [${tail}]` : "";
+	if (/log ?in|sign ?in|not authenticated|unauthor|401/.test(stderr)) return new TunnelAuthError("NOT_LOGGED_IN", `devtunnel is not logged in (or lacks access to this tunnel) on the control-plane machine; run \`devtunnel user login\`${suffix}`);
+	if (/not found|404|does not exist|no such tunnel/.test(stderr)) return new TunnelAuthError("TUNNEL_NOT_FOUND", `devtunnel could not find the tunnel; verify tunnelId with \`devtunnel list\`${suffix}`);
+	return new TunnelAuthError("MINT_FAILED", `devtunnel token failed (exit ${res.code})${suffix}`);
+}
+/**
+* Create a per-process token provider: lazy mint, per-tunnel in-memory cache,
+* single-flight, and short negative backoff on non-timeout failures.
+*/
+function createTunnelTokenProvider(runner = realDevtunnelRunner()) {
+	const cache = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Map();
+	const backoff = /* @__PURE__ */ new Map();
+	async function mint(cfg) {
+		if (!TUNNEL_ID_RE$1.test(cfg.tunnelId)) throw new TunnelAuthError("MINT_FAILED", "invalid tunnelId; must match a devtunnel tunnel name");
+		const args = [
+			"token",
+			cfg.tunnelId,
+			"--scopes",
+			"connect",
+			"--json"
+		];
+		let res;
+		try {
+			res = await runner(args);
+		} catch (err) {
+			if (err instanceof TunnelAuthError) throw err;
+			throw new TunnelAuthError("MINT_FAILED", redactTunnelSecrets(err instanceof Error ? err.message : String(err)));
+		}
+		if (res.timedOut) throw new TunnelAuthError("TIMEOUT", "devtunnel token request timed out");
+		if (res.code !== 0) throw classifyMintFailure(res);
+		const token = extractToken(res.stdout);
+		const expMs = parseJwtExpMs(token);
+		const now = Date.now();
+		if (expMs <= now) throw new TunnelAuthError("PARSE", "devtunnel minted an already-expired token");
+		if (expMs - now > MAX_PLAUSIBLE_TTL_MS) throw new TunnelAuthError("PARSE", "devtunnel token TTL is implausibly long; refusing");
+		const existing = cache.get(cfg.tunnelId);
+		if (!existing || expMs > existing.expMs) cache.set(cfg.tunnelId, {
+			token,
+			expMs,
+			mintedAt: now
+		});
+		return cache.get(cfg.tunnelId).token;
+	}
+	function mintOnce(cfg) {
+		const key = cfg.tunnelId;
+		return (async () => {
+			try {
+				const token = await mint(cfg);
+				backoff.delete(key);
+				return token;
+			} catch (err) {
+				const e = err instanceof TunnelAuthError ? err : new TunnelAuthError("MINT_FAILED", redactTunnelSecrets(String(err)));
+				if (e.code !== "TIMEOUT") backoff.set(key, {
+					until: Date.now() + MINT_FAILURE_BACKOFF_MS,
+					err: e
+				});
+				const c = cache.get(key);
+				if (c && c.expMs > Date.now()) return c.token;
+				throw e;
+			} finally {
+				inflight.delete(key);
+			}
+		})();
+	}
+	return {
+		async getToken(cfg) {
+			const key = cfg.tunnelId;
+			const now = Date.now();
+			const cached$1 = cache.get(key);
+			if (cached$1 && cached$1.expMs > now) {
+				const comfortablyFresh = cached$1.expMs - now > REFRESH_MARGIN_MS;
+				const recentlyMinted = now - cached$1.mintedAt < MIN_REMINT_INTERVAL_MS;
+				if (comfortablyFresh || recentlyMinted) return cached$1.token;
+			}
+			const inf = inflight.get(key);
+			if (inf) return inf;
+			const bo = backoff.get(key);
+			if (bo && now < bo.until) {
+				if (cached$1 && cached$1.expMs > now) return cached$1.token;
+				throw bo.err;
+			}
+			const p = mintOnce(cfg);
+			inflight.set(key, p);
+			return p;
+		},
+		invalidate(cfg) {
+			cache.delete(cfg.tunnelId);
+			backoff.delete(cfg.tunnelId);
+		}
+	};
+}
+
+//#endregion
+//#region src/lib/fleet/client.ts
+var FleetError = class extends Error {
+	code;
+	retryable;
+	status;
+	detail;
+	constructor(args) {
+		super(args.message);
+		this.name = "FleetError";
+		this.code = args.code;
+		this.retryable = args.retryable;
+		this.status = args.status;
+		this.detail = args.detail;
+	}
+};
+function encodeSessionId(instanceId, localId) {
+	return `${instanceId}:${localId}`;
+}
+function decodeSessionId(globalId) {
+	const idx = globalId.indexOf(":");
+	if (idx <= 0 || idx === globalId.length - 1) throw new FleetError({
+		code: "SESSION_NOT_FOUND",
+		message: `invalid fleet sessionId ${JSON.stringify(globalId)}; expected "instanceId:localSessionId"`,
+		retryable: false
+	});
+	return {
+		instanceId: globalId.slice(0, idx),
+		localId: globalId.slice(idx + 1)
+	};
+}
+var FleetClient = class {
+	baseUrl;
+	origin;
+	token;
+	fetchFn;
+	getTunnelToken;
+	onTunnelAuthInvalidate;
+	constructor(options) {
+		this.baseUrl = options.url.replace(/\/+$/, "");
+		this.origin = new URL(this.baseUrl).origin;
+		this.token = options.token;
+		this.fetchFn = options.fetchFn ?? globalThis.fetch.bind(globalThis);
+		this.getTunnelToken = options.getTunnelToken;
+		this.onTunnelAuthInvalidate = options.onTunnelAuthInvalidate;
+	}
+	capabilities(signal) {
+		return this.request("GET", "/api/control/capabilities", void 0, void 0, signal);
+	}
+	listSessions(signal) {
+		return this.request("GET", "/api/control/sessions", void 0, void 0, signal);
+	}
+	status(sessionId, signal) {
+		return this.request("GET", `/api/control/sessions/${encodeURIComponent(sessionId)}/status`, void 0, void 0, signal);
+	}
+	readSession(sessionId, lines, signal) {
+		return this.request("GET", `/api/control/sessions/${encodeURIComponent(sessionId)}/read`, lines === void 0 ? void 0 : { lines: String(lines) }, void 0, signal);
+	}
+	createSession(input, signal) {
+		return this.request("POST", "/api/control/sessions/create", void 0, input, signal);
+	}
+	stopSession(sessionId, modeOrInput, idempotencyKeyOrSignal, signal) {
+		const body = {};
+		let requestSignal;
+		if (typeof modeOrInput === "object" && modeOrInput !== null) {
+			if (modeOrInput.mode !== void 0) body.mode = modeOrInput.mode;
+			if (modeOrInput.idempotencyKey !== void 0) body.idempotencyKey = modeOrInput.idempotencyKey;
+			requestSignal = typeof idempotencyKeyOrSignal === "string" ? signal : idempotencyKeyOrSignal;
+		} else {
+			if (modeOrInput !== void 0) body.mode = modeOrInput;
+			if (typeof idempotencyKeyOrSignal === "string") {
+				body.idempotencyKey = idempotencyKeyOrSignal;
+				requestSignal = signal;
+			} else requestSignal = idempotencyKeyOrSignal;
+		}
+		return this.request("POST", `/api/control/sessions/${encodeURIComponent(sessionId)}/stop`, void 0, body, requestSignal);
+	}
+	sendMessage(sessionId, input, signal) {
+		return this.request("POST", `/api/control/sessions/${encodeURIComponent(sessionId)}/message`, void 0, input, signal);
+	}
+	sendKeys(sessionId, input, signal) {
+		return this.request("POST", `/api/control/sessions/${encodeURIComponent(sessionId)}/keys`, void 0, input, signal);
+	}
+	respond(sessionId, input, signal) {
+		return this.request("POST", `/api/control/sessions/${encodeURIComponent(sessionId)}/respond`, void 0, input, signal);
+	}
+	waitEvents(input, signal) {
+		const query = {};
+		if (input.cursor !== void 0) query.cursor = input.cursor;
+		if (input.timeoutMs !== void 0) query.timeoutMs = String(input.timeoutMs);
+		if (input.sessionIds !== void 0) query.sessionIds = input.sessionIds.join(",");
+		if (input.kinds !== void 0) query.kinds = input.kinds.join(",");
+		return this.request("GET", "/api/control/events", query, void 0, signal);
+	}
+	readFile(pathValue, signal) {
+		return this.request("GET", "/api/files/content", { path: pathValue }, void 0, signal);
+	}
+	listDir(pathValue, signal) {
+		return this.request("GET", "/api/files", { path: pathValue }, void 0, signal);
+	}
+	search(queryValue, pathValue, signal) {
+		const query = { q: queryValue };
+		if (pathValue !== void 0) query.path = pathValue;
+		return this.request("GET", "/api/search", query, void 0, signal);
+	}
+	gitShow(input, signal) {
+		const query = {};
+		for (const [key, value] of Object.entries(input)) {
+			if (value === void 0 || value === null) continue;
+			if (key === "instance") continue;
+			query[key] = String(value);
+		}
+		return this.request("GET", "/api/files/git-show", query, void 0, signal);
+	}
+	async request(method, pathname, query, body, signal) {
+		const url = new URL(pathname, `${this.baseUrl}/`);
+		for (const [key, value] of Object.entries(query ?? {})) url.searchParams.set(key, value);
+		if (url.origin !== this.origin) throw new FleetError({
+			code: "UNREACHABLE",
+			message: "fleet request URL origin did not match the registered instance origin",
+			retryable: false
+		});
+		const devtunnelHost = isDevtunnelHost(url.hostname);
+		const tunnelEligible = this.getTunnelToken !== void 0 && devtunnelHost && url.protocol === "https:";
+		for (let attempt = 0; attempt < 2; attempt++) {
+			let tunnelToken;
+			if (tunnelEligible) try {
+				tunnelToken = await this.getTunnelToken();
+			} catch (err) {
+				throw mapTunnelAuthError(err);
+			}
+			const attachTunnel = tunnelToken !== void 0 && tunnelToken !== "";
+			const canRetry = attachTunnel && !!this.onTunnelAuthInvalidate && attempt === 0;
+			const headers = {
+				Authorization: `Bearer ${this.token}`,
+				...devtunnelHost ? { "X-Tunnel-Skip-Anti-Phishing-Page": "true" } : {},
+				...attachTunnel ? { "X-Tunnel-Authorization": `tunnel ${tunnelToken}` } : {},
+				...body === void 0 ? {} : { "Content-Type": "application/json" }
+			};
+			let response;
+			try {
+				response = await this.fetchFn(url.toString(), {
+					method,
+					headers,
+					body: body === void 0 ? void 0 : JSON.stringify(body),
+					redirect: "error",
+					signal
+				});
+			} catch (err) {
+				if (canRetry && method === "GET") {
+					this.onTunnelAuthInvalidate();
+					continue;
+				}
+				throw mapNetworkError(err, devtunnelHost);
+			}
+			if (!response.ok) {
+				if ((response.status === 401 || response.status === 403) && canRetry) {
+					this.onTunnelAuthInvalidate();
+					continue;
+				}
+				throw await mapHttpError(response, url.toString());
+			}
+			return await response.json();
+		}
+		throw new FleetError({
+			code: "AUTH_FAILED",
+			message: "fleet instance tunnel authentication failed after re-mint; verify the tunnel and `devtunnel user login`",
+			retryable: false
+		});
+	}
+};
+/** Dev Tunnel access tokens are only ever scoped to the `*.devtunnels.ms` service. */
+function isDevtunnelHost(hostname) {
+	return hostname === "devtunnels.ms" || hostname.endsWith(".devtunnels.ms");
+}
+function mapTunnelAuthError(err) {
+	if (err instanceof TunnelAuthError) return new FleetError({
+		code: "AUTH_FAILED",
+		message: err.message,
+		retryable: err.code === "TIMEOUT",
+		detail: { tunnelAuth: err.code }
+	});
+	return mapNetworkError(err);
+}
+async function mapHttpError(response, requestUrl) {
+	const detail = await readErrorDetail(response);
+	const upstreamMessage = detailToMessage(detail);
+	const suffix = upstreamMessage ? `: ${upstreamMessage}` : "";
+	const status = response.status;
+	if (isDevTunnelHost(requestUrl) && detectDevTunnelNoHost(status, detail)) return new FleetError({
+		code: "NO_HOST",
+		message: `dev tunnel relay reports no host connected (${status})${suffix}`,
+		retryable: true,
+		status,
+		detail
+	});
+	if (status === 401 || status === 403) return new FleetError({
+		code: "AUTH_FAILED",
+		message: `fleet instance authentication failed (${status})${suffix}`,
+		retryable: false,
+		status,
+		detail
+	});
+	if (status === 404) return new FleetError({
+		code: "SESSION_NOT_FOUND",
+		message: `fleet session or resource not found (404)${suffix}`,
+		retryable: false,
+		status,
+		detail
+	});
+	if (status === 409 || status === 412) return new FleetError({
+		code: "PRECONDITION_FAILED",
+		message: `fleet instance precondition failed (${status})${suffix}`,
+		retryable: false,
+		status,
+		detail
+	});
+	if (status === 400) return new FleetError({
+		code: "BAD_REQUEST",
+		message: `fleet instance rejected the request (400)${suffix}`,
+		retryable: false,
+		status,
+		detail
+	});
+	if (status === 408 || status === 504) return new FleetError({
+		code: "TIMEOUT",
+		message: `fleet instance request timed out (${status})${suffix}`,
+		retryable: true,
+		status,
+		detail
+	});
+	if ((status === 502 || status === 503) && isDevTunnelHost(requestUrl)) return new FleetError({
+		code: "RELAY_ERROR",
+		message: `dev tunnel relay returned HTTP ${status} (host may be down, restarting, or under load)${suffix}`,
+		retryable: true,
+		status,
+		detail
+	});
+	if (status === 429) return new FleetError({
+		code: "RATE_LIMITED",
+		message: `fleet instance rate-limited the request (429)${suffix}`,
+		retryable: true,
+		status,
+		detail
+	});
+	return new FleetError({
+		code: "UPSTREAM_ERROR",
+		message: `fleet instance returned HTTP ${status}${suffix}`,
+		retryable: status >= 500,
+		status,
+		detail
+	});
+}
+const DEVTUNNEL_HOST_RE$1 = /(?:^|\.)devtunnels\.ms$|(?:^|\.)tunnels\.api\.visualstudio\.com$/i;
+/** F4: only Dev Tunnel relay hosts may be classified NO_HOST / RELAY_ERROR. */
+function isDevTunnelHost(requestUrl) {
+	try {
+		return DEVTUNNEL_HOST_RE$1.test(new URL(requestUrl).hostname);
+	} catch {
+		return false;
+	}
+}
+const DEVTUNNEL_NO_HOST_SIGNALS = [
+	"no host is currently connected",
+	"tunnel is not currently hosted",
+	"host is not accepting connections",
+	"tunnel host is not connected",
+	"no connection to the host",
+	"tunnelporthostnotconnected"
+];
+function detectDevTunnelNoHost(status, detail) {
+	if (status !== 502 && status !== 503 && status !== 404) return false;
+	const haystack = detailToSearchString(detail).toLowerCase();
+	if (haystack === "") return false;
+	return DEVTUNNEL_NO_HOST_SIGNALS.some((signal) => haystack.includes(signal));
+}
+function detailToSearchString(detail) {
+	if (detail === void 0 || detail === null) return "";
+	if (typeof detail === "string") return detail;
+	try {
+		return JSON.stringify(detail);
+	} catch {
+		return String(detail);
+	}
+}
+function mapNetworkError(err, devtunnelHost = false) {
+	if (isAbortLike$1(err)) return new FleetError({
+		code: "TIMEOUT",
+		message: "fleet instance request timed out or was aborted",
+		retryable: true,
+		detail: err
+	});
+	return new FleetError({
+		code: "UNREACHABLE",
+		message: `fleet instance unreachable: ${err instanceof Error ? err.message : String(err)}${devtunnelHost ? " — if this is a private VS Code Dev Tunnel, an unauthenticated request is redirected to GitHub auth (which we refuse to follow): set a `tunnelId` (auto-mint) / `tunnelToken` in the registry, or make the tunnel anonymous" : ""}`,
+		retryable: true,
+		detail: err
+	});
+}
+async function readErrorDetail(response) {
+	const text = await response.text().catch(() => "");
+	if (!text) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+function detailToMessage(detail) {
+	if (typeof detail === "string") return detail;
+	if (typeof detail !== "object" || detail === null) return void 0;
+	const record = detail;
+	const error = record.error;
+	if (typeof error === "string") return error;
+	if (typeof error === "object" && error !== null) {
+		const errorRecord = error;
+		if (typeof errorRecord.message === "string") return errorRecord.message;
+		if (typeof errorRecord.code === "string") return errorRecord.code;
+	}
+	if (typeof record.message === "string") return record.message;
+}
+function isAbortLike$1(err) {
+	return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+}
+
+//#endregion
+//#region src/lib/fleet/registry.ts
+var FleetRegistryError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "FleetRegistryError";
+		this.code = code;
+	}
+};
+function defaultFleetConfigPath() {
+	return process.env.GH_ROUTER_FLEET_CONFIG || nodePath.join(os.homedir(), ".local", "share", "github-router", "fleet.json");
+}
+async function loadFleetRegistryConfig(configPath = defaultFleetConfigPath()) {
+	let stat$1;
+	try {
+		stat$1 = await fs.stat(configPath);
+	} catch (err) {
+		if (isNodeErrorCode(err, "ENOENT")) return { instances: [] };
+		throw err;
+	}
+	if (process.platform !== "win32" && (stat$1.mode & 63) !== 0) console.warn(`[fleet] Registry file ${configPath} is group/other-readable; it contains bearer / tunnel credentials. Consider chmod 600.`);
+	const raw = await fs.readFile(configPath, "utf8");
+	if (raw.trim() === "") return { instances: [] };
+	const parsed = JSON.parse(raw);
+	if (!isObject(parsed)) throw new FleetRegistryError("INVALID_CONFIG", "fleet registry must be a JSON object");
+	const instances = parsed.instances;
+	if (instances === void 0) return { instances: [] };
+	if (!Array.isArray(instances)) throw new FleetRegistryError("INVALID_CONFIG", "fleet registry instances must be an array");
+	return { instances: instances.map(parseInstance) };
+}
+var FleetRegistry = class {
+	loader;
+	loaded;
+	constructor(options = {}) {
+		if (options.config !== void 0) {
+			const config = options.config;
+			this.loader = () => config;
+		} else if (options.loadConfig !== void 0) this.loader = options.loadConfig;
+		else {
+			const configPath = options.configPath;
+			this.loader = () => loadFleetRegistryConfig(configPath);
+		}
+	}
+	async resolveInstance(arg) {
+		const instances = await this.instancesWithTokens();
+		const wanted = typeof arg === "string" ? arg.trim() : "";
+		if (wanted) {
+			const byId = instances.find((instance) => instance.id === wanted);
+			if (byId) return resolvedInstance(byId);
+			const labelMatches = instances.filter((instance) => instance.label.toLocaleLowerCase() === wanted.toLocaleLowerCase());
+			if (labelMatches.length > 1) throw new FleetRegistryError("AMBIGUOUS_LABEL", `fleet instance label ${JSON.stringify(wanted)} matches ${labelMatches.length} instances; use an id`);
+			if (labelMatches.length === 1) return resolvedInstance(labelMatches[0]);
+			throw new FleetRegistryError("INSTANCE_NOT_FOUND", `fleet instance ${JSON.stringify(wanted)} was not found`);
+		}
+		const defaultInstance = instances.find((instance) => instance.default === true);
+		if (defaultInstance) return resolvedInstance(defaultInstance);
+		if (instances.length === 1) return resolvedInstance(instances[0]);
+		throw new FleetRegistryError("INSTANCE_REQUIRED", instances.length === 0 ? "fleet instance is required; registry is empty" : "fleet instance is required; specify an instance id or label");
+	}
+	async listInstances() {
+		return (await this.instancesWithTokens()).map((instance) => ({
+			id: instance.id,
+			label: instance.label,
+			url: instance.url,
+			default: instance.default,
+			allowExec: instance.allowExec
+		}));
+	}
+	instancesWithTokens() {
+		if (!this.loaded) this.loaded = Promise.resolve(this.loader()).then((config) => normalizeConfig(config));
+		return this.loaded;
+	}
+};
+function normalizeConfig(config) {
+	if (!isObject(config)) throw new FleetRegistryError("INVALID_CONFIG", "fleet registry config must be an object");
+	const instances = config.instances ?? [];
+	if (!Array.isArray(instances)) throw new FleetRegistryError("INVALID_CONFIG", "fleet registry instances must be an array");
+	return instances.map(parseInstance);
+}
+function parseInstance(raw) {
+	if (!isObject(raw)) throw new FleetRegistryError("INVALID_CONFIG", "fleet registry instance must be an object");
+	const instance = raw;
+	const id = instance.id;
+	const label = instance.label;
+	const url = instance.url;
+	const token = instance.token;
+	if (typeof id !== "string" || id.trim() === "") throw new FleetRegistryError("INVALID_CONFIG", "fleet registry instance id must be a non-empty string");
+	if (typeof label !== "string" || label.trim() === "") throw new FleetRegistryError("INVALID_CONFIG", `fleet registry instance ${id} label must be a non-empty string`);
+	if (typeof url !== "string" || url.trim() === "") throw new FleetRegistryError("INVALID_CONFIG", `fleet registry instance ${id} url must be a non-empty string`);
+	const trimmedUrl = url.trim();
+	let parsedUrl;
+	try {
+		parsedUrl = new URL(trimmedUrl);
+	} catch {
+		throw invalidInstanceUrlError(id);
+	}
+	if (!isAllowedInstanceUrl(parsedUrl)) throw invalidInstanceUrlError(id);
+	assertDevTunnelUrlShape(id, parsedUrl);
+	if (parsedUrl.username !== "" || parsedUrl.password !== "") throw new FleetRegistryError("INVALID_CONFIG", `fleet registry instance ${id} url must not contain embedded credentials (userinfo)`);
+	if (typeof token !== "string" || token === "") throw new FleetRegistryError("INVALID_CONFIG", `fleet registry instance ${id} token must be a non-empty string`);
+	const tunnelId = parseTunnelId(id, instance.tunnelId);
+	const tunnelToken = parseTunnelToken(id, instance.tunnelToken);
+	return {
+		id: id.trim(),
+		label: label.trim(),
+		url: trimmedUrl,
+		token,
+		default: instance.default === true ? true : void 0,
+		allowExec: instance.allowExec === true ? true : void 0,
+		tunnelId,
+		tunnelToken
+	};
+}
+const TUNNEL_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function parseTunnelId(id, raw) {
+	if (raw === void 0) return void 0;
+	if (typeof raw !== "string" || !TUNNEL_ID_RE.test(raw.trim())) throw new FleetRegistryError("INVALID_CONFIG", `fleet registry instance ${id} tunnelId must match ${TUNNEL_ID_RE.source} (a devtunnel tunnel name from \`devtunnel list\`)`);
+	return raw.trim();
+}
+function parseTunnelToken(id, raw) {
+	if (raw === void 0) return void 0;
+	if (typeof raw !== "string") throw new FleetRegistryError("INVALID_CONFIG", `fleet registry instance ${id} tunnelToken must be a string`);
+	let t = raw.trim();
+	if (t.startsWith("\"") && t.endsWith("\"") || t.startsWith("'") && t.endsWith("'")) t = t.slice(1, -1).trim();
+	t = t.replace(/^X-Tunnel-Authorization:\s*/i, "").replace(/^tunnel\s+/i, "").trim();
+	if (t === "" || /\s/.test(t)) throw new FleetRegistryError("INVALID_CONFIG", `fleet registry instance ${id} tunnelToken must be a non-empty single-line token`);
+	return t;
+}
+function invalidInstanceUrlError(id) {
+	return new FleetRegistryError("INVALID_CONFIG", `${id.trim()} url must be https (or http://localhost for local testing)`);
+}
+function isAllowedInstanceUrl(url) {
+	if (url.protocol === "https:") return true;
+	if (url.protocol !== "http:") return false;
+	return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
+}
+const DEVTUNNEL_HOST_RE = /(?:^|\.)devtunnels\.ms$|(?:^|\.)tunnels\.api\.visualstudio\.com$/i;
+function assertDevTunnelUrlShape(id, url) {
+	if (!DEVTUNNEL_HOST_RE.test(url.hostname)) return;
+	if (url.port === "") return;
+	const firstDot = url.hostname.indexOf(".");
+	const firstLabel = firstDot < 0 ? url.hostname : url.hostname.slice(0, firstDot);
+	const rest = firstDot < 0 ? "" : url.hostname.slice(firstDot + 1);
+	const corrected = rest === "" ? `https://${firstLabel}-${url.port}.devtunnels.ms` : `https://${firstLabel}-${url.port}.${rest}`;
+	throw new FleetRegistryError("INVALID_CONFIG", `${id.trim()} url ${url.href} uses the wrong Dev Tunnel form: the forwarded port must be fused into the hostname, not given as a :port suffix. Use ${corrected} instead (the bare \`<id>.<cluster>.devtunnels.ms:<port>\` host addresses the tunnel-management endpoint, not the relayed service).`);
+}
+function resolvedInstance(instance) {
+	return {
+		id: instance.id,
+		label: instance.label,
+		url: instance.url,
+		token: instance.token,
+		allowExec: instance.allowExec,
+		tunnelId: instance.tunnelId,
+		tunnelToken: instance.tunnelToken
+	};
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNodeErrorCode(err, code) {
+	return isObject(err) && err.code === code;
+}
+
+//#endregion
+//#region src/lib/fleet/tools.ts
+const FLEET_GROUP = "fleet";
+const INSTANCE_PROBE_TIMEOUT_MS = 2e3;
+const INSTANCE_PROBE_CACHE_TTL_MS = 5e3;
+const CAPABILITIES_CACHE_TTL_MS = 6e4;
+const AWAIT_TURN_DEFAULT_TIMEOUT_MS = 3e4;
+const AWAIT_TURN_TIMEOUT_SLACK_MS = 5e3;
+const LIST_INSTANCES_FANOUT_CONCURRENCY = 16;
+const AWAIT_TURN_FANOUT_CONCURRENCY = 256;
+const INSTANCE_PROBE_RATE_LIMIT_MAX_RETRIES = 1;
+const INSTANCE_PROBE_RATE_LIMIT_BACKOFF_BASE_MS = 250;
+const INSTANCE_PROBE_RATE_LIMIT_BACKOFF_MAX_MS = 1e3;
+const FLEET_FANOUT_CONCURRENCY_ENV = "GH_ROUTER_FLEET_FANOUT_CONCURRENCY";
+var FleetToolInputError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "FleetToolInputError";
+		this.code = code;
+	}
+};
+let defaultRegistry;
+let defaultTunnelProvider;
+const awaitTurnCursors = /* @__PURE__ */ new Map();
+const instanceProbeCache = /* @__PURE__ */ new Map();
+function createFleetTools(options = {}) {
+	const registry = options.registry;
+	const clients = /* @__PURE__ */ new Map();
+	const capabilitiesCache = /* @__PURE__ */ new Map();
+	const tunnelProvider = options.tunnelTokenProvider ?? (defaultTunnelProvider ??= createTunnelTokenProvider());
+	const probeRetryDelay = options.probeRetryDelay ?? delay;
+	const awaitTurnDeadlineSlackMs = nonNegativeNumberOrDefault(options.awaitTurnDeadlineSlackMs, AWAIT_TURN_TIMEOUT_SLACK_MS);
+	function getRegistry() {
+		if (registry) return registry;
+		defaultRegistry ??= new FleetRegistry();
+		return defaultRegistry;
+	}
+	function clientFor(instance) {
+		const key = `${instance.id}\0${instance.url}\0${instance.token}\0${instance.tunnelId ?? ""}\0${instance.tunnelToken ?? ""}`;
+		const existing = clients.get(key);
+		if (existing) return existing;
+		const created = options.createClient ? options.createClient(instance) : new FleetClient({
+			url: instance.url,
+			token: instance.token,
+			fetchFn: options.fetchFn,
+			...tunnelClientOptions(instance, tunnelProvider)
+		});
+		clients.set(key, created);
+		return created;
+	}
+	async function getInstanceCapabilities(instance, signal) {
+		const now = Date.now();
+		const cached$1 = capabilitiesCache.get(instance.id);
+		if (cached$1 && now - cached$1.at < CAPABILITIES_CACHE_TTL_MS) return cached$1.caps;
+		try {
+			const response = await clientFor(instance).capabilities(signal);
+			const caps = new Set(response.capabilities);
+			capabilitiesCache.set(instance.id, {
+				caps,
+				at: Date.now()
+			});
+			return caps;
+		} catch {
+			capabilitiesCache.set(instance.id, {
+				caps: null,
+				at: Date.now()
+			});
+			return null;
+		}
+	}
+	async function assertCapability(instance, cap, featureName, signal) {
+		const caps = await getInstanceCapabilities(instance, signal);
+		if (caps !== null && !caps.has(cap)) throw new FleetToolInputError("UNSUPPORTED_CAPABILITY", `fleet instance ${instance.id} does not advertise the '${cap}' capability required for ${featureName}; omit it or upgrade the ai-or-die control plane`);
+	}
+	async function resolve(arg) {
+		return getRegistry().resolveInstance(arg);
+	}
+	async function resolveSession(args) {
+		const globalId = requiredString(args, "sessionId");
+		const decoded = decodeSessionId(globalId);
+		const instance = await resolve(decoded.instanceId);
+		const explicitInstance = optionalString(args, "instance");
+		if (explicitInstance !== void 0) {
+			const explicit = await resolve(explicitInstance);
+			if (explicit.id !== decoded.instanceId) throw new FleetToolInputError("INSTANCE_MISMATCH", `sessionId is for instance ${JSON.stringify(decoded.instanceId)} but arguments.instance resolved to ${JSON.stringify(explicit.id)}`);
+		}
+		return {
+			instance,
+			localId: decoded.localId,
+			globalId
+		};
+	}
+	async function probeInstance(info) {
+		const cacheKey = `${info.id}\0${info.url}`;
+		const now = Date.now();
+		const cached$1 = instanceProbeCache.get(cacheKey);
+		if (cached$1 && now - cached$1.at < INSTANCE_PROBE_CACHE_TTL_MS) return cached$1.result;
+		for (let attempt = 0; attempt <= INSTANCE_PROBE_RATE_LIMIT_MAX_RETRIES; attempt++) {
+			const timeout = createProbeTimeout();
+			try {
+				const response = await clientFor(await resolve(info.id)).listSessions(timeout.signal);
+				const lastSeen = Date.now();
+				const result$1 = {
+					id: info.id,
+					label: info.label,
+					reachable: true,
+					sessionCount: response.sessions.length,
+					lastSeen
+				};
+				instanceProbeCache.set(cacheKey, {
+					result: result$1,
+					at: lastSeen
+				});
+				return result$1;
+			} catch (err) {
+				const code = fleetProbeErrorCode(err);
+				if (code === "RATE_LIMITED" && attempt < INSTANCE_PROBE_RATE_LIMIT_MAX_RETRIES) {
+					timeout.cleanup();
+					await probeRetryDelay(probeRateLimitBackoffMs(attempt));
+					continue;
+				}
+				const result$1 = failedProbeResult(info, code);
+				instanceProbeCache.set(cacheKey, {
+					result: result$1,
+					at: Date.now()
+				});
+				return result$1;
+			} finally {
+				timeout.cleanup();
+			}
+		}
+		const result = failedProbeResult(info, "UNREACHABLE");
+		instanceProbeCache.set(cacheKey, {
+			result,
+			at: Date.now()
+		});
+		return result;
+	}
+	function tool$1(toolNameHttp, description, inputSchema, handler) {
+		return {
+			toolNameHttp,
+			group: FLEET_GROUP,
+			description,
+			inputSchema,
+			capability: "fleet",
+			async handler(args, signal) {
+				try {
+					return await handler(args, signal);
+				} catch (err) {
+					return errorResult(err);
+				}
+			}
+		};
+	}
+	return Object.freeze([
+		tool$1("list_instances", "List registered remote ai-or-die instances in the fleet registry. Tokens are never returned.", objectSchema({}, []), async () => {
+			return ok({ instances: await mapWithConcurrency(await getRegistry().listInstances(), fleetFanoutConcurrency(LIST_INSTANCES_FANOUT_CONCURRENCY), (instance) => probeInstance(instance)) });
+		}),
+		tool$1("list_sessions", "List sessions on one fleet instance, returning globally-addressable session ids.", objectSchema({ instance: stringProp("Instance id or label. Defaults to the registry default, or the sole instance.") }, []), async (args, signal) => {
+			const instance = await resolve(optionalString(args, "instance"));
+			const response = await clientFor(instance).listSessions(signal);
+			return ok({
+				resolvedInstance: publicInstance(instance),
+				sessions: response.sessions.map((session) => globalizeSession(instance.id, session))
+			});
+		}),
+		tool$1("read_session", "Read recent text output from an addressed fleet session.", objectSchema({
+			sessionId: stringProp("Global session id in the form instanceId:localSessionId."),
+			instance: stringProp("Optional instance id/label; when supplied it must agree with sessionId."),
+			lines: numberProp("Number of recent lines to read."),
+			format: stringProp("Reserved for future formatting; results are JSON text today.")
+		}, ["sessionId"]), async (args, signal) => {
+			const { instance, localId, globalId } = await resolveSession(args);
+			const lines = optionalNumber(args, "lines");
+			const response = await clientFor(instance).readSession(localId, lines, signal);
+			return ok({
+				resolvedInstance: publicInstance(instance),
+				...response,
+				sessionId: globalId
+			});
+		}),
+		tool$1("session_status", "Fetch lifecycle and interaction status for an addressed fleet session.", objectSchema({
+			sessionId: stringProp("Global session id in the form instanceId:localSessionId."),
+			instance: stringProp("Optional instance id/label; when supplied it must agree with sessionId.")
+		}, ["sessionId"]), async (args, signal) => {
+			const { instance, localId, globalId } = await resolveSession(args);
+			const response = await clientFor(instance).status(localId, signal);
+			return ok({
+				resolvedInstance: publicInstance(instance),
+				...response,
+				sessionId: globalId
+			});
+		}),
+		tool$1("send_message", "Send a message to a fleet session. isError reflects DELIVERY ONLY: it is true only when the message could not be delivered to the session (transport/precondition failure). A delivered message whose confirmation did not arrive within awaitMs is NOT an error — it returns delivered:true with confirmationPending/confirmationTimedOut, because a long turn legitimately outruns awaitMs. Recommended pattern: send with awaitMs:0 for a fast delivery ack that never blocks on confirmation, then call await_turn (filtered to this sessionId) to observe the session's actual turn completion. The idempotencyKey makes a retried send safe (a retry never re-types the message).", objectSchema({
+			sessionId: stringProp("Global session id in the form instanceId:localSessionId."),
+			instance: stringProp("Optional instance id/label; when supplied it must agree with sessionId."),
+			message: stringProp("Message text to deliver to the session."),
+			idempotencyKey: stringProp("Caller-generated idempotency key. Reuse the same key on retry; the upstream dedupes so a retry never re-types."),
+			awaitMs: numberProp("Optional best-effort confirmation wait (ms) — NOT a deadline. Prefer awaitMs:0 plus await_turn; a turn that outruns awaitMs returns confirmationPending, not an error.")
+		}, [
+			"sessionId",
+			"message",
+			"idempotencyKey"
+		]), async (args, signal) => {
+			const { instance, localId, globalId } = await resolveSession(args);
+			const awaitMs = optionalNumber(args, "awaitMs");
+			const response = await clientFor(instance).sendMessage(localId, {
+				message: requiredString(args, "message"),
+				idempotencyKey: requiredString(args, "idempotencyKey"),
+				...awaitMs === void 0 ? {} : { awaitMs }
+			}, signal);
+			const delivered = !(response.delivered === false || response.delivery?.status === "failed" || response.delivery?.status === "error");
+			const confirmed = delivered && response.confirmed === true;
+			const confirmationTimedOut = delivered && !confirmed && (awaitMs !== void 0 && awaitMs > 0 || response.confirmationTimedOut === true);
+			const isError = !delivered;
+			return jsonResult({
+				resolvedInstance: publicInstance(instance),
+				sessionId: globalId,
+				...response,
+				delivered,
+				confirmed,
+				...confirmationTimedOut ? {
+					confirmationPending: true,
+					confirmationTimedOut: true
+				} : {},
+				...isError ? { message: "message was not delivered to the session by the upstream instance" } : confirmationTimedOut ? { message: "delivered; turn completion not confirmed in the await window. Use await_turn filtered to this sessionId to observe completion (the idempotencyKey makes a retried send safe)." } : {}
+			}, isError);
+		}),
+		tool$1("send_keys", "Send key input to a fleet session.", objectSchema({
+			sessionId: stringProp("Global session id in the form instanceId:localSessionId."),
+			instance: stringProp("Optional instance id/label; when supplied it must agree with sessionId."),
+			keys: stringProp("Key sequence to send."),
+			idempotencyKey: stringProp("Caller-generated idempotency key."),
+			raw: booleanProp("Pass keys through as raw input when the instance supports it.")
+		}, [
+			"sessionId",
+			"keys",
+			"idempotencyKey"
+		]), async (args, signal) => {
+			const { instance, localId, globalId } = await resolveSession(args);
+			const raw = optionalBoolean(args, "raw");
+			const response = await clientFor(instance).sendKeys(localId, {
+				keys: requiredString(args, "keys"),
+				idempotencyKey: requiredString(args, "idempotencyKey"),
+				...raw === void 0 ? {} : { raw }
+			}, signal);
+			return ok({
+				resolvedInstance: publicInstance(instance),
+				sessionId: globalId,
+				...response
+			});
+		}),
+		tool$1("respond", "Answer an awaited prompt in a fleet session by choice, option value, or explicit key override.", objectSchema({
+			sessionId: stringProp("Global session id in the form instanceId:localSessionId."),
+			instance: stringProp("Optional instance id/label; when supplied it must agree with sessionId."),
+			choice: stringProp("Named or numbered choice to select."),
+			optionValue: stringProp("Exact option value to select."),
+			keys: stringProp("Explicit key override to send instead of a mapped choice."),
+			idempotencyKey: stringProp("Caller-generated idempotency key.")
+		}, ["sessionId", "idempotencyKey"]), async (args, signal) => {
+			const { instance, localId, globalId } = await resolveSession(args);
+			const input = definedObject({
+				choice: optionalString(args, "choice"),
+				optionValue: optionalString(args, "optionValue"),
+				keys: optionalString(args, "keys"),
+				idempotencyKey: requiredString(args, "idempotencyKey")
+			});
+			const response = await clientFor(instance).respond(localId, input, signal);
+			return ok({
+				resolvedInstance: publicInstance(instance),
+				sessionId: globalId,
+				...response
+			});
+		}),
+		tool$1("create_session", "Create a new session on a specific fleet instance. The instance argument is required; no default is used.", objectSchema({
+			instance: stringProp("Required instance id or label. Create never uses the registry default."),
+			agent: stringProp("Agent/runtime to create on the instance."),
+			name: stringProp("Optional display name for the session."),
+			workingDir: stringProp("Optional working directory on the remote instance."),
+			idempotencyKey: stringProp("Caller-generated idempotency key."),
+			start: booleanProp("Whether the remote instance should start the session immediately."),
+			readyTimeoutMs: numberProp("F17: bounded ms to wait for the agent to become driveable before returning. The response carries ready/bound/blocker."),
+			permissionMode: stringProp("F10 (claude only): permission mode the launched agent starts in — one of plan | acceptEdits | default | bypassPermissions. Rejected with BAD_REQUEST if unknown or if agentArgs also sets it."),
+			agentArgs: arrayProp("F10 (claude only): extra launcher args appended after the github-router prefix. Must NOT include --permission-mode or --dangerously-skip-permissions (use permissionMode) — rejected with BAD_REQUEST.")
+		}, [
+			"instance",
+			"agent",
+			"idempotencyKey"
+		]), async (args, signal) => {
+			const instance = await resolve(requiredString(args, "instance"));
+			const agent = requiredString(args, "agent");
+			const idempotencyKey = requiredString(args, "idempotencyKey");
+			const permissionMode = optionalString(args, "permissionMode");
+			const agentArgs = optionalStringArray(args, "agentArgs");
+			if (permissionMode !== void 0) await assertCapability(instance, "permission_mode", "permissionMode", signal);
+			if (agentArgs !== void 0) await assertCapability(instance, "agent_args", "agentArgs", signal);
+			const response = await clientFor(instance).createSession(definedObject({
+				agent,
+				name: optionalString(args, "name"),
+				workingDir: optionalString(args, "workingDir"),
+				start: optionalBoolean(args, "start"),
+				readyTimeoutMs: optionalNumber(args, "readyTimeoutMs"),
+				permissionMode,
+				agentArgs,
+				idempotencyKey
+			}), signal);
+			const localSessionId = typeof response.sessionId === "string" ? response.sessionId : "";
+			return ok({
+				resolvedInstance: publicInstance(instance),
+				...response,
+				sessionId: localSessionId ? encodeSessionId(instance.id, localSessionId) : response.sessionId
+			});
+		}),
+		tool$1("stop_session", "Stop a fleet session.", objectSchema({
+			sessionId: stringProp("Global session id in the form instanceId:localSessionId."),
+			instance: stringProp("Optional instance id/label; when supplied it must agree with sessionId."),
+			idempotencyKey: stringProp("Caller-generated idempotency key."),
+			mode: stringProp("Optional stop mode understood by the remote instance.")
+		}, ["sessionId", "idempotencyKey"]), async (args, signal) => {
+			const { instance, localId, globalId } = await resolveSession(args);
+			const idempotencyKey = requiredString(args, "idempotencyKey");
+			const response = await clientFor(instance).stopSession(localId, definedObject({
+				mode: optionalString(args, "mode"),
+				idempotencyKey
+			}), signal);
+			return ok({
+				resolvedInstance: publicInstance(instance),
+				sessionId: globalId,
+				...response
+			});
+		}),
+		tool$1("await_turn", "Long-poll session events across fleet instances. The server owns per-target opaque cursors, so callers do not pass cursor tokens. Distinct concurrent watchers over the same instance set should pass a distinct watcherId so they do not share a cursor.", objectSchema({
+			instances: arrayProp("Instance ids or labels to poll. Omit with sessionIds to target those session instances; omit both to poll every registered instance."),
+			sessionIds: arrayProp("Global session ids to filter to."),
+			timeoutMs: numberProp("Long-poll timeout per instance in milliseconds."),
+			kinds: arrayProp("Optional event kinds to filter to."),
+			watcherId: stringProp("Optional stable id for this watcher. Use a distinct value for concurrent watchers over the same target set to keep cursors isolated.")
+		}, []), async (args, signal) => {
+			const target = await resolveAwaitTarget(args, getRegistry());
+			const cursorByInstance = takeAwaitTurnCursorMap(awaitTurnCursorKey(optionalString(args, "watcherId")));
+			const timeoutMs = optionalNumber(args, "timeoutMs");
+			const kinds = optionalStringArray(args, "kinds");
+			const results = await mapWithConcurrency(target.instances, fleetFanoutConcurrency(AWAIT_TURN_FANOUT_CONCURRENCY), async (instance) => {
+				const deadline = createAwaitTurnDeadline(timeoutMs, awaitTurnDeadlineSlackMs);
+				const combined = combineAbortSignals([signal, deadline.signal]);
+				try {
+					const response = await clientFor(instance).waitEvents(definedObject({
+						cursor: cursorByInstance.get(instance.id),
+						timeoutMs,
+						sessionIds: target.localSessionIdsByInstance.get(instance.id),
+						kinds
+					}), combined.signal);
+					cursorByInstance.set(instance.id, response.cursor);
+					return {
+						ok: true,
+						instance,
+						response
+					};
+				} catch (err) {
+					const error = fleetProbeErrorCode(err);
+					const hint = fleetProbeHint(error);
+					return {
+						ok: false,
+						instance,
+						error,
+						...hint ? { hint } : {}
+					};
+				} finally {
+					combined.cleanup();
+					deadline.cleanup();
+				}
+			});
+			const responses = results.filter(isAwaitTurnSuccess);
+			const errors = results.filter(isAwaitTurnFailure).map(({ instance, error, hint }) => ({
+				instance: publicInstance(instance),
+				error,
+				...hint ? { hint } : {}
+			}));
+			const events$1 = responses.flatMap(({ instance, response }) => response.events.map((event) => stampEvent(instance, event))).sort(compareStampedEvents);
+			const gaps = responses.flatMap(({ instance, response }) => response.gaps.map((gap) => ({
+				instance: publicInstance(instance),
+				...gap
+			})));
+			return ok({
+				resolvedInstances: target.instances.map(publicInstance),
+				events: events$1,
+				gaps,
+				cursors: responses.map(({ instance, response }) => ({
+					instance: publicInstance(instance),
+					cursor: response.cursor
+				})),
+				more: responses.some(({ response }) => response.more),
+				...errors.length > 0 ? { errors } : {}
+			});
+		}),
+		tool$1("read_file", "Read a file from one fleet instance via its existing /api/files/content endpoint.", objectSchema({
+			instance: stringProp("Instance id or label. Defaults to the registry default, or the sole instance."),
+			path: stringProp("Remote file path to read.")
+		}, ["path"]), async (args, signal) => {
+			const instance = await resolve(optionalString(args, "instance"));
+			const response = await clientFor(instance).readFile(requiredString(args, "path"), signal);
+			return ok({
+				resolvedInstance: publicInstance(instance),
+				...response
+			});
+		}),
+		tool$1("list_dir", "List a directory on one fleet instance via its existing /api/files endpoint.", objectSchema({
+			instance: stringProp("Instance id or label. Defaults to the registry default, or the sole instance."),
+			path: stringProp("Remote directory path to list.")
+		}, ["path"]), async (args, signal) => {
+			const instance = await resolve(optionalString(args, "instance"));
+			const response = await clientFor(instance).listDir(requiredString(args, "path"), signal);
+			return ok({
+				resolvedInstance: publicInstance(instance),
+				...response
+			});
+		}),
+		tool$1("search", "Search files on one fleet instance via its existing /api/search endpoint.", objectSchema({
+			instance: stringProp("Instance id or label. Defaults to the registry default, or the sole instance."),
+			query: stringProp("Search query."),
+			path: stringProp("Optional path scope.")
+		}, ["query"]), async (args, signal) => {
+			const instance = await resolve(optionalString(args, "instance"));
+			const response = await clientFor(instance).search(requiredString(args, "query"), optionalString(args, "path"), signal);
+			return ok({
+				resolvedInstance: publicInstance(instance),
+				...response
+			});
+		}),
+		tool$1("git_show", "Read a file/revision through one fleet instance's existing /api/files/git-show endpoint.", objectSchema({
+			instance: stringProp("Instance id or label. Defaults to the registry default, or the sole instance."),
+			path: stringProp("Remote repository path or file path for git-show."),
+			ref: stringProp("Optional git ref/revision."),
+			rev: stringProp("Optional git revision alias."),
+			commit: stringProp("Optional commit id.")
+		}, ["path"]), async (args, signal) => {
+			const instance = await resolve(optionalString(args, "instance"));
+			const response = await clientFor(instance).gitShow({
+				...args,
+				instance: void 0
+			}, signal);
+			return ok({
+				resolvedInstance: publicInstance(instance),
+				...response
+			});
+		})
+	]);
+}
+const FLEET_TOOLS = createFleetTools();
+function createProbeTimeout() {
+	const timeout = AbortSignal.timeout;
+	if (typeof timeout === "function") return {
+		signal: timeout(INSTANCE_PROBE_TIMEOUT_MS),
+		cleanup: () => {}
+	};
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), INSTANCE_PROBE_TIMEOUT_MS);
+	return {
+		signal: controller.signal,
+		cleanup: () => clearTimeout(timer)
+	};
+}
+function createAwaitTurnDeadline(timeoutMs, slackMs) {
+	const deadlineMs = Math.max(0, timeoutMs ?? AWAIT_TURN_DEFAULT_TIMEOUT_MS) + slackMs;
+	const controller = new AbortController();
+	const timer = setTimeout(() => {
+		const err = /* @__PURE__ */ new Error("await_turn per-instance deadline exceeded");
+		err.name = "TimeoutError";
+		controller.abort(err);
+	}, deadlineMs);
+	return {
+		signal: controller.signal,
+		cleanup: () => clearTimeout(timer)
+	};
+}
+function combineAbortSignals(signals) {
+	const noop = () => {};
+	const present = signals.filter((signal) => signal !== void 0);
+	if (present.length === 0) return {
+		signal: void 0,
+		cleanup: noop
+	};
+	if (present.length === 1) return {
+		signal: present[0],
+		cleanup: noop
+	};
+	const any = AbortSignal.any;
+	if (typeof any === "function") return {
+		signal: any(present),
+		cleanup: noop
+	};
+	const controller = new AbortController();
+	const listeners = [];
+	const cleanup = () => {
+		for (const { signal, handler } of listeners) signal.removeEventListener("abort", handler);
+		listeners.length = 0;
+	};
+	for (const signal of present) {
+		if (signal.aborted) {
+			if (!controller.signal.aborted) controller.abort(signal.reason);
+			cleanup();
+			return {
+				signal: controller.signal,
+				cleanup: noop
+			};
+		}
+		const handler = () => {
+			if (!controller.signal.aborted) controller.abort(signal.reason);
+		};
+		signal.addEventListener("abort", handler, { once: true });
+		listeners.push({
+			signal,
+			handler
+		});
+	}
+	return {
+		signal: controller.signal,
+		cleanup
+	};
+}
+function fleetProbeErrorCode(err) {
+	if (typeof err === "object" && err !== null && "code" in err) {
+		const code = err.code;
+		if (typeof code === "string" && isFleetErrorCode(code)) return code;
+	}
+	if (isAbortLike(err)) return "TIMEOUT";
+	return "UNREACHABLE";
+}
+function fleetProbeHint(code) {
+	switch (code) {
+		case "NO_HOST": return "tunnel relay up, no ai-or-die host connected (start the host on that machine)";
+		case "RELAY_ERROR": return "tunnel relay returned an error; the host may be down, restarting, or under load";
+		case "TIMEOUT": return "no response before the probe deadline; the host may be slow or the tunnel may have no host";
+		case "UNREACHABLE": return "could not connect (DNS or connection failure); check the instance url";
+		default: return;
+	}
+}
+function isFleetErrorCode(code) {
+	switch (code) {
+		case "UNREACHABLE":
+		case "AUTH_FAILED":
+		case "SESSION_NOT_FOUND":
+		case "PRECONDITION_FAILED":
+		case "TIMEOUT":
+		case "UPSTREAM_ERROR":
+		case "NO_HOST":
+		case "RELAY_ERROR":
+		case "BAD_REQUEST":
+		case "RATE_LIMITED": return true;
+		default: return false;
+	}
+}
+async function resolveAwaitTarget(args, registry) {
+	const instanceArgs = optionalStringArray(args, "instances");
+	const sessionIdArgs = optionalStringArray(args, "sessionIds");
+	const localSessionIdsByInstance = /* @__PURE__ */ new Map();
+	for (const sessionId of sessionIdArgs ?? []) {
+		const decoded = decodeSessionId(sessionId);
+		const existing = localSessionIdsByInstance.get(decoded.instanceId) ?? [];
+		existing.push(decoded.localId);
+		localSessionIdsByInstance.set(decoded.instanceId, existing);
+	}
+	let instances;
+	if (instanceArgs !== void 0 && instanceArgs.length > 0) {
+		instances = uniqueInstances(await Promise.all(instanceArgs.map((arg) => registry.resolveInstance(arg))));
+		const ids = new Set(instances.map((instance) => instance.id));
+		for (const instanceId of localSessionIdsByInstance.keys()) if (!ids.has(instanceId)) throw new FleetToolInputError("INSTANCE_MISMATCH", `sessionIds include instance ${JSON.stringify(instanceId)} which is not in arguments.instances`);
+	} else if (localSessionIdsByInstance.size > 0) instances = uniqueInstances(await Promise.all([...localSessionIdsByInstance.keys()].map((instanceId) => registry.resolveInstance(instanceId))));
+	else {
+		const infos = await registry.listInstances();
+		if (infos.length === 0) throw new FleetRegistryError("INSTANCE_REQUIRED", "await_turn requires at least one registered fleet instance");
+		instances = uniqueInstances(await Promise.all(infos.map((info) => registry.resolveInstance(info.id))));
+	}
+	return {
+		instances,
+		localSessionIdsByInstance
+	};
+}
+function globalizeSession(instanceId, session) {
+	return {
+		...session,
+		sessionId: encodeSessionId(instanceId, session.sessionId)
+	};
+}
+function stampEvent(instance, event) {
+	return {
+		...event,
+		instance: publicInstance(instance),
+		...typeof event.sessionId === "string" ? { sessionId: encodeSessionId(instance.id, event.sessionId) } : {}
+	};
+}
+function eventAtMs(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string") {
+		const parsed = Date.parse(value);
+		if (!Number.isNaN(parsed)) return parsed;
+	}
+	return 0;
+}
+function compareStampedEvents(a, b) {
+	const atA = eventAtMs(a.at);
+	const atB = eventAtMs(b.at);
+	if (atA !== atB) return atA - atB;
+	return (typeof a.seq === "number" ? a.seq : 0) - (typeof b.seq === "number" ? b.seq : 0);
+}
+const MAX_WATCHER_ID_LEN = 200;
+const MAX_AWAIT_TURN_CURSOR_KEYS = 1024;
+function awaitTurnCursorKey(watcherId) {
+	const id = watcherId ?? "default";
+	return id.length > MAX_WATCHER_ID_LEN ? id.slice(0, MAX_WATCHER_ID_LEN) : id;
+}
+function takeAwaitTurnCursorMap(clientKey) {
+	const existing = awaitTurnCursors.get(clientKey);
+	if (existing) {
+		awaitTurnCursors.delete(clientKey);
+		awaitTurnCursors.set(clientKey, existing);
+		return existing;
+	}
+	const created = /* @__PURE__ */ new Map();
+	awaitTurnCursors.set(clientKey, created);
+	while (awaitTurnCursors.size > MAX_AWAIT_TURN_CURSOR_KEYS) {
+		const oldest = awaitTurnCursors.keys().next().value;
+		if (oldest === void 0) break;
+		awaitTurnCursors.delete(oldest);
+	}
+	return created;
+}
+function isAwaitTurnSuccess(result) {
+	return result.ok;
+}
+function isAwaitTurnFailure(result) {
+	return !result.ok;
+}
+function failedProbeResult(info, code) {
+	const hint = fleetProbeHint(code);
+	return {
+		id: info.id,
+		label: info.label,
+		reachable: false,
+		error: code,
+		...hint ? { hint } : {}
+	};
+}
+async function mapWithConcurrency(items, limit, fn) {
+	const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 1;
+	const concurrency = Math.max(1, Math.min(items.length || 1, safeLimit));
+	const results = new Array(items.length);
+	let nextIndex = 0;
+	async function worker() {
+		while (nextIndex < items.length) {
+			const index = nextIndex++;
+			results[index] = await fn(items[index], index);
+		}
+	}
+	await Promise.all(Array.from({ length: concurrency }, () => worker()));
+	return results;
+}
+function fleetFanoutConcurrency(defaultLimit) {
+	const raw = process.env[FLEET_FANOUT_CONCURRENCY_ENV];
+	const parsed = raw === void 0 ? NaN : Number.parseInt(raw, 10);
+	if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+	return defaultLimit;
+}
+function probeRateLimitBackoffMs(attempt) {
+	return Math.min(INSTANCE_PROBE_RATE_LIMIT_BACKOFF_BASE_MS * 2 ** attempt, INSTANCE_PROBE_RATE_LIMIT_BACKOFF_MAX_MS);
+}
+function nonNegativeNumberOrDefault(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+async function delay(ms) {
+	if (ms <= 0) return;
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isAbortLike(err) {
+	if (!(err instanceof Error)) return false;
+	return err.name === "AbortError" || err.name === "TimeoutError";
+}
+function uniqueInstances(instances) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const instance of instances) {
+		if (seen.has(instance.id)) continue;
+		seen.add(instance.id);
+		result.push(instance);
+	}
+	return result;
+}
+function publicInstance(instance) {
+	return {
+		id: instance.id,
+		label: instance.label
+	};
+}
+/**
+* Build the FleetClient tunnel-auth options for a resolved instance.
+* Resolution order: a `tunnelId` enables auto-mint + auto-refresh (and the
+* evict-on-failure hook); else a static `tunnelToken` is sent directly (no
+* retry, since it cannot be re-minted); else no tunnel auth.
+*/
+function tunnelClientOptions(instance, provider) {
+	if (instance.tunnelId) {
+		const cfg = { tunnelId: instance.tunnelId };
+		return {
+			getTunnelToken: () => provider.getToken(cfg),
+			onTunnelAuthInvalidate: () => provider.invalidate(cfg)
+		};
+	}
+	if (instance.tunnelToken) {
+		const token = instance.tunnelToken;
+		return { getTunnelToken: async () => token };
+	}
+	return {};
+}
+function ok(value) {
+	return jsonResult(value, false);
+}
+function jsonResult(value, isError) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(value)
+		}],
+		...isError ? { isError: true } : {}
+	};
+}
+function errorResult(err) {
+	return jsonResult({ error: {
+		code: errorCode(err),
+		message: err instanceof Error ? err.message : String(err)
+	} }, true);
+}
+function errorCode(err) {
+	if (typeof err === "object" && err !== null && "code" in err) {
+		const code = err.code;
+		if (typeof code === "string") return code;
+	}
+	return "FLEET_ERROR";
+}
+function definedObject(input) {
+	const result = {};
+	for (const [key, value] of Object.entries(input)) if (value !== void 0) result[key] = value;
+	return result;
+}
+function requiredString(args, key) {
+	const value = args[key];
+	if (typeof value !== "string" || value.trim() === "") throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} is required and must be a non-empty string`);
+	return value;
+}
+function optionalString(args, key) {
+	const value = args[key];
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a string`);
+	return value.trim() === "" ? void 0 : value;
+}
+function optionalNumber(args, key) {
+	const value = args[key];
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a finite number`);
+	return value;
+}
+function optionalBoolean(args, key) {
+	const value = args[key];
+	if (value === void 0) return void 0;
+	if (typeof value !== "boolean") throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a boolean`);
+	return value;
+}
+function optionalStringArray(args, key) {
+	const value = args[key];
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} must be an array of non-empty strings`);
+	return value;
+}
+function objectSchema(properties, required) {
+	return {
+		type: "object",
+		required,
+		additionalProperties: false,
+		properties
+	};
+}
+function stringProp(description) {
+	return {
+		type: "string",
+		description
+	};
+}
+function numberProp(description) {
+	return {
+		type: "number",
+		description
+	};
+}
+function booleanProp(description) {
+	return {
+		type: "boolean",
+		description
+	};
+}
+function arrayProp(description) {
+	return {
+		type: "array",
+		items: { type: "string" },
+		description
+	};
+}
+
 //#endregion
 //#region src/lib/tree-sitter-grammars.ts
 /**
@@ -5046,7 +6927,7 @@ async function runInit(workspace) {
 	];
 	const onInactivityCheck = makeIndexProgressProbe(workspace);
 	const startMs = Date.now();
-	let ok = false;
+	let ok$2 = false;
 	let failureClass;
 	try {
 		const res = await runManagedExeCapture(binary, args, {
@@ -5063,10 +6944,10 @@ async function runInit(workspace) {
 				}).catch(() => {});
 			}
 		});
-		ok = !res.stalled && !res.timedOut && res.code === 0;
-		if (!ok) failureClass = res.stalled || res.timedOut ? "stuck" : "error";
+		ok$2 = !res.stalled && !res.timedOut && res.code === 0;
+		if (!ok$2) failureClass = res.stalled || res.timedOut ? "stuck" : "error";
 	} catch {
-		ok = false;
+		ok$2 = false;
 		failureClass = "launch";
 	} finally {
 		releaseInit(workspace);
@@ -5083,9 +6964,9 @@ async function runInit(workspace) {
 			finalMeta.lastIndexedDirty = g.dirty;
 		}
 	} catch {}
-	finalMeta.status = ok ? "ready" : "failed";
+	finalMeta.status = ok$2 ? "ready" : "failed";
 	finalMeta.lastIndexedAt = (/* @__PURE__ */ new Date()).toISOString();
-	if (ok) {
+	if (ok$2) {
 		finalMeta.failedAttempts = 0;
 		finalMeta.failureClass = void 0;
 	} else {
@@ -6164,8 +8045,8 @@ async function isHumanlikeAutoOn(tabId, signal) {
 	} catch {}
 	return humanlikeAutoCache.tabs.has(tabId);
 }
-async function maybeInjectHumanlikeDelay(tool, signal, tabId) {
-	if (!PACED_TOOLS.has(tool)) return;
+async function maybeInjectHumanlikeDelay(tool$1, signal, tabId) {
+	if (!PACED_TOOLS.has(tool$1)) return;
 	let on = state.humanlikeForce === "on";
 	if (!on && state.humanlikeForce === "auto") on = await isHumanlikeAutoOn(tabId, signal);
 	if (!on) return;
@@ -6270,8 +8151,8 @@ const PER_TOOL_TIMEOUTS = {
 		maxMs: 1e4
 	}
 };
-function pickTimeout(tool) {
-	if (tool in PER_TOOL_TIMEOUTS) return PER_TOOL_TIMEOUTS[tool];
+function pickTimeout(tool$1) {
+	if (tool$1 in PER_TOOL_TIMEOUTS) return PER_TOOL_TIMEOUTS[tool$1];
 	return {
 		defaultMs: 1e4,
 		maxMs: 3e4
@@ -6284,7 +8165,7 @@ function pickTimeout(tool) {
 * client sends notifications/cancelled, the WS is force-closed and
 * the promise rejects so the slot releases cleanly.
 */
-async function bridgeCall(endpoint, tool, args, timeoutMs, signal) {
+async function bridgeCall(endpoint, tool$1, args, timeoutMs, signal) {
 	return new Promise((resolve, reject) => {
 		const id = randomUUID();
 		const ws = new WebSocket(`ws://127.0.0.1:${endpoint.port}`, { headers: { authorization: `Bearer ${endpoint.token}` } });
@@ -6318,7 +8199,7 @@ async function bridgeCall(endpoint, tool, args, timeoutMs, signal) {
 			}
 			ws.send(JSON.stringify({
 				id,
-				tool,
+				tool: tool$1,
 				args
 			}));
 		});
@@ -6377,8 +8258,8 @@ function blockedUrlEnvelope(reason) {
 * happy-path `ensureBridgeReady()` (and its NMH install) is the accepted
 * cost of keeping the credentials fresh.
 */
-async function browserPreflight(tool, args) {
-	const policy = preflightUrlPolicy(tool.startsWith("browser_") ? tool : `browser_${tool}`, args);
+async function browserPreflight(tool$1, args) {
+	const policy = preflightUrlPolicy(tool$1.startsWith("browser_") ? tool$1 : `browser_${tool$1}`, args);
 	if (policy.blocked) return { envelope: blockedUrlEnvelope(policy.reason) };
 	const ready = await ensureBridgeReady();
 	if (ready.install_required) return { envelope: installRequiredToolResult(ready) };
@@ -6389,23 +8270,23 @@ async function browserPreflight(tool, args) {
 * src/lib/browser-mcp/index.ts. Returns the standard MCP tool-result
 * envelope.
 */
-async function dispatchBrowserTool(tool, args, signal, opts = {}) {
-	const policy = preflightUrlPolicy(tool, args);
+async function dispatchBrowserTool(tool$1, args, signal, opts = {}) {
+	const policy = preflightUrlPolicy(tool$1, args);
 	if (policy.blocked) return blockedUrlEnvelope(policy.reason);
 	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);
+	await maybeInjectHumanlikeDelay(tool$1, signal, typeof args.tabId === "number" ? args.tabId : void 0);
+	const { defaultMs, maxMs } = pickTimeout(tool$1);
 	const callerTimeout = typeof opts.timeoutMs === "number" && opts.timeoutMs > 0 ? Math.min(opts.timeoutMs, maxMs) : defaultMs;
 	try {
 		const resp = await bridgeCall({
 			port: ready.port,
 			token: ready.token
-		}, tool, args, callerTimeout, signal);
+		}, tool$1, args, callerTimeout, signal);
 		if (resp.ok) {
 			const text = typeof resp.data === "string" ? resp.data : JSON.stringify(resp.data, null, 2);
 			logAudit$1({
-				tool,
+				tool: tool$1,
 				argsBytes: argsByteSize(args),
 				durationMs: 0,
 				profile: typeof args.profile === "string" ? args.profile : "isolated",
@@ -6417,7 +8298,7 @@ async function dispatchBrowserTool(tool, args, signal, opts = {}) {
 			}] };
 		}
 		logAudit$1({
-			tool,
+			tool: tool$1,
 			argsBytes: argsByteSize(args),
 			durationMs: 0,
 			profile: typeof args.profile === "string" ? args.profile : "isolated",
@@ -6427,14 +8308,14 @@ async function dispatchBrowserTool(tool, args, signal, opts = {}) {
 		return {
 			content: [{
 				type: "text",
-				text: `${tool} failed: ${resp.error}${resp.code ? ` (${resp.code})` : ""}`
+				text: `${tool$1} failed: ${resp.error}${resp.code ? ` (${resp.code})` : ""}`
 			}],
 			isError: true
 		};
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
 		logAudit$1({
-			tool,
+			tool: tool$1,
 			argsBytes: argsByteSize(args),
 			durationMs: 0,
 			profile: typeof args.profile === "string" ? args.profile : "isolated",
@@ -6444,7 +8325,7 @@ async function dispatchBrowserTool(tool, args, signal, opts = {}) {
 		return {
 			content: [{
 				type: "text",
-				text: `${tool} failed: ${message}`
+				text: `${tool$1} failed: ${message}`
 			}],
 			isError: true
 		};
@@ -7405,20 +9286,20 @@ function compressorAvailable() {
 * free-form `message.content` and strip a leading / trailing ```` ``` ````
 * code fence before parsing.
 */
-async function callCompressor(systemPrompt, userMessage, tool, signal) {
+async function callCompressor(systemPrompt, userMessage, tool$1, signal) {
 	const backend = pickBackend();
 	if (!backend) 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 {
-		return backend.endpoint === "responses" ? await callViaResponses(backend.id, systemPrompt, userMessage, tool, signal) : await callViaChat(backend.id, systemPrompt, userMessage, tool, signal);
+		return backend.endpoint === "responses" ? await callViaResponses(backend.id, systemPrompt, userMessage, tool$1, signal) : await callViaChat(backend.id, systemPrompt, userMessage, tool$1, signal);
 	} finally {
 		release();
 	}
 }
 /** Forced-tool-call over `/chat/completions`. Parses the function-call
 *  arguments, falling back to fenced free-form content. */
-async function callViaChat(model, systemPrompt, userMessage, tool, signal) {
+async function callViaChat(model, systemPrompt, userMessage, tool$1, signal) {
 	const msg = (await createChatCompletions({
 		model,
 		stream: false,
@@ -7432,14 +9313,14 @@ async function callViaChat(model, systemPrompt, userMessage, tool, signal) {
 		tools: [{
 			type: "function",
 			function: {
-				name: tool.name,
-				description: tool.description,
-				parameters: tool.parameters
+				name: tool$1.name,
+				description: tool$1.description,
+				parameters: tool$1.parameters
 			}
 		}],
 		tool_choice: {
 			type: "function",
-			function: { name: tool.name }
+			function: { name: tool$1.name }
 		}
 	}, void 0, signal)).choices?.[0]?.message;
 	const toolArgs = msg?.tool_calls?.[0]?.function?.arguments;
@@ -7453,7 +9334,7 @@ async function callViaChat(model, systemPrompt, userMessage, tool, signal) {
 *  items of `type: "function_call"` carrying the `arguments` JSON string.
 *  Image parts use `input_image` (vs chat's `image_url`) — see
 *  `toResponsesContent`. */
-async function callViaResponses(model, systemPrompt, userMessage, tool, signal) {
+async function callViaResponses(model, systemPrompt, userMessage, tool$1, signal) {
 	const resp = await createResponses({
 		model,
 		stream: false,
@@ -7466,13 +9347,13 @@ async function callViaResponses(model, systemPrompt, userMessage, tool, signal)
 		}],
 		tools: [{
 			type: "function",
-			name: tool.name,
-			description: tool.description,
-			parameters: tool.parameters
+			name: tool$1.name,
+			description: tool$1.description,
+			parameters: tool$1.parameters
 		}],
 		tool_choice: {
 			type: "function",
-			name: tool.name
+			name: tool$1.name
 		}
 	}, void 0, signal);
 	const output = Array.isArray(resp.output) ? resp.output : [];
@@ -7528,8 +9409,8 @@ function extractResponsesText$1(output) {
 * 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);
+async function callCompressorPublic(systemPrompt, userMessage, tool$1, signal) {
+	return callCompressor(systemPrompt, userMessage, tool$1, signal);
 }
 /**
 * Strip a single leading / trailing ``` (or ```json) code fence from a
@@ -8643,12 +10524,12 @@ const BROWSER_TOOLS = Object.freeze([
 		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 tool$1 = 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, {
+			const env = await dispatchBrowserTool(tool$1, {
 				tabId,
 				level
 			}, signal);
@@ -9536,12 +11417,12 @@ function formatValidationPath(error) {
 * @returns The validated (and potentially coerced) arguments
 * @throws Error with formatted message if validation fails
 */
-function validateToolArguments(tool, toolCall) {
+function validateToolArguments(tool$1, toolCall) {
 	const args = structuredClone(toolCall.arguments);
-	Value.Convert(tool.parameters, args);
-	const validator = getValidator(tool.parameters);
-	if (!hasTypeBoxMetadata(tool.parameters) && isJsonSchemaObject(tool.parameters)) {
-		const coerced = coerceWithJsonSchema(args, tool.parameters);
+	Value.Convert(tool$1.parameters, args);
+	const validator = getValidator(tool$1.parameters);
+	if (!hasTypeBoxMetadata(tool$1.parameters) && isJsonSchemaObject(tool$1.parameters)) {
+		const coerced = coerceWithJsonSchema(args, tool$1.parameters);
 		if (coerced !== args) if (isRecord(args) && isRecord(coerced)) {
 			for (const key of Object.keys(args)) delete args[key];
 			Object.assign(args, coerced);
@@ -9850,9 +11731,9 @@ async function executeToolCallsParallel(currentContext, assistantMessage, toolCa
 function shouldTerminateToolBatch(finalizedCalls) {
 	return finalizedCalls.length > 0 && finalizedCalls.every((finalized) => finalized.result.terminate === true);
 }
-function prepareToolCallArguments(tool, toolCall) {
-	if (!tool.prepareArguments) return toolCall;
-	const preparedArguments = tool.prepareArguments(toolCall.arguments);
+function prepareToolCallArguments(tool$1, toolCall) {
+	if (!tool$1.prepareArguments) return toolCall;
+	const preparedArguments = tool$1.prepareArguments(toolCall.arguments);
 	if (preparedArguments === toolCall.arguments) return toolCall;
 	return {
 		...toolCall,
@@ -9860,14 +11741,14 @@ function prepareToolCallArguments(tool, toolCall) {
 	};
 }
 async function prepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
-	const tool = currentContext.tools?.find((t) => t.name === toolCall.name);
-	if (!tool) return {
+	const tool$1 = currentContext.tools?.find((t) => t.name === toolCall.name);
+	if (!tool$1) return {
 		kind: "immediate",
 		result: createErrorToolResult(`Tool ${toolCall.name} not found`),
 		isError: true
 	};
 	try {
-		const validatedArgs = validateToolArguments(tool, prepareToolCallArguments(tool, toolCall));
+		const validatedArgs = validateToolArguments(tool$1, prepareToolCallArguments(tool$1, toolCall));
 		if (config.beforeToolCall) {
 			const beforeResult = await config.beforeToolCall({
 				assistantMessage,
@@ -9894,7 +11775,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
 		return {
 			kind: "prepared",
 			toolCall,
-			tool,
+			tool: tool$1,
 			args: validatedArgs
 		};
 	} catch (error) {
@@ -12192,7 +14073,7 @@ const REPORT_INSUFFICIENT_DESCRIPTION = "Finish by declaring the requested value
 function makeBrowserTool(meta, parameters, dispatch, sessionId) {
 	const wireName = `browser_${meta.name}`;
 	const policy = tabPolicyFor(meta.name);
-	const tool = {
+	const tool$1 = {
 		name: meta.name,
 		label: meta.label,
 		description: meta.description,
@@ -12217,8 +14098,8 @@ function makeBrowserTool(meta, parameters, dispatch, sessionId) {
 			return textResult$1(text);
 		}
 	};
-	if (meta.executionMode) tool.executionMode = meta.executionMode;
-	return tool;
+	if (meta.executionMode) tool$1.executionMode = meta.executionMode;
+	return tool$1;
 }
 /**
 * Build a synthetic terminal tool. `execute` never touches the browser — it
@@ -12699,9 +14580,9 @@ const calculateParametersTokens = (parameters, encoder, constants) => {
 /**
 * Calculate tokens for a single tool
 */
-const calculateToolTokens = (tool, encoder, constants) => {
+const calculateToolTokens = (tool$1, encoder, constants) => {
 	let tokens = constants.funcInit;
-	const func = tool.function;
+	const func = tool$1.function;
 	const fName = func.name;
 	let fDesc = func.description || "";
 	if (fDesc.endsWith(".")) fDesc = fDesc.slice(0, -1);
@@ -12715,7 +14596,7 @@ const calculateToolTokens = (tool, encoder, constants) => {
 */
 const numTokensForTools = (tools, encoder, constants) => {
 	let funcTokenCount = 0;
-	for (const tool of tools) funcTokenCount += calculateToolTokens(tool, encoder, constants);
+	for (const tool$1 of tools) funcTokenCount += calculateToolTokens(tool$1, encoder, constants);
 	funcTokenCount += constants.funcEnd;
 	return funcTokenCount;
 };
@@ -13001,6 +14882,28 @@ function browserToolsEnabled() {
 	return hasSupportedBrowserInstalled();
 }
 /**
+* Gate for the fleet session-control MCP tools (`mcp__fleet__*`).
+*
+* Returns true iff the operator opted in (`state.fleetEnabled`, set by
+* `--fleet`, OR `GH_ROUTER_ENABLE_FLEET=1` read directly so non-
+* `setupAndServe` startup paths — tests, embedded use — can still flip
+* the gate). Fleet needs no local installed dependency check.
+*/
+function fleetToolsEnabled() {
+	return state.fleetEnabled || process.env.GH_ROUTER_ENABLE_FLEET === "1";
+}
+/**
+* Gate for ai-or-die Artifact review tools.
+*
+* Returns true iff this github-router process was launched inside an
+* ai-or-die tab and received the tab-scoped API trio. The tools are
+* otherwise invisible at `tools/list` and rejected at `tools/call`; direct
+* handler calls still return a friendly isError envelope.
+*/
+function artifactToolsEnabled() {
+	return !!(process.env.AIORDIE_BASE_URL && process.env.AIORDIE_TOKEN && process.env.AIORDIE_SESSION_ID);
+}
+/**
 * Gate for the `browse` worker tool (the Pi-driven autonomous browser
 * agent that delegates a browsing task to its own context).
 *
@@ -13196,6 +15099,8 @@ function toolEntries(scope) {
 		if (t.capability === "browse_agent") return browseAgentEnabled();
 		if (t.capability === "stand_in") return standInToolEnabled();
 		if (t.capability === "browser") return browserToolsEnabled();
+		if (t.capability === "fleet") return fleetToolsEnabled();
+		if (t.capability === "artifact") return artifactToolsEnabled();
 		if (t.capability === "browser_compound") return browserToolsEnabled() && browserCompoundToolsEnabled();
 		if (t.capability === "browser_power") return browserToolsEnabled() && browserPowerToolsEnabled();
 		return true;
@@ -13522,6 +15427,8 @@ async function handleToolsCall(body, scope) {
 	if (nonPersonaTool && nonPersonaTool.capability === "browse_agent" && !browseAgentEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "stand_in" && !standInToolEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "browser" && !browserToolsEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
+	if (nonPersonaTool && nonPersonaTool.capability === "fleet" && !fleetToolsEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
+	if (nonPersonaTool && nonPersonaTool.capability === "artifact" && !artifactToolsEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "browser_compound" && !(browserToolsEnabled() && browserCompoundToolsEnabled())) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "browser_power" && !(browserToolsEnabled() && browserPowerToolsEnabled())) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	let personaPrompt;
@@ -16197,32 +18104,32 @@ function toolbeltTool(workspace) {
 		description: "Run a read-only code-analysis CLI in the workspace with NO shell (args are literal — no pipes / redirects / chaining / globbing). Tools: rg, fd, sg (ast-grep), jq, yq, gron, scc, tokei, difft (difftastic), and git (read-only subcommands). Write/exec flags (fd -x, rg --pre, ast-grep --rewrite, yq -i) and mutating git subcommands are rejected. Returns combined stdout (stderr appended on non-zero exit).",
 		parameters: TOOLBELT_PARAMS,
 		async execute(_toolCallId, params, signal) {
-			const tool = params.tool;
+			const tool$1 = params.tool;
 			const args = Array.isArray(params.args) ? params.args.map(String) : [];
-			if (!TOOLBELT_TOOL_SET.has(tool)) throw new Error(`toolbelt: unknown tool '${tool}'`);
-			if (tool === "git") {
+			if (!TOOLBELT_TOOL_SET.has(tool$1)) throw new Error(`toolbelt: unknown tool '${tool$1}'`);
+			if (tool$1 === "git") {
 				const sub = args[0];
 				if (!sub || !GIT_READONLY_SUBCOMMANDS.has(sub)) throw new Error(`git: only read-only subcommands are allowed and the subcommand must be args[0] (no leading -C/-c). Allowed: ${[...GIT_READONLY_SUBCOMMANDS].join(", ")}. Got: ${sub ? `'${sub}'` : "<none>"}`);
 				for (const arg of args) if (gitArgDenied(arg)) throw new Error(`git: flag '${arg}' is not allowed (toolbelt is read-only)`);
 			} else {
-				if (tool === "sg" && args[0] && SG_DENIED_SUBCOMMANDS.has(args[0])) throw new Error(`sg: subcommand '${args[0]}' is not allowed (toolbelt is read-only)`);
-				const denied = TOOLBELT_DENIED_FLAGS[tool];
+				if (tool$1 === "sg" && args[0] && SG_DENIED_SUBCOMMANDS.has(args[0])) throw new Error(`sg: subcommand '${args[0]}' is not allowed (toolbelt is read-only)`);
+				const denied = TOOLBELT_DENIED_FLAGS[tool$1];
 				if (denied) {
-					for (const arg of args) if (argViolatesDenylist(denied, arg)) throw new Error(`${tool}: arg '${arg}' carries a write/exec flag (toolbelt is read-only)`);
+					for (const arg of args) if (argViolatesDenylist(denied, arg)) throw new Error(`${tool$1}: arg '${arg}' carries a write/exec flag (toolbelt is read-only)`);
 				}
 			}
 			const env = buildEnv();
-			if (tool === "git") {
+			if (tool$1 === "git") {
 				env.GIT_PAGER = "cat";
 				env.PAGER = "cat";
 				env.GIT_TERMINAL_PROMPT = "0";
 				env.GIT_OPTIONAL_LOCKS = "0";
 			}
-			const binPath = resolveExecutable(tool, { env });
-			if (!binPath) return textResult(`${tool}: not available on this host (not on PATH / toolbelt). rg/fd/jq/yq/sg/gron/scc/difft ship with the toolbelt; git and tokei may require a system install.`);
+			const binPath = resolveExecutable(tool$1, { env });
+			if (!binPath) return textResult(`${tool$1}: not available on this host (not on PATH / toolbelt). rg/fd/jq/yq/sg/gron/scc/difft ship with the toolbelt; git and tokei may require a system install.`);
 			const TOOLBELT_TIMEOUT_MS = 6e4;
 			const TOOLBELT_STDOUT_CAP = 1024 * 1024;
-			const res = await runManagedExeCapture(binPath, tool === "git" ? buildGitExecArgs(args) : args, {
+			const res = await runManagedExeCapture(binPath, tool$1 === "git" ? buildGitExecArgs(args) : args, {
 				cwd: workspace,
 				env,
 				timeoutMs: TOOLBELT_TIMEOUT_MS,
@@ -16232,13 +18139,13 @@ function toolbeltTool(workspace) {
 					else signal?.addEventListener("abort", () => killChildTree(child), { once: true });
 				}
 			});
-			if (signal?.aborted) throw new Error(`${tool} aborted`);
-			if (res.timedOut) throw new Error(`${tool} timed out after ${TOOLBELT_TIMEOUT_MS}ms`);
+			if (signal?.aborted) throw new Error(`${tool$1} aborted`);
+			if (res.timedOut) throw new Error(`${tool$1} timed out after ${TOOLBELT_TIMEOUT_MS}ms`);
 			const parts = [];
 			if (res.stdout) parts.push(res.stdout);
 			if ((res.code !== 0 || !res.stdout) && res.stderr.trim()) parts.push(`[stderr] ${res.stderr.trim()}`);
 			if (res.stdoutTruncated) parts.push(`[truncated at ${TOOLBELT_STDOUT_CAP} bytes — narrow the query]`);
-			if (parts.length === 0) parts.push(`(${tool} exited ${res.code} with no output)`);
+			if (parts.length === 0) parts.push(`(${tool$1} exited ${res.code} with no output)`);
 			return textResult(parts.join("\n"));
 		}
 	};
@@ -19233,7 +21140,8 @@ const MCP_GROUPS = Object.freeze([
 	"workers",
 	"orchestrate",
 	"browser",
-	"decide"
+	"decide",
+	"fleet"
 ]);
 const GROUP_META = Object.freeze({
 	peers: {
@@ -19265,6 +21173,11 @@ const GROUP_META = Object.freeze({
 		preferredKey: "decide",
 		urlSuffix: "decide",
 		serverInfoName: "github-router-decide"
+	},
+	fleet: {
+		preferredKey: "fleet",
+		urlSuffix: "fleet",
+		serverInfoName: "github-router-fleet"
 	}
 });
 /** True iff `s` is a registered group name (route `:group` param validation). */
@@ -20376,6 +22289,8 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 			return runStandInToolCall(args, signal);
 		}
 	},
+	...ARTIFACT_TOOLS,
+	...FLEET_TOOLS,
 	...BROWSER_TOOLS.map((t) => ({
 		...t,
 		group: "browser",
@@ -20704,5 +22619,5 @@ async function runStandInToolCall(args, signal) {
 }
 
 //#endregion
-export { handleMcpDelete as $, IMPLEMENT_DEFAULT_MODEL as A, setupGitHubToken as At, TOOLBELT_TOOLS$1 as B, getModels as Bt, stopGateEnabledForRepo as C, UPSTREAM_FETCH_TIMEOUT_MS as Ct, liveExec as D, getPackageVersion as Dt, resolveSealedGate as E, pickClaudeDefault as Et, availableToolCommands as F, filterBetaHeader as Ft, buildAdvisorStream as G, copilotBaseUrl as Gt, searchWeb as H, HTTPError as Ht, buildToolbeltAwareness as I, isNullish as It, buildOpenAIErrorEvent as J, state as Jt, injectAdvisorTool as K, copilotHeaders as Kt, toolbeltEnabled as L, resolveCodexModel as Lt, appendPlanReminder as M, cacheCopilotVersion as Mt, runWorkerAgent as N, cacheModels as Nt, BROWSE_DEFAULT_MODEL as O, withInstallLock as Ot, withNoOutputRetry as P, cacheVSCodeVersion as Pt, relayAnthropicStream as Q, toolbeltSkipSet as R, resolveModel as Rt, repoRoot as S, DEFAULT_PORT as St, trustRepo as T, generateRandomPort as Tt, ADVISOR_INTERNAL_TOOL_NAME as U, forwardError as Ut, assetFor as V, fetchWithTransientRetry as Vt, ADVISOR_TOOL_INSTRUCTIONS as W, GITHUB_API_BASE_URL as Wt, logStreamError as X, isControllerClosedError as Y, readIteratorWithTimeout as Z, fileFindingsStore as _, collapsePathKeys as _t, buildPeerAwarenessSnippet as a, createMessages as at, isSubagentContext as b, DEFAULT_CODEX_MODEL as bt, buildStopHookCommand as c, createChatCompletions as ct, fileBlockBudget as d, parseJsonOrDiagnose as dt, handleMcpPost as et, injectStopHookIntoSettingsFile as f, provisionBrowserAssets as ft, fileBaselineStore as g, extractZipMember as gt, stopReviewEnabled as h, extractTarGzMember as ht, buildAgentPrompt as i, countTokens as it, PLAN_DEFAULT_MODEL as j, tryRefreshAndRetry as jt, DEFAULT_MODEL as k, setupCopilotToken as kt, captureLaunchBaseline as l, MAX_RESPONSE_BODY_BYTES as lt, stopGateId as m, provisionAndIndexColbert as mt, MCP_GROUPS as n, standInToolEnabled as nt, personasFor as o, getTokenCount as ot, launchBaselineKey as p, hasSupportedBrowserInstalled as pt, isAdvisorRequested as q, githubHeaders as qt, assertMcpToolSurfaceConsistent as r, workerToolsEnabled as rt, buildSessionBindHookCommand as s, createResponses as st, GROUP_META as t, browserToolsEnabled as tt, decideStopHook as u, readResponseBodyCapped as ut, fileLastPromptStore as v, toolbeltPathOverride as vt, stopReviewStateDir as w, UPSTREAM_INACTIVITY_TIMEOUT_MS as wt, repoFingerprint as x, DEFAULT_CODEX_MODEL_FALLBACKS as xt, fileReviewDebounce as y, DEFAULT_CLAUDE_MODEL_FALLBACKS as yt, vscodeRipgrepPath as z, sleep as zt };
-//# sourceMappingURL=peer-mcp-personas-CoeEliOe.js.map
+export { handleMcpDelete as $, IMPLEMENT_DEFAULT_MODEL as A, setupCopilotToken as At, TOOLBELT_TOOLS$1 as B, sleep as Bt, stopGateEnabledForRepo as C, DEFAULT_PORT as Ct, liveExec as D, pickClaudeDefault as Dt, resolveSealedGate as E, generateRandomPort as Et, availableToolCommands as F, cacheVSCodeVersion as Ft, buildAdvisorStream as G, GITHUB_API_BASE_URL as Gt, searchWeb as H, fetchWithTransientRetry as Ht, buildToolbeltAwareness as I, filterBetaHeader as It, buildOpenAIErrorEvent as J, githubHeaders as Jt, injectAdvisorTool as K, copilotBaseUrl as Kt, toolbeltEnabled as L, isNullish as Lt, appendPlanReminder as M, tryRefreshAndRetry as Mt, runWorkerAgent as N, cacheCopilotVersion as Nt, BROWSE_DEFAULT_MODEL as O, getPackageVersion as Ot, withNoOutputRetry as P, cacheModels as Pt, relayAnthropicStream as Q, toolbeltSkipSet as R, resolveCodexModel as Rt, repoRoot as S, DEFAULT_CODEX_MODEL_FALLBACKS as St, trustRepo as T, UPSTREAM_INACTIVITY_TIMEOUT_MS as Tt, ADVISOR_INTERNAL_TOOL_NAME as U, HTTPError as Ut, assetFor as V, getModels as Vt, ADVISOR_TOOL_INSTRUCTIONS as W, forwardError as Wt, logStreamError as X, isControllerClosedError as Y, state as Yt, readIteratorWithTimeout as Z, fileFindingsStore as _, extractZipMember as _t, buildPeerAwarenessSnippet as a, countTokens as at, isSubagentContext as b, DEFAULT_CLAUDE_MODEL_FALLBACKS as bt, buildStopHookCommand as c, createResponses as ct, fileBlockBudget as d, readResponseBodyCapped as dt, handleMcpPost as et, injectStopHookIntoSettingsFile as f, parseJsonOrDiagnose as ft, fileBaselineStore as g, extractTarGzMember as gt, stopReviewEnabled as h, provisionAndIndexColbert as ht, buildAgentPrompt as i, workerToolsEnabled as it, PLAN_DEFAULT_MODEL as j, setupGitHubToken as jt, DEFAULT_MODEL as k, withInstallLock as kt, captureLaunchBaseline as l, createChatCompletions as lt, stopGateId as m, hasSupportedBrowserInstalled as mt, MCP_GROUPS as n, fleetToolsEnabled as nt, personasFor as o, createMessages as ot, launchBaselineKey as p, provisionBrowserAssets as pt, isAdvisorRequested as q, copilotHeaders as qt, assertMcpToolSurfaceConsistent as r, standInToolEnabled as rt, buildSessionBindHookCommand as s, getTokenCount as st, GROUP_META as t, browserToolsEnabled as tt, decideStopHook as u, MAX_RESPONSE_BODY_BYTES as ut, fileLastPromptStore as v, collapsePathKeys as vt, stopReviewStateDir as w, UPSTREAM_FETCH_TIMEOUT_MS as wt, repoFingerprint as x, DEFAULT_CODEX_MODEL as xt, fileReviewDebounce as y, toolbeltPathOverride as yt, vscodeRipgrepPath as z, resolveModel as zt };
+//# sourceMappingURL=peer-mcp-personas-Be4SAgm0.js.map