github-router 0.3.151 → 0.3.153

package/dist/{peer-mcp-personas-Dm3UCpXz.js → peer-mcp-personas-DMM1akDa.js}

@@ -1,6 +1,6 @@
-import { t as PATHS } from "./paths-D0tJ_tms.js";
-import { d as runCommandCapture, l as parseBoolEnv, n as isPidAlive, o as trackChild, p as runManagedExeCapture, r as registerColbertExitHandlers, t as getColbertInstanceUuid, u as resolveExecutable } from "./lifecycle-DyEXZu2z.js";
-import { i as registerExitHandlers, n as getInstanceUuid, r as recordWorkerRepo, t as WorktreeRegistry } from "./lifecycle-DGvk4z63.js";
+import { t as PATHS } from "./paths-Bt7sqiVr.js";
+import { d as runCommandCapture, l as parseBoolEnv, n as isPidAlive, o as trackChild, p as runManagedExeCapture, r as registerColbertExitHandlers, t as getColbertInstanceUuid, u as resolveExecutable } from "./lifecycle-VTQI28wT.js";
+import { i as registerExitHandlers, n as getInstanceUuid, r as recordWorkerRepo, t as WorktreeRegistry } from "./lifecycle-C4k0pEvn.js";
 import { createRequire } from "node:module";
 import consola from "consola";
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
@@ -1176,35 +1176,172 @@ var ArtifactError = class extends Error {
 		this.detail = args.detail;
 	}
 };
