github-router 0.3.288 → 0.3.292

package/dist/{peer-mcp-personas-B5Wp6wIn.js → peer-mcp-personas-CHbl6MwM.js}

@@ -1,14 +1,14 @@
 import { n as explicitPackageRoot } from "./package-root-B-osctCk.js";
 import { t as getPackageVersion } from "./version-C8x2hQrZ.js";
-import { t as PATHS } from "./paths-D7_SAaIQ.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-BGCjZwtj.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 { 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-DbM29FLK.js";
-import { t as MCP_WORKSPACE_HEADER } from "./mcp-workspace-header-DRCCWlOi.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 { 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-SXaWssN9.js";
-import { f as resolveSealedGate, m as runGateChecks, p as sealedGateIds } from "./stop-gate-hook-DriRc9xN.js";
-import { t as liveExec } from "./orchestration-BrJwZxMN.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 { 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";
@@ -447,9 +447,17 @@ const DEFAULT_CLAUDE_MODEL_FALLBACKS = [
 * variant" — defaulting safe-side preserves the pre-change behavior).
 */
 const DEFAULT_OPUS_FAMILY = "5";
-/** The lead `-m fast` selects. Anthropic-published dashed slug that is also the
-*  Copilot catalog id verbatim, so `resolveModel` matches it exactly. */
-const BUDGET_LEAD_MODEL = "claude-sonnet-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
+* 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";
 /** 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
@@ -464,28 +472,29 @@ const BUDGET_SMALL_FAST_CATALOG_ID = "claude-haiku-4.5";
 /**
 * Resolve the `-m` argument to the lead slug to launch with.
 *
-*   - `fast`      → `BUDGET_LEAD_MODEL` (budget mode)
+*   - `fast`      → `FAST_LEAD_MODEL` (the fast Luna profile — see
+*                   `./launch-profile`, NOT the retired Sonnet budget lead)
 *   - `N.M`       → the best variant of that Opus family, via `pickClaudeDefault`
 *   - a full slug → unchanged, including Copilot slugs a power user pins
 *   - absent      → the ordinary default
 *
 * Every branch is `[1m]`-decorated against the live catalog, by
 * `pickClaudeDefault` on the two Opus-family branches and by
-* `withOneMSuffixForLead` on the other two. Pinning a MODEL is not a request to
-* give up four fifths of its context window, which is what leaving the other
-* two bare amounted to: `claude-sonnet-5` advertises a 1M window, so `-m fast`
-* and `-m claude-sonnet-5` were both budgeted locally at Claude Code's 200K
-* default and auto-compacted at roughly a fifth of the real window. The
-* decoration is catalog-gated per model, so a genuinely 200K model
-* (`claude-haiku-4.5`) still comes back bare.
-*
-* `fast` resolves to an ordinary slug rather than setting a mode flag, because
-* budget mode is keyed off the RESOLVED lead everywhere it matters (the advisor
-* escalation, the delegation prose, the small/fast tier). `-m fast` and
-* `-m claude-sonnet-5` must therefore produce identical sessions, which a flag
-* only one of the two set would break. The shared decoration is part of that
-* identity: decorating one branch and not the other would reintroduce the
-* divergence through the context budget instead of through a flag.
+* `withOneMSuffixForLead` on the other two. `gpt-5.6-luna` advertises a 1M
+* window, so `-m fast` gets local 1M accounting exactly like every other
+* branch here; the decoration is catalog-gated per model, so a genuinely
+* 200K model (`claude-haiku-4.5`) still comes back bare.
+*
+* `fast` resolves to an ordinary slug rather than setting a mode flag —
+* `resolveLaunchProfile` (`./launch-profile`) is keyed off the SAME raw
+* argument this function receives, so the two can never disagree about
+* which launches are "fast". `isBudgetClaudeLead` (below) stays
+* Claude-family-only and is UNRELATED to the fast profile: `gpt-5.6-luna`
+* is not a Claude model, so `isBudgetClaudeLead(resolveLeadSlugArg("fast"))`
+* is false — the old Sonnet "budget lead" surfaces (advisor escalation,
+* delegation prose, small/fast Haiku tier) simply don't engage for `-m
+* fast` any more; the fast profile has its own separate roster/tier
+* mechanism instead.
 *
 * Callers must keep treating any explicit `-m` as explicit: the
 * `DEFAULT_CLAUDE_MODEL_FALLBACKS` walk applies to the implicit-default path
@@ -494,7 +503,7 @@ const BUDGET_SMALL_FAST_CATALOG_ID = "claude-haiku-4.5";
 function resolveLeadSlugArg(modelArg) {
 	const arg = modelArg?.trim();
 	if (!arg) return pickClaudeDefault();
-	if (arg.toLowerCase() === "fast") return withOneMSuffixForLead(BUDGET_LEAD_MODEL);
+	if (arg.toLowerCase() === "fast") return withOneMSuffixForLead(FAST_LEAD_MODEL);
 	const opusFamilyShorthand = arg.match(/^(\d+\.\d+)$/)?.[1];
 	if (opusFamilyShorthand) return pickClaudeDefault(opusFamilyShorthand);
 	return withOneMSuffixForLead(arg);
@@ -18917,7 +18926,7 @@ function logAudit$1(record) {
 		try {
 			const fs = await import("node:fs/promises");
 			const path = await import("node:path");
-			const { PATHS } = await import("./paths-CTr59UC6.js");
+			const { PATHS } = await import("./paths-DJZoXfAS.js");
 			const dir = path.join(PATHS.APP_DIR, "browser-mcp");
 			await fs.mkdir(dir, { recursive: true });
 			const line = JSON.stringify({
@@ -19497,6 +19506,354 @@ function currentInFlight() {
 	return inFlight$2;
 }
 //#endregion
+//#region src/lib/prompt-cache.ts
+/**
+* Conservative eligibility floor, in UTF-8 BYTES — never `.length`, which
+* counts UTF-16 code units and undercounts anything outside the BMP (an
+* emoji is 2 code units but 4 bytes). This is a proxy for "the prefix is
+* obviously large enough that marking it as a cache breakpoint is worth one
+* of the scarce marker slots," and it deliberately does NOT claim to be a
+* token count: byte-to-token density varies by tokenizer and content — CJK
+* text carries MORE tokens per byte than ASCII prose (undercounting risk is
+* the SAFE direction: we'd skip a marker that might have qualified), while a
+* long run of a repeated character or repeated whitespace carries FEWER
+* tokens per byte than either, since BPE merges long runs into very few
+* tokens (overcounting risk: a byte count clearing the floor doesn't
+* guarantee the real token count clears Anthropic's or Copilot's per-model
+* minimum). No fixed byte threshold can bound that adversarial case; this
+* value is chosen so ordinary Claude Code system prompts and tool schemas
+* (natural-language / JSON, not deliberately repetitive) reliably qualify,
+* while genuinely small prefixes never burn a marker for no benefit.
+*/
+const MIN_CACHEABLE_PREFIX_BYTES = 4096;
+const CACHE_KEY_NAMESPACE = "ghr-cache-v1";
+const CACHE_DIAGNOSTIC_LIMIT = 128;
+const GPT56_EXPLICIT_CACHE_MODELS = /* @__PURE__ */ new Set([
+	"gpt-5.6-sol",
+	"gpt-5.6-terra",
+	"gpt-5.6-luna"
+]);
+const priorSignatures = /* @__PURE__ */ new Map();
+function nonNegativeInt(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return 0;
+	return Math.floor(value);
+}
+/**
+* Pick the first genuinely POSITIVE numeric candidate from an ordered,
+* priority-ranked list of usage-shape fields. `??`-chaining these fields is
+* wrong: it stops at the first field that is merely PRESENT, and a provider
+* surface that always populates a nested detail object with `0` as a
+* placeholder (while the real, positive count is reported only in a
+* lower-priority field, e.g. the top-level one) would have its explicit zero
+* silently shadow that populated count. Falling through zeros to find a real
+* positive value fixes that; when every candidate is zero, absent, or
+* non-numeric, this returns `0` — a genuine all-zero reading, never
+* `undefined` — so downstream `nonNegativeInt` always has a countable value.
+*/
+function firstPositive(...candidates) {
+	for (const c of candidates) if (typeof c === "number" && Number.isFinite(c) && c > 0) return c;
+	return 0;
+}
+function usageDetails(usage) {
+	const input = usage.input_tokens_details ?? {};
+	const prompt = usage.prompt_tokens_details ?? {};
+	return {
+		cached_tokens: firstPositive(input.cached_tokens, prompt.cached_tokens, usage.cache_read_input_tokens),
+		cache_write_tokens: firstPositive(input.cache_write_tokens, input.cache_creation_tokens, prompt.cache_write_tokens, prompt.cache_creation_tokens, usage.cache_write_tokens, usage.cache_creation_input_tokens),
+		cache_ttl_seconds: firstPositive(input.cache_ttl_seconds, prompt.cache_ttl_seconds, usage.cache_ttl_seconds)
+	};
+}
+/**
+* OpenAI totals INCLUDE cached and cache-write tokens. Normalize them into
+* mutually exclusive buckets so Anthropic and Pi consumers do not count the
+* same input twice.
+*/
+function normalizeOpenAIUsage(usage) {
+	if (!usage) return {
+		totalInput: 0,
+		uncachedInput: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0
+	};
+	const totalInput = nonNegativeInt(usage.input_tokens ?? usage.prompt_tokens);
+	const output = nonNegativeInt(usage.output_tokens ?? usage.completion_tokens);
+	const details = usageDetails(usage);
+	const cacheRead = Math.min(totalInput, nonNegativeInt(details.cached_tokens));
+	const remaining = Math.max(0, totalInput - cacheRead);
+	const cacheWrite = Math.min(remaining, nonNegativeInt(details.cache_write_tokens ?? details.cache_creation_tokens));
+	const uncachedInput = Math.max(0, totalInput - cacheRead - cacheWrite);
+	const reportedTotal = nonNegativeInt(usage.total_tokens);
+	const cacheTtlSeconds = nonNegativeInt(details.cache_ttl_seconds);
+	return {
+		totalInput,
+		uncachedInput,
+		output,
+		cacheRead,
+		cacheWrite,
+		totalTokens: Math.max(reportedTotal, totalInput + output),
+		...cacheTtlSeconds > 0 ? { cacheTtlSeconds } : {}
+	};
+}
+function hash(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function signatureFor(value) {
+	return hash(typeof value === "string" ? value : JSON.stringify(value ?? null));
+}
+function serializedBytes(value) {
+	return Buffer.byteLength(typeof value === "string" ? value : JSON.stringify(value ?? null));
+}
+function logCacheSignature(args) {
+	if (parseBoolEnv(process.env.GH_ROUTER_LOG_CACHE) !== true) return;
+	const key = `${args.endpoint}:${args.model}:${args.workload}`;
+	const current = {
+		system: signatureFor(args.system),
+		tools: signatureFor(args.tools),
+		messages: signatureFor(args.messages)
+	};
+	const previous = priorSignatures.get(key);
+	let changed = "cold";
+	if (previous) changed = previous.system !== current.system ? "system" : previous.tools !== current.tools ? "tools" : previous.messages !== current.messages ? "messages" : "none";
+	priorSignatures.set(key, current);
+	if (priorSignatures.size > CACHE_DIAGNOSTIC_LIMIT) {
+		const oldest = priorSignatures.keys().next().value;
+		if (oldest !== void 0) priorSignatures.delete(oldest);
+	}
+	consola.info(`cache-signature endpoint=${args.endpoint} model=${args.model} workload=${args.workload} changed=${changed} system_bytes=${serializedBytes(args.system ?? "")} tools_bytes=${serializedBytes(args.tools ?? [])} messages_bytes=${serializedBytes(args.messages ?? [])}`);
+}
+function hasResponsesBreakpoint(input) {
+	const visit = (value) => {
+		if (!value || typeof value !== "object") return false;
+		if (Array.isArray(value)) return value.some(visit);
+		const record = value;
+		return record.prompt_cache_breakpoint !== void 0 || Object.values(record).some(visit);
+	};
+	return visit(input);
+}
+function gpt56ExplicitCacheEnabled(model) {
+	if (parseBoolEnv(process.env.GH_ROUTER_DISABLE_GPT56_EXPLICIT_CACHE) === true) return false;
+	return GPT56_EXPLICIT_CACHE_MODELS.has(model);
+}
+function responsesCacheKey(payload, opts, stablePrefix) {
+	const digest = hash(JSON.stringify({
+		namespace: CACHE_KEY_NAMESPACE,
+		model: payload.model,
+		workload: opts.workload,
+		scope: opts.scope ?? "",
+		stablePrefix,
+		tools: payload.tools ?? []
+	}));
+	return `${CACHE_KEY_NAMESPACE}-${digest.slice(0, 48)}`;
+}
+/**
+* Add GPT-5.6 explicit caching only to router-owned REUSABLE-PREFIX payloads.
+* Public passthrough routes never call this helper, and existing caller
+* fields always win. Live shape acceptance is pinned by compatibility probe
+* `gpt56_explicit_cache_breakpoint`.
+*
+* **`"conversation"` is deliberately EXCLUDED and left untouched (a no-op),
+* same as `"passthrough"`/`"one-shot"`.** A live-verified regression: on a
+* growing multi-turn conversation (Claude Code's translated main loop and
+* the worker-agent loop, both of which pass `workload: "conversation"`),
+* marking only the stable SYSTEM block with an explicit breakpoint measured
+* substantially worse than leaving caching provider-managed and implicit.
+* Explicit mode is a distinct
+* caching strategy from Copilot's provider-managed automatic caching, not an
+* addition to it — turning it on for a request marks only the bytes an
+* explicit breakpoint names, and the REST of that request's prefix (here,
+* the entire un-marked growing message history) stops receiving automatic
+* prefix-growth caching too. Measured on `gpt-5.6-sol` with explicit mode
+* force-enabled for conversation workloads: turn 1 (cold)
+* `input_tokens=27038, cache_write=2031, cache_read=0`; turn 2
+* `input_tokens=27054, cache_read=2031`; turn 3 `input_tokens=27071,
+* cache_read=2031` — the ~2k-token system block cached once and never grew,
+* while the other ~25k tokens of accumulating history were recomputed from
+* scratch on every single turn. `"reusable-prefix"` calls (peer/advisor/
+* worker-tool/browser-compressor prefixes reused verbatim across many
+* DISCRETE calls, never a single request whose own history keeps growing)
+* do not have this failure mode and keep the explicit treatment below.
+*/
+function applyResponsesCachePolicy(payload, opts) {
+	logCacheSignature({
+		endpoint: "/responses",
+		model: payload.model,
+		workload: opts.workload,
+		system: opts.stablePrefix ?? payload.instructions,
+		tools: payload.tools,
+		messages: payload.input
+	});
+	if (opts.workload !== "reusable-prefix" || !gpt56ExplicitCacheEnabled(payload.model) || payload.prompt_cache_key !== void 0 || payload.prompt_cache_options !== void 0 || hasResponsesBreakpoint(payload.input)) return payload;
+	const stablePrefix = opts.stablePrefix ?? payload.instructions;
+	const stableBytes = serializedBytes(stablePrefix ?? "") + serializedBytes(payload.tools ?? []);
+	if (!stablePrefix || stableBytes < MIN_CACHEABLE_PREFIX_BYTES) return payload;
+	const input = typeof payload.input === "string" ? [{
+		role: "user",
+		content: payload.input
+	}] : [...payload.input];
+	const stableContent = [{
+		type: "input_text",
+		text: stablePrefix,
+		prompt_cache_breakpoint: { mode: "explicit" }
+	}];
+	let nextInput;
+	let removeInstructions = false;
+	if (payload.instructions === stablePrefix) {
+		nextInput = [{
+			role: "system",
+			content: stableContent
+		}, ...input];
+		removeInstructions = true;
+	} else {
+		const stableSystemIndex = input.findIndex((item) => item.role === "system" && item.content === stablePrefix);
+		if (stableSystemIndex < 0) return payload;
+		nextInput = [...input];
+		nextInput[stableSystemIndex] = {
+			...nextInput[stableSystemIndex],
+			content: stableContent
+		};
+	}
+	const next = {
+		...payload,
+		input: nextInput,
+		prompt_cache_key: responsesCacheKey(payload, opts, stablePrefix),
+		prompt_cache_options: {
+			mode: "explicit",
+			ttl: "30m"
+		}
+	};
+	if (removeInstructions) delete next.instructions;
+	return next;
+}
+function itemHasCacheControl(value) {
+	return !!value && typeof value === "object" && value.cache_control !== void 0;
+}
+function hasClaudeCacheControl(body) {
+	if (itemHasCacheControl(body.system)) return true;
+	if (Array.isArray(body.system) && body.system.some(itemHasCacheControl)) return true;
+	if (Array.isArray(body.tools) && body.tools.some(itemHasCacheControl)) return true;
+	if (!Array.isArray(body.messages)) return false;
+	return body.messages.some((message) => {
+		if (!message || typeof message !== "object") return false;
+		const content = message.content;
+		return itemHasCacheControl(content) || Array.isArray(content) && content.some(itemHasCacheControl);
+	});
+}
+/**
+* UTF-8 byte length of the tools array alone — the eligibility floor for the
+* TOOL breakpoint. Marked on the last non-deferred tool, it caches only the
+* tools prefix (Claude's wire order is tools, then system, then messages), so
+* its own size — not the combined system+tools size — is what determines
+* whether that marker is worth spending. See `MIN_CACHEABLE_PREFIX_BYTES`.
+*/
+function claudeToolsPrefixBytes(body) {
+	return serializedBytes(body.tools ?? []);
+}
+/**
+* UTF-8 byte length of tools + system combined — the eligibility floor for
+* the SYSTEM breakpoint. Marked on the last system text block, it caches
+* everything up to and including system (tools THEN system in wire order),
+* so the combined size is the right measure — checked SEPARATELY from the
+* tools-only floor above so a large system prompt behind tiny tools doesn't
+* smuggle a useless tools-only marker in under the combined total, and a
+* large tools array behind an empty system doesn't get double-counted as
+* "small" just because system alone is tiny.
+*/
+function claudeSystemPrefixBytes(body) {
+	return claudeToolsPrefixBytes(body) + serializedBytes(body.system ?? "");
+}
+function markClaudeSystem(body) {
+	if (typeof body.system === "string" && body.system.length > 0) {
+		body.system = [{
+			type: "text",
+			text: body.system,
+			cache_control: { type: "ephemeral" }
+		}];
+		return true;
+	}
+	if (!Array.isArray(body.system)) return false;
+	for (let index = body.system.length - 1; index >= 0; index--) {
+		const block = body.system[index];
+		if (block && typeof block === "object" && block.type === "text" && typeof block.text === "string") {
+			body.system[index] = {
+				...block,
+				cache_control: { type: "ephemeral" }
+			};
+			return true;
+		}
+	}
+	return false;
+}
+function markClaudeTool(body) {
+	if (!Array.isArray(body.tools)) return false;
+	for (let index = body.tools.length - 1; index >= 0; index--) {
+		const tool = body.tools[index];
+		if (tool && typeof tool === "object" && tool.defer_loading !== true) {
+			body.tools[index] = {
+				...tool,
+				cache_control: { type: "ephemeral" }
+			};
+			return true;
+		}
+	}
+	return false;
+}
+/**
+* Apply the bounded Claude anchor policy to router-generated Messages bodies.
+* Caller-owned marker layouts are returned byte-for-byte unchanged.
+*
+* Marks at most TWO breakpoints — the last non-deferred tool and the stable
+* system boundary — each gated on its OWN eligibility check
+* (`claudeToolsPrefixBytes` / `claudeSystemPrefixBytes`) rather than one
+* combined check, so a large system prompt behind tiny tools doesn't also
+* mark a tools breakpoint too small to be worth a marker slot, and vice
+* versa. Anthropic's own hard ceiling is FOUR `cache_control` blocks per
+* request (probe `cache_control_marker_limit_5`); this policy only ever
+* spends up to two of them (`hasClaudeCacheControl` already refuses to run
+* at all once the caller has marked anything itself, so the two never
+* combine with a caller-owned marker to approach that ceiling).
+*
+* There used to be a third, message-level marking path gated on
+* `opts.workload === "conversation"`. It was removed as dead code: every
+* production call site of this function (`src/routes/mcp/handler.ts`,
+* `src/services/advisor/advisor.ts`) passes `workload: "reusable-prefix"`,
+* so the per-message branch never ran outside its own unit test, which gave
+* false confidence that production traffic exercised it. `CacheWorkload`
+* keeps `"conversation"` as a shared enum value — the Responses-side policy,
+* which has no per-message logic of its own, still uses it — so passing it
+* here remains type-valid; it now behaves identically to
+* `"reusable-prefix"`.
+*/
+function applyClaudeCachePolicy(rawBody, opts) {
+	if (opts.workload === "passthrough" || opts.workload === "one-shot" || parseBoolEnv(process.env.GH_ROUTER_DISABLE_CLAUDE_CACHE_POLICY) === true) return rawBody;
+	let parsed;
+	try {
+		parsed = JSON.parse(rawBody);
+	} catch {
+		return rawBody;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return rawBody;
+	const body = parsed;
+	if (typeof body.model !== "string" || !body.model.startsWith("claude-") || hasClaudeCacheControl(body)) return rawBody;
+	const toolsEligible = claudeToolsPrefixBytes(body) >= MIN_CACHEABLE_PREFIX_BYTES;
+	const systemEligible = claudeSystemPrefixBytes(body) >= MIN_CACHEABLE_PREFIX_BYTES;
+	if (!toolsEligible && !systemEligible) return rawBody;
+	let markers = 0;
+	if (toolsEligible && markClaudeTool(body)) markers++;
+	if (systemEligible && markClaudeSystem(body)) markers++;
+	if (markers === 0) return rawBody;
+	logCacheSignature({
+		endpoint: "/messages",
+		model: body.model,
+		workload: opts.workload,
+		system: body.system,
+		tools: body.tools,
+		messages: body.messages
+	});
+	return JSON.stringify(body);
+}
+//#endregion
 //#region src/lib/vision-preflight.ts
 /**
 * Outbound vision handling.
@@ -20421,7 +20778,7 @@ async function callViaChat(model, systemPrompt, userMessage, tool, signal) {
 *  Image parts use `input_image` (vs chat's `image_url`) — see
 *  `toResponsesContent`. */
 async function callViaResponses(model, systemPrompt, userMessage, tool, signal) {
-	const payload = {
+	const payload = applyResponsesCachePolicy({
 		model,
 		stream: false,
 		input: [{
@@ -20441,7 +20798,10 @@ async function callViaResponses(model, systemPrompt, userMessage, tool, signal)
 			type: "function",
 			name: tool.name
 		}
-	};
+	}, {
+		workload: "reusable-prefix",
+		stablePrefix: systemPrompt
+	});
 	const resp = await createResponses(payload, void 0, signal, true);
 	const output = Array.isArray(resp.output) ? resp.output : [];
 	for (const item of output) {
@@ -23897,8 +24257,8 @@ const FALLBACK_TOKEN_PRICES = Object.freeze({
 		out: 2500
 	},
 	"gpt-5.6-sol": {
-		in: 500,
-		out: 3e3
+		in: 200,
+		out: 1e3
 	},
 	"grok-4.5": {
 		in: 200,
@@ -23909,8 +24269,8 @@ const FALLBACK_TOKEN_PRICES = Object.freeze({
 		out: 3e3
 	},
 	"gemini-3.6-flash": {
-		in: 150,
-		out: 750
+		in: 75,
+		out: 375
 	},
 	"gemini-3.5-flash": {
 		in: 150,
@@ -24491,6 +24851,10 @@ function neutralToolsToResponses(tools) {
 /** Assemble the full Responses payload from the neutral request shape. */
 function assembleResponsesPayload(opts) {
 	const input = [];
+	if (opts.dynamicInstructions) input.push({
+		role: "system",
+		content: opts.dynamicInstructions
+	});
 	for (const m of opts.messages) for (const item of neutralMessageToResponsesInput(m)) input.push(item);
 	const payload = {
 		model: opts.model,
@@ -24507,7 +24871,10 @@ function assembleResponsesPayload(opts) {
 	if (typeof opts.maxOutputTokens === "number" && opts.maxOutputTokens > 0) payload.max_output_tokens = Math.max(opts.maxOutputTokens, RESPONSES_MIN_MAX_OUTPUT_TOKENS);
 	if (opts.stopSequences && opts.stopSequences.length > 0) payload.stop = [...opts.stopSequences];
 	if (opts.parallelToolCalls === false) payload.parallel_tool_calls = false;
-	return payload;
+	return opts.cachePolicy ? applyResponsesCachePolicy(payload, {
+		...opts.cachePolicy,
+		stablePrefix: opts.cachePolicy.stablePrefix ?? opts.instructions
+	}) : payload;
 }
 //#endregion
 //#region src/lib/worker-agent/context-budget.ts
@@ -25042,7 +25409,10 @@ function mapResponsesUsage(u) {
 		prompt_tokens: u.input_tokens ?? 0,
 		completion_tokens: u.output_tokens ?? 0,
 		total_tokens: u.total_tokens ?? 0,
-		prompt_tokens_details: u.input_tokens_details?.cached_tokens != null ? { cached_tokens: u.input_tokens_details.cached_tokens } : void 0
+		prompt_tokens_details: u.input_tokens_details != null ? {
+			cached_tokens: u.input_tokens_details.cached_tokens ?? 0,
+			cache_write_tokens: u.input_tokens_details.cache_write_tokens ?? u.input_tokens_details.cache_creation_tokens ?? 0
+		} : void 0
 	};
 }
 /**
@@ -25291,6 +25661,7 @@ function buildResponsesPayload(context, resolved) {
 		messages,
 		tools: piToolsToNeutral(context.tools),
 		reasoningEffort: resolved.thinking,
+		cachePolicy: { workload: "conversation" },
 		stream: true
 	});
 }
@@ -25513,12 +25884,13 @@ function emptyUsage() {
 }
 function deriveUsage(u) {
 	if (!u) return emptyUsage();
+	const normalized = normalizeOpenAIUsage(u);
 	return {
-		input: u.prompt_tokens ?? 0,
-		output: u.completion_tokens ?? 0,
-		cacheRead: u.prompt_tokens_details?.cached_tokens ?? 0,
-		cacheWrite: 0,
-		totalTokens: u.total_tokens ?? 0,
+		input: normalized.uncachedInput,
+		output: normalized.output,
+		cacheRead: normalized.cacheRead,
+		cacheWrite: normalized.cacheWrite,
+		totalTokens: normalized.totalTokens,
 		cost: {
 			input: 0,
 			output: 0,
@@ -26401,6 +26773,67 @@ function capToolResultText(content, capBytes) {
 	];
 }
 //#endregion
+//#region src/lib/launch-registry.ts
+/**
+* Register a new authenticated launch (a `github-router claude` process, or
+* `serve`'s per-repo session) in the keyed registry. Returns the stored
+* entry, including the generated `launchId` when the caller didn't supply
+* one.
+*
+* Callers are expected to mint `nonce` and `secret` as independent random
+* tokens (see `src/claude.ts` / `src/lib/serve/enhancements.ts`) — this
+* function stores whatever it's given without generating credentials
+* itself, so a caller cannot accidentally rely on it for randomness.
+*/
+function registerLaunch(params) {
+	const entry = {
+		launchId: params.launchId ?? randomUUID(),
+		nonce: params.nonce,
+		secret: params.secret,
+		profileId: params.profileId,
+		allowedGroups: params.allowedGroups,
+		allowedPersonas: params.allowedPersonas,
+		createdAt: Date.now()
+	};
+	state.launchRegistry.set(entry.launchId, entry);
+	return entry;
+}
+/** Remove one launch's entry. Idempotent — removing an already-removed or
+*  never-registered id is a no-op. Called from the launch's own cleanup
+*  path so a torn-down session's credentials stop authenticating. */
+function unregisterLaunch(launchId) {
+	state.launchRegistry.delete(launchId);
+}
+/**
+* Constant-time string compare. Per-launch credentials are random tokens,
+* not secrets an attacker gets many guesses at over the network within one
+* process lifetime, so timing attacks aren't a realistic concern here — but
+* it costs nothing and matches the prior nonce-compare's posture.
+*/
+function constantTimeStringEqual(a, b) {
+	if (a.length !== b.length) return false;
+	try {
+		return timingSafeEqual(Buffer.from(a), Buffer.from(b));
+	} catch {
+		return false;
+	}
+}
+/**
+* Find the launch whose `/mcp` bearer (`nonce`) matches. Linear scan over
+* `state.launchRegistry` — expected to hold a handful of entries at most
+* (one per concurrently running `claude`/`serve` session), so this is not a
+* hot-path concern. Returns undefined (never throws) when nothing matches,
+* including when the registry is empty (the "not enabled" case).
+*/
+function findLaunchByNonce(nonce) {
+	for (const entry of state.launchRegistry.values()) if (constantTimeStringEqual(entry.nonce, nonce)) return entry;
+}
+/** Find the launch whose `/v1/messages` identity-preflight bearer
+*  (`secret`) matches. Mirrors `findLaunchByNonce`. */
+function findLaunchBySecret(secret) {
+	for (const entry of state.launchRegistry.values()) if (constantTimeStringEqual(entry.secret, secret)) return entry;
+}
+//#endregion
 //#region src/lib/peer-attachments.ts
 /**
 * Server-side image loading for peer-critic attachments (`imagePaths`).
@@ -27268,6 +27701,67 @@ function generalPurposeFastModel() {
 		minContextTokens: ONE_M_TOKENS
 	});
 }
+const FAST_SCOUT_MODEL = "gpt-5.6-luna";
+const FAST_IMPLEMENTER_MODEL = "gpt-5.6-luna";
+/** 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";
+function fastScoutModel() {
+	return firstPresentInCatalog([FAST_SCOUT_MODEL], {
+		requireToolCalls: true,
+		minContextTokens: ONE_M_TOKENS
+	});
+}
+function fastImplementerModel() {
+	return firstPresentInCatalog([FAST_IMPLEMENTER_MODEL], {
+		requireToolCalls: true,
+		minContextTokens: ONE_M_TOKENS
+	});
+}
+function fastPlannerModel() {
+	const id = firstPresentInCatalog([FAST_PLANNER_MODEL], {
+		requireToolCalls: true,
+		minContextTokens: ONE_M_TOKENS
+	});
+	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;
+	return id;
+}
+/** Gate Grok on the prompt limit that actually constrains pasted review input. */
+function fastReviewerModel() {
+	const models = state.models?.data;
+	if (!models) return void 0;
+	const found = models.find((m) => m.id === FAST_REVIEWER_MODEL);
+	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 ((found.capabilities?.limits?.max_prompt_tokens ?? 0) < 2e5) return void 0;
+	if (pickEndpoint(found) !== "responses") return void 0;
+	return FAST_REVIEWER_MODEL;
+}
+/** Exact Opus 5 only: the fast Oracle never inherits standard opus_critic's
+*  older-family fallback. */
+function fastOracleModel() {
+	const found = state.models?.data.find((m) => m.id === FAST_ORACLE_MODEL);
+	if (!found) return void 0;
+	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 (found.capabilities?.supports?.adaptive_thinking !== true) return void 0;
+	if (!(found.supported_endpoints ?? []).some((endpoint) => endpoint === "/messages" || endpoint === "/v1/messages")) return void 0;
+	return FAST_ORACLE_MODEL;
+}
 /**
 * Gate for the worker tools (`explore`, `review`, `implement`).
 *
@@ -27492,40 +27986,29 @@ function isLoopbackHost(host) {
 	const hostname = idx >= 0 ? host.slice(0, idx) : host;
 	return hostname === "127.0.0.1" || hostname === "localhost";
 }
-/**
-* Constant-time bearer compare. Random per-launch nonces aren't really
-* timing-attackable in practice, but this costs nothing.
-*/
-function nonceMatches(provided, expected) {
-	if (provided.length !== expected.length) return false;
-	const a = Buffer.from(provided);
-	const b = Buffer.from(expected);
-	try {
-		return timingSafeEqual(a, b);
-	} catch {
-		return false;
-	}
-}
 function checkAuth(c) {
 	if (!isLoopbackHost(c.req.header("host"))) return {
 		ok: false,
 		status: 403,
 		reason: "non-loopback Host header rejected"
 	};
-	const expected = state.peerMcpNonce;
-	if (!expected) return {
+	if (state.launchRegistry.size === 0) return {
 		ok: false,
 		status: 401,
 		reason: "/mcp not enabled in this proxy session"
 	};
 	const auth = c.req.header("authorization") ?? "";
 	const m = /^Bearer\s+(.+)$/i.exec(auth);
-	if (!m || !nonceMatches(m[1], expected)) return {
+	const launch = m ? findLaunchByNonce(m[1]) : void 0;
+	if (!launch) return {
 		ok: false,
 		status: 401,
 		reason: "missing or invalid Authorization bearer"
 	};
-	return { ok: true };
+	return {
+		ok: true,
+		launch
+	};
 }
 /**
 * opus_critic's effective model, resolved against the live catalog.
@@ -27566,8 +28049,54 @@ function activePersonas() {
 		};
 	});
 }
-function toolEntries(scope) {
-	const personaEntries = scope === "all" || scope === "peers" ? activePersonas().map((p) => ({
+function oracleToolEntry() {
+	return {
+		name: "oracle",
+		description: "Fast-profile last-resort guidance from exact Opus 5 (1M context) at high effort. Stateless and tool-less: pass complete context plus one precise query only after the primary Luna path, Advisor, and the relevant reviewer/planner path remain stuck. It can advise or request missing information; it cannot inspect the repo, execute, merge, or authorize actions.",
+		inputSchema: {
+			type: "object",
+			required: ["query", "context"],
+			additionalProperties: false,
+			properties: {
+				query: {
+					type: "string",
+					description: "One precise unresolved question."
+				},
+				context: {
+					type: "string",
+					description: "Complete evidence and constraints needed to answer cold-start."
+				}
+			}
+		}
+	};
+}
+function toolEntries(scope, launch) {
+	if (launch.profileId === "fast") {
+		const entries = [];
+		if ((scope === "all" || scope === "peers") && launch.allowedGroups?.has("peers") && launch.allowedPersonas?.has("oracle") && fastOracleModel()) entries.push(oracleToolEntry());
+		for (const tool of NON_PERSONA_MCP_TOOLS) {
+			if (scope !== "all" && tool.group !== scope) continue;
+			if (!launch.allowedGroups?.has(tool.group)) continue;
+			if (tool.group === "search") {
+				entries.push({
+					name: tool.toolNameHttp,
+					description: tool.description,
+					inputSchema: tool.inputSchema
+				});
+				continue;
+			}
+			if (tool.group !== "browser" || !browserToolsEnabled()) continue;
+			if (tool.capability === "browser_compound" && !browserCompoundToolsEnabled()) continue;
+			if (tool.capability === "browser_power" && !browserPowerToolsEnabled()) continue;
+			entries.push({
+				name: tool.toolNameHttp,
+				description: tool.description,
+				inputSchema: tool.inputSchema
+			});
+		}
+		return entries;
+	}
+	const personaEntries = (!launch.allowedGroups || launch.allowedGroups.has("peers")) && (scope === "all" || scope === "peers") ? activePersonas().filter((p) => !launch.allowedPersonas || launch.allowedPersonas.has(p.toolNameHttp)).map((p) => ({
 		name: p.toolNameHttp,
 		description: p.description,
 		inputSchema: {
@@ -27598,6 +28127,7 @@ function toolEntries(scope) {
 	})) : [];
 	const nonPersonaEntries = NON_PERSONA_MCP_TOOLS.filter((t) => {
 		if (scope !== "all" && t.group !== scope) return false;
+		if (launch.allowedGroups && !launch.allowedGroups.has(t.group)) return false;
 		if (t.capability === "worker") return workerToolsEnabled();
 		if (t.capability === "browse_agent") return browseAgentEnabled();
 		if (t.capability === "stand_in") return standInToolEnabled();
@@ -27839,7 +28369,7 @@ function jsonPathPreflightCap(body, scope) {
 async function dispatchModelCall(args) {
 	const resolvedModel = resolveModel(args.model);
 	if (args.endpoint === "/v1/responses") {
-		const payload = {
+		const payload = applyResponsesCachePolicy({
 			model: resolvedModel,
 			instructions: args.instructions,
 			input: [{
@@ -27854,7 +28384,7 @@ async function dispatchModelCall(args) {
 			}],
 			stream: false,
 			reasoning: { effort: args.effort }
-		};
+		}, { workload: "reusable-prefix" });
 		return extractResponsesText(await withTransientRetry(() => createResponses(payload, void 0, args.signal), {
 			signal: args.signal,
 			label: resolvedModel
@@ -27862,7 +28392,7 @@ async function dispatchModelCall(args) {
 	}
 	if (args.endpoint === "/v1/messages") {
 		const maxTokens = args.effort === "low" ? 4096 : args.effort === "medium" ? 8192 : args.effort === "high" ? 16384 : 32768;
-		const body = JSON.stringify({
+		const body = applyClaudeCachePolicy(JSON.stringify({
 			model: resolvedModel,
 			max_tokens: maxTokens,
 			system: args.instructions,
@@ -27885,7 +28415,7 @@ async function dispatchModelCall(args) {
 				role: "user",
 				content: args.userText
 			}]
-		});
+		}), { workload: "reusable-prefix" });
 		return extractMessagesText(await (await withTransientRetry(() => createMessages(body, void 0, args.signal), {
 			signal: args.signal,
 			label: resolvedModel
@@ -27970,16 +28500,87 @@ function applySessionWorkspace(args, sessionWorkspace, tool) {
 	}
 	return "absent";
 }
-async function handleToolsCall(body, scope, sessionWorkspace) {
+async function handleToolsCall(body, scope, launch, sessionWorkspace) {
 	const params = body.params ?? {};
 	const name = typeof params.name === "string" ? params.name : "";
 	const args = params.arguments ?? {};
 	if (!name) return rpcError(body.id, RPC_INVALID_PARAMS, "tools/call missing name");
+	if (launch.profileId === "fast" && name === "oracle") {
+		if (scope !== "all" && scope !== "peers" || !launch.allowedGroups?.has("peers") || !launch.allowedPersonas?.has("oracle") || !fastOracleModel()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
+		const query = typeof args.query === "string" ? args.query.trim() : "";
+		const context = typeof args.context === "string" ? args.context.trim() : "";
+		if (!query || !context) return rpcError(body.id, RPC_INVALID_PARAMS, "tools/call: oracle requires non-empty arguments.query and arguments.context");
+		const MAX_ORACLE_INPUT_BYTES = 262144;
+		const oracleInput = `Query:\n${query}\n\nContext:\n${context}`;
+		const inputBytes = Buffer.byteLength(oracleInput, "utf8");
+		if (inputBytes > MAX_ORACLE_INPUT_BYTES) return rpcResult(body.id, toolError(`pre-flight rejected: oracle input is ${inputBytes} bytes, over the ${MAX_ORACLE_INPUT_BYTES}-byte cap; narrow the context without silently truncating it`));
+		const oraclePersona = {
+			agentName: "oracle",
+			toolNameHttp: "oracle",
+			model: "claude-opus-5",
+			endpoint: "/v1/messages",
+			description: "Fast-profile Oracle",
+			baseInstructions: "You are Oracle, a stateless last-resort consultant. You have no tools or repository access. Answer only from the supplied context. Give focused guidance or ask for the exact missing information. Never claim to execute, approve, merge, or authorize an action.",
+			agentPrompt: "",
+			writeCapable: false,
+			requiresHttp: true,
+			allowedEfforts: ["high"],
+			defaultEffort: "high"
+		};
+		const overflow = await predictedWindowOverflow(oraclePersona, oracleInput, void 0);
+		if (overflow) return rpcResult(body.id, toolError(overflow));
+		const release = acquireInFlightSlot();
+		if (!release) return rpcResult(body.id, toolError(`Peer MCP queue full (${MAX_INFLIGHT_TOOLS_CALL} in-flight). Retry shortly.`));
+		const startedAt = Date.now();
+		const abortKey = body.id !== void 0 && body.id !== null ? body.id : void 0;
+		const aborter = new AbortController();
+		const inflightEntry = {
+			aborter,
+			release
+		};
+		if (abortKey !== void 0) inflightAborts.set(abortKey, inflightEntry);
+		try {
+			const text = await dispatchModelCall({
+				model: "claude-opus-5",
+				endpoint: "/v1/messages",
+				instructions: oraclePersona.baseInstructions,
+				userText: oracleInput,
+				effort: "high",
+				signal: aborter.signal
+			});
+			logTelemetry({
+				name: "oracle",
+				model: "claude-opus-5",
+				durationMs: Date.now() - startedAt,
+				result: "ok"
+			});
+			return rpcResult(body.id, { content: [{
+				type: "text",
+				text
+			}] });
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			logTelemetry({
+				name: "oracle",
+				model: "claude-opus-5",
+				durationMs: Date.now() - startedAt,
+				result: "exception",
+				errorMessage: message
+			});
+			return rpcResult(body.id, toolError(`oracle failed: ${message}`));
+		} finally {
+			if (abortKey !== void 0 && inflightAborts.get(abortKey) === inflightEntry) inflightAborts.delete(abortKey);
+			release();
+		}
+	}
+	if (launch.profileId === "fast" && PERSONAS_READ.some((p) => p.toolNameHttp === name)) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	const persona = activePersonas().find((p) => p.toolNameHttp === name);
 	const nonPersonaTool = persona ? void 0 : NON_PERSONA_MCP_TOOLS.find((t) => t.toolNameHttp === name);
 	if (!persona && !nonPersonaTool) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	const toolGroup = persona ? "peers" : nonPersonaTool.group;
 	if (scope !== "all" && toolGroup !== scope) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
+	if (launch.allowedGroups && !launch.allowedGroups.has(toolGroup)) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
+	if (persona && launch.allowedPersonas && !launch.allowedPersonas.has(persona.toolNameHttp)) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "worker" && !workerToolsEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "browse_agent" && !browseAgentEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "stand_in" && !standInToolEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
@@ -28087,7 +28688,7 @@ function handleCancelledNotification(body) {
 	}
 	cancelInflight(requestId, "client requested cancellation");
 }
-async function handleRpc(_c, body, scope, sessionWorkspace) {
+async function handleRpc(_c, body, scope, launch, sessionWorkspace) {
 	if (body === null || typeof body !== "object" || Array.isArray(body)) return {
 		status: 200,
 		body: rpcError(null, RPC_INVALID_REQUEST, "jsonrpc 2.0 envelope required")
@@ -28129,7 +28730,7 @@ async function handleRpc(_c, body, scope, sessionWorkspace) {
 			};
 			return {
 				status: 200,
-				body: rpcResult(body.id, { tools: toolEntries(scope) })
+				body: rpcResult(body.id, { tools: toolEntries(scope, launch) })
 			};
 		case "tools/call":
 			if (isNotification) return {
@@ -28138,7 +28739,7 @@ async function handleRpc(_c, body, scope, sessionWorkspace) {
 			};
 			return {
 				status: 200,
-				body: await handleToolsCall(body, scope, sessionWorkspace)
+				body: await handleToolsCall(body, scope, launch, sessionWorkspace)
 			};
 		case "resources/list":
 			if (isNotification) return {
@@ -28218,6 +28819,7 @@ async function handleRpc(_c, body, scope, sessionWorkspace) {
 async function handleMcpPost(c, scopeArg = "all") {
 	const auth = checkAuth(c);
 	if (!auth.ok) return c.json(rpcError(null, RPC_INVALID_REQUEST, auth.reason), auth.status);
+	const { launch } = auth;
 	let scope;
 	if (scopeArg === "all") scope = "all";
 	else if (isMcpGroup(scopeArg)) scope = scopeArg;
@@ -28234,13 +28836,13 @@ async function handleMcpPost(c, scopeArg = "all") {
 		const nm = typeof body.params?.name === "string" ? body.params.name : "?";
 		process.stderr.write(`[peer-mcp] recv t=${Date.now()} name=${nm} scope=${scope} inflight=${currentInFlight()}\n`);
 	}
-	if (typeof body === "object" && body !== null && !Array.isArray(body) && body.method === "tools/call" && acceptsEventStream(c.req.header("accept"))) return handleToolsCallSSE(body, scope, sessionWorkspace);
+	if (typeof body === "object" && body !== null && !Array.isArray(body) && body.method === "tools/call" && acceptsEventStream(c.req.header("accept"))) return handleToolsCallSSE(body, scope, launch, sessionWorkspace);
 	if (typeof body === "object" && body !== null && !Array.isArray(body) && body.method === "tools/call") {
 		const preflight = jsonPathPreflightCap(body, scope);
 		if (preflight) return c.json(preflight, 200);
 	}
 	try {
-		const { status, body: respBody } = await handleRpc(c, body, scope, sessionWorkspace);
+		const { status, body: respBody } = await handleRpc(c, body, scope, launch, sessionWorkspace);
 		if (respBody === null) return c.body(null, status);
 		return c.json(respBody, status);
 	} catch (err) {
@@ -28293,9 +28895,9 @@ function acceptsEventStream(accept) {
 * "Invalid state: Controller is already closed" race without warning.
 */
 const SSE_HEARTBEAT_INTERVAL_MS = 5e3;
-async function handleToolsCallSSE(body, scope, sessionWorkspace) {
+async function handleToolsCallSSE(body, scope, launch, sessionWorkspace) {
 	const encoder = new TextEncoder();
-	const callPromise = handleToolsCall(body, scope, sessionWorkspace);
+	const callPromise = handleToolsCall(body, scope, launch, sessionWorkspace);
 	let heartbeatHandle;
 	const stream = new ReadableStream({
 		async start(controller) {
@@ -28972,13 +29574,18 @@ const ADVISOR_INTERNAL_TOOL_NAME = "__anthropic_advisor";
 const ADVISOR_CLIENT_TOOL_NAME = "advisor";
 /** Default advisor model + reasoning effort. Per gemini-critic + user
 *  direction: hardcode to a cross-lab model (gpt-5.6-sol — Copilot's
-*  /responses-only flagship) at xhigh effort. The cross-lab choice
-*  gives a true "second set of eyes" instead of the main model
-*  reviewing itself; xhigh effort buys the deep-dive reasoning that
-*  matches Anthropic's own ADVISOR (which uses a stronger reviewer
-*  model — Opus 4.6/Sonnet 4.6 typically). */
+*  /responses-only flagship). The cross-lab choice gives a true "second set
+*  of eyes" instead of the main model reviewing itself.
+*
+*  Effort default is `high`, not the historical `xhigh`: `resolveAdvisorEffort`
+*  no longer floors the picked effort (see that function), so `high` is both
+*  the default AND the lowest the advisor will ever think at when the picker
+*  expresses no preference — a deliberate, user-approved cost/depth trade
+*  applied uniformly across every advisor target (Sol, the Opus escalation,
+*  and the fast-profile Gemini advisor below all read this same constant). */
 const ADVISOR_DEFAULT_MODEL = "gpt-5.6-sol";
 const ADVISOR_DEFAULT_EFFORT = "xhigh";
+const ADVISOR_MIN_EFFORT = "high";
 /** The Anthropic frontier model the advisor escalates to when the LEAD is a
 *  lighter Claude tier (sonnet, haiku).
 *
@@ -28995,16 +29602,32 @@ const ADVISOR_DEFAULT_EFFORT = "xhigh";
 *  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";
-/** Floor for the advisor's reasoning effort.
-*
-*  The advisor follows the Claude Code effort picker (see `resolveAdvisorEffort`)
-*  so dialing the picker down makes it cheaper, but it does NOT follow it all the
-*  way to the bottom of `EFFORT_ORDER`. The advisor fires a handful of times per
-*  session (`ADVISOR_MAX_TURNS`, typically 1-3), so it is not the budget line —
-*  the lead's own turns are — while an advisor reasoning at `none`/`low` cannot
-*  do the job the consultation exists for. The picker therefore governs the
-*  `high..max` range. */
-const ADVISOR_MIN_EFFORT = "high";
+/** 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. */
+function fastProfileAdvisorAvailable() {
+	return state.models?.data?.some((m) => m.id === "gemini-3.7-flash") ?? false;
+}
 /** Output cap for the Anthropic-branch advisor call when the catalog carries no
 *  limits for the resolved model. The value the branch used unconditionally
 *  before it became reachable, kept so a catalog-less path is no worse off. */
@@ -29036,6 +29659,28 @@ function advisorUsesResponses(resolvedAdvisorModel) {
 	if (endpoints && endpoints.length > 0) return endpoints.some((e) => ADVISOR_RESPONSES_ENDPOINTS.has(e));
 	return /^(gpt-|o\d|.*codex)/i.test(bare);
 }
+/**
+* Decide `advisorTransport` for a resolved advisor model id.
+*
+* Order matters: Claude identity is checked FIRST and wins even though
+* `claude-opus-5` also advertises `/chat/completions` in the live catalog —
+* the historical branch never sent Claude to chat, and this preserves that
+* byte-for-byte (reuses the SAME classifier `classifyMessagesRoute` uses for
+* the main `/v1/messages` shim fork, so the two surfaces cannot disagree
+* about what counts as a Claude model). Responses is checked next
+* (`advisorUsesResponses`, unchanged — catalog-first, name-regex fallback,
+* still exported and directly tested on its own). Anything else defaults to
+* 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.
+*/
+function advisorTransport(resolvedAdvisorModel) {
+	const bare = resolvedAdvisorModel.slice(resolvedAdvisorModel.lastIndexOf("/") + 1);
+	const entry = state.models?.data?.find((m) => m.id === resolvedAdvisorModel || m.id === bare);
+	if (isClaudeModel(resolvedAdvisorModel, entry)) return "messages";
+	if (advisorUsesResponses(resolvedAdvisorModel)) return "responses";
+	return "chat";
+}
 /** True when the model advertises a usable reasoning-effort ladder. */
 function advertisedEffortLadder(resolvedAdvisorModel) {
 	const supported = state.models?.data?.find((m) => m.id === resolvedAdvisorModel)?.capabilities?.supports?.reasoning_effort;
@@ -29072,10 +29717,16 @@ function shouldEscalateAdvisor(leadModel) {
 * Precedence:
 *   1. `GH_ROUTER_ADVISOR_MODEL` (trimmed) — the operator pin, checked first so
 *      it works on every lead.
-*   2. A lighter Claude lead with the escalation model in the catalog.
-*   3. `ADVISOR_DEFAULT_MODEL`.
+*   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 3 returns the LITERAL constant rather than walking the OpenAI frontier
+* 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.
@@ -29104,19 +29755,27 @@ function normalizeAdvisorPin(pinned) {
 	const bare = pinned.slice(pinned.lastIndexOf("/") + 1);
 	return bare !== pinned && models.some((m) => m.id === bare) ? bare : pinned;
 }
-function resolveAdvisorModel(leadModel) {
+function resolveAdvisorModel(leadModel, fastProfile = false) {
 	const pinned = process.env.GH_ROUTER_ADVISOR_MODEL?.trim();
 	if (pinned) return {
 		model: normalizeAdvisorPin(pinned),
-		escalated: false
+		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
+		escalated: true,
+		fastProfile: false
 	};
 	return {
 		model: ADVISOR_DEFAULT_MODEL,
-		escalated: false
+		escalated: false,
+		fastProfile: false
 	};
 }
 /**
@@ -29138,13 +29797,16 @@ function resolveAdvisorModel(leadModel) {
 *   3. `ADVISOR_DEFAULT_EFFORT` — a request expressing no preference behaves
 *      exactly as it did before the picker was honored at all.
 *
-* Then floor, THEN clamp. The order is load-bearing: a model whose ceiling sits
-* below `ADVISOR_MIN_EFFORT` must still receive a value it accepts, so the clamp
-* is allowed to pull back under the floor. Flipping the two would forward an
-* effort upstream rejects.
+* There is deliberately NO floor anymore (removed per the user-approved
+* "default high, no floor" change): the advisor follows the picker all the way
+* down as well as up, so an explicit `none`/`low` pick is honored rather than
+* clamped up to a minimum. The only remaining adjustment is the CEILING clamp
+* against the resolved advisor's own live `reasoning_effort` allowlist — a
+* model whose ladder tops out below the requested tier still needs to receive
+* something it accepts.
 */
-function resolveAdvisorEffort(rawRequestBody, advisorModel) {
-	let requested = ADVISOR_DEFAULT_EFFORT;
+function resolveAdvisorEffort(rawRequestBody, advisorModel, fastProfile = false) {
+	let requested = fastProfile ? "high" : ADVISOR_DEFAULT_EFFORT;
 	if (rawRequestBody) try {
 		const body = JSON.parse(rawRequestBody);
 		const oc = body.output_config;
@@ -29153,10 +29815,11 @@ function resolveAdvisorEffort(rawRequestBody, advisorModel) {
 		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 {}
-	const floored = EFFORT_ORDER.indexOf(requested) < EFFORT_ORDER.indexOf(ADVISOR_MIN_EFFORT) ? ADVISOR_MIN_EFFORT : requested;
+	if (fastProfile) requested = "high";
+	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 floored;
-	return clampEffort(floored, supported);
+	if (!Array.isArray(supported) || supported.length === 0) return requested;
+	return clampEffort(requested, supported);
 }
 /** ADVISOR_TOOL_INSTRUCTIONS verbatim from cc-backup
 *  src/utils/advisor.ts — describes when the model should invoke
@@ -29386,8 +30049,9 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 		maxUnits = ADVISOR_MAX_CONVERSATION_CHARS;
 	}
 	const conversationText = renderConversationAsText(conversation, maxUnits, measure);
-	if (advisorUsesResponses(resolvedAdvisorModel)) {
-		const payload = {
+	const transport = advisorTransport(resolvedAdvisorModel);
+	if (transport === "responses") {
+		const payload = applyResponsesCachePolicy({
 			model: resolvedAdvisorModel,
 			instructions: advisorSystem,
 			input: [{
@@ -29399,7 +30063,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 			}],
 			stream: false,
 			reasoning: { effort: advisorEffort }
-		};
+		}, { workload: "reusable-prefix" });
 		const response = await withTransientRetry(() => createResponses(payload, void 0, signal), {
 			signal,
 			label: resolvedAdvisorModel
@@ -29421,10 +30085,31 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 		if (!text) throw new Error(`Advisor model ${resolvedAdvisorModel} returned empty assistant output`);
 		return text;
 	}
+	if (transport === "chat") {
+		const ladder = advertisedEffortLadder(resolvedAdvisorModel);
+		const chatPayload = {
+			model: resolvedAdvisorModel,
+			messages: [{
+				role: "system",
+				content: advisorSystem
+			}, {
+				role: "user",
+				content: conversationText
+			}],
+			stream: false,
+			...ladder ? { reasoning_effort: advisorEffort } : {}
+		};
+		const text = (await withTransientRetry(() => createChatCompletions(chatPayload, void 0, signal), {
+			signal,
+			label: resolvedAdvisorModel
+		})).choices?.[0]?.message?.content;
+		if (typeof text !== "string" || text.length === 0) throw new Error(`Advisor model ${resolvedAdvisorModel} returned empty response`);
+		return text;
+	}
 	const advisorEntry = state.models?.data?.find((m) => m.id === resolvedAdvisorModel);
 	const limits = advisorEntry?.capabilities?.limits;
 	const maxTokens = limits?.max_non_streaming_output_tokens ?? limits?.max_output_tokens ?? ADVISOR_FALLBACK_MAX_OUTPUT_TOKENS;
-	const advisorBody = JSON.stringify({
+	const advisorBody = applyClaudeCachePolicy(JSON.stringify({
 		model: resolvedAdvisorModel,
 		max_tokens: maxTokens,
 		system: advisorSystem,
@@ -29437,7 +30122,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 			thinking: { type: "adaptive" },
 			...advertisedEffortLadder(resolvedAdvisorModel) ? { output_config: { effort: advisorEffort } } : {}
 		} : {}
-	});
+	}), { workload: "reusable-prefix" });
 	const json = await (await withTransientRetry(() => createMessages(advisorBody, {}, signal), {
 		signal,
 		label: resolvedAdvisorModel
@@ -29449,20 +30134,51 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 /**
 * Derive a spec-compliant `srvtoolu_*` id for a client-facing
 * `server_tool_use` (and matching `advisor_tool_result.tool_use_id`)
-* from the upstream model's `toolu_*` id.
-*
-* Anthropic spec: `^srvtoolu_[a-zA-Z0-9_]+$`. If the upstream id
-* suffix contains chars outside that charset (e.g., a hyphenated id
-* from a non-Anthropic provider, or a corrupt id), fall back to a
-* synthesized stable id keyed by the SSE block index. Defensive
-* against edge cases that would otherwise emit a malformed block —
-* spec violation in either direction is a 400.
-*/
-function toClientServerToolUseId(id, _fallbackIndex) {
-	if (!id.startsWith("toolu_")) throw new Error("advisor tool_use id is not round-trippable");
-	const suffix = id.slice(6);
-	if (!/^[a-zA-Z0-9_]+$/.test(suffix)) throw new Error("advisor tool_use id is not round-trippable");
-	return `srvtoolu_${suffix}`;
+* from the upstream model's tool-call id.
+*
+* TOTAL — never throws. Two paths:
+*
+*   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
+*      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,
+*      unicode, or a corrupt id — sanitize to the Anthropic charset and
+*      prefix with `fallbackIndex` (the caller's per-block synthetic stream
+*      index, unique within one `buildAdvisorStream` run) so two different
+*      raw ids that happen to sanitize to the same string can never
+*      collide. `fallbackIndex` is REQUIRED for this path's uniqueness
+*      guarantee — callers must pass a value that is unique per call within
+*      one advisor stream (every call site does: `myIndex` from the
+*      turn processor's monotonic `nextSyntheticIndex`).
+*
+* This function ONLY has to produce a valid, deterministic, collision-free
+* LABEL — the original raw id is preserved separately for Copilot replay
+* (`CapturedBlock.advisorReplay.id`), never reconstructed from the derived
+* client id. That is what makes totality safe: there is no bijective-decode
+* requirement on this function itself, only on the (id, clientId) pairing a
+* caller keeps alongside it.
+*
+* 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
+* 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
+* is EMPTY), so the advisor's `tool_use{__anthropic_advisor}` block on that
+* lead legitimately carries a `call_*` id and the throw fired on every
+* single advisor call.
+*/
+function toClientServerToolUseId(id, fallbackIndex) {
+	if (id.startsWith("toolu_")) {
+		const suffix = id.slice(6);
+		if (/^[a-zA-Z0-9_]+$/.test(suffix)) return `srvtoolu_${suffix}`;
+	}
+	const sanitized = id.replace(/[^a-zA-Z0-9_]/g, "_");
+	return `srvtoolu_gen${fallbackIndex}${sanitized.length > 0 ? `_${sanitized}` : ""}`;
 }
 /**
 * Build an SSE event line in the canonical Anthropic shape:
@@ -29474,6 +30190,35 @@ function sseEvent(type, data) {
 	return `event: ${type}\ndata: ${JSON.stringify(data)}\n\n`;
 }
 /**
+* The default `continueTurn` for `buildAdvisorStream`: native Claude
+* 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
+* Claude-only repair path entirely rather than inherit dead code that would
+* never fire for it.
+*/
+async function defaultContinueTurn(body, signal, requestHeaders) {
+	let continuationSend = JSON.stringify(body);
+	const knownRepair = repairKnownThinkingHistory(continuationSend);
+	if (knownRepair) continuationSend = knownRepair.body;
+	try {
+		return await createMessages(continuationSend, requestHeaders, signal, true);
+	} catch (continuationError) {
+		if (!(continuationError instanceof HTTPError)) throw continuationError;
+		const errorBody = await continuationError.response.clone().text().catch(() => "");
+		const outcome = repairRejectedThinkingHistory(continuationSend, errorBody);
+		if (!outcome.ok) {
+			consola.warn(`Advisor continuation thinking-history repair declined: ${formatThinkingRepairDecline(outcome.decline)}`);
+			throw continuationError;
+		}
+		consola.warn(`Advisor continuation: retrying without rejected thinking blocks: message=${outcome.repair.messageIndex} removed_blocks=${outcome.repair.removedBlocks}`);
+		const response = await createMessages(outcome.repair.body, requestHeaders, signal, true);
+		rememberThinkingHistoryRepair(outcome.repair.fingerprint);
+		return response;
+	}
+}
+/**
 * The streaming translate-loop. Returns a ReadableStream<Uint8Array>
 * suitable to wrap with Hono's c.body() / new Response().
 *
@@ -29492,6 +30237,7 @@ function buildAdvisorStream(opts) {
 	const advisorModel = opts.advisorModel ?? "gpt-5.6-sol";
 	const advisorEffort = opts.advisorEffort ?? "xhigh";
 	const advisorEscalated = opts.advisorEscalated ?? false;
+	const continueTurn = opts.continueTurn ?? ((body, signal) => defaultContinueTurn(body, signal, opts.requestHeaders));
 	const aborter = opts.externalAborter ?? new AbortController();
 	let conversation = [...opts.initialConversation];
 	return new ReadableStream({
@@ -29789,27 +30535,11 @@ function buildAdvisorStream(opts) {
 						}))
 					});
 					if (aborter.signal.aborted) return;
-					let continuationSend = JSON.stringify({
+					response = await continueTurn({
 						...opts.baseBody,
 						messages: conversation,
 						stream: true
-					});
-					const knownRepair = repairKnownThinkingHistory(continuationSend);
-					if (knownRepair) continuationSend = knownRepair.body;
-					try {
-						response = await createMessages(continuationSend, opts.requestHeaders, aborter.signal, true);
-					} catch (continuationError) {
-						if (!(continuationError instanceof HTTPError)) throw continuationError;
-						const errorBody = await continuationError.response.clone().text().catch(() => "");
-						const outcome = repairRejectedThinkingHistory(continuationSend, errorBody);
-						if (!outcome.ok) {
-							consola.warn(`Advisor continuation thinking-history repair declined: ${formatThinkingRepairDecline(outcome.decline)}`);
-							throw continuationError;
-						}
-						consola.warn(`Advisor continuation: retrying without rejected thinking blocks: message=${outcome.repair.messageIndex} removed_blocks=${outcome.repair.removedBlocks}`);
-						response = await createMessages(outcome.repair.body, opts.requestHeaders, aborter.signal, true);
-						rememberThinkingHistoryRepair(outcome.repair.fingerprint);
-					}
+					}, aborter.signal);
 				}
 				if (aborter.signal.aborted) return;
 				const finalIndex = nextSyntheticIndex++;
@@ -31625,6 +32355,17 @@ const ADVISOR_PARAMS = Type$1.Object({ concern: Type$1.String({
 	description: "What you want a second pair of eyes on — your current approach, the blocker you're stuck on, or the decision you're about to commit. Required: the advisor needs a focal point.",
 	minLength: 1
 }) });
+/**
+* Fixed reasoning effort for the WORKER'S own `advisor` tool call (distinct
+* from the server-side ADVISOR mechanism's `ADVISOR_DEFAULT_EFFORT` in
+* `src/services/advisor/advisor.ts`, which now follows the Claude Code
+* effort picker and defaults to `high`). This tool has no picker to follow —
+* it is a single fixed-effort consultation a worker triggers explicitly, not
+* a per-request value derived from client input — so it keeps its own
+* historical constant rather than sharing one that started varying for an
+* unrelated reason.
+*/
+const WORKER_ADVISOR_EFFORT = "xhigh";
 /** Advisor transcript budget — leaves headroom in the advisor's
 *  context window after the system prompt + concern + reasoning
 *  overhead. Truncate-from-front so the most recent turn (where the
@@ -31715,7 +32456,7 @@ function advisorTool(getMessages) {
 			const release = acquireInFlightSlot();
 			if (!release) throw new Error(`advisor: MCP in-flight cap (${MAX_INFLIGHT_TOOLS_CALL}) saturated; retry shortly`);
 			try {
-				const text = extractResponsesText(await createResponses({
+				const payload = applyResponsesCachePolicy({
 					model: resolvedModel,
 					instructions: advisorSystem,
 					input: [{
@@ -31726,8 +32467,9 @@ function advisorTool(getMessages) {
 						}]
 					}],
 					stream: false,
-					reasoning: { effort: ADVISOR_DEFAULT_EFFORT }
-				}, void 0, signal, true));
+					reasoning: { effort: WORKER_ADVISOR_EFFORT }
+				}, { workload: "reusable-prefix" });
+				const text = extractResponsesText(await createResponses(payload, void 0, signal, true));
 				if (!text) throw new Error("advisor returned empty output");
 				return textResult(text);
 			} finally {
@@ -34808,6 +35550,17 @@ function buildAgentPrompt(persona, opts) {
 */
 function buildPeerAwarenessSnippet(opts) {
 	const key = (g) => opts.groupKeys?.[g] ?? GROUP_META[g].preferredKey;
+	if (opts.profile === "fast") {
+		const fastPeersKey = key("peers");
+		const fastSearchKey = key("search");
+		return [
+			"## Peer review and advisor",
+			"",
+			`This is the fast launch profile. \`mcp__${fastPeersKey}__oracle\` is exact Opus 5 (1M/high), a stateless last-resort consultant after the primary Luna path, Advisor, and reviewer/planner remain stuck. Advisor is the transcript-aware brainstorming, sounding-board, fresh-look, uncertainty, and stuck path.`,
+			"",
+			`\`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.` : ""}`
+		].join("\n");
+	}
 	const peersKey = key("peers");
 	const searchKey = key("search");
 	const workersKey = key("workers");
@@ -34861,6 +35614,12 @@ function buildPeerAwarenessSnippet(opts) {
 */
 function buildPeerAwarenessSummary(opts) {
 	const key = (g) => opts.groupKeys?.[g] ?? GROUP_META[g].preferredKey;
+	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.",
+		`Advisor is the transcript-aware brainstorming/sounding-board/fresh-look path. \`mcp__${key("peers")}__oracle\` is exact Opus 5 (1M/high), stateless and last resort. \`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) => {
 		const modelId = opts.nativeAgentModels?.[name];
 		if (!modelId) return `\`${name}\``;
@@ -34895,6 +35654,22 @@ function buildPeerAwarenessSummary(opts) {
 	return lines.join("\n");
 }
 /**
+* Translate a `toolNameHttp`-keyed persona allowlist (the currency
+* `LaunchProfileDescriptor.personaAllowlist` uses, since that is what the MCP
+* boundary's `tools/call` narrowing filters on) into the `agentName`-keyed
+* allowlist `personasFor`'s `agentAllowlist` consumes (since that is the key
+* `buildPeerAgentDefinitions` uses to build subagent `.md` files). The two
+* identifiers differ (`gemini_critic` vs `gemini-critic`), so a caller wiring
+* a launch profile's persona restriction into subagent generation needs this
+* translation rather than assuming the sets are interchangeable.
+*/
+function agentNamesForToolAllowlist(toolAllowlist) {
+	const allow = toolAllowlist instanceof Set ? toolAllowlist : new Set(toolAllowlist);
+	const names = /* @__PURE__ */ new Set();
+	for (const p of [...PERSONAS_READ, ...PERSONAS_WRITE]) if (allow.has(p.toolNameHttp)) names.add(p.agentName);
+	return names;
+}
+/**
 * Applies the resolved Gemini review model to a persona requiring the Gemini
 * catalog: swaps `.model` and rewrites every literal occurrence of the
 * default id in `.description` so the two never disagree about which model
@@ -34919,8 +35694,10 @@ function resolveGeminiPersona(p, geminiModel) {
 }
 /** Convenience: every persona that should be registered for the given mode. */
 function personasFor(opts) {
+	const allow = opts.agentAllowlist == null ? void 0 : opts.agentAllowlist instanceof Set ? opts.agentAllowlist : new Set(opts.agentAllowlist);
 	const result = [];
 	for (const p of PERSONAS_READ) {
+		if (allow && !allow.has(p.agentName)) continue;
 		if (p.requiresGeminiCatalog) {
 			if (!opts.geminiAvailable) continue;
 			result.push(resolveGeminiPersona(p, opts.geminiModel));
@@ -34928,7 +35705,10 @@ function personasFor(opts) {
 		}
 		result.push(p);
 	}
-	if (opts.codexCli) for (const p of PERSONAS_WRITE) result.push(p);
+	if (opts.codexCli) for (const p of PERSONAS_WRITE) {
+		if (allow && !allow.has(p.agentName)) continue;
+		result.push(p);
+	}
 	return result;
 }
 const WEB_SEARCH_DESCRIPTION = "Web search via GitHub Copilot's MCP that returns answer text plus source URLs the caller can cite. It accepts a natural-language `query`; the upstream provider rewrites for the search index and the handler formats any references as markdown links. Use for current external information such as API documentation, error-message diagnosis, upstream issue searches, and claims that need web sources. Not for local repository discovery or code navigation, use code, Read, Grep, or Glob for workspace content. Prefer it over the built-in WebSearch when source URLs are needed or the built-in surface is geographically constrained.";
@@ -36111,6 +36891,6 @@ function enumerateInjectedMcpToolNames(groupKeys, opts = {}) {
 	return [...new Set(names)];
 }
 //#endregion
-export { handleMcpDelete as $, generateRandomPort as $t, satisfiesMinVersion as A, readResponseBodyCapped as At, rememberThinkingHistoryRepair as B, CONDENSED_OPERATING_SEQUENCE as Bt, availableToolCommands as C, getTokenCount as Ct, vscodeRipgrepPath as D, createResponses as Dt, toolbeltSkipSet as E, resolveMcpToolTimeoutMs as Et, injectAdvisorTool as F, provisionAndIndexColbert as Ft, isControllerClosedError as G, BUDGET_SMALL_FAST_CATALOG_ID as Gt, repairRejectedThinkingHistory as H, shouldUseInsecureTls as Ht, isAdvisorRequested as I, extractTarGzMember as It, relayAnthropicStream as J, DEFAULT_CODEX_MODEL as Jt, logStreamError as K, BUDGET_SMALL_FAST_SLUG as Kt, resolveAdvisorEffort as L, extractZipMember as Lt, ADVISOR_INTERNAL_TOOL_NAME as M, provisionBrowserAssets as Mt, ADVISOR_TOOL_INSTRUCTIONS as N, hasSupportedBrowserInstalled as Nt, TOOLBELT_TOOLS$1 as O, createChatCompletions as Ot, buildAdvisorStream as P, colbertDegradedWarning as Pt, clampEffort as Q, UPSTREAM_INACTIVITY_TIMEOUT_MS as Qt, resolveAdvisorModel as R, warmTreeSitterPool as Rt, buildEnv as S, createMessages as St, toolbeltEnabled as T, warnOnTokenPriceDrift as Tt, buildAnthropicErrorEvent as U, collapsePathKeys as Ut, repairKnownThinkingHistory as V, DEFINITION_OF_GREATNESS as Vt, buildOpenAIErrorEvent as W, toolbeltPathOverride as Wt, UNKNOWN_EFFORT_ANCHOR as X, DEFAULT_PORT as Xt, EFFORT_ORDER as Y, DEFAULT_CODEX_MODEL_FALLBACKS as Yt, bucketEffort as Z, UPSTREAM_FETCH_TIMEOUT_MS as Zt, appendPlanReminder as _, scribeModel as _t, buildPeerAwarenessSnippet as a, classifyMessagesRoute as an, browseAgentEnabled as at, resolveWorkerRunOpts as b, shimDefaultsToXhigh as bt, personasFor as c, withInstallLock as cn, fleetToolsEnabled as ct, EXPLORE_DEFAULT_MODEL as d, implementerFastModel as dt, isBudgetClaudeLead as en, handleMcpPost as et, EXPLORE_DEFAULT_THINKING as f, nativeSubagentModel as ft, TEST_DEFAULT_MODEL as g, scoutModel as gt, REVIEW_DEFAULT_MODEL as h, reviewerModel as ht, buildAgentPrompt as i, upstreamMaxConnections as in, brainstormModel as it, searchWeb as j, parseJsonOrDiagnose as jt, assetFor as k, MAX_RESPONSE_BODY_BYTES as kt, BROWSE_DEFAULT_MODEL as l, geminiAvailable as lt, PLAN_DEFAULT_MODEL as m, reviewerFastModel as mt, MCP_GROUPS as n, resolveLeadSlugArg as nn, agentToolsEnabled as nt, buildPeerAwarenessSummary as o, withOneMSuffix as on, browserCompoundToolsEnabled as ot, IMPLEMENT_DEFAULT_MODEL as p, resolveGeminiReviewModel as pt, readIteratorWithTimeout as q, DEFAULT_CLAUDE_MODEL_FALLBACKS as qt, assertMcpToolSurfaceConsistent as r, upstreamAllowH2 as rn, artifactToolsEnabled as rt, enumerateInjectedMcpToolNames as s, withOneMSuffixForLead as sn, browserToolsEnabled as st, GROUP_META as t, pickClaudeDefault as tn, REVIEW_FAST_DEFAULT_MODEL as tt, DEFAULT_MODEL_CHAIN as u, generalPurposeFastModel as ut, resolveDefaultModel as v, standInToolEnabled as vt, buildToolbeltAwareness as w, assembleResponsesPayload as wt, runWorkerAgent as x, countTokens as xt, resolveModeDefaults as y, workerToolsEnabled as yt, formatThinkingRepairDecline as z, provisionTreeSitterAssets as zt };
+export { bucketEffort as $, CONDENSED_OPERATING_SEQUENCE as $t, assetFor as A, countTokens as At, resolveAdvisorModel as B, createChatCompletions as Bt, buildEnv as C, withOneMSuffixForLead as Cn, reviewerFastModel as Ct, toolbeltSkipSet as D, standInToolEnabled as Dt, toolbeltEnabled as E, scribeModel as Et, buildAdvisorStream as F, unregisterLaunch as Ft, buildAnthropicErrorEvent as G, provisionBrowserAssets as Gt, rememberThinkingHistoryRepair as H, readResponseBodyCapped as Ht, injectAdvisorTool as I, assembleResponsesPayload as It, logStreamError as J, provisionAndIndexColbert as Jt, buildOpenAIErrorEvent as K, hasSupportedBrowserInstalled as Kt, isAdvisorRequested as L, warnOnTokenPriceDrift as Lt, searchWeb as M, getTokenCount as Mt, ADVISOR_INTERNAL_TOOL_NAME as N, findLaunchBySecret as Nt, vscodeRipgrepPath as O, workerToolsEnabled as Ot, ADVISOR_TOOL_INSTRUCTIONS as P, registerLaunch as Pt, UNKNOWN_EFFORT_ANCHOR as Q, provisionTreeSitterAssets as Qt, isFastProfileLead as R, resolveMcpToolTimeoutMs as Rt, runWorkerAgent as S, withOneMSuffix as Sn, resolveGeminiReviewModel as St, buildToolbeltAwareness as T, scoutModel as Tt, repairKnownThinkingHistory as U, parseJsonOrDiagnose as Ut, formatThinkingRepairDecline as V, MAX_RESPONSE_BODY_BYTES as Vt, repairRejectedThinkingHistory as W, normalizeOpenAIUsage as Wt, relayAnthropicStream as X, extractZipMember as Xt, readIteratorWithTimeout as Y, extractTarGzMember as Yt, EFFORT_ORDER as Z, warmTreeSitterPool as Zt, TEST_DEFAULT_MODEL as _, upstreamMaxConnections as _n, fleetToolsEnabled as _t, buildAgentPrompt as a, BUDGET_SMALL_FAST_SLUG as an, FAST_SCOUT_EFFORT as at, resolveModeDefaults as b, catalogAdvertises1M as bn, implementerFastModel as bt, enumerateInjectedMcpToolNames as c, DEFAULT_CODEX_MODEL_FALLBACKS as cn, brainstormModel as ct, DEFAULT_MODEL_CHAIN as d, UPSTREAM_INACTIVITY_TIMEOUT_MS as dn, browserToolsEnabled as dt, DEFINITION_OF_GREATNESS as en, clampEffort as et, EXPLORE_DEFAULT_MODEL as f, generateRandomPort as fn, fastImplementerModel as ft, REVIEW_DEFAULT_MODEL as g, upstreamAllowH2 as gn, fastScoutModel as gt, PLAN_DEFAULT_MODEL as h, resolveLeadSlugArg as hn, fastReviewerModel as ht, assertMcpToolSurfaceConsistent as i, BUDGET_SMALL_FAST_CATALOG_ID as in, FAST_REVIEWER_EFFORT as it, satisfiesMinVersion as j, createMessages as jt, TOOLBELT_TOOLS$1 as k, shimDefaultsToXhigh as kt, personasFor as l, DEFAULT_PORT as ln, browseAgentEnabled as lt, IMPLEMENT_DEFAULT_MODEL as m, pickClaudeDefault as mn, fastPlannerModel as mt, MCP_GROUPS as n, collapsePathKeys as nn, handleMcpPost as nt, buildPeerAwarenessSnippet as o, DEFAULT_CLAUDE_MODEL_FALLBACKS as on, agentToolsEnabled as ot, EXPLORE_DEFAULT_THINKING as p, isBudgetClaudeLead as pn, fastOracleModel as pt, isControllerClosedError as q, colbertDegradedWarning as qt, agentNamesForToolAllowlist as r, toolbeltPathOverride as rn, FAST_PLANNER_EFFORT as rt, buildPeerAwarenessSummary as s, DEFAULT_CODEX_MODEL as sn, artifactToolsEnabled as st, GROUP_META as t, shouldUseInsecureTls as tn, handleMcpDelete as tt, BROWSE_DEFAULT_MODEL as u, UPSTREAM_FETCH_TIMEOUT_MS as un, browserCompoundToolsEnabled as ut, appendPlanReminder as v, classifyMessagesRoute as vn, geminiAvailable as vt, availableToolCommands as w, withInstallLock as wn, reviewerModel as wt, resolveWorkerRunOpts as x, oneMContextDisabled as xn, nativeSubagentModel as xt, resolveDefaultModel as y, pickEndpoint as yn, generalPurposeFastModel as yt, resolveAdvisorEffort as z, createResponses as zt };
 
-//# sourceMappingURL=peer-mcp-personas-B5Wp6wIn.js.map
+//# sourceMappingURL=peer-mcp-personas-CHbl6MwM.js.map