github-router 0.3.270 → 0.3.273

package/dist/{peer-mcp-personas-pWP3Eyt7.js → peer-mcp-personas-DAZU1OfN.js}

@@ -1,11 +1,11 @@
 import { t as getPackageVersion } from "./version-_Q1WpsQp.js";
 import { t as PATHS } from "./paths-Bg1_DWhi.js";
-import { A as state, C as GITHUB_GRAPHQL_URL, D as githubAgentGraphQLHeaders, E as copilotVersion, O as githubAgentHeaders, S as GITHUB_API_BASE_URL, T as copilotHeaders, b as sanitizeTransportText, d as resolveModel, f as sleep$2, g as HTTPError, h as isAllowedCopilotHost, i as tryRefreshAndRetry, v as classifyTransportError, w as copilotBaseUrl, x as withTransientRetry, y as fetchWithTransientRetry } from "./token-iaSGp76k.js";
+import { A as state, C as GITHUB_GRAPHQL_URL, D as githubAgentGraphQLHeaders, E as copilotVersion, O as githubAgentHeaders, S as GITHUB_API_BASE_URL, T as copilotHeaders, b as sanitizeTransportText, d as resolveModel, f as sleep$2, g as HTTPError, h as isAllowedCopilotHost, i as tryRefreshAndRetry, v as classifyTransportError, w as copilotBaseUrl, x as withTransientRetry, y as fetchWithTransientRetry } from "./token-Bz7iN8US.js";
 import { a as resolveExecutable, c as runManagedExeCapture, i as parseIntEnv, l as spawnTaskkillBestEffort, r as parseBoolEnv } from "./exec-y8C_MU8A.js";
 import { i as registerExitHandlers$1, n as getInstanceUuid, r as recordWorkerRepo, t as WorktreeRegistry } from "./lifecycle-0XrazT05.js";
 import { t as MCP_WORKSPACE_HEADER } from "./mcp-workspace-header-CGJbNeHb.js";
 import { n as ArtifactError, r as applyInsecureTls, t as ArtifactClient } from "./client-CQMfroGV.js";
-import { n as isPidAlive, r as registerColbertExitHandlers, s as trackChild, t as getColbertInstanceUuid } from "./lifecycle-AgNOtFRv.js";
+import { n as isPidAlive$1, r as registerColbertExitHandlers, s as trackChild, t as getColbertInstanceUuid } from "./lifecycle-AgNOtFRv.js";
 import { h as runGateChecks, m as sealedGateIds, p as resolveSealedGate } from "./stop-gate-hook-BqpumJtl.js";
 import { t as liveExec } from "./orchestration-B_Q3ncXI.js";
 import { createRequire } from "node:module";
@@ -272,6 +272,12 @@ function envInt$1(key, fallback) {
 }
 const UPSTREAM_FETCH_TIMEOUT_MS = envInt$1("UPSTREAM_FETCH_TIMEOUT_MS", 0);
 const UPSTREAM_INACTIVITY_TIMEOUT_MS = envInt$1("UPSTREAM_INACTIVITY_TIMEOUT_MS", 3e5);
