github-router 0.3.293 → 0.3.295

package/dist/{peer-mcp-personas-DhI7ZPSx.js → peer-mcp-personas-BwNtC8jt.js}

@@ -1,14 +1,14 @@
 import { n as explicitPackageRoot } from "./package-root-B-osctCk.js";
 import { t as getPackageVersion } from "./version-C8x2hQrZ.js";
-import { t as PATHS } from "./paths-BH4J7slC.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-8drORhXg.js";
+import { t as PATHS } from "./paths-Ci485qSJ.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-BtJhjXXu.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-nuOHfwgj.js";
-import { t as MCP_WORKSPACE_HEADER } from "./mcp-workspace-header-q34H_4wL.js";
+import { i as registerExitHandlers$1, n as getInstanceUuid, r as recordWorkerRepo, t as WorktreeRegistry } from "./lifecycle-Bg6doY3-.js";
+import { t as MCP_WORKSPACE_HEADER } from "./mcp-workspace-header-dERl2YTT.js";
 import { n as ArtifactError, r as applyInsecureTls, t as ArtifactClient } from "./client-CQMfroGV.js";
-import { n as isPidAlive$1, r as registerColbertExitHandlers, s as trackChild, t as getColbertInstanceUuid } from "./lifecycle-LeSfa7wH.js";
-import { f as resolveSealedGate, m as runGateChecks, p as sealedGateIds } from "./stop-gate-hook-BiBp5aGm.js";
-import { t as liveExec } from "./orchestration-pzbrKkgD.js";
+import { n as isPidAlive$1, r as registerColbertExitHandlers, s as trackChild, t as getColbertInstanceUuid } from "./lifecycle-CM9eTzvk.js";
+import { f as resolveSealedGate, m as runGateChecks, p as sealedGateIds } from "./stop-gate-hook-DQnh_KfI.js";
+import { t as liveExec } from "./orchestration-BiGCEwbH.js";
 import { createRequire } from "node:module";
 import consola from "consola";
 import { chmodSync, closeSync, constants, cpSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
@@ -96,6 +96,25 @@ async function tryCreateLock(p) {
 	}
 }
 //#endregion
+//#region src/lib/model-suffix.ts
+/** Strip every trailing `[1m]` marker, case-insensitively. */
+function stripTrailingOneMSuffix(id) {
+	const match = id.match(/(?:\[1m\])+$/i);
+	if (!match || match.index === void 0) return {
+		base: id,
+		hadSuffix: false
+	};
+	return {
+		base: id.slice(0, match.index),
+		hadSuffix: true
+	};
+}
+/** Reapply at most one canonical `[1m]` marker when the input had one. */
+function normalizeTrailingOneMSuffix(id) {
+	const { base, hadSuffix } = stripTrailingOneMSuffix(id);
+	return hadSuffix ? `${base}[1m]` : base;
+}
+//#endregion
 //#region src/lib/one-m-context.ts
 /**
 * Context-window threshold at which Claude Code's `[1m]` accounting unlock is
@@ -160,8 +179,9 @@ function oneMContextDisabled() {
 * conservative 200K accounting rather than being over-budgeted into an overflow.
 */
 function withOneMSuffix(id) {
-	if (oneMContextDisabled()) return id;
-	return catalogAdvertises1M(id) ? `${id}[1m]` : id;
+	const base = normalizeTrailingOneMSuffix(id).replace(/\[1m\]$/i, "");
+	if (oneMContextDisabled()) return base;
+	return catalogAdvertises1M(base) ? `${base}[1m]` : base;
 }
 /**
 * Decorate a slug the USER named — a `-m` argument or a launcher default — with
@@ -208,9 +228,48 @@ function withOneMSuffix(id) {
 * default — under-accounting, never overflow.
 */
 function withOneMSuffixForLead(slug) {
-	if (oneMContextDisabled()) return slug;
-	if (/\[1m\]$/i.test(slug)) return slug;
-	return catalogAdvertises1M(resolveModel(slug)) ? `${slug}[1m]` : slug;
+	const base = normalizeTrailingOneMSuffix(slug).replace(/\[1m\]$/i, "");
+	if (oneMContextDisabled()) return base;
+	return catalogAdvertises1M(resolveModel(base)) ? `${base}[1m]` : base;
+}
+//#endregion
+//#region src/lib/fast-endpoint.ts
+const ENDPOINTS = {
+	chat: /* @__PURE__ */ new Set(["/chat/completions", "/v1/chat/completions"]),
+	responses: /* @__PURE__ */ new Set(["/responses", "/v1/responses"]),
+	messages: /* @__PURE__ */ new Set(["/messages", "/v1/messages"])
+};
+/**
+* Return the endpoint mandated by a fast-profile roster model.
+*
+* This is intentionally independent of the standard `pickEndpoint`: that
+* resolver prefers chat when a catalog entry advertises both clients, while
+* fast roles have a fixed provider contract. Gemini stays on chat; Luna, Sol,
+* and Grok stay on Responses; the Opus Oracle stays on native Messages.
+* Unknown ids return undefined so a fast caller cannot guess a transport.
+*/
+function fastEndpointRequirement(modelId) {
+	const id = modelId.replace(/(?:\[1m\])+$/i, "");
+	if (id === "gemini-3.7-flash") return "chat";
+	if (id === "gpt-5.6-luna" || id === "gpt-5.6-sol" || id === "grok-4.6") return "responses";
+	if (id === "claude-opus-5") return "messages";
+}
+/**
+* Resolve the fixed fast transport only when the catalog explicitly advertises
+* the required endpoint. An entry that advertises both still resolves to the
+* policy endpoint, regardless of advertisement order.
+*/
+function fastEndpointForModel(model) {
+	const required = fastEndpointRequirement(model.id);
+	if (!required) return void 0;
+	const advertised = model.supported_endpoints;
+	if (!Array.isArray(advertised) || advertised.length === 0) return void 0;
+	return advertised.some((endpoint) => ENDPOINTS[required].has(endpoint)) ? required : void 0;
+}
+/** Resolve a fast endpoint from a catalog id, without selecting a fallback. */
+function fastEndpointForCatalogId(modelId, catalog) {
+	const found = catalog?.find((model) => model.id === modelId);
+	return found ? fastEndpointForModel(found) : void 0;
 }
 //#endregion
 //#region src/services/copilot/endpoint.ts