+const AWAIT_DEFAULT_TIMEOUT_MS = 25e3;
+const AWAIT_ABORT_MARGIN_MS = 5e3;
+const DEFAULT_RETRY_BASE_MS = 250;
+const TRANSIENT_RETRIES = 2;
+const DEFAULT_RETRYABLE_CODES = new Set(["UNREACHABLE", "TIMEOUT"]);
+const AWAIT_RETRYABLE_CODES = new Set(["UNREACHABLE"]);
 var ArtifactClient = class {
 	baseUrl;
 	token;
 	sessionId;
 	fetchFn;
 	insecureTLS;
+	retryBaseMs;
 	constructor(options) {
 		this.baseUrl = options.baseUrl.replace(/\/+$/, "");
 		this.token = options.token;
 		this.sessionId = options.sessionId;
 		this.fetchFn = options.fetchFn ?? globalThis.fetch.bind(globalThis);
 		this.insecureTLS = options.insecureTLS ?? false;
+		this.retryBaseMs = options.retryBaseMs ?? DEFAULT_RETRY_BASE_MS;
 	}
-	open(file, signal) {
-		return this.request("POST", `/api/artifact/${encodeURIComponent(this.sessionId)}/open`, { file }, signal);
+	/**
+	* Open (or replace) the review for this session. `mode` is advisory metadata
+	* forwarded to the server (forward-compat: ignored if unknown); the actual
+	* interactivity comes from the served HTML's `data-aod-*` markup. Retried on a
+	* transient failure with a STABLE idempotency key so a retry-after-success does
+	* not double-open.
+	*/
+	open(file, opts = {}) {
+		const idempotencyKey = opts.idempotencyKey ?? randomUUID();
+		const body = { file };
+		if (opts.mode) body.mode = opts.mode;
+		return this.withRetry(() => this.requestOnce({
+			method: "POST",
+			pathname: this.path("/open"),
+			body,
+			signal: opts.signal,
+			idempotencyKey
+		}), TRANSIENT_RETRIES, opts.signal);
 	}
-	poll(timeoutMsHint, signal) {
-		return this.request("GET", `/api/artifact/${encodeURIComponent(this.sessionId)}/poll`, void 0, signal, timeoutMsHint);
+	/**
+	* Replace the current review's content. Exactly one of `file` | `html` (the
+	* caller-facing tool enforces that). `html` is written by the SERVER to the
+	* review's existing sandboxed file, so `html` with no existing review is an
+	* INVALID_REQUEST from the server. Retried with a stable idempotency key.
+	*/
+	update(opts) {
+		const idempotencyKey = opts.idempotencyKey ?? randomUUID();
+		const body = {};
+		if (opts.file !== void 0) body.file = opts.file;
+		if (opts.html !== void 0) body.html = opts.html;
+		return this.withRetry(() => this.requestOnce({
+			method: "POST",
+			pathname: this.path("/update"),
+			body,
+			signal: opts.signal,
+			idempotencyKey,
+			allowEmptyJson: true
+		}), TRANSIENT_RETRIES, opts.signal);
 	}
+	/** Force a reload from disk (no content change). Single-shot (idempotent, cheap). */
+	refresh(signal) {
+		return this.requestOnce({
+			method: "POST",
+			pathname: this.path("/refresh"),
+			signal,
+			allowEmptyJson: true
+		});
+	}
+	/** Hide the panel UI while keeping the review alive. Single-shot; server idempotent. */
+	dismiss(signal) {
+		return this.requestOnce({
+			method: "POST",
+			pathname: this.path("/dismiss"),
+			signal,
+			allowEmptyJson: true
+		});
+	}
+	/**
+	* Typed drain (contract v2.2 §1/§2). Long-holds up to the server cap, returns
+	* events with `id > cursor` plus the new high-water `cursor`. Idempotent by
+	* (cursor, event.id): re-calling with the same cursor replays the same window
+	* from the server's bounded buffer, so a lost cursor (compaction) is
+	* recoverable. Retried on a transient network failure (the cursor makes retry
+	* safe — no double-consumption).
+	*/
+	awaitEvents(opts = {}) {
+		const serverTimeoutMs = typeof opts.timeoutMs === "number" && Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0 ? opts.timeoutMs : AWAIT_DEFAULT_TIMEOUT_MS;
+		const clientTimeoutMs = serverTimeoutMs + AWAIT_ABORT_MARGIN_MS;
+		return this.withRetry(() => this.requestOnce({
+			method: "GET",
+			pathname: this.path("/await"),
+			query: {
+				cursor: opts.cursor,
+				timeoutMs: String(serverTimeoutMs)
+			},
+			signal: opts.signal,
+			timeoutMsHint: clientTimeoutMs
+		}), TRANSIENT_RETRIES, opts.signal, AWAIT_RETRYABLE_CODES);
+	}
+	/** Free-text agent->human reply. SINGLE-SHOT (not retried): a retry-after-success
+	*  would render a duplicate chat bubble server-side. */
 	agentReply(text, signal) {
-		return this.request("POST", `/api/artifact/${encodeURIComponent(this.sessionId)}/agent-reply`, { text }, signal, void 0, true);
+		return this.requestOnce({
+			method: "POST",
+			pathname: this.path("/agent-reply"),
+			body: { text },
+			signal,
+			allowEmptyJson: true
+		});
 	}
-	end(signal) {
-		return this.request("POST", `/api/artifact/${encodeURIComponent(this.sessionId)}/end`, void 0, signal, void 0, true);
+	/**
+	* End the review. Retried with a stable idempotency key; a NOT_FOUND (the
+	* review is already ended — whether by a prior call or by a retry landing after
+	* the first attempt succeeded) is mapped to a successful `{ ok, status:"ended" }`
+	* rather than surfaced as a 404 (contract v2.2 §1.1).
+	*/
+	async end(signal) {
+		const idempotencyKey = randomUUID();
+		try {
+			return await this.withRetry(() => this.requestOnce({
+				method: "POST",
+				pathname: this.path("/end"),
+				signal,
+				idempotencyKey,
+				allowEmptyJson: true
+			}), TRANSIENT_RETRIES, signal);
+		} catch (err) {
+			if (err instanceof ArtifactError && err.code === "NOT_FOUND") return {
+				ok: true,
+				status: "ended"
+			};
+			throw err;
+		}
 	}
-	async request(method, pathname, body, signal, timeoutMsHint, allowEmptyJson = false) {
+	/**
+	* FROZEN legacy long-poll (contract v2.2 §1). Old payload shape,
+	* comment-equivalent only. New agents use `awaitEvents`. Single request per
+	* call (the caller-facing tool owns the bounded re-poll budget).
+	*/
+	poll(timeoutMsHint, signal) {
+		return this.requestOnce({
+			method: "GET",
+			pathname: this.path("/poll"),
+			signal,
+			timeoutMsHint
+		});
+	}
+	path(suffix) {
+		return `/api/artifact/${encodeURIComponent(this.sessionId)}${suffix}`;
+	}
+	async withRetry(fn, retries, signal, retryableCodes = DEFAULT_RETRYABLE_CODES) {
+		let attempt = 0;
+		for (;;) try {
+			return await fn();
+		} catch (err) {
+			attempt += 1;
+			if (!(err instanceof ArtifactError && err.retryable && retryableCodes.has(err.code)) || attempt > retries || signal?.aborted) throw err;
+			const base = this.retryBaseMs;
+			await sleep$1(base <= 0 ? 0 : Math.round(base * 2 ** (attempt - 1) * (.5 + Math.random() * .5)), signal);
+		}
+	}
+	async requestOnce(o) {
 		let url;
 		try {
-			url = new URL(pathname, `${this.baseUrl}/`);
+			url = new URL(o.pathname, `${this.baseUrl}/`);
 		} catch (err) {
 			throw new ArtifactError({
 				code: "UNREACHABLE",
@@ -1213,48 +1350,73 @@ var ArtifactClient = class {
 				detail: err
 			});
 		}
-		const timeout = combineSignalAndTimeout(signal, timeoutMsHint);
-		let response;
+		if (o.query) {
+			for (const [key, value] of Object.entries(o.query)) if (value !== void 0) url.searchParams.set(key, value);
+		}
+		const timeout = combineSignalAndTimeout(o.signal, o.timeoutMsHint);
 		try {
+			const headers = { Authorization: `Bearer ${this.token}` };
+			if (o.body !== void 0) headers["Content-Type"] = "application/json";
+			if (o.idempotencyKey) headers["Idempotency-Key"] = o.idempotencyKey;
 			const init = {
-				method,
-				headers: {
-					Authorization: `Bearer ${this.token}`,
-					...body === void 0 ? {} : { "Content-Type": "application/json" }
-				},
-				body: body === void 0 ? void 0 : JSON.stringify(body),
+				method: o.method,
+				headers,
+				body: o.body === void 0 ? void 0 : JSON.stringify(o.body),
 				redirect: "error",
 				signal: timeout.signal
 			};
 			if (this.insecureTLS) applyInsecureTls(init);
-			response = await this.fetchFn(url.toString(), init);
+			const response = await this.fetchFn(url.toString(), init);
+			if (!response.ok) throw await mapHttpError$1(response);
+			let text;
+			try {
+				text = await response.text();
+			} catch (err) {
+				if (isAbortLike$2(err)) throw mapNetworkError$1(err);
+				throw new ArtifactError({
+					code: "INVALID_RESPONSE",
+					message: "artifact API response body could not be read",
+					retryable: false,
+					detail: err
+				});
+			}
+			if (!text && o.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
+				});
+			}
 		} catch (err) {
+			if (err instanceof ArtifactError) throw 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 sleep$1(ms, signal) {
+	if (ms <= 0) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(new DOMException("retry backoff aborted", "AbortError"));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		if (signal?.aborted) {
+			onAbort();
+			return;
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
 function combineSignalAndTimeout(signal, timeoutMsHint) {
 	const timeoutMs = typeof timeoutMsHint === "number" && Number.isFinite(timeoutMsHint) && timeoutMsHint > 0 ? timeoutMsHint : void 0;
 	if (timeoutMs === void 0) return {
@@ -1311,6 +1473,13 @@ async function mapHttpError$1(response) {
 		status: response.status,
 		detail
 	});
+	if (response.status === 400 && detailToCode(detail)?.toUpperCase() === "INVALID_REQUEST") return new ArtifactError({
+		code: "INVALID_REQUEST",
+		message: `artifact API rejected the request (400)${suffix}`,
+		retryable: false,
+		status: response.status,
+		detail
+	});
 	return new ArtifactError({
 		code: "UPSTREAM_ERROR",
 		message: `artifact API returned HTTP ${response.status}${suffix}`,
@@ -1355,6 +1524,18 @@ function detailToMessage$1(detail) {
 	}
 	if (typeof record.message === "string") return record.message;
 }
+/** Extract a machine `code` from an upstream error body (`{error:{code}}` or
+*  `{code}`) so a tagged 400 can be classified (INVALID_REQUEST). */
+function detailToCode(detail) {
+	if (typeof detail !== "object" || detail === null) return void 0;
+	const record = detail;
+	const error = record.error;
+	if (typeof error === "object" && error !== null) {
+		const code = error.code;
+		if (typeof code === "string") return code;
+	}
+	if (typeof record.code === "string") return record.code;
+}
 function isAbortLike$2(err) {
 	return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
 }
@@ -1383,27 +1564,86 @@ function tool(toolNameHttp, description, inputSchema, handler) {
 	};
 }
 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$2({ file: stringProp$2("Workspace-relative or absolute file path to show in the Artifact panel.") }, ["file"]), async (args, signal) => {
+	tool("artifact_open", "Open a workspace file in ai-or-die's Artifact review panel for human review. Pass mode:\"interactive\" when the HTML carries data-aod-* action controls. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({
+		file: stringProp$2("Workspace-relative or absolute file path to show in the Artifact panel."),
+		mode: enumProp(["static", "interactive"], "Advisory. \"interactive\" signals the HTML contains data-aod-* action controls the panel should wire; \"static\" (default) is a read-and-annotate artifact.")
+	}, ["file"]), async (args, signal) => {
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
 		const file = requiredString$2(args, "file");
+		const mode = optionalEnum(args, "mode", ["static", "interactive"]);
+		const response = await clientFromEnv(env).open(file, {
+			mode,
+			signal
+		});
 		return ok$2({
-			viewUrl: (await clientFromEnv(env).open(file, signal)).viewUrl,
-			next_step: "Tell the user to review at the Artifact panel, then call artifact_poll."
+			viewUrl: response.viewUrl,
+			sessionId: response.sessionId,
+			key: response.key,
+			next_step: "Tell the user to review at the Artifact panel, then call artifact_await to receive their feedback."
 		});
 	}),
-	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$2({}, []), async (_args, signal) => {
+	tool("artifact_update", "Replace the current Artifact review's content in place. Provide EXACTLY ONE of file (a workspace file path) or html (raw HTML the server writes to the review's sandboxed file). html requires an already-open review. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({
+		file: stringProp$2("Workspace-relative or absolute file path to become the review's new content."),
+		html: stringProp$2("Raw HTML to write into the review's existing sandboxed file, then reload."),
+		idempotencyKey: stringProp$2("Optional stable key so a retried update is de-duplicated by the server.")
+	}, []), async (args, signal) => {
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
-		return ok$2(formatPollResponse(await pollUntilReady(clientFromEnv(env), signal)));
+		const file = optionalString$2(args, "file");
+		const html = optionalString$2(args, "html");
+		if (file === void 0 === (html === void 0)) throw new ArtifactToolInputError("INVALID_ARGUMENT", "artifact_update requires EXACTLY ONE of arguments.file or arguments.html");
+		const idempotencyKey = optionalString$2(args, "idempotencyKey");
+		return ok$2({
+			...await clientFromEnv(env).update({
+				file,
+				html,
+				idempotencyKey,
+				signal
+			}),
+			ok: true,
+			next_step: "The panel now shows the updated content. Call artifact_await for further feedback."
+		});
+	}),
+	tool("artifact_refresh", "Force the ai-or-die Artifact panel to reload the current artifact from disk (no content change). Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({}, []), async (_args, signal) => {
+		const env = readArtifactEnv();
+		if (!env) return missingEnvResult();
+		return ok$2({
+			...await clientFromEnv(env).refresh(signal),
+			ok: true,
+			next_step: "The panel reloaded the artifact. Call artifact_await for feedback."
+		});
+	}),
+	tool("artifact_await", "Wait for the human's next Artifact review events (typed drain: comments AND structured action-button/checkbox events) and return them with a cursor. Pass the returned cursor on the next call to receive only newer events. Supersedes artifact_poll. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({
+		cursor: stringProp$2("High-water cursor from the previous artifact_await response. Omit on the first call."),
+		timeoutMs: numberProp$2("Optional server long-hold budget in ms (default ~25000).")
+	}, []), async (args, signal) => {
+		const env = readArtifactEnv();
+		if (!env) return missingEnvResult();
+		const cursor = optionalString$2(args, "cursor");
+		const timeoutMs = optionalNumber$2(args, "timeoutMs");
+		return ok$2(formatAwaitResponse(await clientFromEnv(env).awaitEvents({
+			cursor,
+			timeoutMs,
+			signal
+		})));
+	}),
+	tool("artifact_dismiss", "Hide the ai-or-die Artifact panel UI while keeping the review alive (queued feedback preserved, channel open, re-openable). Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({}, []), async (_args, signal) => {
+		const env = readArtifactEnv();
+		if (!env) return missingEnvResult();
+		return ok$2({
+			...await clientFromEnv(env).dismiss(signal),
+			ok: true,
+			next_step: "The panel is hidden but the review is still live. Re-open the artifact or call artifact_await when ready."
+		});
 	}),
 	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$2({ text: stringProp$2("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$2(args, "text");
 		return ok$2({
-			ok: true,
 			...await clientFromEnv(env).agentReply(text, signal),
+			ok: true,
 			next_step: "Wait for further human review, or continue if the review loop is complete."
 		});
 	}),
@@ -1411,10 +1651,15 @@ const ARTIFACT_TOOLS = Object.freeze([
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
 		return ok$2({
-			ok: true,
 			...await clientFromEnv(env).end(signal),
+			ok: true,
 			next_step: "Artifact review loop ended."
 		});
+	}),
+	tool("artifact_poll", "FROZEN legacy alias for artifact_await (old payload, human comments only, no structured actions). New agents should call artifact_await instead. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({ timeoutMs: numberProp$2("Optional per-call budget hint in ms (advisory).") }, []), async (_args, signal) => {
+		const env = readArtifactEnv();
+		if (!env) return missingEnvResult();
+		return ok$2(formatPollResponse(await pollUntilReady(clientFromEnv(env), signal)));
 	})
 ]);
 function readArtifactEnv() {
@@ -1489,6 +1734,30 @@ function formatPollResponse(response) {
 		next_step: response.next_step ?? defaultPollNextStep(response.status)
 	});
 }
