github-router 0.3.289 → 0.3.293

package/dist/{peer-mcp-personas-Bd56EmiO.js → peer-mcp-personas-DhI7ZPSx.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`.
+*
+* 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.
@@ -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
@@ -29540,6 +29840,18 @@ On tasks longer than a few steps, call advisor at least once before committing t
 Give the advice serious weight. If you follow a step and it fails empirically, or you have primary-source evidence that contradicts a specific claim (the file says X, the code does Y), adapt. A passing self-test is not evidence the advice is wrong -- it's evidence your test doesn't check what the advice is checking.
 
 If you've already retrieved data pointing one way and the advisor points another: don't silently switch. Surface the conflict in one more advisor call -- "I found X, you suggest Y, which constraint breaks the tie?" The advisor saw your evidence but may have underweighted it; a reconcile call is cheaper than committing to the wrong branch.`;
+/** Fast-profile lead-only policy. Unlike the standard Claude Code instructions
+* above, this makes consultation optional and leaves decision ownership with
+* the Luna lead. Fast Task subagents never receive an advisor tool at all. */
+const FAST_ADVISOR_TOOL_INSTRUCTIONS = `# Advisor Tool
+
+You have access to an optional, transcript-aware \`advisor\` tool. It takes no parameters and returns non-binding consultation. You remain responsible for every decision.
+
+Use advisor only when a focused, consequential uncertainty remains after direct investigation: conflicting evidence, a materially changed assumption, a genuinely non-converging approach, a hard-to-reverse trade-off, or an explicit request for a fresh perspective. State the precise uncertainty in your response immediately before calling it.
+
+Do not call advisor for routine progress, while waiting on a subagent, after ordinary tool output, for a fact that code or a command can verify, to obtain planner approval or reviewer verification, or as a ritual before implementation or completion.
+
+Treat the result as advice, not authority. Weigh it against the user's intent, verified repository evidence, planner output, and reviewer findings. You may consult again when materially new evidence creates a different question or directly conflicts with earlier advice.`;
 const ADVISOR_OPT_OUT_ENV = "CLAUDE_CODE_DISABLE_ADVISOR_TOOL";
 /**
 * Detect whether the request asked for ADVISOR (incoming
@@ -29572,8 +29884,8 @@ function isAdvisorRequested(rawBetaHeader) {
 * client-shape `server_tool_use{name:"advisor"}` + `advisor_tool_result`
 * blocks the client expects.
 */
-function injectAdvisorTool(rawBody) {
-	if (rawBody.includes(`"name":"__anthropic_advisor"`) && !rawBody.includes("\"advisor_")) return rawBody;
+function injectAdvisorTool(rawBody, instructions = ADVISOR_TOOL_INSTRUCTIONS) {
+	if (instructions === ADVISOR_TOOL_INSTRUCTIONS && rawBody.includes(`"name":"__anthropic_advisor"`) && !rawBody.includes("\"advisor_")) return rawBody;
 	let parsed;
 	try {
 		parsed = JSON.parse(rawBody);
@@ -29588,10 +29900,14 @@ function injectAdvisorTool(rawBody) {
 	});
 	const stripped = tools.length !== rawTools.length;
 	const alreadyInjected = tools.some((t) => t?.name === ADVISOR_INTERNAL_TOOL_NAME);
-	if (alreadyInjected && !stripped) return rawBody;
-	parsed.tools = alreadyInjected ? tools : [...tools, {
+	const needsDescriptionUpdate = alreadyInjected && tools.some((t) => t?.name === "__anthropic_advisor" && t.description !== instructions);
+	if (alreadyInjected && !stripped && !needsDescriptionUpdate) return rawBody;
+	parsed.tools = alreadyInjected ? tools.map((tool) => tool?.name === "__anthropic_advisor" ? {
+		...tool,
+		description: instructions
+	} : tool) : [...tools, {
 		name: ADVISOR_INTERNAL_TOOL_NAME,
-		description: ADVISOR_TOOL_INSTRUCTIONS,
+		description: instructions,
 		input_schema: {
 			type: "object",
 			properties: {},
@@ -29732,9 +30048,9 @@ function truncateTailToUnits(text, maxUnits, measure) {
 * Anthropic's own ADVISOR ("see the whole task + every tool call +
 * every result").
 */
-async function runAdvisor(conversation, advisorModel, advisorEffort, signal, advisorEscalated = false) {
+async function runAdvisor(conversation, advisorModel, advisorEffort, signal, advisorEscalated = false, fastProfile = false) {
 	if (signal?.aborted) throw new Error("advisor call aborted before dispatch");
-	const advisorSystem = "You are an expert advisor reviewing an in-progress Claude Code session. The transcript below is the work-in-progress (turns numbered, with tool calls and results inlined). Read carefully and provide concrete, actionable advice on the next step or course-correction. Be specific — cite the parts of the transcript you're responding to. If the assistant is on the right track, say so explicitly. If they're stuck or off-track, name the specific assumption or step to revisit. Aim for 2-5 paragraphs of substantive guidance." + (advisorEscalated ? " The requesting agent is running a lighter, faster model than you. Give a directive recommendation and commit to the decision rather than laying out options for it to weigh." : "");
+	const advisorSystem = "You are an expert advisor reviewing an in-progress Claude Code session. The transcript below is the work-in-progress (turns numbered, with tool calls and results inlined). Read carefully and provide concrete, actionable advice on the next step or course-correction. Be specific — cite the parts of the transcript you're responding to. If the assistant is on the right track, say so explicitly. If they're stuck or off-track, name the specific assumption or step to revisit. Aim for 2-5 paragraphs of substantive guidance." + (fastProfile ? " You are a non-binding consultant to the primary lead. Analyze the focused uncertainty that prompted this call and provide a recommendation, its assumptions, material risks, credible alternatives, confidence, and any evidence gap that should be resolved. Do not approve, veto, dictate, or take ownership of the workflow; the lead will weigh your advice against the user's intent and verified evidence." : "") + (advisorEscalated && !fastProfile ? " The requesting agent is running a lighter, faster model than you. Give a directive recommendation and commit to the decision rather than laying out options for it to weigh." : "");
 	const resolvedAdvisorModel = resolveModel(advisorModel);
 	let measure;
 	let maxUnits;
@@ -29749,7 +30065,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 +30101,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 +30150,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 +30206,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 +30253,8 @@ function buildAdvisorStream(opts) {
 	const advisorModel = opts.advisorModel ?? "gpt-5.6-sol";
 	const advisorEffort = opts.advisorEffort ?? "xhigh";
 	const advisorEscalated = opts.advisorEscalated ?? false;
+	const advisorFastProfile = opts.advisorFastProfile ?? 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({
@@ -30104,7 +30504,7 @@ function buildAdvisorStream(opts) {
 					const advisorConversation = conversation;
 					const advisorTexts = await Promise.all(advisorToolUses.map(async () => {
 						try {
-							return await runAdvisor(advisorConversation, advisorModel, advisorEffort, aborter.signal, advisorEscalated);
+							return await runAdvisor(advisorConversation, advisorModel, advisorEffort, aborter.signal, advisorEscalated, advisorFastProfile);
 						} catch (err) {
 							if (aborter.signal.aborted) throw err;
 							const msg = err instanceof Error ? err.message : String(err);
@@ -30152,27 +30552,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 +32372,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 +32484,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 +35567,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. Advisor is an optional, non-binding, lead-only transcript-aware sounding board for consequential unresolved uncertainty or a genuinely stuck path, not routine progress, waiting, verification, approval, or completion. \`mcp__${fastPeersKey}__oracle\` is exact Opus 5 (1M/high), a stateless last-resort consultant available to the lead, reviewer, and planner.`,
+			"",
+			`\`mcp__${fastSearchKey}__code\` is semantic-first code search and \`mcp__${fastSearchKey}__web\` surfaces citable sources. Native Task roster: \`scout\` (broad discovery), \`implementer\` (mechanical implementation), \`reviewer\` (repo-aware verification/reproduction), and \`planner\` (Sol plan consultant/approver after Luna's draft). Before implementation obtain planner approval; before declaring done run relevant tests and ask reviewer to verify.${opts.browseAvailable ? ` \`mcp__${key("browser")}__*\` is the opt-in browser surface.` : ""}`
+		].join("\n");
+	}
 	const peersKey = key("peers");
 	const searchKey = key("search");
 	const workersKey = key("workers");
@@ -35225,6 +35631,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 optional, non-binding, transcript-aware, and lead-only; use it for consequential unresolved uncertainty, not routine progress or workflow gates. \`mcp__${key("peers")}__oracle\` is exact Opus 5 (1M/high), stateless and last resort for the lead, reviewer, and planner. \`mcp__${key("search")}__code\` and \`mcp__${key("search")}__web\` provide search.${opts.browseAvailable ? ` \`mcp__${key("browser")}__*\` provides the opt-in browser.` : ""}`
+	].join("\n");
 	const renderNative = (name) => {
 		const modelId = opts.nativeAgentModels?.[name];
 		if (!modelId) return `\`${name}\``;
@@ -35259,6 +35671,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 +35711,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 +35722,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 +36908,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 { UNKNOWN_EFFORT_ANCHOR as $, provisionTreeSitterAssets as $t, assetFor as A, shimDefaultsToXhigh as At, resolveAdvisorEffort as B, createResponses as Bt, buildEnv as C, withOneMSuffix as Cn, resolveGeminiReviewModel as Ct, toolbeltSkipSet as D, scribeModel as Dt, toolbeltEnabled as E, scoutModel as Et, FAST_ADVISOR_TOOL_INSTRUCTIONS as F, registerLaunch as Ft, repairRejectedThinkingHistory as G, normalizeOpenAIUsage as Gt, formatThinkingRepairDecline as H, MAX_RESPONSE_BODY_BYTES as Ht, buildAdvisorStream as I, unregisterLaunch as It, isControllerClosedError as J, colbertDegradedWarning as Jt, buildAnthropicErrorEvent as K, provisionBrowserAssets as Kt, injectAdvisorTool as L, assembleResponsesPayload as Lt, searchWeb as M, createMessages as Mt, ADVISOR_INTERNAL_TOOL_NAME as N, getTokenCount as Nt, vscodeRipgrepPath as O, standInToolEnabled as Ot, ADVISOR_TOOL_INSTRUCTIONS as P, findLaunchBySecret as Pt, EFFORT_ORDER as Q, warmTreeSitterPool as Qt, isAdvisorRequested as R, warnOnTokenPriceDrift as Rt, runWorkerAgent as S, oneMContextDisabled as Sn, nativeSubagentModel as St, buildToolbeltAwareness as T, withInstallLock as Tn, reviewerModel as Tt, rememberThinkingHistoryRepair as U, readResponseBodyCapped as Ut, resolveAdvisorModel as V, createChatCompletions as Vt, repairKnownThinkingHistory as W, parseJsonOrDiagnose as Wt, readIteratorWithTimeout as X, extractTarGzMember as Xt, logStreamError as Y, provisionAndIndexColbert as Yt, relayAnthropicStream as Z, extractZipMember as Zt, TEST_DEFAULT_MODEL as _, upstreamAllowH2 as _n, fastScoutModel as _t, buildAgentPrompt as a, BUDGET_SMALL_FAST_CATALOG_ID as an, FAST_REVIEWER_EFFORT as at, resolveModeDefaults as b, pickEndpoint as bn, generalPurposeFastModel as bt, enumerateInjectedMcpToolNames as c, DEFAULT_CODEX_MODEL as cn, artifactToolsEnabled as ct, DEFAULT_MODEL_CHAIN as d, UPSTREAM_FETCH_TIMEOUT_MS as dn, browserCompoundToolsEnabled as dt, CONDENSED_OPERATING_SEQUENCE as en, bucketEffort as et, EXPLORE_DEFAULT_MODEL as f, UPSTREAM_INACTIVITY_TIMEOUT_MS as fn, browserToolsEnabled as ft, REVIEW_DEFAULT_MODEL as g, resolveLeadSlugArg as gn, fastReviewerModel as gt, PLAN_DEFAULT_MODEL as h, pickClaudeDefault as hn, fastPlannerModel as ht, assertMcpToolSurfaceConsistent as i, toolbeltPathOverride as in, FAST_PLANNER_EFFORT as it, satisfiesMinVersion as j, countTokens as jt, TOOLBELT_TOOLS$1 as k, workerToolsEnabled as kt, personasFor as l, DEFAULT_CODEX_MODEL_FALLBACKS as ln, brainstormModel as lt, IMPLEMENT_DEFAULT_MODEL as m, isBudgetClaudeLead as mn, fastOracleModel as mt, MCP_GROUPS as n, shouldUseInsecureTls as nn, handleMcpDelete as nt, buildPeerAwarenessSnippet as o, BUDGET_SMALL_FAST_SLUG as on, FAST_SCOUT_EFFORT as ot, EXPLORE_DEFAULT_THINKING as p, generateRandomPort as pn, fastImplementerModel as pt, buildOpenAIErrorEvent as q, hasSupportedBrowserInstalled as qt, agentNamesForToolAllowlist as r, collapsePathKeys as rn, handleMcpPost as rt, buildPeerAwarenessSummary as s, DEFAULT_CLAUDE_MODEL_FALLBACKS as sn, agentToolsEnabled as st, GROUP_META as t, DEFINITION_OF_GREATNESS as tn, clampEffort as tt, BROWSE_DEFAULT_MODEL as u, DEFAULT_PORT as un, browseAgentEnabled as ut, appendPlanReminder as v, upstreamMaxConnections as vn, fleetToolsEnabled as vt, availableToolCommands as w, withOneMSuffixForLead as wn, reviewerFastModel as wt, resolveWorkerRunOpts as x, catalogAdvertises1M as xn, implementerFastModel as xt, resolveDefaultModel as y, classifyMessagesRoute as yn, geminiAvailable as yt, isFastProfileLead as z, resolveMcpToolTimeoutMs as zt };
 
-//# sourceMappingURL=peer-mcp-personas-Bd56EmiO.js.map
+//# sourceMappingURL=peer-mcp-personas-DhI7ZPSx.js.map