+function upstreamAllowH2() {
+	return process.env.GH_ROUTER_UPSTREAM_ALLOW_H2 === "1";
+}
+function upstreamMaxConnections() {
+	return envInt$1("GH_ROUTER_UPSTREAM_MAX_CONNECTIONS", 256);
+}
 //#endregion
 //#region src/lib/toolbelt/path-inject.ts
 /**
@@ -4966,19 +4972,19 @@ function resolveTierModel(tier) {
 }
 //#endregion
 //#region src/lib/first-mate/classifier.ts
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function firstMessageContent$1(value) {
-	if (!isRecord$1(value) || !Array.isArray(value.choices)) return null;
+	if (!isRecord$2(value) || !Array.isArray(value.choices)) return null;
 	const first = value.choices[0];
-	if (!isRecord$1(first) || !isRecord$1(first.message)) return null;
+	if (!isRecord$2(first) || !isRecord$2(first.message)) return null;
 	return typeof first.message.content === "string" ? first.message.content : null;
 }
 function parseJsonObject(value) {
 	try {
 		const parsed = JSON.parse(value);
-		return isRecord$1(parsed) ? parsed : null;
+		return isRecord$2(parsed) ? parsed : null;
 	} catch {
 		return null;
 	}
@@ -5048,7 +5054,7 @@ async function classifyPlanReady(logExcerpt) {
 		schemaHint: "{\"planReady\":boolean,\"planExcerpt\":\"<=1200 chars from the completed plan, or empty\",\"confidence\":number}",
 		maxTokens: 500,
 		validate(value) {
-			if (!isRecord$1(value)) return null;
+			if (!isRecord$2(value)) return null;
 			const planReady = booleanValue$1(value.planReady);
 			const planExcerpt = stringValue$1(value.planExcerpt);
 			if (planReady === null || planExcerpt === null) return null;
@@ -5065,7 +5071,7 @@ async function classifyQuestionAnswerable(question, acceptanceCriteria) {
 		user: `Acceptance criteria:\n${acceptanceCriteria}\n\nAgent question:\n${question}`,
 		schemaHint: "{\"answerable\":boolean,\"answer\":\"present only when answerable\",\"confidence\":number}",
 		validate(value) {
-			if (!isRecord$1(value)) return null;
+			if (!isRecord$2(value)) return null;
 			const answerable = booleanValue$1(value.answerable);
 			if (answerable === null) return null;
 			const answer = stringValue$1(value.answer);
@@ -5083,7 +5089,7 @@ async function classifyFixAddressed(failureSummary, latestLogExcerpt) {
 		user: `Failure summary:\n${failureSummary}\n\nLatest log excerpt:\n${latestLogExcerpt}`,
 		schemaHint: "{\"addressed\":boolean,\"confidence\":number}",
 		validate(value) {
-			if (!isRecord$1(value)) return null;
+			if (!isRecord$2(value)) return null;
 			const addressed = booleanValue$1(value.addressed);
 			return addressed === null ? null : { addressed };
 		}
@@ -5095,7 +5101,7 @@ async function classifyStuck(logExcerpt) {
 		user: `Log excerpt:\n${logExcerpt}`,
 		schemaHint: "{\"stuck\":boolean,\"confidence\":number}",
 		validate(value) {
-			if (!isRecord$1(value)) return null;
+			if (!isRecord$2(value)) return null;
 			const stuck = booleanValue$1(value.stuck);
 			return stuck === null ? null : { stuck };
 		}
@@ -9975,6 +9981,40 @@ const WIN_RENAME_TRANSIENT = /* @__PURE__ */ new Set([
 	"EBUSY"
 ]);
 /**
+* Owner pid embedded in a `.draining.<pid>.<rand>` or `.claim.<pid>.<rand>`
+* segment. A file can carry both (a claimed orphan keeps the drain segment), so
+* the LAST match is the current owner.
+*/
+const OWNER_SEGMENT_RE = /\.(?:draining|claim)\.(\d+)\./g;
+/**
+* Claims held by a live drainer in THIS process, across instances. Per-instance
+* `inflight` cannot see a peer instance's claim, and both share our pid, so pid
+* liveness cannot separate them either. A claim abandoned on a read error is
+* never added here, which is what keeps it replayable (R3 #4).
+*/
+const heldClaims = /* @__PURE__ */ new Set();
+function ownerPidOf(name) {
+	let pid;
+	for (const match of name.matchAll(OWNER_SEGMENT_RE)) pid = Number(match[1]);
+	return pid !== void 0 && Number.isInteger(pid) && pid > 0 ? pid : void 0;
+}
+/**
+* `process.kill(pid, 0)` probes existence without signalling; `EPERM` means the
+* process exists but is owned by another user (still alive). Mirrors the copies
+* in `lib/paths.ts`, `lib/colbert/lifecycle.ts`, and `lib/worker-agent/
+* lifecycle.ts` — kept local so first-mate takes no dependency on those modules.
+*/
+function isPidAlive(pid) {
+	if (!Number.isInteger(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		if (err.code === "EPERM") return true;
+		return false;
+	}
+}
+/**
 * Atomically claim `from` by renaming it to the process-unique `to`.
 * Returns `true` if THIS caller won the claim, `false` if a peer already took it
 * (source gone). Retries transient Windows sharing violations so two concurrent
@@ -10070,6 +10110,9 @@ var AnswerInbox = class {
 			if (!name.startsWith(`${base}.draining.`)) continue;
 			const orphan = path.join(dir, name);
 			if (this.inflight.has(orphan)) continue;
+			if (heldClaims.has(orphan)) continue;
+			const owner = ownerPidOf(name);
+			if (owner !== void 0 && owner !== process.pid && isPidAlive(owner)) continue;
 			const claim = `${orphan}.claim.${process.pid}.${randomBytes(4).toString("hex")}`;
 			if (!await claimByRename(orphan, claim)) continue;
 			try {
@@ -10086,11 +10129,15 @@ var AnswerInbox = class {
 		} catch (err) {
 			if (err.code !== "ENOENT") consola.warn(`first-mate: deferring unreadable inbox claim ${target} for retry:`, err);
 		}
-		for (const p of claimed) this.inflight.add(p);
+		for (const p of claimed) {
+			this.inflight.add(p);
+			heldClaims.add(p);
+		}
 		const ack = async () => {
 			for (const p of claimed) {
 				await fs$1.unlink(p).catch(() => {});
 				this.inflight.delete(p);
+				heldClaims.delete(p);
 			}
 		};
 		return {
@@ -11499,7 +11546,7 @@ function parsePackageJson(text) {
 	if (text === void 0) return void 0;
 	try {
 		const parsed = JSON.parse(text);
-		if (!isRecord(parsed)) return void 0;
+		if (!isRecord$1(parsed)) return void 0;
 		return {
 			scripts: stringRecord(parsed.scripts),
 			dependencies: stringRecord(parsed.dependencies),
@@ -11699,11 +11746,11 @@ function buildScaffoldPrBody(reports) {
 		"No factory protocol files are seeded; orchestration remains external to the repository."
 	].join("\n");
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringRecord(value) {
-	if (!isRecord(value)) return {};
+	if (!isRecord$1(value)) return {};
 	const result = {};
 	for (const [key, entry] of Object.entries(value)) if (typeof entry === "string") result[key] = entry;
 	return result;
@@ -15779,7 +15826,7 @@ async function freshnessVerdict(workspace) {
 	};
 	if (meta.status === "building") {
 		const pid = typeof meta.buildPid === "number" ? meta.buildPid : 0;
-		if (isInitInFlight(workspace) || pid > 0 && isPidAlive(pid)) return {
+		if (isInitInFlight(workspace) || pid > 0 && isPidAlive$1(pid)) return {
 			verdict: "building",
 			meta
 		};
@@ -27358,7 +27405,6 @@ function classifyNamedStreamError(errName, errMessage) {
 }
 function classifyStreamError(details) {
 	if (details.name === "AbortError" || details.name === "InactivityTimeout" || details.name === "TimeoutError" || details.name === "timeout_error") return "timeout_error";
-	if (details.classification === "transient") return "overloaded_error";
 	return "api_error";
 }
 function formatStreamErrorMessage(details) {
@@ -27384,6 +27430,255 @@ function logStreamError(routePath, error, bytesRelayed) {
 	};
 }
 //#endregion
+//#region src/lib/thinking-history-repair.ts
+const THINKING_INTEGRITY_ERROR_RES = [/messages\.(\d+)\.content\.(\d+):\s*`thinking` or `redacted_thinking` blocks in the latest assistant message cannot be modified/, /messages\.(\d+)\.content\.(\d+):\s*Invalid `signature` in `thinking` block/];
+const MAX_REMEMBERED_REPAIRS = 1e3;
+const OMITTED_THINKING_PLACEHOLDER = "[prior reasoning omitted]";
+const repairSalt = randomBytes(32);
+const rememberedRepairs = /* @__PURE__ */ new Set();
+function declined(reason, detail = {}) {
+	return {
+		ok: false,
+		decline: {
+			reason,
+			...detail
+		}
+	};
+}
+/** Render a decline as a single log-safe `key=value` line. */
+function formatThinkingRepairDecline(decline) {
+	return Object.entries(decline).filter(([, value]) => value !== void 0).map(([key, value]) => `${key}=${String(value)}`).join(" ");
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/** Count signed blocks without hashing — used only to explain a decline. */
+function countSignedBlocks(content) {
+	return content.filter((block) => isRecord(block) && (block.type === "thinking" || block.type === "redacted_thinking")).length;
+}
+function signedBlockFingerprint(_messageIndex, content) {
+	const hash = createHash("sha256");
+	hash.update(repairSalt);
+	let signedBlocks = 0;
+	for (let index = 0; index < content.length; index++) {
+		const block = content[index];
+		if (!isRecord(block)) continue;
+		if (block.type !== "thinking" && block.type !== "redacted_thinking") continue;
+		signedBlocks++;
+		hash.update(String(index));
+		hash.update(String(block.type));
+		if (typeof block.signature === "string") hash.update(block.signature);
+		if (typeof block.data === "string") hash.update(block.data);
+	}
+	return signedBlocks > 0 ? hash.digest("hex") : void 0;
+}
+function repairAtArrayIndex(parsed, messageIndex) {
+	if (!Array.isArray(parsed.messages)) return declined("no-messages-array", { messageIndex });
+	const messages = [...parsed.messages];
+	const detail = {
+		messageIndex,
+		messageCount: messages.length
+	};
+	const message = messages[messageIndex];
+	if (!isRecord(message)) return declined("message-missing", detail);
+	if (message.role !== "assistant") return declined("message-not-assistant", {
+		...detail,
+		roleAtIndex: typeof message.role === "string" ? message.role : "unknown"
+	});
+	if (!Array.isArray(message.content)) return declined("content-not-array", {
+		...detail,
+		roleAtIndex: "assistant"
+	});
+	const shape = {
+		...detail,
+		roleAtIndex: "assistant",
+		blocksAtIndex: message.content.length,
+		signedBlocksAtIndex: countSignedBlocks(message.content)
+	};
+	const fingerprint = signedBlockFingerprint(messageIndex, message.content);
+	if (!fingerprint) return declined("no-signed-blocks", shape);
+	const repairedContent = message.content.filter((block) => !isRecord(block) || block.type !== "thinking" && block.type !== "redacted_thinking");
+	const removedBlocks = message.content.length - repairedContent.length;
+	if (removedBlocks === 0) return declined("no-blocks-removed", shape);
+	if (repairedContent.length === 0) repairedContent.push({
+		type: "text",
+		text: OMITTED_THINKING_PLACEHOLDER
+	});
+	messages[messageIndex] = {
+		...message,
+		content: repairedContent
+	};
+	parsed.messages = messages;
+	return {
+		ok: true,
+		repair: {
+			body: JSON.stringify(parsed),
+			fingerprint,
+			messageIndex,
+			removedBlocks
+		}
+	};
+}
+/** Roles in order, for a decline log. Roles only, so it carries no content. */
+function roleSequenceOf(messages) {
+	return messages.map((message) => isRecord(message) && typeof message.role === "string" ? message.role : "unknown").join(",");
+}
+/** Elements upstream would not count as a conversation turn. */
+function isHoistedElement(message) {
+	if (!isRecord(message)) return false;
+	return message.role !== "user" && message.role !== "assistant";
+}
+/**
+* Translate an upstream-reported message index into an index in THIS array,
+* skipping elements upstream would not have counted.
+*
+* Anthropic's Messages schema has no in-array `system` role, yet clients do
+* send one, and upstream evidently accepts it and drops it before validating —
+* which shifts every index after it. Returns undefined when nothing is hoisted
+* (the mapping would be the identity) or when the target does not exist.
+*/
+function hoistAdjustedIndex(messages, reportedIndex) {
+	let retained = 0;
+	for (let index = 0; index < messages.length; index++) {
+		if (isHoistedElement(messages[index])) continue;
+		if (retained === reportedIndex) return index === reportedIndex ? void 0 : index;
+		retained++;
+	}
+}
+/** True when `content[contentIndex]` is a signed thinking block. */
+function hasSignedBlockAt(content, contentIndex) {
+	if (!Array.isArray(content)) return false;
+	const block = content[contentIndex];
+	if (!isRecord(block)) return false;
+	return block.type === "thinking" || block.type === "redacted_thinking";
+}
+/**
+* Resolve the message upstream named, then repair it.
+*
+* DIRECT INDEX FIRST, hoist-adjusted index only as a fallback. The ordering is
+* the whole safety argument: every request that repairs correctly today takes
+* the direct path untouched, and the adjusted path runs only where the code
+* would otherwise have declined outright. Mapping first would REGRESS a working
+* case — with `[user, system, assistant]` and upstream naming `messages.2`, the
+* direct lookup repairs the assistant turn correctly while a retained-role
+* mapping yields only `[user, assistant]` and runs off the end.
+*
+* The fallback is self-validating rather than trusted: it is accepted only if
+* the block upstream actually named is a signed thinking block at the adjusted
+* position. If the index shift has some other cause, that check fails and the
+* original decline stands, so a wrong hypothesis fails closed instead of
+* stripping blocks from an innocent turn.
+*/
+/** True when `index` names an assistant carrying the block upstream reported. */
+function namesReportedBlock(messages, index, contentIndex) {
+	const message = messages[index];
+	if (!isRecord(message) || message.role !== "assistant") return false;
+	return hasSignedBlockAt(message.content, contentIndex);
+}
+/**
+* Resolve the message upstream named, then repair it.
+*
+* When nothing is hoisted, this array and upstream's are indexed alike, so the
+* reported index is used directly — the identity case, and the overwhelming
+* majority of traffic, whose behaviour is unchanged.
+*
+* When something IS hoisted, the two arrays provably disagree and the reported
+* index alone cannot say which turn was meant. Both the raw index and the
+* hoist-adjusted one can land on a signed assistant, and picking the raw one
+* blind would strip a healthy turn while leaving the corrupt one in place. So
+* the block index upstream reported is used as the tiebreak: whichever
+* candidate actually carries a signed block THERE is the one repaired. If both
+* do, the request is genuinely ambiguous and we decline — the client sees the
+* same 400 it would have seen anyway, with no innocent turn rewritten.
+*/
+function repairMessageAt(parsed, messageIndex, contentIndex) {
+	if (!Array.isArray(parsed.messages)) return repairAtArrayIndex(parsed, messageIndex);
+	const messages = parsed.messages;
+	const hoistedCount = messages.filter((m) => isHoistedElement(m)).length;
+	const mapped = hoistedCount === 0 ? void 0 : hoistAdjustedIndex(messages, messageIndex);
+	const annotate = (outcome, extra = {}) => outcome.ok ? outcome : declined(outcome.decline.reason, {
+		...outcome.decline,
+		hoistedCount,
+		roleSequence: roleSequenceOf(messages),
+		...extra
+	});
+	if (hoistedCount === 0 || contentIndex === void 0 || mapped === void 0) return annotate(repairAtArrayIndex(parsed, messageIndex));
+	const directNames = namesReportedBlock(messages, messageIndex, contentIndex);
+	const mappedNames = namesReportedBlock(messages, mapped, contentIndex);
+	if (directNames && mappedNames) return declined("ambiguous-index", {
+		messageIndex,
+		messageCount: messages.length,
+		hoistedCount,
+		roleSequence: roleSequenceOf(messages),
+		mappedIndex: mapped
+	});
+	if (mappedNames) return annotate(repairAtArrayIndex(parsed, mapped), { mappedIndex: mapped });
+	return annotate(repairAtArrayIndex(parsed, messageIndex), { mappedIndex: mapped });
+}
+/**
+* Build a one-shot repair only for Copilot's known signed-thinking integrity
+* rejections. The upstream error is the oracle: valid omitted-display thinking
+* also has an empty `thinking` string, so request shape alone cannot identify a
+* corrupt signature safely.
+*
+* Returns a discriminated outcome so a caller can report WHY a repair was not
+* applied; a silent decline is what made the original incident undiagnosable.
+*/
+function repairRejectedThinkingHistory(rawBody, upstreamErrorText) {
+	const match = THINKING_INTEGRITY_ERROR_RES.map((pattern) => pattern.exec(upstreamErrorText)).find((candidate) => candidate !== null);
+	if (!match) return declined("error-not-recognized");
+	const messageIndex = Number(match[1]);
+	if (!Number.isSafeInteger(messageIndex) || messageIndex < 0) return declined("message-index-invalid", { messageIndex });
+	const parsedContentIndex = Number(match[2]);
+	const contentIndex = Number.isSafeInteger(parsedContentIndex) && parsedContentIndex >= 0 ? parsedContentIndex : void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(rawBody);
+	} catch {
+		return declined("body-not-json", { messageIndex });
+	}
+	return repairMessageAt(parsed, messageIndex, contentIndex);
+}
+/**
+* Reapply a repair already proven successful in this process. Only salted
+* digests are retained; no message, thinking, signature, or tool content is
+* stored.
+*/
+function repairKnownThinkingHistory(rawBody) {
+	if (rememberedRepairs.size === 0) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(rawBody);
+	} catch {
+		return;
+	}
+	if (!Array.isArray(parsed.messages)) return void 0;
+	let repaired;
+	let totalRemovedBlocks = 0;
+	for (let index = parsed.messages.length - 1; index >= 0; index--) {
+		const message = parsed.messages[index];
+		if (!isRecord(message) || !Array.isArray(message.content)) continue;
+		const fingerprint = signedBlockFingerprint(index, message.content);
+		if (!fingerprint || !rememberedRepairs.has(fingerprint)) continue;
+		const attempt = repairAtArrayIndex(parsed, index);
+		if (!attempt.ok) continue;
+		totalRemovedBlocks += attempt.repair.removedBlocks;
+		repaired = {
+			...attempt.repair,
+			removedBlocks: totalRemovedBlocks
+		};
+	}
+	return repaired;
+}
+function rememberThinkingHistoryRepair(fingerprint) {
+	if (rememberedRepairs.has(fingerprint)) return;
+	if (rememberedRepairs.size >= MAX_REMEMBERED_REPAIRS) {
+		const oldest = rememberedRepairs.values().next().value;
+		if (typeof oldest === "string") rememberedRepairs.delete(oldest);
+	}
+	rememberedRepairs.add(fingerprint);
+}
+//#endregion
 //#region src/services/advisor/advisor.ts
 /**
 * Phase I: ADVISOR proxy-side translation.
@@ -28062,11 +28357,27 @@ function buildAdvisorStream(opts) {
 						}))
 					});
 					if (aborter.signal.aborted) return;
-					response = await createMessages(JSON.stringify({
+					let continuationSend = JSON.stringify({
 						...opts.baseBody,
 						messages: conversation,
 						stream: true
-					}), opts.requestHeaders, aborter.signal, true);
+					});
+					const knownRepair = repairKnownThinkingHistory(continuationSend);
+					if (knownRepair) continuationSend = knownRepair.body;
+					try {
+						response = await createMessages(continuationSend, opts.requestHeaders, aborter.signal, true);
+					} catch (continuationError) {
+						if (!(continuationError instanceof HTTPError)) throw continuationError;
+						const errorBody = await continuationError.response.clone().text().catch(() => "");
+						const outcome = repairRejectedThinkingHistory(continuationSend, errorBody);
+						if (!outcome.ok) {
+							consola.warn(`Advisor continuation thinking-history repair declined: ${formatThinkingRepairDecline(outcome.decline)}`);
+							throw continuationError;
+						}
+						consola.warn(`Advisor continuation: retrying without rejected thinking blocks: message=${outcome.repair.messageIndex} removed_blocks=${outcome.repair.removedBlocks}`);
+						response = await createMessages(outcome.repair.body, opts.requestHeaders, aborter.signal, true);
+						rememberThinkingHistoryRepair(outcome.repair.fingerprint);
+					}
 				}
 				if (aborter.signal.aborted) return;
 				const finalIndex = nextSyntheticIndex++;
@@ -34285,6 +34596,6 @@ function enumerateInjectedMcpToolNames(groupKeys, opts = {}) {
 	return [...new Set(names)];
 }
 //#endregion
-export { reviewerModel as $, searchWeb as A, DEFAULT_CODEX_MODEL_FALLBACKS as At, readIteratorWithTimeout as B, buildToolbeltAwareness as C, CONDENSED_OPERATING_SEQUENCE as Ct, TOOLBELT_TOOLS$1 as D, toolbeltPathOverride as Dt, vscodeRipgrepPath as E, collapsePathKeys as Et, isAdvisorRequested as F, pickClaudeDefault as Ft, artifactToolsEnabled as G, handleMcpDelete as H, buildAnthropicErrorEvent as I, withOneMSuffix as It, browserCompoundToolsEnabled as J, brainstormModel as K, buildOpenAIErrorEvent as L, withInstallLock as Lt, ADVISOR_TOOL_INSTRUCTIONS as M, UPSTREAM_FETCH_TIMEOUT_MS as Mt, buildAdvisorStream as N, UPSTREAM_INACTIVITY_TIMEOUT_MS as Nt, assetFor as O, DEFAULT_CLAUDE_MODEL_FALLBACKS as Ot, injectAdvisorTool as P, generateRandomPort as Pt, nativeSubagentModel as Q, isControllerClosedError as R, availableToolCommands as S, warmTreeSitterPool as St, toolbeltSkipSet as T, shouldUseInsecureTls as Tt, handleMcpPost as U, relayAnthropicStream as V, agentToolsEnabled as W, fleetToolsEnabled as X, browserToolsEnabled as Y, geminiAvailable as Z, appendPlanReminder as _, hasSupportedBrowserInstalled as _t, buildPeerAwarenessSnippet as a, countTokens as at, runWorkerAgent as b, extractTarGzMember as bt, personasFor as c, assembleResponsesPayload as ct, EXPLORE_DEFAULT_MODEL as d, createResponses as dt, scoutModel as et, EXPLORE_DEFAULT_THINKING as f, createChatCompletions as ft, TEST_DEFAULT_MODEL as g, provisionBrowserAssets as gt, REVIEW_DEFAULT_MODEL as h, parseJsonOrDiagnose as ht, buildAgentPrompt as i, shimDefaultsToXhigh as it, ADVISOR_INTERNAL_TOOL_NAME as j, DEFAULT_PORT as jt, satisfiesMinVersion as k, DEFAULT_CODEX_MODEL as kt, BROWSE_DEFAULT_MODEL as l, resolveMcpToolTimeoutMs as lt, PLAN_DEFAULT_MODEL as m, readResponseBodyCapped as mt, MCP_GROUPS as n, standInToolEnabled as nt, buildPeerAwarenessSummary as o, createMessages as ot, IMPLEMENT_DEFAULT_MODEL as p, MAX_RESPONSE_BODY_BYTES as pt, browseAgentEnabled as q, assertMcpToolSurfaceConsistent as r, workerToolsEnabled as rt, enumerateInjectedMcpToolNames as s, getTokenCount as st, GROUP_META as t, scribeModel as tt, DEFAULT_MODEL as u, pickEndpoint as ut, resolveModeDefaults as v, colbertDegradedWarning as vt, toolbeltEnabled as w, DEFINITION_OF_GREATNESS as wt, buildEnv as x, extractZipMember as xt, resolveWorkerRunOpts as y, provisionAndIndexColbert as yt, logStreamError as z };
+export { browserToolsEnabled as $, searchWeb as A, collapsePathKeys as At, buildAnthropicErrorEvent as B, upstreamAllowH2 as Bt, buildToolbeltAwareness as C, provisionAndIndexColbert as Ct, TOOLBELT_TOOLS$1 as D, CONDENSED_OPERATING_SEQUENCE as Dt, vscodeRipgrepPath as E, warmTreeSitterPool as Et, isAdvisorRequested as F, DEFAULT_PORT as Ft, relayAnthropicStream as G, isControllerClosedError as H, withOneMSuffix as Ht, formatThinkingRepairDecline as I, UPSTREAM_FETCH_TIMEOUT_MS as It, agentToolsEnabled as J, handleMcpDelete as K, rememberThinkingHistoryRepair as L, UPSTREAM_INACTIVITY_TIMEOUT_MS as Lt, ADVISOR_TOOL_INSTRUCTIONS as M, DEFAULT_CLAUDE_MODEL_FALLBACKS as Mt, buildAdvisorStream as N, DEFAULT_CODEX_MODEL as Nt, assetFor as O, DEFINITION_OF_GREATNESS as Ot, injectAdvisorTool as P, DEFAULT_CODEX_MODEL_FALLBACKS as Pt, browserCompoundToolsEnabled as Q, repairKnownThinkingHistory as R, generateRandomPort as Rt, availableToolCommands as S, colbertDegradedWarning as St, toolbeltSkipSet as T, extractZipMember as Tt, logStreamError as U, withInstallLock as Ut, buildOpenAIErrorEvent as V, upstreamMaxConnections as Vt, readIteratorWithTimeout as W, brainstormModel as X, artifactToolsEnabled as Y, browseAgentEnabled as Z, appendPlanReminder as _, MAX_RESPONSE_BODY_BYTES as _t, buildPeerAwarenessSnippet as a, scribeModel as at, runWorkerAgent as b, provisionBrowserAssets as bt, personasFor as c, shimDefaultsToXhigh as ct, EXPLORE_DEFAULT_MODEL as d, getTokenCount as dt, fleetToolsEnabled as et, EXPLORE_DEFAULT_THINKING as f, assembleResponsesPayload as ft, TEST_DEFAULT_MODEL as g, createChatCompletions as gt, REVIEW_DEFAULT_MODEL as h, createResponses as ht, buildAgentPrompt as i, scoutModel as it, ADVISOR_INTERNAL_TOOL_NAME as j, toolbeltPathOverride as jt, satisfiesMinVersion as k, shouldUseInsecureTls as kt, BROWSE_DEFAULT_MODEL as l, countTokens as lt, PLAN_DEFAULT_MODEL as m, pickEndpoint as mt, MCP_GROUPS as n, nativeSubagentModel as nt, buildPeerAwarenessSummary as o, standInToolEnabled as ot, IMPLEMENT_DEFAULT_MODEL as p, resolveMcpToolTimeoutMs as pt, handleMcpPost as q, assertMcpToolSurfaceConsistent as r, reviewerModel as rt, enumerateInjectedMcpToolNames as s, workerToolsEnabled as st, GROUP_META as t, geminiAvailable as tt, DEFAULT_MODEL as u, createMessages as ut, resolveModeDefaults as v, readResponseBodyCapped as vt, toolbeltEnabled as w, extractTarGzMember as wt, buildEnv as x, hasSupportedBrowserInstalled as xt, resolveWorkerRunOpts as y, parseJsonOrDiagnose as yt, repairRejectedThinkingHistory as z, pickClaudeDefault as zt };
 
-//# sourceMappingURL=peer-mcp-personas-pWP3Eyt7.js.map
+//# sourceMappingURL=peer-mcp-personas-DAZU1OfN.js.map