github-router 0.3.289 → 0.3.292

package/dist/{server-setup-DlztZAGT.js → server-setup-CqlaZukJ.js}

@@ -1,8 +1,8 @@
-import { $ as handleMcpDelete, $t as UPSTREAM_INACTIVITY_TIMEOUT_MS, At as readResponseBodyCapped, B as rememberThinkingHistoryRepair, Bt as provisionTreeSitterAssets, Ct as getTokenCount, Dt as createResponses, Et as resolveMcpToolTimeoutMs, F as injectAdvisorTool, G as isControllerClosedError, Gt as toolbeltPathOverride, H as repairRejectedThinkingHistory, I as isAdvisorRequested, J as relayAnthropicStream, K as logStreamError, L as resolveAdvisorEffort, M as ADVISOR_INTERNAL_TOOL_NAME, Mt as normalizeOpenAIUsage, N as ADVISOR_TOOL_INSTRUCTIONS, Ot as createChatCompletions, P as buildAdvisorStream, Q as clampEffort, Qt as UPSTREAM_FETCH_TIMEOUT_MS, R as resolveAdvisorModel, St as createMessages, T as toolbeltEnabled, Tt as warnOnTokenPriceDrift, U as buildAnthropicErrorEvent, V as repairKnownThinkingHistory, W as buildOpenAIErrorEvent, X as UNKNOWN_EFFORT_ANCHOR, Y as EFFORT_ORDER, Z as bucketEffort, an as upstreamMaxConnections, bt as shimDefaultsToXhigh, cn as withOneMSuffixForLead, en as generateRandomPort, et as handleMcpPost, in as upstreamAllowH2, j as searchWeb, jt as parseJsonOrDiagnose, kt as MAX_RESPONSE_BODY_BYTES, ln as withInstallLock, nt as agentToolsEnabled, on as classifyMessagesRoute, pt as resolveGeminiReviewModel, q as readIteratorWithTimeout, qt as BUDGET_SMALL_FAST_SLUG, r as assertMcpToolSurfaceConsistent, sn as withOneMSuffix, tn as isBudgetClaudeLead, wt as assembleResponsesPayload, xt as countTokens, z as formatThinkingRepairDecline } from "./peer-mcp-personas-Bd56EmiO.js";
+import { $ as bucketEffort, At as countTokens, B as resolveAdvisorModel, Bt as createChatCompletions, Cn as withOneMSuffixForLead, E as toolbeltEnabled, F as buildAdvisorStream, G as buildAnthropicErrorEvent, H as rememberThinkingHistoryRepair, Ht as readResponseBodyCapped, I as injectAdvisorTool, It as assembleResponsesPayload, J as logStreamError, K as buildOpenAIErrorEvent, L as isAdvisorRequested, Lt as warnOnTokenPriceDrift, M as searchWeb, Mt as getTokenCount, N as ADVISOR_INTERNAL_TOOL_NAME, Nt as findLaunchBySecret, P as ADVISOR_TOOL_INSTRUCTIONS, Q as UNKNOWN_EFFORT_ANCHOR, Qt as provisionTreeSitterAssets, R as isFastProfileLead, Rt as resolveMcpToolTimeoutMs, Sn as withOneMSuffix, U as repairKnownThinkingHistory, Ut as parseJsonOrDiagnose, V as formatThinkingRepairDecline, Vt as MAX_RESPONSE_BODY_BYTES, W as repairRejectedThinkingHistory, Wt as normalizeOpenAIUsage, X as relayAnthropicStream, Y as readIteratorWithTimeout, Z as EFFORT_ORDER, _n as upstreamMaxConnections, an as BUDGET_SMALL_FAST_SLUG, bn as catalogAdvertises1M, dn as UPSTREAM_INACTIVITY_TIMEOUT_MS, et as clampEffort, fn as generateRandomPort, gn as upstreamAllowH2, i as assertMcpToolSurfaceConsistent, jt as createMessages, kt as shimDefaultsToXhigh, nt as handleMcpPost, ot as agentToolsEnabled, pn as isBudgetClaudeLead, q as isControllerClosedError, rn as toolbeltPathOverride, tt as handleMcpDelete, un as UPSTREAM_FETCH_TIMEOUT_MS, vn as classifyMessagesRoute, wn as withInstallLock, xn as oneMContextDisabled, yn as pickEndpoint, z as resolveAdvisorEffort, zt as createResponses } from "./peer-mcp-personas-CHbl6MwM.js";
 import { t as getPackageVersion } from "./version-C8x2hQrZ.js";
-import { i as ensurePaths, t as PATHS } from "./paths-D7_SAaIQ.js";
-import { A as state, T as copilotHeaders, _ as forwardError, a as cacheCopilotVersion, c as filterBetaHeader, d as resolveModel, f as sleep, g as HTTPError, i as tryRefreshAndRetry, l as isNullish, n as setupGitHubAgentToken, o as cacheModels, r as setupGitHubToken, s as cacheVSCodeVersion, t as setupCopilotToken, w as copilotBaseUrl, y as fetchWithTransientRetry } from "./token-BGCjZwtj.js";
-import { t as getCopilotUsage } from "./get-copilot-usage-BjA0nyGR.js";
+import { i as ensurePaths, t as PATHS } from "./paths-BH4J7slC.js";
+import { A as state, T as copilotHeaders, _ as forwardError, a as cacheCopilotVersion, c as filterBetaHeader, d as resolveModel, f as sleep, g as HTTPError, i as tryRefreshAndRetry, l as isNullish, n as setupGitHubAgentToken, o as cacheModels, r as setupGitHubToken, s as cacheVSCodeVersion, t as setupCopilotToken, w as copilotBaseUrl, y as fetchWithTransientRetry } from "./token-8drORhXg.js";
+import { t as getCopilotUsage } from "./get-copilot-usage-CRrf1ZSC.js";
 import { a as resolveExecutable, n as killManagedTree, o as runCommandCapture, r as parseBoolEnv, s as runCommandVoid } from "./exec-y8C_MU8A.js";
 import consola from "consola";
 import * as fs$2 from "node:fs";