@@ -368,12 +427,16 @@ function isClaudeModel(modelId, model, originalModelId) {
 * `originalModelId` is the optional pre-resolution request id; when supplied it
 * is checked for Claude-likeness alongside the resolved id so an alias that
 * resolves to a non-Claude-looking id can't slip past.
+*
+* `fastProfile` is an authenticated launch-policy signal. It replaces only the
+* endpoint selection step with the fixed fast roster policy; Claude identity
+* still wins first, and standard/BYO callers retain `pickEndpoint` unchanged.
 */
-function classifyMessagesRoute(modelId, model, originalModelId) {
+function classifyMessagesRoute(modelId, model, originalModelId, fastProfile = false) {
 	if (!modelId) return "claude-passthrough";
 	if (isClaudeModel(modelId, model, originalModelId)) return "claude-passthrough";
 	if (!model) return "claude-passthrough";
-	const endpoint = pickEndpoint(model);
+	const endpoint = fastProfile ? fastEndpointForModel(model) : pickEndpoint(model);
 	if (endpoint === "responses") return "responses-shim";
 	if (endpoint === "chat") return "chat-shim";
 	return "claude-passthrough";
@@ -451,7 +514,7 @@ const DEFAULT_OPUS_FAMILY = "5";
 * The lead `-m fast` selects. `gpt-5.6-luna` — a distinct Luna-driven
 * profile (see `./launch-profile`), NOT a Claude Sonnet budget lead. This
 * REPLACES the earlier `-m fast` → `claude-sonnet-5` mapping: `fast` now
-* names a deliberately lean Luna surface (three native agents, one peer
+* names a deliberately lean Luna surface (five native agents, one peer
 * persona, `peers`/`search` MCP groups only), not "budget Sonnet with the
 * full standard surface". `resolveLaunchProfile` in `./launch-profile`
 * keys off the same raw `-m` argument this constant is selected by, so the
@@ -18926,7 +18989,7 @@ function logAudit$1(record) {
 		try {
 			const fs = await import("node:fs/promises");
 			const path = await import("node:path");
-			const { PATHS } = await import("./paths-DJZoXfAS.js");
+			const { PATHS } = await import("./paths-GD7bgGGy.js");
 			const dir = path.join(PATHS.APP_DIR, "browser-mcp");
 			await fs.mkdir(dir, { recursive: true });
 			const line = JSON.stringify({
@@ -27454,6 +27517,247 @@ function shimDefaultsToXhigh(id) {
 	return XHIGH_DEFAULT_SHIM_MODELS.includes(normalizeModelId(id));
 }
 //#endregion
+//#region src/lib/launch-profile.ts
+const STANDARD_PROFILE = Object.freeze({
+	id: "standard",
+	hasCoordinator: true
+});
+/**
+* The `-m fast` roster: exactly five native agents (`scout`, `implementer`,
+* `reviewer`, `planner`, `critic`), the fast-only `oracle` peer tool, no coordinator,
+* and only `peers`/`search` plus the ordinary opt-in `browser` group.
+* `workers`/`orchestrate`/`decide`/`fleet`/`first-mate` are hard denies even
+* when their independent standard-profile gates pass.
+*/
+const FAST_PROFILE = Object.freeze({
+	id: "fast",
+	nativeRoster: /* @__PURE__ */ new Set([
+		"scout",
+		"implementer",
+		"reviewer",
+		"planner",
+		"critic"
+	]),
+	personaAllowlist: /* @__PURE__ */ new Set(["oracle"]),
+	allowedGroups: /* @__PURE__ */ new Set([
+		"peers",
+		"search",
+		"browser"
+	]),
+	hasCoordinator: false
+});
+function profileDescriptor(id) {
+	return id === "fast" ? FAST_PROFILE : STANDARD_PROFILE;
+}
+/**
+* Resolve the parsed `-m` argument to a launch profile.
+*
+* Deliberately keyed on the RAW alias string (trimmed, case-insensitive
+* `"fast"`), never on a resolved model id: `resolveLeadSlugArg` maps `fast`
+* to `FAST_LEAD_MODEL` (`./port`) before this is of any use to a caller who
+* only has the resolved id, so callers that already resolved the lead must
+* pass the ORIGINAL `-m` value here, not the resolved one. This is what
+* keeps `-m gpt-5.6-luna` (a direct pin of the same underlying model) a
+* standard-surface launch — only the literal alias narrows the surface.
+*/
+function resolveLaunchProfile(modelArg) {
+	return modelArg?.trim().toLowerCase() === "fast" ? "fast" : "standard";
+}
+/**
+* Router-owned alias id for the fast profile's Sonnet-tier row
+* (`ANTHROPIC_DEFAULT_SONNET_MODEL`). Never sent upstream — canonicalized to
+* `LUNA_REAL_MODEL_ID` by `canonicalizeAliasModel` before the request
+* reaches Copilot.
+*/
+const LUNA_DRIVER_ALIAS_ID = "gh-router-luna-driver-max";
+/** Fast native-agent alias ids preserve role-specific effort provenance until
+*  the authenticated request boundary. They both canonicalize to Luna, but the
+*  scout is fixed high while the implementer is fixed max. */
+const LUNA_SCOUT_ALIAS_ID = "gh-router-luna-scout-high";
+const LUNA_IMPLEMENTER_ALIAS_ID = "gh-router-luna-implementer-max";
+/** Fast-profile critic alias. It preserves Gemini's fixed medium effort until
+* the authenticated request boundary; bare Gemini remains high for the lead
+* and Advisor traffic. */
+const FAST_CRITIC_ALIAS_ID = "gh-router-fast-critic-medium";
+const LUNA_SONNET_ALIAS_ID = "gh-router-luna-sonnet-xhigh";
+/**
+* Router-owned alias id for the fast profile's Haiku-tier row
+* (`ANTHROPIC_DEFAULT_HAIKU_MODEL` / `ANTHROPIC_SMALL_FAST_MODEL`).
+*/
+const LUNA_HAIKU_ALIAS_ID = "gh-router-luna-haiku-high";
+/** The real Copilot catalog id every Luna alias (including the driver
+*  itself) canonicalizes to. */
+const LUNA_REAL_MODEL_ID = "gpt-5.6-luna";
+/**
+* The full alias table, keyed by `aliasId`. A simpler model-id-only table is
+* rejected by design: the driver, the Sonnet tier, and the Haiku tier all
+* resolve to the SAME Luna catalog id, while the fast critic alias resolves
+* to Gemini. After early canonicalization a table keyed on the real id could
+* no longer tell which absent-effort default applies. Alias provenance is the
+* minimum discriminator that survives from tier selection through to request
+* preprocessing, which is why canonicalization must happen LAST (in the
+* `/v1/messages` identity preflight), after the effort default has already
+* been read off the alias.
+*/
+const MODEL_ALIAS_TABLE = /* @__PURE__ */ new Map([
+	[LUNA_DRIVER_ALIAS_ID, {
+		aliasId: LUNA_DRIVER_ALIAS_ID,
+		realModel: LUNA_REAL_MODEL_ID,
+		absentEffortDefault: "max"
+	}],
+	[LUNA_SCOUT_ALIAS_ID, {
+		aliasId: LUNA_SCOUT_ALIAS_ID,
+		realModel: LUNA_REAL_MODEL_ID,
+		absentEffortDefault: "high"
+	}],
+	[LUNA_IMPLEMENTER_ALIAS_ID, {
+		aliasId: LUNA_IMPLEMENTER_ALIAS_ID,
+		realModel: LUNA_REAL_MODEL_ID,
+		absentEffortDefault: "max"
+	}],
+	[FAST_CRITIC_ALIAS_ID, {
+		aliasId: FAST_CRITIC_ALIAS_ID,
+		realModel: "gemini-3.7-flash",
+		absentEffortDefault: "medium"
+	}],
+	[LUNA_SONNET_ALIAS_ID, {
+		aliasId: LUNA_SONNET_ALIAS_ID,
+		realModel: LUNA_REAL_MODEL_ID,
+		absentEffortDefault: "xhigh"
+	}],
+	[LUNA_HAIKU_ALIAS_ID, {
+		aliasId: LUNA_HAIKU_ALIAS_ID,
+		realModel: LUNA_REAL_MODEL_ID,
+		absentEffortDefault: "high"
+	}]
+]);
+/**
+* Look up the alias descriptor for a wire-facing model id (with or without
+* a trailing `[1m]` bracket — the bracket is stripped before the table
+* lookup and is orthogonal to alias identity). Returns undefined for any
+* id that isn't one of the registered aliases (including bare `claude-*`
+* ids and every other real Copilot catalog id).
+*/
+function resolveModelAlias(id) {
+	const { base } = stripTrailingOneMSuffix(id);
+	return MODEL_ALIAS_TABLE.get(base);
+}
+/**
+* Strip alias provenance and return the real catalog id to send upstream.
+* Idempotent passthrough for any id that isn't a registered alias (a bare
+* `claude-*` slug, an already-real Copilot id, or anything else) — this is
+* safe to call unconditionally on every `body.model` at the outbound
+* boundary. Preserves a trailing `[1m]` bracket: canonicalization only
+* erases ALIAS identity, not the 1M-context accounting decoration.
+*/
+function canonicalizeAliasModel(id) {
+	const { base, hadSuffix } = stripTrailingOneMSuffix(id);
+	const alias = MODEL_ALIAS_TABLE.get(base);
+	if (!alias) return normalizeTrailingOneMSuffix(id);
+	return hadSuffix ? `${alias.realModel}[1m]` : alias.realModel;
+}
+const FAST_REQUIRED_CONTEXT_TOKENS = 1e6;
+function findModel(catalog, id) {
+	return catalog?.data?.find((m) => m.id === id);
+}
+function hasToolCalls(model) {
+	return model?.capabilities?.supports?.tool_calls === true;
+}
+function hasContextAtLeast(model, tokens) {
+	return (model?.capabilities?.limits?.max_context_window_tokens ?? 0) >= tokens;
+}
+function supportsEffort(model, effort) {
+	const list = model?.capabilities?.supports?.reasoning_effort;
+	return Array.isArray(list) && list.includes(effort);
+}
+const FAST_REVIEWER_MIN_PROMPT_TOKENS = 2e5;
+function supportsEndpoint(model, endpoint) {
+	return model !== void 0 && fastEndpointForModel(model) === endpoint;
+}
+function hasUsablePromptMetadata(model) {
+	const prompt = model?.capabilities?.limits?.max_prompt_tokens;
+	return typeof prompt === "number" && Number.isFinite(prompt) && prompt > 0;
+}
+function hasPromptAtLeast(model, tokens) {
+	const prompt = model?.capabilities?.limits?.max_prompt_tokens;
+	return typeof prompt === "number" && Number.isFinite(prompt) && prompt >= tokens;
+}
+/**
+* Validate the live Copilot catalog carries every model the fast profile's
+* EXACT roster depends on, with the specific capabilities each assignment
+* needs. These are capability-availability PREREQUISITES for constructing
+* the roster — not an allowlist of models the user may select later in the
+* session — so a partial catalog fails the whole `-m fast` launch rather
+* than silently substituting or dropping an agent.
+*
+* Checks, per the fast-launch-profile design:
+*   - Luna lead/scout/implementer: tool calls, >=1M, high+max, Responses.
+*   - Sol planner: tool calls, >=1M, high, Responses.
+*   - Grok reviewer: tool calls, medium, Responses, usable prompt metadata.
+*   - Gemini Advisor: >=1M, high, chat-completions.
+*   - Gemini critic: tool calls, >=1M, medium, chat-completions.
+*   - Opus Oracle: exact Opus 5, >=1M, adaptive/high, Messages, prompt metadata.
+*
+* Pure over the passed-in catalog snapshot so it's unit-testable without
+* `state` — callers pass `state.models` at call time.
+*/
+function validateFastProfilePrerequisites(catalog) {
+	const missing = [];
+	const luna = findModel(catalog, LUNA_REAL_MODEL_ID);
+	if (!luna) missing.push(`${LUNA_REAL_MODEL_ID}: absent from the live catalog`);
+	else {
+		if (!hasToolCalls(luna)) missing.push(`${LUNA_REAL_MODEL_ID}: does not advertise tool_calls`);
+		if (!hasContextAtLeast(luna, FAST_REQUIRED_CONTEXT_TOKENS)) missing.push(`${LUNA_REAL_MODEL_ID}: advertised context window is below 1M`);
+		if (!supportsEffort(luna, "high") || !supportsEffort(luna, "max")) missing.push(`${LUNA_REAL_MODEL_ID}: does not advertise both "high" and "max" reasoning effort`);
+		if (!supportsEndpoint(luna, "responses")) missing.push(`${LUNA_REAL_MODEL_ID}: does not advertise a supported Responses endpoint`);
+	}
+	const sol = findModel(catalog, "gpt-5.6-sol");
+	if (!sol) missing.push("gpt-5.6-sol: absent from the live catalog");
+	else {
+		if (!hasToolCalls(sol)) missing.push("gpt-5.6-sol: does not advertise tool_calls");
+		if (!hasContextAtLeast(sol, FAST_REQUIRED_CONTEXT_TOKENS)) missing.push("gpt-5.6-sol: advertised context window is below 1M");
+		if (!supportsEffort(sol, "high")) missing.push("gpt-5.6-sol: does not advertise a \"high\" reasoning effort");
+		if (!supportsEndpoint(sol, "responses")) missing.push("gpt-5.6-sol: does not advertise a supported Responses endpoint");
+	}
+	const grok = findModel(catalog, "grok-4.6");
+	if (!grok) missing.push("grok-4.6: absent from the live catalog");
+	else {
+		if (!hasToolCalls(grok)) missing.push("grok-4.6: does not advertise tool_calls");
+		if (!supportsEffort(grok, "medium")) missing.push("grok-4.6: does not advertise a \"medium\" reasoning effort");
+		if (!hasPromptAtLeast(grok, 2e5)) missing.push(`grok-4.6: advertised max_prompt_tokens is below ${FAST_REVIEWER_MIN_PROMPT_TOKENS}`);
+		if (!supportsEndpoint(grok, "responses")) missing.push("grok-4.6: does not advertise a supported Responses endpoint");
+	}
+	const gemini = findModel(catalog, "gemini-3.7-flash");
+	if (!gemini) missing.push("gemini-3.7-flash: absent from the live catalog");
+	else {
+		if (!hasToolCalls(gemini)) missing.push("gemini-3.7-flash: does not advertise tool_calls for the native critic");
+		if (!hasContextAtLeast(gemini, FAST_REQUIRED_CONTEXT_TOKENS)) missing.push("gemini-3.7-flash: advertised context window is below 1M");
+		if (!supportsEffort(gemini, "high")) missing.push("gemini-3.7-flash: does not advertise a \"high\" reasoning effort for Advisor");
+		if (!supportsEffort(gemini, "medium")) missing.push("gemini-3.7-flash: does not advertise a \"medium\" reasoning effort for the native critic");
+		if (!supportsEndpoint(gemini, "chat")) missing.push("gemini-3.7-flash: does not advertise a supported chat-completions endpoint");
+	}
+	const opus = findModel(catalog, "claude-opus-5");
+	if (!opus) missing.push("claude-opus-5: absent from the live catalog");
+	else {
+		if (!hasContextAtLeast(opus, FAST_REQUIRED_CONTEXT_TOKENS)) missing.push("claude-opus-5: advertised context window is below 1M");
+		if (!supportsEffort(opus, "high")) missing.push("claude-opus-5: does not advertise a \"high\" reasoning effort");
+		if (opus.capabilities?.supports?.adaptive_thinking !== true) missing.push("claude-opus-5: does not advertise adaptive_thinking");
+		if (!hasUsablePromptMetadata(opus)) missing.push("claude-opus-5: no usable max_prompt_tokens metadata");
+		if (!supportsEndpoint(opus, "messages")) missing.push("claude-opus-5: does not advertise a supported Messages endpoint");
+	}
+	return {
+		ok: missing.length === 0,
+		missing
+	};
+}
+/**
+* Format `validateFastProfilePrerequisites`'s failure list into the launch
+* error message: every missing/invalid model, plus the rollback command.
+*/
+function formatFastPrerequisiteFailure(missing) {
+	return "github-router claude -m fast requires the following live-catalog capabilities, which this account's catalog does not fully provide:\n" + missing.map((m) => `  - ${m}`).join("\n") + "\n\nFalling back or silently dropping an agent is not supported for the fast profile's exact roster. Run plain `github-router claude` instead.";
+}
+//#endregion
 //#region src/lib/mcp-capabilities.ts
 /**
 * Capability-gate predicates for the proxy's MCP tool surface.
@@ -27707,22 +28011,30 @@ const FAST_IMPLEMENTER_MODEL = "gpt-5.6-luna";
 *  and is gated by max_prompt_tokens rather than the 1M floor. */
 const FAST_REVIEWER_MODEL = "grok-4.6";
 const FAST_PLANNER_MODEL = "gpt-5.6-sol";
+const FAST_CRITIC_MODEL = "gemini-3.7-flash";
 const FAST_ORACLE_MODEL = "claude-opus-5";
 /** Fixed effort pins for the fast profile. */
 const FAST_SCOUT_EFFORT = "high";
 const FAST_REVIEWER_EFFORT = "medium";
 const FAST_PLANNER_EFFORT = "high";
+const FAST_CRITIC_EFFORT = "medium";
 function fastScoutModel() {
-	return firstPresentInCatalog([FAST_SCOUT_MODEL], {
+	const id = firstPresentInCatalog([FAST_SCOUT_MODEL], {
 		requireToolCalls: true,
 		minContextTokens: ONE_M_TOKENS
 	});
+	if (!id) return void 0;
+	const found = state.models?.data.find((m) => m.id === id);
+	return found && fastEndpointForModel(found) === "responses" ? id : void 0;
 }
 function fastImplementerModel() {
-	return firstPresentInCatalog([FAST_IMPLEMENTER_MODEL], {
+	const id = firstPresentInCatalog([FAST_IMPLEMENTER_MODEL], {
 		requireToolCalls: true,
 		minContextTokens: ONE_M_TOKENS
 	});
+	if (!id) return void 0;
+	const found = state.models?.data.find((m) => m.id === id);
+	return found && fastEndpointForModel(found) === "responses" ? id : void 0;
 }
 function fastPlannerModel() {
 	const id = firstPresentInCatalog([FAST_PLANNER_MODEL], {
@@ -27733,7 +28045,7 @@ function fastPlannerModel() {
 	const found = state.models?.data.find((m) => m.id === id);
 	const efforts = found?.capabilities?.supports?.reasoning_effort;
 	if (!Array.isArray(efforts) || !efforts.includes("high")) return void 0;
-	if (pickEndpoint(found) !== "responses") return void 0;
+	if (!found || fastEndpointForModel(found) !== "responses") return void 0;
 	return id;
 }
 /** Gate Grok on the prompt limit that actually constrains pasted review input. */
@@ -27746,9 +28058,21 @@ function fastReviewerModel() {
 	const efforts = found.capabilities?.supports?.reasoning_effort;
 	if (!Array.isArray(efforts) || !efforts.includes("medium")) return void 0;
 	if ((found.capabilities?.limits?.max_prompt_tokens ?? 0) < 2e5) return void 0;
-	if (pickEndpoint(found) !== "responses") return void 0;
+	if (fastEndpointForModel(found) !== "responses") return void 0;
 	return FAST_REVIEWER_MODEL;
 }
+/** Exact Gemini 3.7 Flash only: the fast native critic has no fallback.
+* Unlike the fast Advisor, it needs tool calls and a medium effort choice. */
+function fastCriticModel() {
+	const found = state.models?.data.find((m) => m.id === FAST_CRITIC_MODEL);
+	if (!found) return void 0;
+	if (found.capabilities?.supports?.tool_calls !== true) return void 0;
+	if ((found.capabilities?.limits?.max_context_window_tokens ?? 0) < 1e6) return void 0;
+	const efforts = found.capabilities?.supports?.reasoning_effort;
+	if (!Array.isArray(efforts) || !efforts.includes("medium")) return void 0;
+	if (fastEndpointForModel(found) !== "chat") return void 0;
+	return FAST_CRITIC_MODEL;
+}
 /** Exact Opus 5 only: the fast Oracle never inherits standard opus_critic's
 *  older-family fallback. */
 function fastOracleModel() {
@@ -27759,7 +28083,7 @@ function fastOracleModel() {
 	const efforts = found.capabilities?.supports?.reasoning_effort;
 	if (!Array.isArray(efforts) || !efforts.includes("high")) return void 0;
 	if (found.capabilities?.supports?.adaptive_thinking !== true) return void 0;
-	if (!(found.supported_endpoints ?? []).some((endpoint) => endpoint === "/messages" || endpoint === "/v1/messages")) return void 0;
+	if (fastEndpointForModel(found) !== "messages") return void 0;
 	return FAST_ORACLE_MODEL;
 }
 /**
@@ -29602,31 +29926,16 @@ const ADVISOR_MIN_EFFORT = "high";
 *  the decorrelation instrument and are untouched. `GH_ROUTER_ADVISOR_MODEL`
 *  keeps a cross-lab advisor one env var away for anyone who wants it back. */
 const ADVISOR_ESCALATION_MODEL = "claude-opus-5";
-/** The Advisor model for the fast Luna profile. Gemini 3.7 Flash is a
-*  different lab from BOTH the Luna lead (OpenAI) and the fast profile's
-*  `gemini-critic` persona shares this same model — see
-*  `docs/default-models.md` "Fast launch profile" for the roster this
-*  belongs to. Kept distinct from `ADVISOR_DEFAULT_MODEL` so the two never
-*  have to agree; `resolveAdvisorModel` picks between them purely on lead
-*  identity, never model availability heuristics beyond a live-catalog
-*  presence check (mirrors `shouldEscalateAdvisor`'s pattern). */
+/** The Advisor model for an authenticated fast primary lead. Gemini 3.7 Flash
+* is cross-lab from the OpenAI-backed Luna/Sol leads and is selected only when
+* its live catalog entry advertises the required Chat endpoint. Kept distinct
+* from `ADVISOR_DEFAULT_MODEL` so standard launches remain unchanged. */
 const ADVISOR_FAST_PROFILE_MODEL = "gemini-3.7-flash";
-/**
-* True when `leadModel` names the fast-profile Luna lead (bare, or with the
-* `[1m]` context decoration `withOneMSuffixForLead` applies to it).
-*/
-function isFastProfileLead(leadModel) {
-	if (!leadModel) return false;
-	const bare = leadModel.replace(/\[1m\]$/, "").trim();
-	const lastSegment = bare.slice(bare.lastIndexOf("/") + 1);
-	return bare === "gpt-5.6-luna" || lastSegment === "gpt-5.6-luna";
-}
-/** True when the live catalog actually carries `ADVISOR_FAST_PROFILE_MODEL`.
-*  Mirrors `shouldEscalateAdvisor`'s catalog probe: never advertise a model
-*  the account cannot reach, and fall back to the cross-lab default instead
-*  of a hard failure when it's absent. */
+/** True only when the live Gemini entry satisfies the fixed fast transport.
+* An ID-only presence check is insufficient: selecting a model whose catalog
+* row lost Chat support would silently degrade every fast Advisor call. */
 function fastProfileAdvisorAvailable() {
-	return state.models?.data?.some((m) => m.id === "gemini-3.7-flash") ?? false;
+	return fastEndpointForCatalogId(ADVISOR_FAST_PROFILE_MODEL, state.models?.data) === "chat";
 }
 /** Output cap for the Anthropic-branch advisor call when the catalog carries no
 *  limits for the resolved model. The value the branch used unconditionally
@@ -29673,10 +29982,18 @@ function advisorUsesResponses(resolvedAdvisorModel) {
 * chat, mirroring `pickEndpoint`'s "omits supported_endpoints => chat-eligible"
 * convention — the same convention `classifyMessagesRoute` relies on for a
 * lead model, applied here to the advisor's OWN model instead.
+*
+* The authenticated fast Advisor passes `fastProfile:true`, which uses the same
+* fixed endpoint policy as its lead/agent roster. Standard calls leave this
+* false and retain the historical catalog/name behavior.
 */
-function advisorTransport(resolvedAdvisorModel) {
+function advisorTransport(resolvedAdvisorModel, fastProfile = false) {
 	const bare = resolvedAdvisorModel.slice(resolvedAdvisorModel.lastIndexOf("/") + 1);
 	const entry = state.models?.data?.find((m) => m.id === resolvedAdvisorModel || m.id === bare);
+	if (fastProfile && entry) {
+		const fixed = fastEndpointForModel(entry);
+		if (fixed === "messages" || fixed === "responses" || fixed === "chat") return fixed;
+	}
 	if (isClaudeModel(resolvedAdvisorModel, entry)) return "messages";
 	if (advisorUsesResponses(resolvedAdvisorModel)) return "responses";
 	return "chat";
@@ -29707,29 +30024,20 @@ function shouldEscalateAdvisor(leadModel) {
 	return state.models?.data?.some((m) => m.id === "claude-opus-5") ?? false;
 }
 /**
-* Pick the advisor model for one request from the LEAD model that request is
-* running on.
-*
-* Resolved per request rather than at launch because the lead changes
-* mid-session via the `/model` picker; launch-time env plumbing would pin the
-* advisor to whatever was selected at spawn.
+* Pick the Advisor model for one request. Standard selection follows the
+* current lead so a `/model` switch can change budget escalation; authenticated
+* fast selection follows launch identity instead, so changing among the fixed
+* fast lead models never removes Gemini Advisor.
 *
 * Precedence:
-*   1. `GH_ROUTER_ADVISOR_MODEL` (trimmed) — the operator pin, checked first so
-*      it works on every lead.
-*   2. An authenticated fast launch whose current lead is Luna, with
-*      `ADVISOR_FAST_PROFILE_MODEL` present in the live catalog.
-*   3. A lighter Claude lead with the escalation model in the catalog.
-*   4. `ADVISOR_DEFAULT_MODEL`.
-*
-* Steps 2 and 3 are mutually exclusive lead families (non-Claude Luna vs. a
-* lighter Claude tier) so their relative order does not matter functionally;
-* fast-profile is checked first only because it is the more specific match.
+*   1. `GH_ROUTER_ADVISOR_MODEL` (trimmed), on every launch and lead.
+*   2. Authenticated fast primary lead, when Gemini advertises the required
+*      Chat endpoint.
+*   3. Standard lighter Claude lead with Opus escalation available.
+*   4. The literal `ADVISOR_DEFAULT_MODEL`.
 *
-* Step 4 returns the LITERAL constant rather than walking the OpenAI frontier
-* chain. An Opus lead must resolve to exactly what it resolves to today, and a
-* frontier walk could yield `gpt-5.5` on a catalog missing `gpt-5.6-sol` —
-* a silent change to the one path that is required not to move.
+* Step 4 deliberately does not walk the OpenAI frontier chain. That would
+* silently change the standard Opus-lead path when Sol is absent.
 */
 /**
 * Map an operator pin onto the id the catalog actually carries.
@@ -29762,7 +30070,7 @@ function resolveAdvisorModel(leadModel, fastProfile = false) {
 		escalated: false,
 		fastProfile: false
 	};
-	if (fastProfile && leadModel && isFastProfileLead(leadModel) && fastProfileAdvisorAvailable()) return {
+	if (fastProfile && fastProfileAdvisorAvailable()) return {
 		model: ADVISOR_FAST_PROFILE_MODEL,
 		escalated: false,
 		fastProfile: true
@@ -29842,7 +30150,7 @@ Give the advice serious weight. If you follow a step and it fails empirically, o
 If you've already retrieved data pointing one way and the advisor points another: don't silently switch. Surface the conflict in one more advisor call -- "I found X, you suggest Y, which constraint breaks the tie?" The advisor saw your evidence but may have underweighted it; a reconcile call is cheaper than committing to the wrong branch.`;
 /** Fast-profile lead-only policy. Unlike the standard Claude Code instructions
 * above, this makes consultation optional and leaves decision ownership with
-* the Luna lead. Fast Task subagents never receive an advisor tool at all. */
+* the authenticated fast primary lead. Fast Task subagents never receive an advisor tool at all. */
 const FAST_ADVISOR_TOOL_INSTRUCTIONS = `# Advisor Tool
 
 You have access to an optional, transcript-aware \`advisor\` tool. It takes no parameters and returns non-binding consultation. You remain responsible for every decision.
@@ -30065,7 +30373,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 		maxUnits = ADVISOR_MAX_CONVERSATION_CHARS;
 	}
 	const conversationText = renderConversationAsText(conversation, maxUnits, measure);
-	const transport = advisorTransport(resolvedAdvisorModel);
+	const transport = advisorTransport(resolvedAdvisorModel, fastProfile);
 	if (transport === "responses") {
 		const payload = applyResponsesCachePolicy({
 			model: resolvedAdvisorModel,
@@ -30157,7 +30465,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 *   1. A real Anthropic `toolu_*` id whose suffix is already in the
 *      `^[a-zA-Z0-9_]+$` charset: `srvtoolu_<suffix>`, byte-for-byte
 *      identical to the historical (Claude-lead) behavior.
-*   2. Anything else — a Responses `call_*` id (the fast Luna profile's
+*   2. Anything else — a Responses `call_*` id (an authenticated fast lead's
 *      lead, once its `tool_use{__anthropic_advisor}` block is synthesized
 *      by the anthropic-translate shim from a Copilot `/responses` tool
 *      call), a hyphenated or otherwise non-conforming id, an empty string,
@@ -30180,7 +30488,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 * Historically this threw "advisor tool_use id is not round-trippable" for
 * any non-`toolu_` shape. That was correct for a Claude-only advisor lead —
 * Copilot's native `/v1/messages` never emits anything else — but became a
-* live defect once the advisor loop could run on a non-Claude (Luna) lead
+* live defect once the advisor loop could run on a non-Claude fast lead
 * shimmed through `/responses`: `responses-egress.ts` forwards a Responses
 * `call_*` id VERBATIM as the synthesized `tool_use.id` (see
 * `makeToolUseId` — it only synthesizes a `toolu_*` id when the upstream id
@@ -30210,7 +30518,7 @@ function sseEvent(type, data) {
 * passthrough (`createMessages`) plus signed-thinking-history repair-and-retry.
 * Extracted verbatim from the loop body so the behavior is byte-identical to
 * before `continueTurn` became injectable, and so a non-Claude
-* `continueTurn` (the fast Luna profile's shim-backed one) can omit this
+* `continueTurn` (the fast profile's shim-backed one) can omit this
 * Claude-only repair path entirely rather than inherit dead code that would
 * never fire for it.
 */
@@ -35575,7 +35883,8 @@ function buildPeerAwarenessSnippet(opts) {
 			"",
 			`This is the fast launch profile. Advisor is an optional, non-binding, lead-only transcript-aware sounding board for consequential unresolved uncertainty or a genuinely stuck path, not routine progress, waiting, verification, approval, or completion. \`mcp__${fastPeersKey}__oracle\` is exact Opus 5 (1M/high), a stateless last-resort consultant available to the lead, reviewer, and planner.`,
 			"",
-			`\`mcp__${fastSearchKey}__code\` is semantic-first code search and \`mcp__${fastSearchKey}__web\` surfaces citable sources. Native Task roster: \`scout\` (broad discovery), \`implementer\` (mechanical implementation), \`reviewer\` (repo-aware verification/reproduction), and \`planner\` (Sol plan consultant/approver after Luna's draft). Before implementation obtain planner approval; before declaring done run relevant tests and ask reviewer to verify.${opts.browseAvailable ? ` \`mcp__${key("browser")}__*\` is the opt-in browser surface.` : ""}`
+			`\`mcp__${fastSearchKey}__code\` is semantic-first code search and \`mcp__${fastSearchKey}__web\` surfaces citable sources. Native Task roster: \`scout\` (broad discovery), \`implementer\` (mechanical implementation), \`reviewer\` (repo-aware verification/reproduction), \`planner\` (Sol plan consultant/approver after Luna's draft), and \`critic\` (fresh-context cross-lab review). Before implementation obtain planner approval; before declaring done run relevant tests and ask reviewer to verify.${opts.browseAvailable ? ` \`mcp__${key("browser")}__*\` is the opt-in browser surface.` : ""}`,
+			"Native delegation is ACL-scoped: the lead may invoke all five; planner may invoke reviewer, scout, and critic; implementer may invoke reviewer and critic; reviewer, scout, and critic cannot invoke native subagents."
 		].join("\n");
 	}
 	const peersKey = key("peers");
@@ -35634,7 +35943,8 @@ function buildPeerAwarenessSummary(opts) {
 	if (opts.profile === "fast") return [
 		"## Injected capabilities (summary)",
 		"",
-		"Fast launch profile. Task roster: `scout`, `implementer`, `reviewer`, `planner`. Luna investigates and drafts; `planner` must approve before implementation. Before declaring done, run relevant tests and ask `reviewer` to verify.",
+		"Fast launch profile. Task roster: `scout`, `implementer`, `reviewer`, `planner`, `critic`. Luna investigates and drafts; `planner` must approve before implementation. Before declaring done, run relevant tests and ask `reviewer` to verify.",
+		"Native delegation is ACL-scoped: the lead may invoke all five; `planner` may invoke `reviewer`, `scout`, and `critic`; `implementer` may invoke `reviewer` and `critic`; `reviewer`, `scout`, and `critic` cannot invoke native subagents.",
 		`Advisor is optional, non-binding, transcript-aware, and lead-only; use it for consequential unresolved uncertainty, not routine progress or workflow gates. \`mcp__${key("peers")}__oracle\` is exact Opus 5 (1M/high), stateless and last resort for the lead, reviewer, and planner. \`mcp__${key("search")}__code\` and \`mcp__${key("search")}__web\` provide search.${opts.browseAvailable ? ` \`mcp__${key("browser")}__*\` provides the opt-in browser.` : ""}`
 	].join("\n");
 	const renderNative = (name) => {
@@ -36908,6 +37218,6 @@ function enumerateInjectedMcpToolNames(groupKeys, opts = {}) {
 	return [...new Set(names)];
 }
 //#endregion
-export { UNKNOWN_EFFORT_ANCHOR as $, provisionTreeSitterAssets as $t, assetFor as A, shimDefaultsToXhigh as At, resolveAdvisorEffort as B, createResponses as Bt, buildEnv as C, withOneMSuffix as Cn, resolveGeminiReviewModel as Ct, toolbeltSkipSet as D, scribeModel as Dt, toolbeltEnabled as E, scoutModel as Et, FAST_ADVISOR_TOOL_INSTRUCTIONS as F, registerLaunch as Ft, repairRejectedThinkingHistory as G, normalizeOpenAIUsage as Gt, formatThinkingRepairDecline as H, MAX_RESPONSE_BODY_BYTES as Ht, buildAdvisorStream as I, unregisterLaunch as It, isControllerClosedError as J, colbertDegradedWarning as Jt, buildAnthropicErrorEvent as K, provisionBrowserAssets as Kt, injectAdvisorTool as L, assembleResponsesPayload as Lt, searchWeb as M, createMessages as Mt, ADVISOR_INTERNAL_TOOL_NAME as N, getTokenCount as Nt, vscodeRipgrepPath as O, standInToolEnabled as Ot, ADVISOR_TOOL_INSTRUCTIONS as P, findLaunchBySecret as Pt, EFFORT_ORDER as Q, warmTreeSitterPool as Qt, isAdvisorRequested as R, warnOnTokenPriceDrift as Rt, runWorkerAgent as S, oneMContextDisabled as Sn, nativeSubagentModel as St, buildToolbeltAwareness as T, withInstallLock as Tn, reviewerModel as Tt, rememberThinkingHistoryRepair as U, readResponseBodyCapped as Ut, resolveAdvisorModel as V, createChatCompletions as Vt, repairKnownThinkingHistory as W, parseJsonOrDiagnose as Wt, readIteratorWithTimeout as X, extractTarGzMember as Xt, logStreamError as Y, provisionAndIndexColbert as Yt, relayAnthropicStream as Z, extractZipMember as Zt, TEST_DEFAULT_MODEL as _, upstreamAllowH2 as _n, fastScoutModel as _t, buildAgentPrompt as a, BUDGET_SMALL_FAST_CATALOG_ID as an, FAST_REVIEWER_EFFORT as at, resolveModeDefaults as b, pickEndpoint as bn, generalPurposeFastModel as bt, enumerateInjectedMcpToolNames as c, DEFAULT_CODEX_MODEL as cn, artifactToolsEnabled as ct, DEFAULT_MODEL_CHAIN as d, UPSTREAM_FETCH_TIMEOUT_MS as dn, browserCompoundToolsEnabled as dt, CONDENSED_OPERATING_SEQUENCE as en, bucketEffort as et, EXPLORE_DEFAULT_MODEL as f, UPSTREAM_INACTIVITY_TIMEOUT_MS as fn, browserToolsEnabled as ft, REVIEW_DEFAULT_MODEL as g, resolveLeadSlugArg as gn, fastReviewerModel as gt, PLAN_DEFAULT_MODEL as h, pickClaudeDefault as hn, fastPlannerModel as ht, assertMcpToolSurfaceConsistent as i, toolbeltPathOverride as in, FAST_PLANNER_EFFORT as it, satisfiesMinVersion as j, countTokens as jt, TOOLBELT_TOOLS$1 as k, workerToolsEnabled as kt, personasFor as l, DEFAULT_CODEX_MODEL_FALLBACKS as ln, brainstormModel as lt, IMPLEMENT_DEFAULT_MODEL as m, isBudgetClaudeLead as mn, fastOracleModel as mt, MCP_GROUPS as n, shouldUseInsecureTls as nn, handleMcpDelete as nt, buildPeerAwarenessSnippet as o, BUDGET_SMALL_FAST_SLUG as on, FAST_SCOUT_EFFORT as ot, EXPLORE_DEFAULT_THINKING as p, generateRandomPort as pn, fastImplementerModel as pt, buildOpenAIErrorEvent as q, hasSupportedBrowserInstalled as qt, agentNamesForToolAllowlist as r, collapsePathKeys as rn, handleMcpPost as rt, buildPeerAwarenessSummary as s, DEFAULT_CLAUDE_MODEL_FALLBACKS as sn, agentToolsEnabled as st, GROUP_META as t, DEFINITION_OF_GREATNESS as tn, clampEffort as tt, BROWSE_DEFAULT_MODEL as u, DEFAULT_PORT as un, browseAgentEnabled as ut, appendPlanReminder as v, upstreamMaxConnections as vn, fleetToolsEnabled as vt, availableToolCommands as w, withOneMSuffixForLead as wn, reviewerFastModel as wt, resolveWorkerRunOpts as x, catalogAdvertises1M as xn, implementerFastModel as xt, resolveDefaultModel as y, classifyMessagesRoute as yn, geminiAvailable as yt, isFastProfileLead as z, resolveMcpToolTimeoutMs as zt };
+export { bucketEffort as $, assembleResponsesPayload as $t, assetFor as A, isBudgetClaudeLead as An, workerToolsEnabled as At, resolveAdvisorModel as B, stripTrailingOneMSuffix as Bn, profileDescriptor as Bt, buildEnv as C, DEFAULT_CLAUDE_MODEL_FALLBACKS as Cn, nativeSubagentModel as Ct, toolbeltSkipSet as D, UPSTREAM_FETCH_TIMEOUT_MS as Dn, scoutModel as Dt, toolbeltEnabled as E, DEFAULT_PORT as En, reviewerModel as Et, FAST_ADVISOR_TOOL_INSTRUCTIONS as F, classifyMessagesRoute as Fn, LUNA_REAL_MODEL_ID as Ft, buildAnthropicErrorEvent as G, countTokens as Gt, rememberThinkingHistoryRepair as H, resolveModelAlias as Ht, buildAdvisorStream as I, catalogAdvertises1M as In, LUNA_SCOUT_ALIAS_ID as It, logStreamError as J, getTokenCount as Jt, buildOpenAIErrorEvent as K, createMessages as Kt, injectAdvisorTool as L, oneMContextDisabled as Ln, LUNA_SONNET_ALIAS_ID as Lt, searchWeb as M, resolveLeadSlugArg as Mn, LUNA_DRIVER_ALIAS_ID as Mt, ADVISOR_INTERNAL_TOOL_NAME as N, upstreamAllowH2 as Nn, LUNA_HAIKU_ALIAS_ID as Nt, vscodeRipgrepPath as O, UPSTREAM_INACTIVITY_TIMEOUT_MS as On, scribeModel as Ot, ADVISOR_TOOL_INSTRUCTIONS as P, upstreamMaxConnections as Pn, LUNA_IMPLEMENTER_ALIAS_ID as Pt, UNKNOWN_EFFORT_ANCHOR as Q, unregisterLaunch as Qt, isAdvisorRequested as R, withOneMSuffix as Rn, canonicalizeAliasModel as Rt, runWorkerAgent as S, BUDGET_SMALL_FAST_SLUG as Sn, implementerFastModel as St, buildToolbeltAwareness as T, DEFAULT_CODEX_MODEL_FALLBACKS as Tn, reviewerFastModel as Tt, repairKnownThinkingHistory as U, validateFastProfilePrerequisites as Ut, formatThinkingRepairDecline as V, withInstallLock as Vn, resolveLaunchProfile as Vt, repairRejectedThinkingHistory as W, shimDefaultsToXhigh as Wt, relayAnthropicStream as X, findLaunchBySecret as Xt, readIteratorWithTimeout as Y, getTokenizerFromModel as Yt, EFFORT_ORDER as Z, registerLaunch as Zt, TEST_DEFAULT_MODEL as _, DEFINITION_OF_GREATNESS as _n, fastReviewerModel as _t, buildAgentPrompt as a, readResponseBodyCapped as an, FAST_REVIEWER_EFFORT as at, resolveModeDefaults as b, toolbeltPathOverride as bn, geminiAvailable as bt, enumerateInjectedMcpToolNames as c, provisionBrowserAssets as cn, artifactToolsEnabled as ct, DEFAULT_MODEL_CHAIN as d, provisionAndIndexColbert as dn, browserCompoundToolsEnabled as dt, warnOnTokenPriceDrift as en, clampEffort as et, EXPLORE_DEFAULT_MODEL as f, extractTarGzMember as fn, browserToolsEnabled as ft, REVIEW_DEFAULT_MODEL as g, CONDENSED_OPERATING_SEQUENCE as gn, fastPlannerModel as gt, PLAN_DEFAULT_MODEL as h, provisionTreeSitterAssets as hn, fastOracleModel as ht, assertMcpToolSurfaceConsistent as i, MAX_RESPONSE_BODY_BYTES as in, FAST_PLANNER_EFFORT as it, satisfiesMinVersion as j, pickClaudeDefault as jn, FAST_CRITIC_ALIAS_ID as jt, TOOLBELT_TOOLS$1 as k, generateRandomPort as kn, standInToolEnabled as kt, personasFor as l, hasSupportedBrowserInstalled as ln, brainstormModel as lt, IMPLEMENT_DEFAULT_MODEL as m, warmTreeSitterPool as mn, fastImplementerModel as mt, MCP_GROUPS as n, createResponses as nn, handleMcpPost as nt, buildPeerAwarenessSnippet as o, parseJsonOrDiagnose as on, FAST_SCOUT_EFFORT as ot, EXPLORE_DEFAULT_THINKING as p, extractZipMember as pn, fastCriticModel as pt, isControllerClosedError as q, getTextTokenCount as qt, agentNamesForToolAllowlist as r, createChatCompletions as rn, FAST_CRITIC_EFFORT as rt, buildPeerAwarenessSummary as s, normalizeOpenAIUsage as sn, agentToolsEnabled as st, GROUP_META as t, resolveMcpToolTimeoutMs as tn, handleMcpDelete as tt, BROWSE_DEFAULT_MODEL as u, colbertDegradedWarning as un, browseAgentEnabled as ut, appendPlanReminder as v, shouldUseInsecureTls as vn, fastScoutModel as vt, availableToolCommands as w, DEFAULT_CODEX_MODEL as wn, resolveGeminiReviewModel as wt, resolveWorkerRunOpts as x, BUDGET_SMALL_FAST_CATALOG_ID as xn, generalPurposeFastModel as xt, resolveDefaultModel as y, collapsePathKeys as yn, fleetToolsEnabled as yt, resolveAdvisorEffort as z, withOneMSuffixForLead as zn, formatFastPrerequisiteFailure as zt };
 
-//# sourceMappingURL=peer-mcp-personas-DhI7ZPSx.js.map
+//# sourceMappingURL=peer-mcp-personas-BwNtC8jt.js.map