+/**
+* Shape the typed drain for the model: pass events through verbatim (unknown
+* `kind`s preserved — the model ignores what it does not understand), echo the
+* cursor to thread into the next call, and pick a next_step from the events.
+*/
+function formatAwaitResponse(response) {
+	const events$1 = Array.isArray(response.events) ? response.events : [];
+	const status = typeof response.status === "string" ? response.status : void 0;
+	return definedObject$1({
+		events: events$1,
+		status,
+		cursor: response.cursor,
+		next_step: awaitNextStep(status ?? "", events$1)
+	});
+}
+function awaitNextStep(status, events$1) {
+	if ((status ?? "").toLowerCase() === "ended") return "The review has ended. No further feedback will arrive.";
+	if (events$1.length === 0) return "No feedback yet. Call artifact_await again, passing the returned cursor.";
+	const hasAction = events$1.some((e) => e.kind === "action");
+	const hasComment = events$1.some((e) => e.kind === "comment");
+	if (hasAction && hasComment) return "Act on the action events (buttons/checkboxes) and the comments, reply with artifact_reply, then call artifact_await with the returned cursor.";
+	if (hasAction) return "The human triggered action controls. Act on them, optionally artifact_reply, then call artifact_await with the returned cursor.";
+	return "Apply the human comments, call artifact_reply with a concise summary, then artifact_await with the returned cursor.";
+}
 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.";
 }