@@ -354,6 +354,232 @@ async function runSelfUpdate(opts) {
 	}
 }
 //#endregion
+//#region src/lib/launch-profile.ts
+const STANDARD_PROFILE = Object.freeze({
+	id: "standard",
+	hasCoordinator: true
+});
+/**
+* The `-m fast` roster: exactly four native agents (`scout`, `implementer`,
+* `reviewer`, `planner`), 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"
+	]),
+	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";
+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, so after early canonicalization a
+* table keyed on the real id could no longer tell which absent-effort
+* default applies. Alias provenance — which of the three ids the request
+* actually carried — 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"
+	}],
+	[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 three registered aliases (including the bare
+* `claude-*` ids and every other real Copilot catalog id).
+*/
+function resolveModelAlias(id) {
+	const bare = id.replace(/\[1m\]$/i, "");
+	return MODEL_ALIAS_TABLE.get(bare);
+}
+/**
+* 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 bracket = /\[1m\]$/i.test(id) ? "[1m]" : "";
+	const bare = bracket ? id.slice(0, -bracket.length) : id;
+	const alias = MODEL_ALIAS_TABLE.get(bare);
+	return alias ? `${alias.realModel}${bracket}` : id;
+}
+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);
+}
+function supportsEndpoint(model, paths) {
+	const endpoints = model?.supported_endpoints;
+	return Array.isArray(endpoints) && endpoints.some((endpoint) => paths.has(endpoint));
+}
+const RESPONSES_ENDPOINTS = /* @__PURE__ */ new Set(["/responses", "/v1/responses"]);
+const MESSAGES_ENDPOINTS = /* @__PURE__ */ new Set(["/messages", "/v1/messages"]);
+function hasUsablePromptMetadata(model) {
+	const prompt = model?.capabilities?.limits?.max_prompt_tokens;
+	return typeof prompt === "number" && Number.isFinite(prompt) && prompt > 0;
+}
+/**
+* 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.
+*   - 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_ENDPOINTS)) 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_ENDPOINTS)) 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 (!hasUsablePromptMetadata(grok)) missing.push("grok-4.6: no usable max_prompt_tokens metadata");
+		if (!supportsEndpoint(grok, RESPONSES_ENDPOINTS)) 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 (!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");
+		if (pickEndpoint(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_ENDPOINTS)) 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/file-log-reporter.ts
 const MAX_LOG_BYTES = 1048576;
 const DEDUP_MAX = 1e3;
@@ -1430,7 +1656,7 @@ function collectToolFieldKeys(body) {
 //#endregion
 //#region package.json
 var name = "github-router";
-var version = "0.3.289";
+var version = "0.3.292";
 //#endregion
 //#region src/lib/approval.ts
 const awaitApproval = async () => {
@@ -3063,6 +3289,18 @@ function anthropicMessageToNeutral(msg) {
 				name: typeof b.name === "string" ? b.name : "",
 				arguments: b.input ?? {}
 			});
+			else if (b.type === "server_tool_use" && b.name === "advisor") parts.push({
+				type: "text",
+				text: "[Consulted advisor]"
+			});
+			else if (b.type === "advisor_tool_result") {
+				const resultContent = b.content;
+				const text = resultContent && typeof resultContent === "object" && typeof resultContent.text === "string" ? resultContent.text : "";
+				if (text.length > 0) parts.push({
+					type: "text",
+					text: `[Advisor response]\n${text}`
+				});
+			}
 		}
 		return [{
 			role: "assistant",
@@ -4042,6 +4280,75 @@ function isAsyncIterable(x) {
 	return x != null && typeof x[Symbol.asyncIterator] === "function";
 }
 /**
+* Context-free, caller-abortable core of the non-Claude shim's STREAMING
+* path for one already-parsed Anthropic request.
+*
+* "Context-free": no Hono `Context` dependency, unlike
+* `handleNonClaudeResponses`/`handleNonClaudeChat` below (which need one to
+* build their JSON error responses and read `c.req.path` for logging).
+* "Caller-abortable": takes the caller's OWN `AbortSignal` rather than
+* constructing an internal `AbortController` — this function never creates
+* one — and forwards an optional `onCancel` so a caller that DOES own a
+* controller (the two handlers below, for the initial request) can still
+* tear it down when the stream it returns is cancelled.
+*
+* Shared by:
+*   - `handleNonClaudeResponses` / `handleNonClaudeChat` (this module), for
+*     the initial request — each already knows its own endpoint statically
+*     (they are dispatched by `classifyMessagesRoute`), so this function
+*     takes `endpoint` as an explicit argument rather than re-deriving it
+*     from the catalog (which would also mean re-parsing/re-picking work the
+*     caller already did).
+*   - `makeShimContinueTurn` (below), which `buildAdvisorStream`
+*     (`src/services/advisor/advisor.ts`) injects as its `continueTurn` for
+*     the fast Luna-lead profile, so an advisor continuation on a non-Claude
+*     lead runs through the SAME translation + SSE-synthesis machinery as
+*     the initial turn instead of a parallel, divergent implementation.
+*/
+async function streamParsedRequestViaShim(parsed, endpoint, opts, signal) {
+	const routePath = opts.routePath ?? "/v1/messages (advisor lead shim)";
+	if (endpoint === "chat") {
+		const payload = parsedToChatPayload(parsed);
+		const result = await createChatCompletions(payload, opts.model?.requestHeaders, signal, true);
+		if (!isAsyncIterable(result)) throw new Error("Upstream /chat/completions did not return an SSE stream (stream: true expected)");
+		const stream = anthropicSseStreamFromEvents(synthAnthropicFromChat(result, { modelId: opts.modelId }), {
+			routePath,
+			onCancel: opts.onCancel,
+			inactivityTimeoutMs: UPSTREAM_INACTIVITY_TIMEOUT_MS
+		});
+		return new Response(stream, {
+			status: 200,
+			headers: STREAM_HEADERS
+		});
+	}
+	const payload = parsedToResponsesPayload(parsed);
+	const result = await createResponses(payload, opts.model?.requestHeaders, signal, true);
+	if (!isAsyncIterable(result)) throw new Error("Upstream /responses did not return an SSE stream (stream: true expected)");
+	const stream = anthropicSseStreamFromEvents(synthAnthropicFromResponses(result, { modelId: opts.modelId }), {
+		routePath,
+		onCancel: opts.onCancel,
+		inactivityTimeoutMs: UPSTREAM_INACTIVITY_TIMEOUT_MS
+	});
+	return new Response(stream, {
+		status: 200,
+		headers: STREAM_HEADERS
+	});
+}
+/**
+* Build an injectable `continueTurn(body, signal)` for `buildAdvisorStream`
+* (`src/services/advisor/advisor.ts`) that routes a continuation turn
+* through THIS module's non-Claude shim instead of Claude passthrough — used
+* for the fast Luna-lead profile's advisor translate-loop. No `onCancel` is
+* threaded through: the advisor loop's own `aborter` (shared with `signal`
+* here) already tears down on consumer cancel via `buildAdvisorStream`'s
+* `cancel()`, so this stream needs no independent teardown hook.
+*/
+function makeShimContinueTurn(endpoint, opts) {
+	return (body, signal) => {
+		return streamParsedRequestViaShim(parseAnthropicRequest(body, opts.modelId, opts.model), endpoint, opts, signal);
+	};
+}
+/**
 * Handle a `/v1/messages` request targeting a non-Claude `/responses` model.
 * Returns a streaming or non-streaming Anthropic-format Response. Upstream
 * non-2xx / abort errors are thrown (as HTTPError) and handled by the route's
@@ -4062,12 +4369,15 @@ async function handleNonClaudeResponses(c, opts) {
 		}, 400);
 	}
 	const parsed = parseAnthropicRequest(body, opts.modelId, opts.model);
-	const payload = parsedToResponsesPayload(parsed);
 	if (consola.level >= 4) consola.debug(`Anthropic-translate → /responses model=${opts.modelId} stream=${parsed.stream} tools=${parsed.tools?.length ?? 0} effort=${parsed.reasoningEffort ?? "none"}`);
 	if (parsed.stream) {
 		const aborter = new AbortController();
-		const result = await createResponses(payload, opts.model?.requestHeaders, aborter.signal, true);
-		if (!isAsyncIterable(result)) throw new Error("Upstream /responses did not return an SSE stream (stream: true expected)");
+		const stream = await streamParsedRequestViaShim(parsed, "responses", {
+			modelId: opts.modelId,
+			model: opts.model,
+			routePath,
+			onCancel: () => aborter.abort()
+		}, aborter.signal);
 		logRequest({
 			method: "POST",
 			path: routePath,
@@ -4076,16 +4386,9 @@ async function handleNonClaudeResponses(c, opts) {
 			status: 200,
 			streaming: true
 		}, opts.model, opts.startTime);
-		const stream = anthropicSseStreamFromEvents(synthAnthropicFromResponses(result, { modelId: opts.modelId }), {
-			routePath,
-			onCancel: () => aborter.abort(),
-			inactivityTimeoutMs: UPSTREAM_INACTIVITY_TIMEOUT_MS
-		});
-		return new Response(stream, {
-			status: 200,
-			headers: STREAM_HEADERS
-		});
+		return stream;
 	}
+	const payload = parsedToResponsesPayload(parsed);
 	const anthropic = responsesResponseToAnthropicMessage(await createResponses(payload, opts.model?.requestHeaders, void 0, true), opts.modelId);
 	const usage = anthropic.usage;
 	logRequest({
@@ -4122,12 +4425,15 @@ async function handleNonClaudeChat(c, opts) {
 		}, 400);
 	}
 	const parsed = parseAnthropicRequest(body, opts.modelId, opts.model);
-	const payload = parsedToChatPayload(parsed);
 	if (consola.level >= 4) consola.debug(`Anthropic-translate → /chat/completions model=${opts.modelId} stream=${parsed.stream} tools=${parsed.tools?.length ?? 0} effort=${parsed.reasoningEffort ?? "none"}`);
 	if (parsed.stream) {
 		const aborter = new AbortController();
-		const result = await createChatCompletions(payload, opts.model?.requestHeaders, aborter.signal, true);
-		if (!isAsyncIterable(result)) throw new Error("Upstream /chat/completions did not return an SSE stream (stream: true expected)");
+		const stream = await streamParsedRequestViaShim(parsed, "chat", {
+			modelId: opts.modelId,
+			model: opts.model,
+			routePath,
+			onCancel: () => aborter.abort()
+		}, aborter.signal);
 		logRequest({
 			method: "POST",
 			path: routePath,
@@ -4136,16 +4442,9 @@ async function handleNonClaudeChat(c, opts) {
 			status: 200,
 			streaming: true
 		}, opts.model, opts.startTime);
-		const stream = anthropicSseStreamFromEvents(synthAnthropicFromChat(result, { modelId: opts.modelId }), {
-			routePath,
-			onCancel: () => aborter.abort(),
-			inactivityTimeoutMs: UPSTREAM_INACTIVITY_TIMEOUT_MS
-		});
-		return new Response(stream, {
-			status: 200,
-			headers: STREAM_HEADERS
-		});
+		return stream;
 	}
+	const payload = parsedToChatPayload(parsed);
 	const anthropic = chatResponseToAnthropicMessage(await createChatCompletions(payload, opts.model?.requestHeaders, void 0, true), opts.modelId);
 	const usage = anthropic.usage;
 	logRequest({
@@ -4162,6 +4461,126 @@ async function handleNonClaudeChat(c, opts) {
 	return c.json(anthropic, 200);
 }
 //#endregion
+//#region src/lib/messages-identity-preflight.ts
+/**
+* `/v1/messages` identity-preflight bearer, distinct from the `/mcp` nonce
+* (`Authorization` header). Delivered to the spawned Claude Code process via
+* `ANTHROPIC_CUSTOM_HEADERS` (an Anthropic SDK env var already carried
+* through `getClaudeCodeEnvVars`), so it rides on EVERY `/v1/messages`
+* request the client sends — main-loop turns, subagents, hooks calling the
+* loopback endpoint directly, all of it.
+*
+* A raw BYO client (`start`/`codex`, or any script hitting `/v1/messages`
+* directly) never sets this header, and that is intentional: header
+* PRESENCE is what marks a request as asserting a bound-launch identity.
+* Absence is not a downgrade from some previously-enforced state — it is
+* today's status quo for every `/v1/messages` caller, preserved exactly.
+* Only a request that DOES present the header is held to it: if a matching
+* registry entry can't be found for it (wrong value, launch already torn
+* down, a claude session that raced this header against a proxy restart),
+* that specific request fails closed.
+*/
+const LAUNCH_SECRET_HEADER = "X-GH-Router-Launch-Secret";
+/**
+* Validate the launch-secret header BEFORE any body consumer runs (i.e.
+* before `c.req.text()`/`c.req.json()` — this function only reads a
+* header). Callers running this must NOT surface a bare 401 on the
+* `/v1/messages` boundary: this route observes the same no-401 invariant
+* `forwardError` enforces for upstream failures (Claude Code's reactive
+* refresh path fires on ANY 401 and would try to use the synthetic
+* refresh token, breaking the session). Use `identityPreflightErrorResponse`
+* below, which answers 403, to reject a failed preflight.
+*/
+function runMessagesIdentityPreflight(c) {
+	const header = c.req.header(LAUNCH_SECRET_HEADER);
+	if (!header) return { ok: true };
+	const launch = findLaunchBySecret(header);
+	if (!launch) return {
+		ok: false,
+		reason: "X-GH-Router-Launch-Secret header did not match any registered launch (the launch may have been restarted, or the header was tampered with)"
+	};
+	return {
+		ok: true,
+		launch
+	};
+}
+/**
+* Anthropic-shaped rejection for a failed identity preflight. 403, never
+* 401 — see the no-401 invariant note on `runMessagesIdentityPreflight`.
+*/
+function identityPreflightErrorResponse(c, reason, path = "/v1/messages") {
+	return c.json({
+		type: "error",
+		error: {
+			type: "permission_error",
+			message: `${path} identity preflight rejected: ${reason}`
+		}
+	}, 403);
+}
+//#endregion
+//#region src/lib/fast-request-preprocess.ts
+/**
+* Apply authenticated fast-profile model and effort policy before ordinary model
+* resolution. Synthetic aliases are refused outside an authenticated fast
+* launch, so raw/BYO traffic cannot opt itself into private profile semantics.
+*/
+function preprocessFastRequest(rawBody, launch) {
+	let parsed;
+	try {
+		parsed = JSON.parse(rawBody);
+	} catch {
+		return {
+			body: rawBody,
+			modified: false
+		};
+	}
+	const originalModel = typeof parsed.model === "string" ? parsed.model : void 0;
+	if (!originalModel) return {
+		body: rawBody,
+		modified: false
+	};
+	const alias = resolveModelAlias(originalModel);
+	if (alias && launch?.profileId !== "fast") return {
+		body: rawBody,
+		originalModel,
+		modified: false,
+		rejectedAlias: originalModel
+	};
+	if (launch?.profileId !== "fast") return {
+		body: rawBody,
+		originalModel,
+		modified: false
+	};
+	const bare = originalModel.replace(/\[1m\]$/i, "");
+	let effort;
+	if (alias) {
+		effort = alias.absentEffortDefault;
+		parsed.model = canonicalizeAliasModel(originalModel);
+	} else if (bare === "gpt-5.6-luna") effort = "max";
+	else if (bare === "gpt-5.6-sol") effort = "high";
+	else if (bare === "grok-4.6") effort = "medium";
+	else if (bare === "gemini-3.7-flash") effort = "high";
+	else if (bare === "claude-opus-5") effort = "high";
+	if (!effort && !alias) return {
+		body: rawBody,
+		originalModel,
+		modified: false,
+		rejectedModel: originalModel
+	};
+	const outputConfig = parsed.output_config && typeof parsed.output_config === "object" ? parsed.output_config : {};
+	parsed.output_config = {
+		...outputConfig,
+		effort
+	};
+	const thinking = parsed.thinking;
+	if (thinking && typeof thinking === "object" && thinking.type === "enabled") parsed.thinking = { type: "adaptive" };
+	return {
+		body: JSON.stringify(parsed),
+		originalModel,
+		modified: true
+	};
+}
+//#endregion
 //#region src/routes/messages/handler.ts
 const MAX_THINKING_REPAIR_ATTEMPTS = 5;
 const isWebSearchTool$1 = (tool) => !!tool && typeof tool === "object" && (typeof tool.type === "string" && tool.type.startsWith("web_search") || tool.name === "web_search");
