github-router 0.3.293 → 0.3.297

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

@@ -1,14 +1,15 @@
 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 { a as FAST_PROFILE_MODELS, c as FAST_PROFILE_NATIVE_MODELS, l as FAST_PROFILE_ORACLE_EFFORT, n as FAST_PROFILE_ADVISOR_EFFORT, o as FAST_PROFILE_NATIVE_AGENT_NAMES, r as FAST_PROFILE_ADVISOR_MODEL, s as FAST_PROFILE_NATIVE_EFFORTS, u as FAST_PROFILE_ORACLE_MODEL } from "./fast-profile-contract-K3P58nj3.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 +97,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 +180,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 +229,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 +428,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,13 +515,13 @@ 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
 * two can never disagree about which launches count as "fast".
 */
-const FAST_LEAD_MODEL = "gpt-5.6-luna";
+const FAST_LEAD_MODEL = FAST_PROFILE_MODELS.luna;
 /** Small/fast tier for a budget lead, in the two forms this codebase needs.
 *
 *  `SLUG` is the Anthropic-published DASHED form and is what goes into
@@ -18926,7 +18990,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 +27518,241 @@ 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 (`Explore`, `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: new Set(FAST_PROFILE_NATIVE_AGENT_NAMES),
+	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
+*  Explore 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 = FAST_PROFILE_MODELS.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: FAST_PROFILE_MODELS.critic,
+		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/Explore/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, FAST_PROFILE_MODELS.planner);
+	if (!sol) missing.push(`${FAST_PROFILE_MODELS.planner}: absent from the live catalog`);
+	else {
+		if (!hasToolCalls(sol)) missing.push(`${FAST_PROFILE_MODELS.planner}: does not advertise tool_calls`);
+		if (!hasContextAtLeast(sol, FAST_REQUIRED_CONTEXT_TOKENS)) missing.push(`${FAST_PROFILE_MODELS.planner}: advertised context window is below 1M`);
+		if (!supportsEffort(sol, "high")) missing.push(`${FAST_PROFILE_MODELS.planner}: does not advertise a "high" reasoning effort`);
+		if (!supportsEndpoint(sol, "responses")) missing.push(`${FAST_PROFILE_MODELS.planner}: does not advertise a supported Responses endpoint`);
+	}
+	const grok = findModel(catalog, FAST_PROFILE_MODELS.reviewer);
+	if (!grok) missing.push(`${FAST_PROFILE_MODELS.reviewer}: absent from the live catalog`);
+	else {
+		if (!hasToolCalls(grok)) missing.push(`${FAST_PROFILE_MODELS.reviewer}: does not advertise tool_calls`);
+		if (!supportsEffort(grok, "medium")) missing.push(`${FAST_PROFILE_MODELS.reviewer}: does not advertise a "medium" reasoning effort`);
+		if (!hasPromptAtLeast(grok, 2e5)) missing.push(`${FAST_PROFILE_MODELS.reviewer}: advertised max_prompt_tokens is below ${FAST_REVIEWER_MIN_PROMPT_TOKENS}`);
+		if (!supportsEndpoint(grok, "responses")) missing.push(`${FAST_PROFILE_MODELS.reviewer}: does not advertise a supported Responses endpoint`);
+	}
+	const gemini = findModel(catalog, FAST_PROFILE_MODELS.critic);
+	if (!gemini) missing.push(`${FAST_PROFILE_MODELS.critic}: absent from the live catalog`);
+	else {
+		if (!hasToolCalls(gemini)) missing.push(`${FAST_PROFILE_MODELS.critic}: does not advertise tool_calls for the native critic`);
+		if (!hasContextAtLeast(gemini, FAST_REQUIRED_CONTEXT_TOKENS)) missing.push(`${FAST_PROFILE_MODELS.critic}: advertised context window is below 1M`);
+		if (!supportsEffort(gemini, "high")) missing.push(`${FAST_PROFILE_MODELS.critic}: does not advertise a "high" reasoning effort for Advisor`);
+		if (!supportsEffort(gemini, "medium")) missing.push(`${FAST_PROFILE_MODELS.critic}: does not advertise a "medium" reasoning effort for the native critic`);
+		if (!supportsEndpoint(gemini, "chat")) missing.push(`${FAST_PROFILE_MODELS.critic}: does not advertise a supported chat-completions endpoint`);
+	}
+	const opus = findModel(catalog, FAST_PROFILE_MODELS.oracle);
+	if (!opus) missing.push(`${FAST_PROFILE_MODELS.oracle}: absent from the live catalog`);
+	else {
+		if (!hasContextAtLeast(opus, FAST_REQUIRED_CONTEXT_TOKENS)) missing.push(`${FAST_PROFILE_MODELS.oracle}: advertised context window is below 1M`);
+		if (!supportsEffort(opus, "high")) missing.push(`${FAST_PROFILE_MODELS.oracle}: does not advertise a "high" reasoning effort`);
+		if (opus.capabilities?.supports?.adaptive_thinking !== true) missing.push(`${FAST_PROFILE_MODELS.oracle}: does not advertise adaptive_thinking`);
+		if (!hasUsablePromptMetadata(opus)) missing.push(`${FAST_PROFILE_MODELS.oracle}: no usable max_prompt_tokens metadata`);
+		if (!supportsEndpoint(opus, "messages")) missing.push(`${FAST_PROFILE_MODELS.oracle}: 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.
@@ -27701,28 +28000,39 @@ function generalPurposeFastModel() {
 		minContextTokens: ONE_M_TOKENS
 	});
 }
-const FAST_SCOUT_MODEL = "gpt-5.6-luna";
-const FAST_IMPLEMENTER_MODEL = "gpt-5.6-luna";
+/** @deprecated Fast `scout` was renamed to capitalized `Explore`. */
+const FAST_SCOUT_MODEL = FAST_PROFILE_NATIVE_MODELS.Explore;
+const FAST_IMPLEMENTER_MODEL = FAST_PROFILE_NATIVE_MODELS.implementer;
 /** Grok 4.6 advertises 500K total context / 372K max prompt, so it remains bare
 *  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_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_REVIEWER_MODEL = FAST_PROFILE_NATIVE_MODELS.reviewer;
+const FAST_PLANNER_MODEL = FAST_PROFILE_NATIVE_MODELS.planner;
+const FAST_CRITIC_MODEL = FAST_PROFILE_NATIVE_MODELS.critic;
+const FAST_ORACLE_MODEL = FAST_PROFILE_ORACLE_MODEL;
+/** @deprecated Fast `scout` was renamed to capitalized `Explore`. */
+const FAST_SCOUT_EFFORT = FAST_PROFILE_NATIVE_EFFORTS.Explore;
+const FAST_IMPLEMENTER_EFFORT = FAST_PROFILE_NATIVE_EFFORTS.implementer;
+const FAST_REVIEWER_EFFORT = FAST_PROFILE_NATIVE_EFFORTS.reviewer;
+const FAST_PLANNER_EFFORT = FAST_PROFILE_NATIVE_EFFORTS.planner;
+const FAST_CRITIC_EFFORT = FAST_PROFILE_NATIVE_EFFORTS.critic;
+const FAST_ORACLE_EFFORT = FAST_PROFILE_ORACLE_EFFORT;
 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], {
@@ -27732,8 +28042,8 @@ function fastPlannerModel() {
 	if (!id) return void 0;
 	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 (!Array.isArray(efforts) || !efforts.includes(FAST_PLANNER_EFFORT)) 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. */
@@ -27744,11 +28054,23 @@ function fastReviewerModel() {
 	if (!found) return void 0;
 	if (found.capabilities?.supports?.tool_calls !== true) return void 0;
 	const efforts = found.capabilities?.supports?.reasoning_effort;
-	if (!Array.isArray(efforts) || !efforts.includes("medium")) return void 0;
+	if (!Array.isArray(efforts) || !efforts.includes(FAST_REVIEWER_EFFORT)) 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(FAST_CRITIC_EFFORT)) 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() {
@@ -27757,9 +28079,9 @@ function fastOracleModel() {
 	if ((found.capabilities?.limits?.max_context_window_tokens ?? 0) < 1e6) return void 0;
 	if ((found.capabilities?.limits?.max_prompt_tokens ?? 0) <= 0) return void 0;
 	const efforts = found.capabilities?.supports?.reasoning_effort;
-	if (!Array.isArray(efforts) || !efforts.includes("high")) return void 0;
+	if (!Array.isArray(efforts) || !efforts.includes(FAST_ORACLE_EFFORT)) 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 +29924,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). */
-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. */
+/** 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 = FAST_PROFILE_ADVISOR_MODEL;
+/** 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 +29980,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 +30022,19 @@ 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.
+* 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.
 *
-* 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.
+* Fast profile is a separate fixed contract: it requires Gemini's Chat endpoint
+* and ignores standard operator pins. Standard-profile precedence remains:
+*   1. `GH_ROUTER_ADVISOR_MODEL` (trimmed).
+*   2. A lighter Claude lead with Opus escalation available.
+*   3. The literal `ADVISOR_DEFAULT_MODEL`.
 *
-* 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.
-*
-* 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 3 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.
@@ -29756,17 +30061,20 @@ function normalizeAdvisorPin(pinned) {
 	return bare !== pinned && models.some((m) => m.id === bare) ? bare : pinned;
 }
 function resolveAdvisorModel(leadModel, fastProfile = false) {
+	if (fastProfile) {
+		if (!fastProfileAdvisorAvailable()) throw new Error(`fast Advisor invariant failed: ${ADVISOR_FAST_PROFILE_MODEL} must advertise the Chat endpoint`);
+		return {
+			model: ADVISOR_FAST_PROFILE_MODEL,
+			escalated: false,
+			fastProfile: true
+		};
+	}
 	const pinned = process.env.GH_ROUTER_ADVISOR_MODEL?.trim();
 	if (pinned) return {
 		model: normalizeAdvisorPin(pinned),
 		escalated: false,
 		fastProfile: false
 	};
-	if (fastProfile && leadModel && isFastProfileLead(leadModel) && fastProfileAdvisorAvailable()) return {
-		model: ADVISOR_FAST_PROFILE_MODEL,
-		escalated: false,
-		fastProfile: true
-	};
 	if (leadModel && shouldEscalateAdvisor(leadModel)) return {
 		model: ADVISOR_ESCALATION_MODEL,
 		escalated: true,
@@ -29806,7 +30114,7 @@ function resolveAdvisorModel(leadModel, fastProfile = false) {
 * something it accepts.
 */
 function resolveAdvisorEffort(rawRequestBody, advisorModel, fastProfile = false) {
-	let requested = fastProfile ? "high" : ADVISOR_DEFAULT_EFFORT;
+	let requested = fastProfile ? FAST_PROFILE_ADVISOR_EFFORT : ADVISOR_DEFAULT_EFFORT;
 	if (rawRequestBody) try {
 		const body = JSON.parse(rawRequestBody);
 		const oc = body.output_config;
@@ -29815,7 +30123,7 @@ function resolveAdvisorEffort(rawRequestBody, advisorModel, fastProfile = false)
 		if (typeof explicit === "string" && EFFORT_ORDER.includes(explicit)) requested = explicit;
 		else if (thinking && typeof thinking === "object" && thinking.type === "enabled") requested = bucketEffort(thinking.budget_tokens);
 	} catch {}
-	if (fastProfile) requested = "high";
+	if (fastProfile) requested = FAST_PROFILE_ADVISOR_EFFORT;
 	else if (EFFORT_ORDER.indexOf(requested) < EFFORT_ORDER.indexOf(ADVISOR_MIN_EFFORT)) requested = ADVISOR_MIN_EFFORT;
 	const supported = state.models?.data?.find((m) => m.id === resolveModel(advisorModel))?.capabilities?.supports?.reasoning_effort;
 	if (!Array.isArray(supported) || supported.length === 0) return requested;
@@ -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,8 @@ 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 (fastProfile) consola.warn(`fast Advisor dispatch: model=${resolvedAdvisorModel} transport=${transport} effort=${advisorEffort}`);
 	if (transport === "responses") {
 		const payload = applyResponsesCachePolicy({
 			model: resolvedAdvisorModel,
@@ -30157,7 +30466,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 +30489,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 +30519,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 +35884,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: \`Explore\` (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, Explore, and critic; implementer may invoke reviewer and critic; reviewer, Explore, and critic cannot invoke native subagents."
 		].join("\n");
 	}
 	const peersKey = key("peers");
@@ -35634,7 +35944,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: `Explore`, `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`, `Explore`, and `critic`; `implementer` may invoke `reviewer` and `critic`; `reviewer`, `Explore`, 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 +37219,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 $, unregisterLaunch as $t, assetFor as A, generateRandomPort as An, standInToolEnabled as At, resolveAdvisorModel as B, withOneMSuffixForLead as Bn, formatFastPrerequisiteFailure as Bt, buildEnv as C, BUDGET_SMALL_FAST_SLUG as Cn, implementerFastModel as Ct, toolbeltSkipSet as D, DEFAULT_PORT as Dn, reviewerModel as Dt, toolbeltEnabled as E, DEFAULT_CODEX_MODEL_FALLBACKS as En, reviewerFastModel as Et, FAST_ADVISOR_TOOL_INSTRUCTIONS as F, upstreamMaxConnections as Fn, LUNA_IMPLEMENTER_ALIAS_ID as Ft, buildAnthropicErrorEvent as G, shimDefaultsToXhigh as Gt, rememberThinkingHistoryRepair as H, withInstallLock as Hn, resolveLaunchProfile as Ht, buildAdvisorStream as I, classifyMessagesRoute as In, LUNA_REAL_MODEL_ID as It, logStreamError as J, getTextTokenCount as Jt, buildOpenAIErrorEvent as K, countTokens as Kt, injectAdvisorTool as L, catalogAdvertises1M as Ln, LUNA_SCOUT_ALIAS_ID as Lt, searchWeb as M, pickClaudeDefault as Mn, FAST_CRITIC_ALIAS_ID as Mt, ADVISOR_INTERNAL_TOOL_NAME as N, resolveLeadSlugArg as Nn, LUNA_DRIVER_ALIAS_ID as Nt, vscodeRipgrepPath as O, UPSTREAM_FETCH_TIMEOUT_MS as On, scoutModel as Ot, ADVISOR_TOOL_INSTRUCTIONS as P, upstreamAllowH2 as Pn, LUNA_HAIKU_ALIAS_ID as Pt, UNKNOWN_EFFORT_ANCHOR as Q, registerLaunch as Qt, isAdvisorRequested as R, oneMContextDisabled as Rn, LUNA_SONNET_ALIAS_ID as Rt, runWorkerAgent as S, BUDGET_SMALL_FAST_CATALOG_ID as Sn, generalPurposeFastModel as St, buildToolbeltAwareness as T, DEFAULT_CODEX_MODEL as Tn, resolveGeminiReviewModel as Tt, repairKnownThinkingHistory as U, resolveModelAlias as Ut, formatThinkingRepairDecline as V, stripTrailingOneMSuffix as Vn, profileDescriptor as Vt, repairRejectedThinkingHistory as W, validateFastProfilePrerequisites as Wt, relayAnthropicStream as X, getTokenizerFromModel as Xt, readIteratorWithTimeout as Y, getTokenCount as Yt, EFFORT_ORDER as Z, findLaunchBySecret as Zt, TEST_DEFAULT_MODEL as _, CONDENSED_OPERATING_SEQUENCE as _n, fastPlannerModel as _t, buildAgentPrompt as a, MAX_RESPONSE_BODY_BYTES as an, FAST_PLANNER_EFFORT as at, resolveModeDefaults as b, collapsePathKeys as bn, fleetToolsEnabled as bt, enumerateInjectedMcpToolNames as c, normalizeOpenAIUsage as cn, agentToolsEnabled as ct, DEFAULT_MODEL_CHAIN as d, colbertDegradedWarning as dn, browseAgentEnabled as dt, assembleResponsesPayload as en, clampEffort as et, EXPLORE_DEFAULT_MODEL as f, provisionAndIndexColbert as fn, browserCompoundToolsEnabled as ft, REVIEW_DEFAULT_MODEL as g, provisionTreeSitterAssets as gn, fastOracleModel as gt, PLAN_DEFAULT_MODEL as h, warmTreeSitterPool as hn, fastImplementerModel as ht, assertMcpToolSurfaceConsistent as i, createChatCompletions as in, FAST_IMPLEMENTER_EFFORT as it, satisfiesMinVersion as j, isBudgetClaudeLead as jn, workerToolsEnabled as jt, TOOLBELT_TOOLS$1 as k, UPSTREAM_INACTIVITY_TIMEOUT_MS as kn, scribeModel as kt, personasFor as l, provisionBrowserAssets as ln, artifactToolsEnabled as lt, IMPLEMENT_DEFAULT_MODEL as m, extractZipMember as mn, fastCriticModel as mt, MCP_GROUPS as n, resolveMcpToolTimeoutMs as nn, handleMcpPost as nt, buildPeerAwarenessSnippet as o, readResponseBodyCapped as on, FAST_REVIEWER_EFFORT as ot, EXPLORE_DEFAULT_THINKING as p, extractTarGzMember as pn, browserToolsEnabled as pt, isControllerClosedError as q, createMessages as qt, agentNamesForToolAllowlist as r, createResponses as rn, FAST_CRITIC_EFFORT as rt, buildPeerAwarenessSummary as s, parseJsonOrDiagnose as sn, FAST_SCOUT_EFFORT as st, GROUP_META as t, warnOnTokenPriceDrift as tn, handleMcpDelete as tt, BROWSE_DEFAULT_MODEL as u, hasSupportedBrowserInstalled as un, brainstormModel as ut, appendPlanReminder as v, DEFINITION_OF_GREATNESS as vn, fastReviewerModel as vt, availableToolCommands as w, DEFAULT_CLAUDE_MODEL_FALLBACKS as wn, nativeSubagentModel as wt, resolveWorkerRunOpts as x, toolbeltPathOverride as xn, geminiAvailable as xt, resolveDefaultModel as y, shouldUseInsecureTls as yn, fastScoutModel as yt, resolveAdvisorEffort as z, withOneMSuffix as zn, canonicalizeAliasModel as zt };
 
-//# sourceMappingURL=peer-mcp-personas-DhI7ZPSx.js.map
+//# sourceMappingURL=peer-mcp-personas-ce6_YMnX.js.map