github-router 0.3.121 → 0.3.122

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

@@ -40,6 +40,7 @@ const state = {
 	showToken: false,
 	extendedBetas: false,
 	browseEnabled: false,
+	fleetEnabled: false,
 	powerBrowseEnabled: false,
 	humanlikeForce: "auto",
 	sessionId: randomUUID(),
@@ -1045,6 +1046,1273 @@ 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$1(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$1(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/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;
+	token;
+	fetchFn;
+	constructor(options) {
+		this.baseUrl = options.url.replace(/\/+$/, "");
+		this.token = options.token;
+		this.fetchFn = options.fetchFn ?? globalThis.fetch.bind(globalThis);
+	}
+	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);
+		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
+			});
+		} catch (err) {
+			throw mapNetworkError(err);
+		}
+		if (!response.ok) throw await mapHttpError(response);
+		return await response.json();
+	}
+};
+async function mapHttpError(response) {
+	const detail = await readErrorDetail(response);
+	const upstreamMessage = detailToMessage(detail);
+	const suffix = upstreamMessage ? `: ${upstreamMessage}` : "";
+	if (response.status === 401 || response.status === 403) return new FleetError({
+		code: "AUTH_FAILED",
+		message: `fleet instance authentication failed (${response.status})${suffix}`,
+		retryable: false,
+		status: response.status,
+		detail
+	});
+	if (response.status === 404) return new FleetError({
+		code: "SESSION_NOT_FOUND",
+		message: `fleet session or resource not found (404)${suffix}`,
+		retryable: false,
+		status: response.status,
+		detail
+	});
+	if (response.status === 409 || response.status === 412) return new FleetError({
+		code: "PRECONDITION_FAILED",
+		message: `fleet instance precondition failed (${response.status})${suffix}`,
+		retryable: false,
+		status: response.status,
+		detail
+	});
+	if (response.status === 408 || response.status === 504) return new FleetError({
+		code: "TIMEOUT",
+		message: `fleet instance request timed out (${response.status})${suffix}`,
+		retryable: true,
+		status: response.status,
+		detail
+	});
+	return new FleetError({
+		code: "UPSTREAM_ERROR",
+		message: `fleet instance returned HTTP ${response.status}${suffix}`,
+		retryable: response.status === 429 || response.status >= 500,
+		status: response.status,
+		detail
+	});
+}
+function mapNetworkError(err) {
+	if (isAbortLike(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)}`,
+		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(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 tokens. 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);
+	if (typeof token !== "string" || token === "") throw new FleetRegistryError("INVALID_CONFIG", `fleet registry instance ${id} token must be a non-empty string`);
+	return {
+		id: id.trim(),
+		label: label.trim(),
+		url: trimmedUrl,
+		token,
+		default: instance.default === true ? true : void 0,
+		allowExec: instance.allowExec === true ? true : void 0
+	};
+}
+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]";
+}
+function resolvedInstance(instance) {
+	return {
+		id: instance.id,
+		label: instance.label,
+		url: instance.url,
+		token: instance.token,
+		allowExec: instance.allowExec
+	};
+}
+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;
+var FleetToolInputError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "FleetToolInputError";
+		this.code = code;
+	}
+};
+let defaultRegistry;
+const awaitTurnCursors = /* @__PURE__ */ new Map();
+const instanceProbeCache = /* @__PURE__ */ new Map();
+function createFleetTools(options = {}) {
+	const registry = options.registry;
+	const clients = /* @__PURE__ */ new Map();
+	function getRegistry() {
+		if (registry) return registry;
+		defaultRegistry ??= new FleetRegistry();
+		return defaultRegistry;
+	}
+	function clientFor(instance) {
+		const key = `${instance.id}\0${instance.url}\0${instance.token}`;
+		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
+		});
+		clients.set(key, created);
+		return created;
+	}
+	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;
+		const timeout = createProbeTimeout();
+		try {
+			const response = await clientFor(await resolve(info.id)).listSessions(timeout.signal);
+			const lastSeen = Date.now();
+			const result = {
+				id: info.id,
+				label: info.label,
+				reachable: true,
+				sessionCount: response.sessions.length,
+				lastSeen
+			};
+			instanceProbeCache.set(cacheKey, {
+				result,
+				at: lastSeen
+			});
+			return result;
+		} catch (err) {
+			const result = {
+				id: info.id,
+				label: info.label,
+				reachable: false,
+				error: fleetProbeErrorCode(err)
+			};
+			instanceProbeCache.set(cacheKey, {
+				result,
+				at: Date.now()
+			});
+			return result;
+		} finally {
+			timeout.cleanup();
+		}
+	}
+	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 () => {
+			const instances = await getRegistry().listInstances();
+			return ok({ instances: await Promise.all(instances.map((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. Returns isError if delivery failed or an awaited confirmation did not arrive.", 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."),
+			awaitMs: numberProp("Optional confirmation wait time in milliseconds.")
+		}, [
+			"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;
+			const confirmed = response.confirmed !== false;
+			const isError = !delivered || awaitMs !== void 0 && awaitMs > 0 && !confirmed;
+			return jsonResult({
+				resolvedInstance: publicInstance(instance),
+				sessionId: globalId,
+				...response,
+				...isError ? { message: !delivered ? "message was not delivered by the upstream instance" : `message delivery was not confirmed within awaitMs=${awaitMs}` } : {}
+			}, 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.")
+		}, [
+			"instance",
+			"agent",
+			"idempotencyKey"
+		]), async (args, signal) => {
+			const instance = await resolve(requiredString(args, "instance"));
+			const idempotencyKey = requiredString(args, "idempotencyKey");
+			const response = await clientFor(instance).createSession(definedObject({
+				agent: requiredString(args, "agent"),
+				name: optionalString(args, "name"),
+				workingDir: optionalString(args, "workingDir"),
+				start: optionalBoolean(args, "start"),
+				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 cursors, so callers do not pass cursor tokens.", 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.")
+		}, []), async (args, signal) => {
+			const target = await resolveAwaitTarget(args, getRegistry());
+			const clientKey = target.instances.map((instance) => instance.id).sort().join(",");
+			const cursorByInstance = awaitTurnCursors.get(clientKey) ?? /* @__PURE__ */ new Map();
+			awaitTurnCursors.set(clientKey, cursorByInstance);
+			const timeoutMs = optionalNumber(args, "timeoutMs");
+			const kinds = optionalStringArray(args, "kinds");
+			const responses = await Promise.all(target.instances.map(async (instance) => {
+				const response = await clientFor(instance).waitEvents(definedObject({
+					cursor: cursorByInstance.get(instance.id),
+					timeoutMs,
+					sessionIds: target.localSessionIdsByInstance.get(instance.id),
+					kinds
+				}), signal);
+				cursorByInstance.set(instance.id, response.cursor);
+				return {
+					instance,
+					response
+				};
+			}));
+			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),
+					...parseCursor(response.cursor)
+				})),
+				more: responses.some(({ response }) => response.more)
+			});
+		}),
+		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 fleetProbeErrorCode(err) {
+	if (typeof err === "object" && err !== null && "code" in err) {
+		const code = err.code;
+		if (typeof code === "string" && isFleetErrorCode(code)) return code;
+	}
+	return "UNREACHABLE";
+}
+function isFleetErrorCode(code) {
+	switch (code) {
+		case "UNREACHABLE":
+		case "AUTH_FAILED":
+		case "SESSION_NOT_FOUND":
+		case "PRECONDITION_FAILED":
+		case "TIMEOUT":
+		case "UPSTREAM_ERROR": 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 compareStampedEvents(a, b) {
+	const atA = typeof a.at === "string" ? a.at : "";
+	const atB = typeof b.at === "string" ? b.at : "";
+	if (atA !== atB) return atA < atB ? -1 : 1;
+	return (typeof a.seq === "number" ? a.seq : 0) - (typeof b.seq === "number" ? b.seq : 0);
+}
+function parseCursor(cursor) {
+	const idx = cursor.indexOf(":");
+	if (idx < 0) return { cursor };
+	const seq = Number(cursor.slice(idx + 1));
+	return {
+		cursor,
+		epoch: cursor.slice(0, idx),
+		...Number.isFinite(seq) ? { seq } : {}
+	};
+}
+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
+	};
+}
+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 +6314,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 +6331,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 +6351,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 +7432,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 +7538,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 +7552,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 +7586,7 @@ async function bridgeCall(endpoint, tool, args, timeoutMs, signal) {
 			}
 			ws.send(JSON.stringify({
 				id,
-				tool,
+				tool: tool$1,
 				args
 			}));
 		});
@@ -6377,8 +7645,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 +7657,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 +7685,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 +7695,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 +7712,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 +8673,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 +8700,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 +8721,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 +8734,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 +8796,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 +9911,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 +10804,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 +11118,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 +11128,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 +11162,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
 		return {
 			kind: "prepared",
 			toolCall,
-			tool,
+			tool: tool$1,
 			args: validatedArgs
 		};
 	} catch (error) {
@@ -12192,7 +13460,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 +13485,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 +13967,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 +13983,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 +14269,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 +14486,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 +14814,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 +17491,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 +17526,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 +20527,8 @@ const MCP_GROUPS = Object.freeze([
 	"workers",
 	"orchestrate",
 	"browser",
-	"decide"
+	"decide",
+	"fleet"
 ]);
 const GROUP_META = Object.freeze({
 	peers: {
@@ -19265,6 +20560,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 +21676,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 +22006,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-B6z15bmc.js.map