github-router 0.3.289 → 0.3.292

package/dist/{peer-mcp-personas-Bd56EmiO.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({
@@ -24248,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,
@@ -24260,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,
@@ -26764,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`).
@@ -27631,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`).
 *
@@ -27855,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.
@@ -27929,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: {
@@ -27961,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();
@@ -28333,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}"`);
@@ -28450,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")
@@ -28492,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 {
@@ -28501,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 {
@@ -28581,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;
@@ -28597,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) {
@@ -28656,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) {
@@ -29335,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).
 *
@@ -29358,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. */
@@ -29399,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;
@@ -29435,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`.
 *
-* Step 3 returns the LITERAL constant rather than walking the OpenAI frontier
+* Steps 2 and 3 are mutually exclusive lead families (non-Claude Luna vs. a
+* lighter Claude tier) so their relative order does not matter functionally;
+* fast-profile is checked first only because it is the more specific match.
+*
+* Step 4 returns the LITERAL constant rather than walking the OpenAI frontier
 * chain. An Opus lead must resolve to exactly what it resolves to today, and a
 * frontier walk could yield `gpt-5.5` on a catalog missing `gpt-5.6-sol` —
 * a silent change to the one path that is required not to move.
@@ -29467,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
 	};
 }
 /**
@@ -29501,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;
@@ -29516,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
@@ -29749,7 +30049,8 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 		maxUnits = ADVISOR_MAX_CONVERSATION_CHARS;
 	}
 	const conversationText = renderConversationAsText(conversation, maxUnits, measure);
-	if (advisorUsesResponses(resolvedAdvisorModel)) {
+	const transport = advisorTransport(resolvedAdvisorModel);
+	if (transport === "responses") {
 		const payload = applyResponsesCachePolicy({
 			model: resolvedAdvisorModel,
 			instructions: advisorSystem,
@@ -29784,6 +30085,27 @@ 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;
@@ -29812,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:
@@ -29837,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().
 *
@@ -29855,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({
@@ -30152,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++;
@@ -31988,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
@@ -32089,7 +32467,7 @@ function advisorTool(getMessages) {
 						}]
 					}],
 					stream: false,
-					reasoning: { effort: ADVISOR_DEFAULT_EFFORT }
+					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");
@@ -35172,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");
@@ -35225,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}\``;
@@ -35259,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
@@ -35283,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));
@@ -35292,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.";
@@ -36475,6 +36891,6 @@ function enumerateInjectedMcpToolNames(groupKeys, opts = {}) {
 	return [...new Set(names)];
 }
 //#endregion
-export { handleMcpDelete as $, UPSTREAM_INACTIVITY_TIMEOUT_MS as $t, satisfiesMinVersion as A, readResponseBodyCapped as At, rememberThinkingHistoryRepair as B, provisionTreeSitterAssets as Bt, availableToolCommands as C, getTokenCount as Ct, vscodeRipgrepPath as D, createResponses as Dt, toolbeltSkipSet as E, resolveMcpToolTimeoutMs as Et, injectAdvisorTool as F, colbertDegradedWarning as Ft, isControllerClosedError as G, toolbeltPathOverride as Gt, repairRejectedThinkingHistory as H, DEFINITION_OF_GREATNESS as Ht, isAdvisorRequested as I, provisionAndIndexColbert as It, relayAnthropicStream as J, DEFAULT_CLAUDE_MODEL_FALLBACKS as Jt, logStreamError as K, BUDGET_SMALL_FAST_CATALOG_ID as Kt, resolveAdvisorEffort as L, extractTarGzMember as Lt, ADVISOR_INTERNAL_TOOL_NAME as M, normalizeOpenAIUsage as Mt, ADVISOR_TOOL_INSTRUCTIONS as N, provisionBrowserAssets as Nt, TOOLBELT_TOOLS$1 as O, createChatCompletions as Ot, buildAdvisorStream as P, hasSupportedBrowserInstalled as Pt, clampEffort as Q, UPSTREAM_FETCH_TIMEOUT_MS as Qt, resolveAdvisorModel as R, extractZipMember as Rt, buildEnv as S, createMessages as St, toolbeltEnabled as T, warnOnTokenPriceDrift as Tt, buildAnthropicErrorEvent as U, shouldUseInsecureTls as Ut, repairKnownThinkingHistory as V, CONDENSED_OPERATING_SEQUENCE as Vt, buildOpenAIErrorEvent as W, collapsePathKeys as Wt, UNKNOWN_EFFORT_ANCHOR as X, DEFAULT_CODEX_MODEL_FALLBACKS as Xt, EFFORT_ORDER as Y, DEFAULT_CODEX_MODEL as Yt, bucketEffort as Z, DEFAULT_PORT as Zt, appendPlanReminder as _, scribeModel as _t, buildPeerAwarenessSnippet as a, upstreamMaxConnections as an, browseAgentEnabled as at, resolveWorkerRunOpts as b, shimDefaultsToXhigh as bt, personasFor as c, withOneMSuffixForLead as cn, fleetToolsEnabled as ct, EXPLORE_DEFAULT_MODEL as d, implementerFastModel as dt, generateRandomPort 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, upstreamAllowH2 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, withInstallLock as ln, geminiAvailable as lt, PLAN_DEFAULT_MODEL as m, reviewerFastModel as mt, MCP_GROUPS as n, pickClaudeDefault as nn, agentToolsEnabled as nt, buildPeerAwarenessSummary as o, classifyMessagesRoute as on, browserCompoundToolsEnabled as ot, IMPLEMENT_DEFAULT_MODEL as p, resolveGeminiReviewModel as pt, readIteratorWithTimeout as q, BUDGET_SMALL_FAST_SLUG as qt, assertMcpToolSurfaceConsistent as r, resolveLeadSlugArg as rn, artifactToolsEnabled as rt, enumerateInjectedMcpToolNames as s, withOneMSuffix as sn, browserToolsEnabled as st, GROUP_META as t, isBudgetClaudeLead 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, warmTreeSitterPool 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-Bd56EmiO.js.map
+//# sourceMappingURL=peer-mcp-personas-CHbl6MwM.js.map