@@ -1501,6 +1770,24 @@ function requiredString$2(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;
 }
+function optionalString$2(args, key) {
+	const value = args[key];
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value !== "string" || value.trim() === "") throw new ArtifactToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a non-empty string when provided`);
+	return value;
+}
+function optionalNumber$2(args, key) {
+	const value = args[key];
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) throw new ArtifactToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a positive number when provided`);
+	return value;
+}
+function optionalEnum(args, key, allowed) {
+	const value = optionalString$2(args, key);
+	if (value === void 0) return void 0;
+	if (!allowed.includes(value)) throw new ArtifactToolInputError("INVALID_ARGUMENT", `arguments.${key} must be one of ${allowed.join(", ")}`);
+	return value;
+}
 var ArtifactToolInputError = class extends Error {
 	code;
 	constructor(code, message) {
@@ -1565,6 +1852,19 @@ function stringProp$2(description) {
 		description
 	};
 }
+function numberProp$2(description) {
+	return {
+		type: "number",
+		description
+	};
+}
+function enumProp(values, description) {
+	return {
+		type: "string",
+		enum: [...values],
+		description
+	};
+}
 
 //#endregion
 //#region src/lib/fleet/mesh-egress-agent.ts
@@ -2769,7 +3069,7 @@ function isHardNotReady(reason) {
 */
 async function waitForMessageReady(client, localId, options = {}) {
 	const now = options.now ?? Date.now;
-	const sleep$1 = options.sleep ?? realSleep;
+	const sleep$2 = options.sleep ?? realSleep;
 	const waitMs = Math.max(0, options.waitMs ?? 0);
 	const pollMs = Math.max(1, options.pollMs ?? DEFAULT_READY_POLL_MS);
 	const deadline = now() + waitMs;
@@ -2801,7 +3101,7 @@ async function waitForMessageReady(client, localId, options = {}) {
 			ready: false,
 			readiness: last
 		};
-		await sleep$1(Math.min(pollMs, remaining));
+		await sleep$2(Math.min(pollMs, remaining));
 	}
 }
 /**
@@ -2879,7 +3179,7 @@ async function primeTurnCursor(client, localId, timeoutMs, signal) {
 */
 async function waitForTurnSettled(client, localId, options) {
 	const now = options.now ?? Date.now;
-	const sleep$1 = options.sleep ?? realSleep;
+	const sleep$2 = options.sleep ?? realSleep;
 	const pollTimeoutMs = Math.max(1, options.pollTimeoutMs ?? DEFAULT_TURN_POLL_MS);
 	const budget = Number.isFinite(options.timeoutMs) ? Math.max(0, options.timeoutMs) : 0;
 	const deadline = now() + budget;
@@ -2911,7 +3211,7 @@ async function waitForTurnSettled(client, localId, options) {
 				reason: "timeout",
 				cursor
 			};
-			await sleep$1(Math.min(TURN_POLL_ERROR_BACKOFF_MS, Math.max(0, deadline - now())));
+			await sleep$2(Math.min(TURN_POLL_ERROR_BACKOFF_MS, Math.max(0, deadline - now())));
 			continue;
 		}
 		cursor = response.cursor;
@@ -3028,13 +3328,13 @@ async function readTail(client, localId, lines, signal) {
 async function driveTask(deps) {
 	const { client, localId, prompt, timeoutMs, expectReport, idempotencyKey, interruptKey, reportId, signal } = deps;
 	const now = deps.now ?? Date.now;
-	const sleep$1 = deps.sleep ?? realSleep;
+	const sleep$2 = deps.sleep ?? realSleep;
 	const tailLines = deps.tailLines ?? DEFAULT_TAIL_LINES;
 	const pollTimeoutMs = deps.pollTimeoutMs;
 	const readyResult = await waitForMessageReady(client, localId, {
 		waitMs: deps.idleWaitMs ?? DEFAULT_IDLE_WAIT_MS,
 		now,
-		sleep: sleep$1,
+		sleep: sleep$2,
 		signal
 	});
 	if (!readyResult.ready && isHardNotReady(readyResult.readiness.reason)) return {
@@ -3077,7 +3377,7 @@ async function driveTask(deps) {
 		pollTimeoutMs,
 		cursor,
 		now,
-		sleep: sleep$1,
+		sleep: sleep$2,
 		signal
 	});
 	cursor = settle.cursor;
@@ -3099,7 +3399,7 @@ async function driveTask(deps) {
 			pollTimeoutMs,
 			cursor,
 			now,
-			sleep: sleep$1,
+			sleep: sleep$2,
 			signal
 		});
 		recovered = recovery.settled;
@@ -12558,7 +12858,7 @@ function logAudit$1(record) {
 		try {
 			const fs$2 = await import("node:fs/promises");
 			const path$1 = await import("node:path");
-			const { PATHS: PATHS$1 } = await import("./paths-DhLJ9bLG.js");
+			const { PATHS: PATHS$1 } = await import("./paths-C9Nkr_NK.js");
 			const dir = path$1.join(PATHS$1.APP_DIR, "browser-mcp");
 			await fs$2.mkdir(dir, { recursive: true });
 			const line = JSON.stringify({
@@ -25782,17 +26082,28 @@ function buildAgentPrompt(persona, opts) {
 * anchors disguised as description ("cheapest first move", "saves them
 * the discovery step", "waste wall-clock"). Pure capability inventory.
 *
+* Wording budget (minimal sufficient guidance, NOT sentence-count parity):
+* each tool/group gets only the wording needed for correct, safe, high-value
+* use; extra wording must earn its attention cost. "Importance" shows up via
+* cost-of-misuse / ambiguity / invocation complexity, not proportional length
+* (a critical-but-simple tool can be one clause). When editing this snippet or
+* any injected guidance, re-check the whole surface for balance rather than
+* only expanding whatever was last touched.
+*
 * Surface contract (regression-pinned in tests/peer-mcp-personas.test.ts):
 *   - Always lists codex_critic, codex_reviewer, opus_critic, advisor,
 *     peer-review-coordinator, and the subagent-inheritance fact (the
 *     load-bearing UX claim: spawned subagents inherit the peer-MCP
 *     toolset via the mirrored `.claude.json`).
 *   - Conditionally lists gemini_critic only when `geminiAvailable`.
-*   - Conditionally lists worker_explore / worker_implement /
-*     "Workers themselves have code_search" only when
-*     `workerToolsAvailable` (mirrors `workerToolsEnabled()` in
-*     src/routes/mcp/handler.ts so the snippet never names a tool gated
-*     out of the live catalog).
+*   - Conditionally lists the `worker-*` background dispatcher subagents
+*     (worker-explore / worker-review / worker-plan / worker-implement /
+*     worker-test), the non-blocking-guard fact, and "Workers themselves
+*     have code_search" only when `workerToolsAvailable` (mirrors
+*     `workerToolsEnabled()` so the snippet never names a surface gated out
+*     of the live catalog). The raw `mcp__<workers>__*` tools are named only
+*     as the guarded plumbing the dispatchers call, never as a main-agent
+*     interface.
 *   - Conditionally lists stand_in only when `standInAvailable`
 *     (mirrors `standInToolEnabled()`).
 *   - Conditionally lists gh-first-mate only when `agentToolsAvailable`
@@ -25820,7 +26131,7 @@ function buildPeerAwarenessSnippet(opts) {
 	criticList.push("`opus_critic` (Opus 4.7)");
 	const codexCliClause = opts.codexCli ? " `mcp__codex-cli__codex` dispatches to `codex-implementer` (gpt-5.3-codex with workspace-write) for end-to-end coding tasks." : "";
 	const para2Parts = [`\`mcp__${searchKey}__code\` is the one-stop code search (no extra model call). Its DEFAULT mode (or \`mode:"semantic"\`) ranks by MEANING via ColBERT over a per-workspace index, the first thing to reach for on intent/concept questions ("where is retry/backoff handled", "how does auth work"); when that index isn't ready it transparently falls back to lexical (the response \`source\` says which engine ran). Forced modes cover the rest: \`lexical\` (BM25F-ranked + tree-sitter, best for exact symbols), \`exact\`, \`regex\`, \`complete\` (exhaustive set), \`ast_pattern\`+\`ast_lang\` for multi-line AST shapes, \`scan\` for a whole-workspace symbol outline, \`multiline\` for cross-line regex. Multiple queries can run in a single turn. The index covers code-shaped files; for unstructured files (logs, \`.csv\`, \`.env*\`, config-only wiring), \`grep\`/\`glob\` still apply.`];
-	if (opts.workerToolsAvailable) para2Parts.push(`\`mcp__${workersKey}__explore\` runs a Gemini-backed read-only worker that returns a summary, using its own context rather than yours; concurrent launches share the \`MAX_INFLIGHT_TOOLS_CALL\` cap (default 128) with operator traffic.`, `\`mcp__${workersKey}__review\` is the same worker framed as a code reviewer that reads the code itself to verify a change or claim, reporting findings with severity, so it checks context the \`peers\` critics (stateless calls on the pasted artifact) cannot.`, `\`mcp__${workersKey}__plan\` is the same read-only worker framed as a planner: from a task + acceptance criteria it returns an ordered implementation plan.`, `\`mcp__${workersKey}__implement\` is the same worker with edit/write/bash; \`worktree: true\` runs it in an isolated git worktree and returns the diff.`, `\`mcp__${workersKey}__test\` is a write-capable worker framed as an independent test author: it authors tests that try to break the implementation and reports pass/fail, never editing the implementation to make them pass.`, "Workers themselves have `code_search` in their toolset.");
+	if (opts.workerToolsAvailable) para2Parts.push(`\`worker-*\` are background Agent subagents (subagent_type) that run the matching worker in its own context and deliver the result as a completion notification, so a long run never blocks the turn: \`worker-explore\` (read-only research), \`worker-review\` (reads the code to verify a change or claim), \`worker-plan\` (ordered implementation plan), \`worker-implement\` (edit/write/bash; \`worktree: true\` isolates in a git worktree and returns the diff), \`worker-test\` (independent test author). The raw \`mcp__${workersKey}__*\` tools they call are guarded (a direct main-thread call is redirected to the matching agent); Workers themselves have \`code_search\`.`);
 	if (opts.workerToolsAvailable) para2Parts.push(`\`mcp__${orchestrateKey}__decompose\` composes an open-ended ask into a typed, VERIFIED workflow IR (a strong driver decorrelated by a cross-lab critic, so the decompose step isn't a single point of failure), and \`mcp__${orchestrateKey}__run_workflow\` executes that IR through a frozen kernel delivering max(orchestrated, baseline) over a sealed executable gate, so it never ships worse than a plain single-model run. \`mcp__${orchestrateKey}__verify_workflow\` checks an IR's floor invariants before you run it, and \`mcp__${orchestrateKey}__attest_step\` audits that a finished run's producers were each checked by a different lab. They suit non-trivial, role-separated asks; a trivial ask does not need them.`);
 	else para2Parts.push(`\`mcp__${orchestrateKey}__verify_workflow\` statically checks a workflow IR's floor invariants and \`mcp__${orchestrateKey}__attest_step\` audits a run's cross-lab lineage (the \`decompose\`/\`run_workflow\` composer + kernel need the worker backend, unavailable here).`);
 	if (opts.workerToolsAvailable) {
@@ -26058,7 +26369,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "explore",
 		group: "workers",
 		capability: "worker",
-		description: "Read-only investigation by an autonomous worker (Pi runtime; default model `gpt-5.4-mini` at xhigh reasoning, override via the `model` arg with any Copilot-catalog model that advertises `tool_calls`). Tools: read, glob, grep, code_search (semantic-first), web_search, fetch_url, advisor (consult a stronger cross-lab model), update_plan (planning checklist), and toolbelt (run a read-only analysis CLI: rg/fd/jq/yq/sg/gron/tokei/difft/git). The worker's system prompt sandboxes it and gives one-line descriptions of each tool, so brief it on the investigation, not on tool semantics. Offloads bounded research that would otherwise eat your context window — the worker plans its own tool calls and returns a single text answer. Examples: \"find files matching X then summarize\", \"how does library Y handle Z\", \"survey this codebase for usages of deprecated API\".",
+		description: "Runs as the background `worker-explore` agent. Dispatch via the Agent tool (subagent_type: worker-explore) so your turn is never blocked; the result arrives as a completion notification. Read-only investigation by an autonomous worker (Pi runtime; default model `gpt-5.4-mini` at xhigh reasoning, override via the `model` arg with any Copilot-catalog model that advertises `tool_calls`). Tools: read, glob, grep, code_search (semantic-first), web_search, fetch_url, advisor (consult a stronger cross-lab model), update_plan (planning checklist), and toolbelt (run a read-only analysis CLI: rg/fd/jq/yq/sg/gron/tokei/difft/git). The worker's system prompt sandboxes it and gives one-line descriptions of each tool, so brief it on the investigation, not on tool semantics. Offloads bounded research that would otherwise eat your context window — the worker plans its own tool calls and returns a single text answer. Examples: \"find files matching X then summarize\", \"how does library Y handle Z\", \"survey this codebase for usages of deprecated API\".",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -26102,7 +26413,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "implement",
 		group: "workers",
 		capability: "worker",
-		description: "Delegates a scoped coding task to an autonomous worker (Pi runtime; default model `gpt-5.5` at xhigh reasoning, override via the `model` arg with any Copilot-catalog model that advertises `tool_calls`). Tools: the explore read-only set (read, glob, grep, code_search, web_search, fetch_url, advisor, update_plan, toolbelt) plus edit, write, bash, and codex_review (code review by codex-reviewer / gpt-5.3-codex). The worker's system prompt sandboxes it and gives one-line descriptions of each tool, so brief it on the task, not on tool semantics. With `worktree: false` (default) edits in place — concurrent worker_implement calls and Claude's own edits to the same files will race. With `worktree: true` runs in an isolated git worktree and returns the diff for review. HARD ERROR if true and the workspace is not a git repository.",
+		description: "Runs as the background `worker-implement` agent. Dispatch via the Agent tool (subagent_type: worker-implement) so your turn is never blocked; the result arrives as a completion notification. Delegates a scoped coding task to an autonomous worker (Pi runtime; default model `gpt-5.5` at xhigh reasoning, override via the `model` arg with any Copilot-catalog model that advertises `tool_calls`). Tools: the explore read-only set (read, glob, grep, code_search, web_search, fetch_url, advisor, update_plan, toolbelt) plus edit, write, bash, and codex_review (code review by codex-reviewer / gpt-5.3-codex). The worker's system prompt sandboxes it and gives one-line descriptions of each tool, so brief it on the task, not on tool semantics. With `worktree: false` (default) edits in place — concurrent worker_implement calls and Claude's own edits to the same files will race. With `worktree: true` runs in an isolated git worktree and returns the diff for review. HARD ERROR if true and the workspace is not a git repository.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -26150,7 +26461,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "review",
 		group: "workers",
 		capability: "worker",
-		description: "Read-only code review by an autonomous worker (Pi runtime; default model `gpt-5.5` at xhigh reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). Same read-only toolset as `explore` (read, glob, grep, code_search, web_search, fetch_url, advisor, update_plan, toolbelt) — it CANNOT edit — but the worker is framed as a reviewer: it verifies correctness against the actual code itself rather than trusting a claim, and reports findings (bugs, edge cases, security / concurrency / resource risks, missing handling) with a severity and `file:line`. Brief it with the change / diff / claim to verify (paste it, or name the files) — it reads the code to confirm, so you get a self-verifying second opinion that doesn't depend on you having pre-extracted the relevant code. Unlike the `peers` critics (single stateless model calls on the artifact you paste), this worker can navigate the repo to check surrounding context for itself.",
+		description: "Runs as the background `worker-review` agent. Dispatch via the Agent tool (subagent_type: worker-review) so your turn is never blocked; the result arrives as a completion notification. Read-only code review by an autonomous worker (Pi runtime; default model `gpt-5.5` at xhigh reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). Same read-only toolset as `explore` (read, glob, grep, code_search, web_search, fetch_url, advisor, update_plan, toolbelt) — it CANNOT edit — but the worker is framed as a reviewer: it verifies correctness against the actual code itself rather than trusting a claim, and reports findings (bugs, edge cases, security / concurrency / resource risks, missing handling) with a severity and `file:line`. Brief it with the change / diff / claim to verify (paste it, or name the files) — it reads the code to confirm, so you get a self-verifying second opinion that doesn't depend on you having pre-extracted the relevant code. Unlike the `peers` critics (single stateless model calls on the artifact you paste), this worker can navigate the repo to check surrounding context for itself.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -26194,7 +26505,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "plan",
 		group: "workers",
 		capability: "worker",
-		description: "Read-only implementation planning by an autonomous worker (Pi runtime; default model `claude-opus-4.8`, override via `model` with any Copilot-catalog model that advertises `tool_calls`). Same read-only toolset as `explore` (read, glob, grep, code_search, web_search, fetch_url, advisor, update_plan, toolbelt) — it CANNOT edit — but the worker is framed as a planner: from the task and acceptance criteria it produces a concrete, ordered implementation plan (the files to change, the approach, the key risks, and how each acceptance criterion will be verified), grounded by reading the actual code. Brief it with the task and any acceptance criteria; it returns a single plan, not code.",
+		description: "Runs as the background `worker-plan` agent. Dispatch via the Agent tool (subagent_type: worker-plan) so your turn is never blocked; the result arrives as a completion notification. Read-only implementation planning by an autonomous worker (Pi runtime; default model `claude-opus-4.8`, override via `model` with any Copilot-catalog model that advertises `tool_calls`). Same read-only toolset as `explore` (read, glob, grep, code_search, web_search, fetch_url, advisor, update_plan, toolbelt) — it CANNOT edit — but the worker is framed as a planner: from the task and acceptance criteria it produces a concrete, ordered implementation plan (the files to change, the approach, the key risks, and how each acceptance criterion will be verified), grounded by reading the actual code. Brief it with the task and any acceptance criteria; it returns a single plan, not code.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -26238,7 +26549,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "test",
 		group: "workers",
 		capability: "worker",
-		description: "Independent adversarial test authoring by an autonomous worker (Pi runtime; default model `gpt-5.5` at xhigh reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). Same read+write toolset as `implement` (the explore set plus edit, write, bash, codex_review). The worker is framed as an INDEPENDENT test author that did NOT write the code under test: from the task and acceptance criteria it writes tests that try to BREAK the implementation (edge cases, error paths, the acceptance criteria as executable checks), runs them, and reports which pass and fail — it does NOT modify the implementation to make tests pass. With `worktree: true` runs in an isolated git worktree and returns the diff; HARD ERROR if true and the workspace is not a git repository.",
+		description: "Runs as the background `worker-test` agent. Dispatch via the Agent tool (subagent_type: worker-test) so your turn is never blocked; the result arrives as a completion notification. Independent adversarial test authoring by an autonomous worker (Pi runtime; default model `gpt-5.5` at xhigh reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). Same read+write toolset as `implement` (the explore set plus edit, write, bash, codex_review). The worker is framed as an INDEPENDENT test author that did NOT write the code under test: from the task and acceptance criteria it writes tests that try to BREAK the implementation (edge cases, error paths, the acceptance criteria as executable checks), runs them, and reports which pass and fail — it does NOT modify the implementation to make tests pass. With `worktree: true` runs in an isolated git worktree and returns the diff; HARD ERROR if true and the workspace is not a git repository.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -26485,7 +26796,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "browse",
 		group: "workers",
 		capability: "browse_agent",
-		description: "A Pi-driven autonomous browser agent (gpt-5.4-mini) that drives a real browser to accomplish `task` and returns the result. Runs in its own context to preserve the lead's window (raw DOM / page snapshots stay inside the agent). Pass `sessionId` to continue a prior session (its id is returned appended to the result as `[browse session: <id>]`); omit it for a fresh isolated session. Multiple concurrent calls run as parallel sessions on the one shared browser. Examples: \"find the cheapest flight LHR-JFK next Tuesday\", \"log into the dashboard and read the current MRR\", \"summarize the top 3 HN front-page stories\".",
+		description: "Runs as the background `worker-browse` agent. Dispatch via the Agent tool (subagent_type: worker-browse) so your turn is never blocked; the result arrives as a completion notification. A Pi-driven autonomous browser agent (gpt-5.4-mini) that drives a real browser to accomplish `task` and returns the result. Runs in its own context to preserve the lead's window (raw DOM / page snapshots stay inside the agent). Pass `sessionId` to continue a prior session (its id is returned appended to the result as `[browse session: <id>]`); omit it for a fresh isolated session. Multiple concurrent calls run as parallel sessions on the one shared browser. Examples: \"find the cheapest flight LHR-JFK next Tuesday\", \"log into the dashboard and read the current MRR\", \"summarize the top 3 HN front-page stories\".",
 		inputSchema: {
 			type: "object",
 			required: ["task"],
@@ -26889,5 +27200,5 @@ async function runStandInToolCall(args, signal) {
 }
 
 //#endregion
-export { logStreamError as $, copilotBaseUrl as $t, BROWSE_DEFAULT_MODEL as A, UPSTREAM_FETCH_TIMEOUT_MS as At, toolbeltEnabled as B, cacheCopilotVersion as Bt, repoFingerprint as C, ArtifactClient as Ct, trustRepo as D, DEFAULT_CODEX_MODEL as Dt, stopReviewStateDir as E, DEFAULT_CLAUDE_MODEL_FALLBACKS as Et, appendPlanReminder as F, withInstallLock as Ft, searchWeb as G, resolveCodexModel as Gt, vscodeRipgrepPath as H, cacheVSCodeVersion as Ht, runWorkerAgent as I, setupCopilotToken as It, buildAdvisorStream as J, getModels as Jt, ADVISOR_INTERNAL_TOOL_NAME as K, resolveModel as Kt, withNoOutputRetry as L, setupGitHubAgentToken as Lt, IMPLEMENT_DEFAULT_MODEL as M, generateRandomPort as Mt, PLAN_DEFAULT_MODEL as N, pickClaudeDefault as Nt, resolveSealedGate as O, DEFAULT_CODEX_MODEL_FALLBACKS as Ot, REVIEW_DEFAULT_MODEL as P, getPackageVersion as Pt, isControllerClosedError as Q, GITHUB_API_BASE_URL as Qt, availableToolCommands as R, setupGitHubToken as Rt, isSubagentContext as S, shouldUseInsecureTls as St, stopGateEnabledForRepo as T, toolbeltPathOverride as Tt, TOOLBELT_TOOLS$1 as U, filterBetaHeader as Ut, toolbeltSkipSet as V, cacheModels as Vt, assetFor as W, isNullish as Wt, isAdvisorRequested as X, HTTPError as Xt, injectAdvisorTool as Y, fetchWithTransientRetry as Yt, buildOpenAIErrorEvent as Z, forwardError as Zt, stopReviewEnabled as _, provisionBrowserAssets as _t, buildPeerAwarenessSnippet as a, browserToolsEnabled as at, fileLastPromptStore as b, extractTarGzMember as bt, buildSessionBindHookCommand as c, workerToolsEnabled as ct, decideStopHook as d, getTokenCount as dt, copilotHeaders as en, readIteratorWithTimeout as et, fileBlockBudget as f, createResponses as ft, stopGateId as g, parseJsonOrDiagnose as gt, stopGateDisabled as h, readResponseBodyCapped as ht, buildAgentPrompt as i, agentToolsEnabled as it, DEFAULT_MODEL as j, UPSTREAM_INACTIVITY_TIMEOUT_MS as jt, liveExec as k, DEFAULT_PORT as kt, buildStopHookCommand as l, countTokens as lt, launchBaselineKey as m, MAX_RESPONSE_BODY_BYTES as mt, MCP_GROUPS as n, state as nn, handleMcpDelete as nt, personasFor as o, fleetToolsEnabled as ot, injectStopHookIntoSettingsFile as p, createChatCompletions as pt, ADVISOR_TOOL_INSTRUCTIONS as q, sleep as qt, assertMcpToolSurfaceConsistent as r, handleMcpPost as rt, buildArtifactOpenHookCommand as s, standInToolEnabled as st, GROUP_META as t, githubHeaders as tn, relayAnthropicStream as tt, captureLaunchBaseline as u, createMessages as ut, fileBaselineStore as v, hasSupportedBrowserInstalled as vt, repoRoot as w, collapsePathKeys as wt, fileReviewDebounce as x, extractZipMember as xt, fileFindingsStore as y, provisionAndIndexColbert as yt, buildToolbeltAwareness as z, tryRefreshAndRetry as zt };
-//# sourceMappingURL=peer-mcp-personas-Dm3UCpXz.js.map
+export { logStreamError as $, GITHUB_API_BASE_URL as $t, BROWSE_DEFAULT_MODEL as A, DEFAULT_PORT as At, toolbeltEnabled as B, tryRefreshAndRetry as Bt, repoFingerprint as C, shouldUseInsecureTls as Ct, trustRepo as D, DEFAULT_CLAUDE_MODEL_FALLBACKS as Dt, stopReviewStateDir as E, toolbeltPathOverride as Et, appendPlanReminder as F, getPackageVersion as Ft, searchWeb as G, isNullish as Gt, vscodeRipgrepPath as H, cacheModels as Ht, runWorkerAgent as I, withInstallLock as It, buildAdvisorStream as J, sleep as Jt, ADVISOR_INTERNAL_TOOL_NAME as K, resolveCodexModel as Kt, withNoOutputRetry as L, setupCopilotToken as Lt, IMPLEMENT_DEFAULT_MODEL as M, UPSTREAM_INACTIVITY_TIMEOUT_MS as Mt, PLAN_DEFAULT_MODEL as N, generateRandomPort as Nt, resolveSealedGate as O, DEFAULT_CODEX_MODEL as Ot, REVIEW_DEFAULT_MODEL as P, pickClaudeDefault as Pt, isControllerClosedError as Q, forwardError as Qt, availableToolCommands as R, setupGitHubAgentToken as Rt, isSubagentContext as S, extractZipMember as St, stopGateEnabledForRepo as T, collapsePathKeys as Tt, TOOLBELT_TOOLS$1 as U, cacheVSCodeVersion as Ut, toolbeltSkipSet as V, cacheCopilotVersion as Vt, assetFor as W, filterBetaHeader as Wt, isAdvisorRequested as X, fetchWithTransientRetry as Xt, injectAdvisorTool as Y, getModels as Yt, buildOpenAIErrorEvent as Z, HTTPError as Zt, stopReviewEnabled as _, parseJsonOrDiagnose as _t, buildPeerAwarenessSnippet as a, browseAgentEnabled as at, fileLastPromptStore as b, provisionAndIndexColbert as bt, buildSessionBindHookCommand as c, standInToolEnabled as ct, decideStopHook as d, createMessages as dt, copilotBaseUrl as en, readIteratorWithTimeout as et, fileBlockBudget as f, getTokenCount as ft, stopGateId as g, readResponseBodyCapped as gt, stopGateDisabled as h, MAX_RESPONSE_BODY_BYTES as ht, buildAgentPrompt as i, agentToolsEnabled as it, DEFAULT_MODEL as j, UPSTREAM_FETCH_TIMEOUT_MS as jt, liveExec as k, DEFAULT_CODEX_MODEL_FALLBACKS as kt, buildStopHookCommand as l, workerToolsEnabled as lt, launchBaselineKey as m, createChatCompletions as mt, MCP_GROUPS as n, githubHeaders as nn, handleMcpDelete as nt, personasFor as o, browserToolsEnabled as ot, injectStopHookIntoSettingsFile as p, createResponses as pt, ADVISOR_TOOL_INSTRUCTIONS as q, resolveModel as qt, assertMcpToolSurfaceConsistent as r, state as rn, handleMcpPost as rt, buildArtifactOpenHookCommand as s, fleetToolsEnabled as st, GROUP_META as t, copilotHeaders as tn, relayAnthropicStream as tt, captureLaunchBaseline as u, countTokens as ut, fileBaselineStore as v, provisionBrowserAssets as vt, repoRoot as w, ArtifactClient as wt, fileReviewDebounce as x, extractTarGzMember as xt, fileFindingsStore as y, hasSupportedBrowserInstalled as yt, buildToolbeltAwareness as z, setupGitHubToken as zt };
+//# sourceMappingURL=peer-mcp-personas-DMM1akDa.js.map