@@ -4285,6 +4704,8 @@ async function processWebSearch(rawBody) {
 }
 async function handleCompletion(c) {
 	const startTime = Date.now();
+	const identity = runMessagesIdentityPreflight(c);
+	if (!identity.ok) return identityPreflightErrorResponse(c, identity.reason);
 	await checkRateLimit(state);
 	const rawBody = await c.req.text();
 	recordBodySize(rawBody.length);
@@ -4360,7 +4781,18 @@ async function handleCompletion(c) {
 	const betaHeaders = extractBetaHeaders(c);
 	const incomingBeta = c.req.header("anthropic-beta");
 	const advisorEnabled = isAdvisorRequested(incomingBeta);
-	let finalBody = await processWebSearch(rawBody);
+	const fastPreprocess = preprocessFastRequest(rawBody, identity.launch);
+	if (fastPreprocess.rejectedAlias || fastPreprocess.rejectedModel) {
+		const message = fastPreprocess.rejectedAlias ? `Router-owned model alias ${JSON.stringify(fastPreprocess.rejectedAlias)} is valid only for an authenticated -m fast launch.` : `Model ${JSON.stringify(fastPreprocess.rejectedModel)} is outside the fixed -m fast model set.`;
+		return c.json({
+			type: "error",
+			error: {
+				type: "invalid_request_error",
+				message
+			}
+		}, 400);
+	}
+	let finalBody = await processWebSearch(fastPreprocess.body);
 	finalBody = sanitizeAnthropicBody(finalBody);
 	const loopGuard = guardAnthropicBody(finalBody);
 	if (loopGuard.action === "abort") return c.json({
@@ -4389,6 +4821,54 @@ async function handleCompletion(c) {
 	const modelId = resolvedModel ?? originalModel;
 	const messagesRoute = classifyMessagesRoute(modelId, selectedModel, originalModel);
 	if (messagesRoute !== "claude-passthrough") {
+		const endpoint = messagesRoute === "chat-shim" ? "chat" : "responses";
+		let parsedBase;
+		try {
+			parsedBase = JSON.parse(resolvedBody);
+		} catch {}
+		const wantsStream = parsedBase?.stream === true;
+		if (advisorEnabled && wantsStream && identity.launch?.profileId === "fast" && isFastProfileLead(modelId)) {
+			const initialConversation = Array.isArray(parsedBase.messages) ? parsedBase.messages : [];
+			const parsedInitial = parseAnthropicRequest(parsedBase, modelId, selectedModel);
+			const fastAdvisorAborter = new AbortController();
+			const firstResponse = await streamParsedRequestViaShim(parsedInitial, endpoint, {
+				modelId,
+				model: selectedModel,
+				routePath: c.req.path,
+				onCancel: () => fastAdvisorAborter.abort()
+			}, fastAdvisorAborter.signal);
+			logRequest({
+				method: "POST",
+				path: c.req.path,
+				model: originalModel,
+				resolvedModel: modelId,
+				status: 200,
+				streaming: true
+			}, selectedModel, startTime);
+			const advisorChoice = resolveAdvisorModel(modelId, true);
+			return new Response(buildAdvisorStream({
+				firstResponse,
+				initialConversation,
+				baseBody: parsedBase,
+				requestHeaders: {},
+				advisorModel: advisorChoice.model,
+				advisorEscalated: advisorChoice.escalated || advisorChoice.fastProfile,
+				advisorEffort: resolveAdvisorEffort(rawBody, advisorChoice.model, true),
+				externalAborter: fastAdvisorAborter,
+				continueTurn: makeShimContinueTurn(endpoint, {
+					modelId,
+					model: selectedModel
+				})
+			}), {
+				status: 200,
+				headers: {
+					"content-type": "text/event-stream",
+					"cache-control": "no-cache",
+					"transfer-encoding": "chunked",
+					connection: "keep-alive"
+				}
+			});
+		}
 		const shimBody = stripAdvisorTool(resolvedBody);
 		if (advisorEnabled) consola.info("ADVISOR requested with a non-Claude model — stripping the injected __anthropic_advisor tool and proceeding without advisor (Claude-only feature; gracefully degraded).");
 		const shimOpts = {
@@ -4541,9 +5021,10 @@ function resolveModelInBody$1(rawBody) {
 	}
 	const originalModel = typeof parsed.model === "string" ? parsed.model : void 0;
 	let modified = false;
-	if (originalModel) {
-		const resolved = resolveModel(originalModel);
-		if (resolved !== originalModel) {
+	const resolvedOriginalModel = typeof parsed.model === "string" ? parsed.model : originalModel;
+	if (resolvedOriginalModel) {
+		const resolved = resolveModel(resolvedOriginalModel);
+		if (resolved !== resolvedOriginalModel) {
 			parsed.model = resolved;
 			modified = true;
 		}
@@ -4823,7 +5304,20 @@ function stripWebSearchFromBody(rawBody) {
 */
 async function handleCountTokens(c) {
 	const startTime = Date.now();
-	const strippedBody = stripWebSearchFromBody(sanitizeAnthropicBody(await c.req.text()));
+	const identity = runMessagesIdentityPreflight(c);
+	if (!identity.ok) return identityPreflightErrorResponse(c, identity.reason, c.req.path);
+	const fastPreprocess = preprocessFastRequest(await c.req.text(), identity.launch);
+	if (fastPreprocess.rejectedAlias || fastPreprocess.rejectedModel) {
+		const message = fastPreprocess.rejectedAlias ? `Router-owned model alias ${JSON.stringify(fastPreprocess.rejectedAlias)} is valid only for an authenticated -m fast launch.` : `Model ${JSON.stringify(fastPreprocess.rejectedModel)} is outside the fixed -m fast model set.`;
+		return c.json({
+			type: "error",
+			error: {
+				type: "invalid_request_error",
+				message
+			}
+		}, 400);
+	}
+	const strippedBody = stripWebSearchFromBody(sanitizeAnthropicBody(fastPreprocess.body));
 	if (strippedBody.includes("\"mcp_servers\"")) try {
 		const probe = JSON.parse(strippedBody);
 		if (Array.isArray(probe.mcp_servers) && probe.mcp_servers.length > 0) return c.json({
@@ -5798,12 +6292,18 @@ function parseSharedArgs(args) {
 }
 /**
 * Non-Claude models we surface as first-class, selectable rows in Claude
-* Code's model picker (Phase 3 of native-non-claude-models). The main
-* agent loop runs on them through the `/v1/messages` translation shim
-* (`src/lib/anthropic-translate/*`, branched in `routes/messages/handler.ts`)
-* that forwards non-Claude targets to Copilot `/responses` (gpt) or
-* `/chat/completions` (gemini). The Gemini review row prefers
-* `gemini-3.1-pro-preview` and degrades to `gemini-3.7-flash`.
+* Code's model picker (Phase 3 of native-non-claude-models, later
+* modernized to exactly these four live models by the fast-launch-profile
+* change). The main agent loop runs on them through the `/v1/messages`
+* translation shim (`src/lib/anthropic-translate/*`, branched in
+* `routes/messages/handler.ts`) that forwards non-Claude targets to
+* Copilot `/responses` (gpt) or `/chat/completions` (gemini/grok).
+*
+* This list is EXACT and STATIC — no dynamic Gemini-review append (the
+* earlier `gemini-3.1-pro-preview`-preferred / `gemini-3.7-flash`-fallback
+* row is retired: `gemini-3.7-flash` is now a first-class row on its own,
+* always at this fixed id). A model missing from the catalog is simply
+* omitted, never substituted — see `nativeSelectableModelsInCatalog`.
 *
 * Display labels only: the gateway-model cache schema Claude Code reads is
 * `{id, display_name?}` per model — there is NO per-model context-window
@@ -5817,48 +6317,52 @@ const NATIVE_NON_CLAUDE_MODELS = [
 		displayName: "GPT-5.6 Sol"
 	},
 	{
-		id: "gpt-5.5",
-		displayName: "GPT-5.5"
+		id: "gpt-5.6-luna",
+		displayName: "GPT-5.6 Luna"
 	},
 	{
-		id: "gpt-5.3-codex",
-		displayName: "GPT-5.3 Codex"
+		id: "gemini-3.7-flash",
+		displayName: "Gemini 3.7 Flash"
 	},
 	{
-		id: "gemini-3.5-flash",
-		displayName: "Gemini 3.5 Flash"
+		id: "grok-4.6",
+		displayName: "Grok 4.6"
 	}
 ];
 /**
+* `grok-4.6` never carries `[1m]` — its live-catalog window is 500K total
+* (372K max prompt), genuinely below the 1M accounting threshold, and this
+* project deliberately does NOT inject a global
+* `CLAUDE_CODE_MAX_CONTEXT_TOKENS` override for it (see
+* `docs/default-models.md` "fast launch profile" once landed): Claude Code
+* permits arbitrary bare non-Claude ids and runtime `/model` switches, so a
+* Grok-specific process-global window override would incorrectly follow the
+* session onto every other model after a switch. Grok is simply left bare,
+* which is also its true accounting rather than an over- or under-estimate
+* disguised as one.
+*/
+const NEVER_1M_MODEL_IDS = /* @__PURE__ */ new Set(["grok-4.6"]);
+/**
 * The subset of `NATIVE_NON_CLAUDE_MODELS` actually present in the live
-* Copilot catalog. License tiers differ (gpt-5.5 needs
-* pro_plus/business/enterprise/max; gemini-3.5-flash is absent on
-* edu/individual_trial), so a model missing from the catalog is silently
-* dropped — the caller then neither enables discovery nor writes a cache
-* for it, and lesser tiers see the unchanged picker. Pure (reads
-* `state.models`), so it is unit-testable without side effects.
+* Copilot catalog. License tiers differ, so a model missing from the
+* catalog is silently dropped — the caller then neither enables discovery
+* nor writes a cache for it, and lesser tiers see the unchanged picker.
+* Pure (reads `state.models`), so it is unit-testable without side effects.
 *
 * The projected id carries a `[1m]` suffix when the catalog advertises a
-* >=1M window for it, because Claude Code budgets a gateway-discovered row
-* at its 200K default otherwise — `gpt-5.6-sol` (1,050,000) would compact at
-* roughly a fifth of its real window. `withOneMSuffix` is catalog-gated, so
-* `gpt-5.3-codex` (400K) stays bare and keeps the conservative accounting;
-* over-budgeting it would trade premature compaction for a hard overflow.
-* The lookup below still keys off the BARE id — the decoration is applied
-* only to the value handed to Claude Code.
+* >=1M window for it AND the id isn't in `NEVER_1M_MODEL_IDS`, because
+* Claude Code budgets a gateway-discovered row at its 200K default
+* otherwise. `withOneMSuffix` is catalog-gated on top of that, so a model
+* whose advertised window shrinks below 1M stays bare regardless. The
+* lookup below still keys off the BARE id — the decoration is applied only
+* to the value handed to Claude Code.
 */
 function nativeSelectableModelsInCatalog() {
 	const catalog = state.models?.data;
 	if (!catalog || catalog.length === 0) return [];
 	const present = new Set(catalog.map((m) => m.id));
-	const models = NATIVE_NON_CLAUDE_MODELS.filter((m) => present.has(m.id));
-	const geminiReviewModel = resolveGeminiReviewModel();
-	if (geminiReviewModel) models.push({
-		id: geminiReviewModel,
-		displayName: geminiReviewModel === "gemini-3.7-flash" ? "Gemini 3.7 Flash" : "Gemini 3.1 Pro (preview)"
-	});
-	return models.map((m) => ({
-		id: withOneMSuffix(m.id),
+	return NATIVE_NON_CLAUDE_MODELS.filter((m) => present.has(m.id)).map((m) => ({
+		id: NEVER_1M_MODEL_IDS.has(m.id) ? m.id : withOneMSuffix(m.id),
 		display_name: m.displayName
 	}));
 }
@@ -5979,7 +6483,19 @@ function clearGatewayModelCache(configDir = PATHS.CLAUDE_CONFIG_DIR) {
 * MUST NOT return 401 on the Anthropic-shape boundary even when
 * upstream Copilot returns 401. See `src/routes/messages/handler.ts`.
 */
-function getClaudeCodeEnvVars(serverUrl, model) {
+/**
+* Decorate a Luna-alias id with `[1m]` based on the REAL `gpt-5.6-luna`
+* catalog entry's advertised window, never on the alias string itself
+* (which is never a catalog entry — `catalogAdvertises1M`/`resolveModel`
+* would find nothing and silently leave it bare). Shared by every
+* fast-profile tier-row seed below so they can't disagree about whether
+* Luna currently backs 1M.
+*/
+function oneMSuffixForAlias(aliasId) {
+	if (oneMContextDisabled()) return aliasId;
+	return catalogAdvertises1M("gpt-5.6-luna") ? `${aliasId}[1m]` : aliasId;
+}
+function getClaudeCodeEnvVars(serverUrl, model, launchProfileId = "standard") {
 	const vars = {
 		ANTHROPIC_BASE_URL: serverUrl,
 		CLAUDE_CONFIG_DIR: PATHS.CLAUDE_CONFIG_DIR,
@@ -5991,15 +6507,34 @@ function getClaudeCodeEnvVars(serverUrl, model) {
 	const mcpToolTimeoutMs = String(resolveMcpToolTimeoutMs());
 	if (process.env.MCP_TIMEOUT === void 0) vars.MCP_TIMEOUT = mcpToolTimeoutMs;
 	if (process.env.MCP_TOOL_TIMEOUT === void 0) vars.MCP_TOOL_TIMEOUT = mcpToolTimeoutMs;
-	const smallFastModel = isBudgetClaudeLead(model) && (state.models?.data?.some((m) => m.id === "claude-haiku-4.5") ?? false) ? BUDGET_SMALL_FAST_SLUG : "claude-sonnet-5";
-	if (process.env.ANTHROPIC_SMALL_FAST_MODEL === void 0) vars.ANTHROPIC_SMALL_FAST_MODEL = smallFastModel;
+	const isFastProfile = launchProfileId === "fast";
+	const smallFastModel = isFastProfile ? LUNA_HAIKU_ALIAS_ID : isBudgetClaudeLead(model) && (state.models?.data?.some((m) => m.id === "claude-haiku-4.5") ?? false) ? BUDGET_SMALL_FAST_SLUG : "claude-sonnet-5";
+	if (process.env.ANTHROPIC_SMALL_FAST_MODEL === void 0) vars.ANTHROPIC_SMALL_FAST_MODEL = isFastProfile ? oneMSuffixForAlias(smallFastModel) : smallFastModel;
 	const seedTierRow = (modelKey, nameKey, bareSlug) => {
 		if (process.env[modelKey] !== void 0) return;
 		vars[modelKey] = withOneMSuffixForLead(bareSlug);
 		if (process.env[nameKey] === void 0) vars[nameKey] = bareSlug;
 	};
-	seedTierRow("ANTHROPIC_DEFAULT_SONNET_MODEL", "ANTHROPIC_DEFAULT_SONNET_MODEL_NAME", "claude-sonnet-5");
-	seedTierRow("ANTHROPIC_DEFAULT_HAIKU_MODEL", "ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME", smallFastModel);
+	const seedFastAliasTierRow = (modelKey, nameKey, aliasId, displayName) => {
+		if (process.env[modelKey] !== void 0) return;
+		vars[modelKey] = oneMSuffixForAlias(aliasId);
+		if (process.env[nameKey] === void 0) vars[nameKey] = displayName;
+	};
+	if (isFastProfile) {
+		seedFastAliasTierRow("ANTHROPIC_DEFAULT_SONNET_MODEL", "ANTHROPIC_DEFAULT_SONNET_MODEL_NAME", LUNA_SONNET_ALIAS_ID, "GPT-5.6 Luna (xhigh)");
+		seedFastAliasTierRow("ANTHROPIC_DEFAULT_HAIKU_MODEL", "ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME", LUNA_HAIKU_ALIAS_ID, "GPT-5.6 Luna (high)");
+		const fastAliasCapabilities = "effort,xhigh_effort,max_effort,thinking,adaptive_thinking,interleaved_thinking";
+		if (process.env.ANTHROPIC_DEFAULT_SONNET_MODEL_SUPPORTED_CAPABILITIES === void 0) vars.ANTHROPIC_DEFAULT_SONNET_MODEL_SUPPORTED_CAPABILITIES = fastAliasCapabilities;
+		if (process.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_SUPPORTED_CAPABILITIES === void 0) vars.ANTHROPIC_DEFAULT_HAIKU_MODEL_SUPPORTED_CAPABILITIES = fastAliasCapabilities;
+		if (process.env.ANTHROPIC_CUSTOM_MODEL_OPTION === void 0) {
+			vars.ANTHROPIC_CUSTOM_MODEL_OPTION = oneMSuffixForAlias(LUNA_DRIVER_ALIAS_ID);
+			if (process.env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME === void 0) vars.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME = "GPT-5.6 Luna (max)";
+			if (process.env.ANTHROPIC_CUSTOM_MODEL_OPTION_SUPPORTED_CAPABILITIES === void 0) vars.ANTHROPIC_CUSTOM_MODEL_OPTION_SUPPORTED_CAPABILITIES = fastAliasCapabilities;
+		}
+	} else {
+		seedTierRow("ANTHROPIC_DEFAULT_SONNET_MODEL", "ANTHROPIC_DEFAULT_SONNET_MODEL_NAME", "claude-sonnet-5");
+		seedTierRow("ANTHROPIC_DEFAULT_HAIKU_MODEL", "ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME", smallFastModel);
+	}
 	seedTierRow("ANTHROPIC_DEFAULT_OPUS_MODEL", "ANTHROPIC_DEFAULT_OPUS_MODEL_NAME", "claude-opus-5");
 	if (process.env.CLAUDE_CODE_PLAN_V2_AGENT_COUNT === void 0) vars.CLAUDE_CODE_PLAN_V2_AGENT_COUNT = "7";
 	for (const key of [
@@ -6038,6 +6573,6 @@ function getCodexEnvVars(serverUrl) {
 	return vars;
 }
 //#endregion
-export { sharedServerArgs as a, listModelsForEndpoint as c, checkClaudeVersion as d, updateClaude as f, setupAndServe as i, enableFileLogging as l, getCodexEnvVars as n, startKeepAwake as o, parseSharedArgs as r, stopKeepAwake as s, getClaudeCodeEnvVars as t, runSelfUpdate as u };
+export { validateFastProfilePrerequisites as _, sharedServerArgs as a, updateClaude as b, stopKeepAwake as c, LUNA_DRIVER_ALIAS_ID as d, LUNA_IMPLEMENTER_ALIAS_ID as f, resolveLaunchProfile as g, profileDescriptor as h, setupAndServe as i, listModelsForEndpoint as l, formatFastPrerequisiteFailure as m, getCodexEnvVars as n, LAUNCH_SECRET_HEADER as o, LUNA_SCOUT_ALIAS_ID as p, parseSharedArgs as r, startKeepAwake as s, getClaudeCodeEnvVars as t, enableFileLogging as u, runSelfUpdate as v, checkClaudeVersion as y };
 
-//# sourceMappingURL=server-setup-DlztZAGT.js.map
+//# sourceMappingURL=server-setup-CqlaZukJ.js.map