github-router 0.3.285 → 0.3.289

package/dist/{peer-mcp-personas-V6stFvpq.js → peer-mcp-personas-Bd56EmiO.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-wLC0InjX.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-CnlB0884.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 { 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-B7CHqKlF.js";
-import { t as MCP_WORKSPACE_HEADER } from "./mcp-workspace-header-ucs2SDST.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 { 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-D-rL81tT.js";
-import { f as resolveSealedGate, m as runGateChecks, p as sealedGateIds } from "./stop-gate-hook-DgJ6sW8N.js";
-import { t as liveExec } from "./orchestration-CtM6FYNx.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 { 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";
@@ -995,6 +995,9 @@ function enumProp$1(values, description) {
 	};
 }
 //#endregion
+//#region src/lib/gemini-review-model.ts
+const GEMINI_REVIEW_DEFAULT_MODEL = "gemini-3.1-pro-preview";
+//#endregion
 //#region src/lib/fleet/mesh-egress-agent.ts
 /**
 * Runtime-aware "route this fetch through the mesh loopback egress proxy" for a
@@ -18914,7 +18917,7 @@ function logAudit$1(record) {
 		try {
 			const fs = await import("node:fs/promises");
 			const path = await import("node:path");
-			const { PATHS } = await import("./paths-CV9K7Xqm.js");
+			const { PATHS } = await import("./paths-CTr59UC6.js");
 			const dir = path.join(PATHS.APP_DIR, "browser-mcp");
 			await fs.mkdir(dir, { recursive: true });
 			const line = JSON.stringify({
@@ -19494,6 +19497,354 @@ function currentInFlight() {
 	return inFlight$2;
 }
 //#endregion
+//#region src/lib/prompt-cache.ts
+/**
+* Conservative eligibility floor, in UTF-8 BYTES — never `.length`, which
+* counts UTF-16 code units and undercounts anything outside the BMP (an
+* emoji is 2 code units but 4 bytes). This is a proxy for "the prefix is
+* obviously large enough that marking it as a cache breakpoint is worth one
+* of the scarce marker slots," and it deliberately does NOT claim to be a
+* token count: byte-to-token density varies by tokenizer and content — CJK
+* text carries MORE tokens per byte than ASCII prose (undercounting risk is
+* the SAFE direction: we'd skip a marker that might have qualified), while a
+* long run of a repeated character or repeated whitespace carries FEWER
+* tokens per byte than either, since BPE merges long runs into very few
+* tokens (overcounting risk: a byte count clearing the floor doesn't
+* guarantee the real token count clears Anthropic's or Copilot's per-model
+* minimum). No fixed byte threshold can bound that adversarial case; this
+* value is chosen so ordinary Claude Code system prompts and tool schemas
+* (natural-language / JSON, not deliberately repetitive) reliably qualify,
+* while genuinely small prefixes never burn a marker for no benefit.
+*/
+const MIN_CACHEABLE_PREFIX_BYTES = 4096;
+const CACHE_KEY_NAMESPACE = "ghr-cache-v1";
+const CACHE_DIAGNOSTIC_LIMIT = 128;
+const GPT56_EXPLICIT_CACHE_MODELS = /* @__PURE__ */ new Set([
+	"gpt-5.6-sol",
+	"gpt-5.6-terra",
+	"gpt-5.6-luna"
+]);
+const priorSignatures = /* @__PURE__ */ new Map();
+function nonNegativeInt(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return 0;
+	return Math.floor(value);
+}
+/**
+* Pick the first genuinely POSITIVE numeric candidate from an ordered,
+* priority-ranked list of usage-shape fields. `??`-chaining these fields is
+* wrong: it stops at the first field that is merely PRESENT, and a provider
+* surface that always populates a nested detail object with `0` as a
+* placeholder (while the real, positive count is reported only in a
+* lower-priority field, e.g. the top-level one) would have its explicit zero
+* silently shadow that populated count. Falling through zeros to find a real
+* positive value fixes that; when every candidate is zero, absent, or
+* non-numeric, this returns `0` — a genuine all-zero reading, never
+* `undefined` — so downstream `nonNegativeInt` always has a countable value.
+*/
+function firstPositive(...candidates) {
+	for (const c of candidates) if (typeof c === "number" && Number.isFinite(c) && c > 0) return c;
+	return 0;
+}
+function usageDetails(usage) {
+	const input = usage.input_tokens_details ?? {};
+	const prompt = usage.prompt_tokens_details ?? {};
+	return {
+		cached_tokens: firstPositive(input.cached_tokens, prompt.cached_tokens, usage.cache_read_input_tokens),
+		cache_write_tokens: firstPositive(input.cache_write_tokens, input.cache_creation_tokens, prompt.cache_write_tokens, prompt.cache_creation_tokens, usage.cache_write_tokens, usage.cache_creation_input_tokens),
+		cache_ttl_seconds: firstPositive(input.cache_ttl_seconds, prompt.cache_ttl_seconds, usage.cache_ttl_seconds)
+	};
+}
+/**
+* OpenAI totals INCLUDE cached and cache-write tokens. Normalize them into
+* mutually exclusive buckets so Anthropic and Pi consumers do not count the
+* same input twice.
+*/
+function normalizeOpenAIUsage(usage) {
+	if (!usage) return {
+		totalInput: 0,
+		uncachedInput: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0
+	};
+	const totalInput = nonNegativeInt(usage.input_tokens ?? usage.prompt_tokens);
+	const output = nonNegativeInt(usage.output_tokens ?? usage.completion_tokens);
+	const details = usageDetails(usage);
+	const cacheRead = Math.min(totalInput, nonNegativeInt(details.cached_tokens));
+	const remaining = Math.max(0, totalInput - cacheRead);
+	const cacheWrite = Math.min(remaining, nonNegativeInt(details.cache_write_tokens ?? details.cache_creation_tokens));
+	const uncachedInput = Math.max(0, totalInput - cacheRead - cacheWrite);
+	const reportedTotal = nonNegativeInt(usage.total_tokens);
+	const cacheTtlSeconds = nonNegativeInt(details.cache_ttl_seconds);
+	return {
+		totalInput,
+		uncachedInput,
+		output,
+		cacheRead,
+		cacheWrite,
+		totalTokens: Math.max(reportedTotal, totalInput + output),
+		...cacheTtlSeconds > 0 ? { cacheTtlSeconds } : {}
+	};
+}
+function hash(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function signatureFor(value) {
+	return hash(typeof value === "string" ? value : JSON.stringify(value ?? null));
+}
+function serializedBytes(value) {
+	return Buffer.byteLength(typeof value === "string" ? value : JSON.stringify(value ?? null));
+}
+function logCacheSignature(args) {
+	if (parseBoolEnv(process.env.GH_ROUTER_LOG_CACHE) !== true) return;
+	const key = `${args.endpoint}:${args.model}:${args.workload}`;
+	const current = {
+		system: signatureFor(args.system),
+		tools: signatureFor(args.tools),
+		messages: signatureFor(args.messages)
+	};
+	const previous = priorSignatures.get(key);
+	let changed = "cold";
+	if (previous) changed = previous.system !== current.system ? "system" : previous.tools !== current.tools ? "tools" : previous.messages !== current.messages ? "messages" : "none";
+	priorSignatures.set(key, current);
+	if (priorSignatures.size > CACHE_DIAGNOSTIC_LIMIT) {
+		const oldest = priorSignatures.keys().next().value;
+		if (oldest !== void 0) priorSignatures.delete(oldest);
+	}
+	consola.info(`cache-signature endpoint=${args.endpoint} model=${args.model} workload=${args.workload} changed=${changed} system_bytes=${serializedBytes(args.system ?? "")} tools_bytes=${serializedBytes(args.tools ?? [])} messages_bytes=${serializedBytes(args.messages ?? [])}`);
+}
+function hasResponsesBreakpoint(input) {
+	const visit = (value) => {
+		if (!value || typeof value !== "object") return false;
+		if (Array.isArray(value)) return value.some(visit);
+		const record = value;
+		return record.prompt_cache_breakpoint !== void 0 || Object.values(record).some(visit);
+	};
+	return visit(input);
+}
+function gpt56ExplicitCacheEnabled(model) {
+	if (parseBoolEnv(process.env.GH_ROUTER_DISABLE_GPT56_EXPLICIT_CACHE) === true) return false;
+	return GPT56_EXPLICIT_CACHE_MODELS.has(model);
+}
+function responsesCacheKey(payload, opts, stablePrefix) {
+	const digest = hash(JSON.stringify({
+		namespace: CACHE_KEY_NAMESPACE,
+		model: payload.model,
+		workload: opts.workload,
+		scope: opts.scope ?? "",
+		stablePrefix,
+		tools: payload.tools ?? []
+	}));
+	return `${CACHE_KEY_NAMESPACE}-${digest.slice(0, 48)}`;
+}
+/**
+* Add GPT-5.6 explicit caching only to router-owned REUSABLE-PREFIX payloads.
+* Public passthrough routes never call this helper, and existing caller
+* fields always win. Live shape acceptance is pinned by compatibility probe
+* `gpt56_explicit_cache_breakpoint`.
+*
+* **`"conversation"` is deliberately EXCLUDED and left untouched (a no-op),
+* same as `"passthrough"`/`"one-shot"`.** A live-verified regression: on a
+* growing multi-turn conversation (Claude Code's translated main loop and
+* the worker-agent loop, both of which pass `workload: "conversation"`),
+* marking only the stable SYSTEM block with an explicit breakpoint measured
+* substantially worse than leaving caching provider-managed and implicit.
+* Explicit mode is a distinct
+* caching strategy from Copilot's provider-managed automatic caching, not an
+* addition to it — turning it on for a request marks only the bytes an
+* explicit breakpoint names, and the REST of that request's prefix (here,
+* the entire un-marked growing message history) stops receiving automatic
+* prefix-growth caching too. Measured on `gpt-5.6-sol` with explicit mode
+* force-enabled for conversation workloads: turn 1 (cold)
+* `input_tokens=27038, cache_write=2031, cache_read=0`; turn 2
+* `input_tokens=27054, cache_read=2031`; turn 3 `input_tokens=27071,
+* cache_read=2031` — the ~2k-token system block cached once and never grew,
+* while the other ~25k tokens of accumulating history were recomputed from
+* scratch on every single turn. `"reusable-prefix"` calls (peer/advisor/
+* worker-tool/browser-compressor prefixes reused verbatim across many
+* DISCRETE calls, never a single request whose own history keeps growing)
+* do not have this failure mode and keep the explicit treatment below.
+*/
+function applyResponsesCachePolicy(payload, opts) {
+	logCacheSignature({
+		endpoint: "/responses",
+		model: payload.model,
+		workload: opts.workload,
+		system: opts.stablePrefix ?? payload.instructions,
+		tools: payload.tools,
+		messages: payload.input
+	});
+	if (opts.workload !== "reusable-prefix" || !gpt56ExplicitCacheEnabled(payload.model) || payload.prompt_cache_key !== void 0 || payload.prompt_cache_options !== void 0 || hasResponsesBreakpoint(payload.input)) return payload;
+	const stablePrefix = opts.stablePrefix ?? payload.instructions;
+	const stableBytes = serializedBytes(stablePrefix ?? "") + serializedBytes(payload.tools ?? []);
+	if (!stablePrefix || stableBytes < MIN_CACHEABLE_PREFIX_BYTES) return payload;
+	const input = typeof payload.input === "string" ? [{
+		role: "user",
+		content: payload.input
+	}] : [...payload.input];
+	const stableContent = [{
+		type: "input_text",
+		text: stablePrefix,
+		prompt_cache_breakpoint: { mode: "explicit" }
+	}];
+	let nextInput;
+	let removeInstructions = false;
+	if (payload.instructions === stablePrefix) {
+		nextInput = [{
+			role: "system",
+			content: stableContent
+		}, ...input];
+		removeInstructions = true;
+	} else {
+		const stableSystemIndex = input.findIndex((item) => item.role === "system" && item.content === stablePrefix);
+		if (stableSystemIndex < 0) return payload;
+		nextInput = [...input];
+		nextInput[stableSystemIndex] = {
+			...nextInput[stableSystemIndex],
+			content: stableContent
+		};
+	}
+	const next = {
+		...payload,
+		input: nextInput,
+		prompt_cache_key: responsesCacheKey(payload, opts, stablePrefix),
+		prompt_cache_options: {
+			mode: "explicit",
+			ttl: "30m"
+		}
+	};
+	if (removeInstructions) delete next.instructions;
+	return next;
+}
+function itemHasCacheControl(value) {
+	return !!value && typeof value === "object" && value.cache_control !== void 0;
+}
+function hasClaudeCacheControl(body) {
+	if (itemHasCacheControl(body.system)) return true;
+	if (Array.isArray(body.system) && body.system.some(itemHasCacheControl)) return true;
+	if (Array.isArray(body.tools) && body.tools.some(itemHasCacheControl)) return true;
+	if (!Array.isArray(body.messages)) return false;
+	return body.messages.some((message) => {
+		if (!message || typeof message !== "object") return false;
+		const content = message.content;
+		return itemHasCacheControl(content) || Array.isArray(content) && content.some(itemHasCacheControl);
+	});
+}
+/**
+* UTF-8 byte length of the tools array alone — the eligibility floor for the
+* TOOL breakpoint. Marked on the last non-deferred tool, it caches only the
+* tools prefix (Claude's wire order is tools, then system, then messages), so
+* its own size — not the combined system+tools size — is what determines
+* whether that marker is worth spending. See `MIN_CACHEABLE_PREFIX_BYTES`.
+*/
+function claudeToolsPrefixBytes(body) {
+	return serializedBytes(body.tools ?? []);
+}
+/**
+* UTF-8 byte length of tools + system combined — the eligibility floor for
+* the SYSTEM breakpoint. Marked on the last system text block, it caches
+* everything up to and including system (tools THEN system in wire order),
+* so the combined size is the right measure — checked SEPARATELY from the
+* tools-only floor above so a large system prompt behind tiny tools doesn't
+* smuggle a useless tools-only marker in under the combined total, and a
+* large tools array behind an empty system doesn't get double-counted as
+* "small" just because system alone is tiny.
+*/
+function claudeSystemPrefixBytes(body) {
+	return claudeToolsPrefixBytes(body) + serializedBytes(body.system ?? "");
+}
+function markClaudeSystem(body) {
+	if (typeof body.system === "string" && body.system.length > 0) {
+		body.system = [{
+			type: "text",
+			text: body.system,
+			cache_control: { type: "ephemeral" }
+		}];
+		return true;
+	}
+	if (!Array.isArray(body.system)) return false;
+	for (let index = body.system.length - 1; index >= 0; index--) {
+		const block = body.system[index];
+		if (block && typeof block === "object" && block.type === "text" && typeof block.text === "string") {
+			body.system[index] = {
+				...block,
+				cache_control: { type: "ephemeral" }
+			};
+			return true;
+		}
+	}
+	return false;
+}
+function markClaudeTool(body) {
+	if (!Array.isArray(body.tools)) return false;
+	for (let index = body.tools.length - 1; index >= 0; index--) {
+		const tool = body.tools[index];
+		if (tool && typeof tool === "object" && tool.defer_loading !== true) {
+			body.tools[index] = {
+				...tool,
+				cache_control: { type: "ephemeral" }
+			};
+			return true;
+		}
+	}
+	return false;
+}
+/**
+* Apply the bounded Claude anchor policy to router-generated Messages bodies.
+* Caller-owned marker layouts are returned byte-for-byte unchanged.
+*
+* Marks at most TWO breakpoints — the last non-deferred tool and the stable
+* system boundary — each gated on its OWN eligibility check
+* (`claudeToolsPrefixBytes` / `claudeSystemPrefixBytes`) rather than one
+* combined check, so a large system prompt behind tiny tools doesn't also
+* mark a tools breakpoint too small to be worth a marker slot, and vice
+* versa. Anthropic's own hard ceiling is FOUR `cache_control` blocks per
+* request (probe `cache_control_marker_limit_5`); this policy only ever
+* spends up to two of them (`hasClaudeCacheControl` already refuses to run
+* at all once the caller has marked anything itself, so the two never
+* combine with a caller-owned marker to approach that ceiling).
+*
+* There used to be a third, message-level marking path gated on
+* `opts.workload === "conversation"`. It was removed as dead code: every
+* production call site of this function (`src/routes/mcp/handler.ts`,
+* `src/services/advisor/advisor.ts`) passes `workload: "reusable-prefix"`,
+* so the per-message branch never ran outside its own unit test, which gave
+* false confidence that production traffic exercised it. `CacheWorkload`
+* keeps `"conversation"` as a shared enum value — the Responses-side policy,
+* which has no per-message logic of its own, still uses it — so passing it
+* here remains type-valid; it now behaves identically to
+* `"reusable-prefix"`.
+*/
+function applyClaudeCachePolicy(rawBody, opts) {
+	if (opts.workload === "passthrough" || opts.workload === "one-shot" || parseBoolEnv(process.env.GH_ROUTER_DISABLE_CLAUDE_CACHE_POLICY) === true) return rawBody;
+	let parsed;
+	try {
+		parsed = JSON.parse(rawBody);
+	} catch {
+		return rawBody;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return rawBody;
+	const body = parsed;
+	if (typeof body.model !== "string" || !body.model.startsWith("claude-") || hasClaudeCacheControl(body)) return rawBody;
+	const toolsEligible = claudeToolsPrefixBytes(body) >= MIN_CACHEABLE_PREFIX_BYTES;
+	const systemEligible = claudeSystemPrefixBytes(body) >= MIN_CACHEABLE_PREFIX_BYTES;
+	if (!toolsEligible && !systemEligible) return rawBody;
+	let markers = 0;
+	if (toolsEligible && markClaudeTool(body)) markers++;
+	if (systemEligible && markClaudeSystem(body)) markers++;
+	if (markers === 0) return rawBody;
+	logCacheSignature({
+		endpoint: "/messages",
+		model: body.model,
+		workload: opts.workload,
+		system: body.system,
+		tools: body.tools,
+		messages: body.messages
+	});
+	return JSON.stringify(body);
+}
+//#endregion
 //#region src/lib/vision-preflight.ts
 /**
 * Outbound vision handling.
@@ -20418,7 +20769,7 @@ async function callViaChat(model, systemPrompt, userMessage, tool, signal) {
 *  Image parts use `input_image` (vs chat's `image_url`) — see
 *  `toResponsesContent`. */
 async function callViaResponses(model, systemPrompt, userMessage, tool, signal) {
-	const payload = {
+	const payload = applyResponsesCachePolicy({
 		model,
 		stream: false,
 		input: [{
@@ -20438,7 +20789,10 @@ async function callViaResponses(model, systemPrompt, userMessage, tool, signal)
 			type: "function",
 			name: tool.name
 		}
-	};
+	}, {
+		workload: "reusable-prefix",
+		stablePrefix: systemPrompt
+	});
 	const resp = await createResponses(payload, void 0, signal, true);
 	const output = Array.isArray(resp.output) ? resp.output : [];
 	for (const item of output) {
@@ -23916,6 +24270,10 @@ const FALLBACK_TOKEN_PRICES = Object.freeze({
 	"gemini-3.1-pro-preview": {
 		in: 200,
 		out: 1200
+	},
+	"gemini-3.7-flash": {
+		in: 75,
+		out: 375
 	}
 });
 /**
@@ -23976,6 +24334,22 @@ function catalogTokenPrices(modelId) {
 * takes ~0.9s. That figure is deliberately NOT surfaced to the model, because a
 * second speed axis invites optimising a routing choice that policy already
 * settles (see the decorrelation note below).
+*
+* `gemini-3.7-flash` and the re-measured `gemini-3.1-pro-preview` (2026-08-13,
+* n=5, one untimed warmup rep) used the script's newer `GH_ROUTER_BENCH_STREAM=1`
+* mode, which splits wall-clock into TTFT and a decode-phase rate excluding the
+* first delta's own time+tokens. This row still records the SAME metric family
+* as every other row here (total tokens / total wall-clock, i.e. the script's
+* "total tok/s" column) — NOT the new decode-phase figure — so the table stays
+* internally comparable across rows measured at different times. The decode
+* figure is materially different and worth knowing for routing decisions that
+* care about steady-state throughput specifically: at matched effort,
+* `gemini-3.7-flash` decodes at ~275-315 tok/s (Google's own ~340 tok/s
+* Artificial Analysis figure, roughly confirmed once TTFT is excluded) against
+* `gpt-5.6-terra`'s ~135-190 tok/s decode — gemini-3.7-flash is the faster
+* decoder, but its ~1.1-1.7s TTFT (vs terra's ~0.9-1.0s) drags its TOTAL rate
+* below terra's on short responses, which is exactly why this row uses total,
+* not decode, to stay consistent with its neighbors.
 */
 const INDICATIVE_TOKENS_PER_SECOND = Object.freeze({
 	"gpt-5.6-luna": 120,
@@ -23988,9 +24362,10 @@ const INDICATIVE_TOKENS_PER_SECOND = Object.freeze({
 	"gpt-5.6-sol": 75,
 	"grok-4.5": 70,
 	"gpt-5.5": 65,
+	"gemini-3.7-flash": 91,
 	"gemini-3.6-flash": 45,
 	"gemini-3.5-flash": 40,
-	"gemini-3.1-pro-preview": 25
+	"gemini-3.1-pro-preview": 33
 });
 /** Returns the approximate, indicative output speed when it was measured. */
 function indicativeTokensPerSecond(modelId) {
@@ -24467,6 +24842,10 @@ function neutralToolsToResponses(tools) {
 /** Assemble the full Responses payload from the neutral request shape. */
 function assembleResponsesPayload(opts) {
 	const input = [];
+	if (opts.dynamicInstructions) input.push({
+		role: "system",
+		content: opts.dynamicInstructions
+	});
 	for (const m of opts.messages) for (const item of neutralMessageToResponsesInput(m)) input.push(item);
 	const payload = {
 		model: opts.model,
@@ -24483,7 +24862,10 @@ function assembleResponsesPayload(opts) {
 	if (typeof opts.maxOutputTokens === "number" && opts.maxOutputTokens > 0) payload.max_output_tokens = Math.max(opts.maxOutputTokens, RESPONSES_MIN_MAX_OUTPUT_TOKENS);
 	if (opts.stopSequences && opts.stopSequences.length > 0) payload.stop = [...opts.stopSequences];
 	if (opts.parallelToolCalls === false) payload.parallel_tool_calls = false;
-	return payload;
+	return opts.cachePolicy ? applyResponsesCachePolicy(payload, {
+		...opts.cachePolicy,
+		stablePrefix: opts.cachePolicy.stablePrefix ?? opts.instructions
+	}) : payload;
 }
 //#endregion
 //#region src/lib/worker-agent/context-budget.ts
@@ -25018,7 +25400,10 @@ function mapResponsesUsage(u) {
 		prompt_tokens: u.input_tokens ?? 0,
 		completion_tokens: u.output_tokens ?? 0,
 		total_tokens: u.total_tokens ?? 0,
-		prompt_tokens_details: u.input_tokens_details?.cached_tokens != null ? { cached_tokens: u.input_tokens_details.cached_tokens } : void 0
+		prompt_tokens_details: u.input_tokens_details != null ? {
+			cached_tokens: u.input_tokens_details.cached_tokens ?? 0,
+			cache_write_tokens: u.input_tokens_details.cache_write_tokens ?? u.input_tokens_details.cache_creation_tokens ?? 0
+		} : void 0
 	};
 }
 /**
@@ -25267,6 +25652,7 @@ function buildResponsesPayload(context, resolved) {
 		messages,
 		tools: piToolsToNeutral(context.tools),
 		reasoningEffort: resolved.thinking,
+		cachePolicy: { workload: "conversation" },
 		stream: true
 	});
 }
@@ -25489,12 +25875,13 @@ function emptyUsage() {
 }
 function deriveUsage(u) {
 	if (!u) return emptyUsage();
+	const normalized = normalizeOpenAIUsage(u);
 	return {
-		input: u.prompt_tokens ?? 0,
-		output: u.completion_tokens ?? 0,
-		cacheRead: u.prompt_tokens_details?.cached_tokens ?? 0,
-		cacheWrite: 0,
-		totalTokens: u.total_tokens ?? 0,
+		input: normalized.uncachedInput,
+		output: normalized.output,
+		cacheRead: normalized.cacheRead,
+		cacheWrite: normalized.cacheWrite,
+		totalTokens: normalized.totalTokens,
 		cost: {
 			input: 0,
 			output: 0,
@@ -27013,6 +27400,7 @@ function shimDefaultsToXhigh(id) {
 * live tool list would be a silent regression (the snippet would name
 * a tool the live catalog doesn't expose).
 */
+const REVIEW_FAST_DEFAULT_MODEL = "gemini-3.7-flash";
 /**
 * Gate for the `stand_in` tool.
 *
@@ -27021,9 +27409,8 @@ function shimDefaultsToXhigh(id) {
 *   - an OpenAI frontier model (`gpt-5.6-sol`, else `gpt-5.5` — see
 *     `resolveOpenAiFrontier`)
 *   - `claude-opus-5`       (stand_in's Anthropic slot)
-*   - any `gemini-3.X.*pro` (gemini_critic's model family — matches the
-*     same regex `geminiAvailable()` uses, so the gate stays in sync if
-*     the GA slug renames `gemini-3.1-pro-preview` → `gemini-3.1-pro`)
+*   - the preferred Gemini reviewer model (`gemini-3.1-pro-preview`, falling
+*     back to `gemini-3.7-flash` after the preview's 2026-09-01 removal)
 *
 * If any one is missing, `stand_in` is dropped from `tools/list` AND
 * fails `tools/call` with -32601 (mirroring the `worker` capability's
@@ -27032,10 +27419,47 @@ function shimDefaultsToXhigh(id) {
 * `claude-opus-5` is a single-segment slug (dotted == dashed), so the
 * catalog probe matches Copilot's actual id shape directly.
 */
-function geminiAvailable(source = state) {
+/**
+* Any live-catalog model matching Google's `gemini-3.x-pro` family, excluding
+* the two known literals — catches a GA rename of the preview slug (e.g.
+* `gemini-3.1-pro-preview` -> `gemini-3.1-pro`) so a vendor rename doesn't
+* silently downgrade every Gemini-gated resolver to the flash fallback while a
+* real pro-tier successor is actually present in the catalog. This is the
+* same regex the removed `geminiAvailable()` used, for the same reason —
+* losing it here was a real regression caught in review, not a deliberate
+* simplification.
+*/
+function findGeminiProGaRename(models) {
+	return models.find((m) => /^gemini-3\..*pro/i.test(m.id) && m.id !== "gemini-3.1-pro-preview" && m.id !== "gemini-3.7-flash")?.id;
+}
+function resolveGeminiReviewModel(source = state) {
 	const models = source.models?.data;
-	if (!models) return false;
-	return models.some((m) => /^gemini-3\..*pro/i.test(m.id));
+	if (!models) return void 0;
+	if (models.some((m) => m.id === "gemini-3.1-pro-preview")) return GEMINI_REVIEW_DEFAULT_MODEL;
+	const gaRename = findGeminiProGaRename(models);
+	if (gaRename) return gaRename;
+	if (models.some((m) => m.id === "gemini-3.7-flash")) return REVIEW_FAST_DEFAULT_MODEL;
+}
+/**
+* Gemini review candidates in preference order, for resolvers that ALSO need
+* `firstPresentInCatalog`'s `requireToolCalls`/`minContextTokens` enforcement
+* (`resolveGeminiReviewModel()` only checks id presence, not those capability
+* flags). Mirrors `resolveGeminiReviewModel()`'s own preference order: the
+* known preview id, then a GA rename of it, then the flash fallback — kept as
+* a shared helper so `reviewerModel()`/`brainstormModel()` can't drift from
+* `resolveGeminiReviewModel()`'s GA-rename handling the way the hardcoded
+* per-resolver chains did before this was extracted.
+*/
+function geminiReviewChainCandidates() {
+	const gaRename = findGeminiProGaRename(state.models?.data ?? []);
+	return [
+		GEMINI_REVIEW_DEFAULT_MODEL,
+		...gaRename ? [gaRename] : [],
+		REVIEW_FAST_DEFAULT_MODEL
+	];
+}
+function geminiAvailable(source = state) {
+	return resolveGeminiReviewModel(source) != null;
 }
 /**
 * First id in `chain` that is present in the live catalog. With
@@ -27107,7 +27531,7 @@ function nativeSubagentModel() {
 * was one model checking its own output. Not merely the same lab: the same
 * model. Two independent blind audits flagged it, and the repo already applies
 * the opposite rule one layer down, where `worker-review` runs
-* `REVIEW_DEFAULT_MODEL` precisely so the reviewer's lab is decorrelated from the
+* `GEMINI_REVIEW_DEFAULT_MODEL` precisely so the reviewer's lab is decorrelated from the
 * producer's.
 *
 * The Anthropic lead and the OpenAI-frontier `implementer` are the two producers
@@ -27115,7 +27539,7 @@ function nativeSubagentModel() {
 * frontier remains the fallback: a same-lab reviewer still beats no reviewer.
 */
 function reviewerModel() {
-	return firstPresentInCatalog([REVIEW_DEFAULT_MODEL, ...OPENAI_FRONTIER_MODELS], { requireToolCalls: true });
+	return firstPresentInCatalog([...geminiReviewChainCandidates(), ...OPENAI_FRONTIER_MODELS], { requireToolCalls: true });
 }
 /** Model for `brainstorm`. Absent → inherits the lead's model.
 *
@@ -27124,7 +27548,7 @@ function reviewerModel() {
 *  `implementer`/`reviewer`, so a same-lab brainstormer would mostly restate
 *  what the lead already thought of. */
 function brainstormModel() {
-	return firstPresentInCatalog([REVIEW_DEFAULT_MODEL, ...OPENAI_FRONTIER_MODELS], { requireToolCalls: true });
+	return firstPresentInCatalog([...geminiReviewChainCandidates(), ...OPENAI_FRONTIER_MODELS], { requireToolCalls: true });
 }
 /** Model for `scribe`. Absent → inherits the lead's model.
 *
@@ -27146,18 +27570,24 @@ function scribeModel() {
 * impostor wearing the cheap agent's name.
 *
 * `gpt-5.6-luna` leads because it is the cheapest 1M-context model in the
-* catalog; `gemini-3.6-flash` remains the cross-vendor fallback so an OpenAI-side
+* catalog; `gemini-3.7-flash` remains the cross-vendor fallback so an OpenAI-side
 * outage does not remove the scout. Both entries must continue advertising at
 * least 1M context so Claude Code's `[1m]` accounting remains honest if an
 * upstream catalog entry shrinks.
 *
+* The fallback moved off `gemini-3.6-flash` on 2026-08-13: `gemini-3.7-flash`
+* is strictly better on every axis this chain cares about — half the price
+* (75/375 vs 150/750 per 1M), materially faster (measured tool-call p50 ~1.2s
+* against 3.6's ~2.6s), same 1M window, same vendor, so the cross-vendor
+* property the fallback exists for is preserved.
+*
 * This chain deliberately uses literal ids rather than `EXPLORE_DEFAULT_MODEL`:
 * the explore worker default and scout's cross-vendor fallback are independent
 * policies, so retuning one must not silently collapse the other. There is no
 * 400K last resort. On a catalog carrying neither chain member, `scout` is
 * dropped rather than inheriting the lead or presenting a narrower-context agent.
 */
-const SCOUT_MODEL_CHAIN = Object.freeze(["gpt-5.6-luna", "gemini-3.6-flash"]);
+const SCOUT_MODEL_CHAIN = Object.freeze(["gpt-5.6-luna", "gemini-3.7-flash"]);
 function scoutModel() {
 	return firstPresentInCatalog(SCOUT_MODEL_CHAIN, {
 		requireToolCalls: true,
@@ -27172,7 +27602,17 @@ function scoutModel() {
 *  well-specified, mechanical changes at a lower tier. Both entries are 1M+;
 *  their different speed and effort properties stay out of shared claims. */
 function implementerFastModel() {
-	return firstPresentInCatalog(["gpt-5.6-terra", REVIEW_DEFAULT_MODEL], {
+	return firstPresentInCatalog(["gpt-5.6-terra", GEMINI_REVIEW_DEFAULT_MODEL], {
+		requireToolCalls: true,
+		minContextTokens: ONE_M_TOKENS
+	});
+}
+/** Model for `reviewer-fast` — the cheaper Google review tier. Absent → the
+*  agent is dropped. Single-entry by design: inheriting the lead or falling
+*  across labs would defeat both its cost purpose and its decorrelation from
+*  the OpenAI-backed implementer. */
+function reviewerFastModel() {
+	return firstPresentInCatalog([REVIEW_FAST_DEFAULT_MODEL], {
 		requireToolCalls: true,
 		minContextTokens: ONE_M_TOKENS
 	});
@@ -27473,6 +27913,7 @@ function resolveOpusCriticModel() {
 }
 function activePersonas() {
 	return PERSONAS_READ.filter((p) => !p.requiresGeminiCatalog || geminiAvailable()).map((p) => {
+		if (p.requiresGeminiCatalog) return resolveGeminiPersona(p, resolveGeminiReviewModel());
 		if (p.toolNameHttp !== "opus_critic") return p;
 		const model = resolveOpusCriticModel();
 		const allowedEfforts = model === "claude-opus-5" ? [
@@ -27761,7 +28202,7 @@ function jsonPathPreflightCap(body, scope) {
 async function dispatchModelCall(args) {
 	const resolvedModel = resolveModel(args.model);
 	if (args.endpoint === "/v1/responses") {
-		const payload = {
+		const payload = applyResponsesCachePolicy({
 			model: resolvedModel,
 			instructions: args.instructions,
 			input: [{
@@ -27776,7 +28217,7 @@ async function dispatchModelCall(args) {
 			}],
 			stream: false,
 			reasoning: { effort: args.effort }
-		};
+		}, { workload: "reusable-prefix" });
 		return extractResponsesText(await withTransientRetry(() => createResponses(payload, void 0, args.signal), {
 			signal: args.signal,
 			label: resolvedModel
@@ -27784,7 +28225,7 @@ async function dispatchModelCall(args) {
 	}
 	if (args.endpoint === "/v1/messages") {
 		const maxTokens = args.effort === "low" ? 4096 : args.effort === "medium" ? 8192 : args.effort === "high" ? 16384 : 32768;
-		const body = JSON.stringify({
+		const body = applyClaudeCachePolicy(JSON.stringify({
 			model: resolvedModel,
 			max_tokens: maxTokens,
 			system: args.instructions,
@@ -27807,7 +28248,7 @@ async function dispatchModelCall(args) {
 				role: "user",
 				content: args.userText
 			}]
-		});
+		}), { workload: "reusable-prefix" });
 		return extractMessagesText(await (await withTransientRetry(() => createMessages(body, void 0, args.signal), {
 			signal: args.signal,
 			label: resolvedModel
@@ -29309,7 +29750,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 	}
 	const conversationText = renderConversationAsText(conversation, maxUnits, measure);
 	if (advisorUsesResponses(resolvedAdvisorModel)) {
-		const payload = {
+		const payload = applyResponsesCachePolicy({
 			model: resolvedAdvisorModel,
 			instructions: advisorSystem,
 			input: [{
@@ -29321,7 +29762,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 			}],
 			stream: false,
 			reasoning: { effort: advisorEffort }
-		};
+		}, { workload: "reusable-prefix" });
 		const response = await withTransientRetry(() => createResponses(payload, void 0, signal), {
 			signal,
 			label: resolvedAdvisorModel
@@ -29346,7 +29787,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 	const advisorEntry = state.models?.data?.find((m) => m.id === resolvedAdvisorModel);
 	const limits = advisorEntry?.capabilities?.limits;
 	const maxTokens = limits?.max_non_streaming_output_tokens ?? limits?.max_output_tokens ?? ADVISOR_FALLBACK_MAX_OUTPUT_TOKENS;
-	const advisorBody = JSON.stringify({
+	const advisorBody = applyClaudeCachePolicy(JSON.stringify({
 		model: resolvedAdvisorModel,
 		max_tokens: maxTokens,
 		system: advisorSystem,
@@ -29359,7 +29800,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 			thinking: { type: "adaptive" },
 			...advertisedEffortLadder(resolvedAdvisorModel) ? { output_config: { effort: advisorEffort } } : {}
 		} : {}
-	});
+	}), { workload: "reusable-prefix" });
 	const json = await (await withTransientRetry(() => createMessages(advisorBody, {}, signal), {
 		signal,
 		label: resolvedAdvisorModel
@@ -31637,7 +32078,7 @@ function advisorTool(getMessages) {
 			const release = acquireInFlightSlot();
 			if (!release) throw new Error(`advisor: MCP in-flight cap (${MAX_INFLIGHT_TOOLS_CALL}) saturated; retry shortly`);
 			try {
-				const text = extractResponsesText(await createResponses({
+				const payload = applyResponsesCachePolicy({
 					model: resolvedModel,
 					instructions: advisorSystem,
 					input: [{
@@ -31649,7 +32090,8 @@ function advisorTool(getMessages) {
 					}],
 					stream: false,
 					reasoning: { effort: ADVISOR_DEFAULT_EFFORT }
-				}, void 0, signal, true));
+				}, { workload: "reusable-prefix" });
+				const text = extractResponsesText(await createResponses(payload, void 0, signal, true));
 				if (!text) throw new Error("advisor returned empty output");
 				return textResult(text);
 			} finally {
@@ -32927,7 +33369,7 @@ function appendPlanReminder(messages, planState) {
 * gemini-3.1-pro-preview is pinned to `high` because the model rejects
 * `xhigh` at the wire with a Copilot 400. `high` is the realistic ceiling.
 */
-const STAND_IN_MODELS = Object.freeze([
+const STAND_IN_MODELS_BASE = Object.freeze([
 	{
 		key: "gpt-5.6-sol",
 		model: "gpt-5.6-sol",
@@ -32947,6 +33389,13 @@ const STAND_IN_MODELS = Object.freeze([
 		effort: "high"
 	}
 ]);
+function standInModels() {
+	const geminiModel = resolveGeminiReviewModel();
+	return STAND_IN_MODELS_BASE.map((config) => config.key === "gemini-3.1-pro-preview" ? {
+		...config,
+		model: geminiModel ?? "gemini-3.7-flash"
+	} : config);
+}
 const SYSTEM_PROMPT_R1 = `You are one of three frontier reasoning models the user has authorized to stand in for them on a bounded decision while they are unavailable. Your task: pick the best option from those provided.
 
 Respond with ONLY a single JSON object — no prose, no markdown fences, no preamble. Schema:
@@ -32998,7 +33447,7 @@ const RETRY_PROMPT_SUFFIX = `\n\nYour previous response was not valid JSON match
 async function runStandIn(input, signal) {
 	const validIds = new Set(input.options.map((o) => o.id));
 	const r1UserText = buildRound1UserText(input);
-	const r1 = await Promise.all(STAND_IN_MODELS.map((cfg) => callAndParse(cfg, SYSTEM_PROMPT_R1, r1UserText, validIds, signal)));
+	const r1 = await Promise.all(standInModels().map((cfg) => callAndParse(cfg, SYSTEM_PROMPT_R1, r1UserText, validIds, signal)));
 	const successfulR1 = r1.filter((r) => isVote(r.vote));
 	const nmiR1 = gapAbstainVerdict(successfulR1, r1, null);
 	if (nmiR1) return nmiR1;
@@ -33018,7 +33467,7 @@ async function runStandIn(input, signal) {
 		notes: `Only ${successfulR1.length} of 3 models returned a parseable round-1 vote; insufficient signal to run round 2.`
 	}, r1, null);
 	const r2UserTextBase = buildRound2UserTextBase(input, r1);
-	const r2 = await Promise.all(STAND_IN_MODELS.map((cfg) => callAndParse(cfg, SYSTEM_PROMPT_R2, r2UserTextBase + `\n\nYou are ${cfg.key}. Reconsider and vote.`, validIds, signal)));
+	const r2 = await Promise.all(standInModels().map((cfg) => callAndParse(cfg, SYSTEM_PROMPT_R2, r2UserTextBase + `\n\nYou are ${cfg.key}. Reconsider and vote.`, validIds, signal)));
 	const successfulR2 = r2.filter((r) => isVote(r.vote));
 	if (successfulR2.length < 2) return withDerivedNotes({
 		verdict: "no_consensus",
@@ -33195,7 +33644,7 @@ function aggregateVotes(results) {
 		topCount = count;
 		topSumConfidence = sumConfidence;
 	}
-	const total = STAND_IN_MODELS.length;
+	const total = standInModels().length;
 	if (topChoice && topCount === total) return {
 		verdict: "consensus",
 		winner: topChoice,
@@ -33246,7 +33695,7 @@ function gapAbstainVerdict(successful, r1, r2) {
 	const gapVotes = successful.filter((r) => r.vote.choice === null && r.vote.needMoreInfo);
 	if (gapVotes.length < 2) return null;
 	const gaps = gapVotes.map((r) => `- ${r.key}: ${r.vote.needMoreInfo}`).join("\n");
-	const header = gapVotes.length === STAND_IN_MODELS.length ? "All three models reported they need more context to decide:" : `${gapVotes.length} of 3 models reported they need more context to decide:`;
+	const header = gapVotes.length === standInModels().length ? "All three models reported they need more context to decide:" : `${gapVotes.length} of 3 models reported they need more context to decide:`;
 	return withDerivedNotes({
 		verdict: "need_more_info",
 		recommendation: null,
@@ -33262,7 +33711,7 @@ function gapAbstainVerdict(successful, r1, r2) {
 */
 function freshestVotes(r1, r2) {
 	const out = [];
-	for (const cfg of STAND_IN_MODELS) {
+	for (const cfg of standInModels()) {
 		const r2Entry = r2?.find((r) => r.key === cfg.key);
 		const r1Entry = r1.find((r) => r.key === cfg.key);
 		const vote = r2Entry && isVote(r2Entry.vote) ? r2Entry.vote : r1Entry && isVote(r1Entry.vote) ? r1Entry.vote : null;
@@ -33300,7 +33749,7 @@ function withDerivedNotes(result, r1, r2) {
 }
 function voteRecord(r1, r2) {
 	const record = {};
-	for (const cfg of STAND_IN_MODELS) {
+	for (const cfg of standInModels()) {
 		const r1Entry = r1.find((r) => r.key === cfg.key);
 		const r2Entry = r2?.find((r) => r.key === cfg.key) ?? null;
 		record[cfg.key] = {
@@ -34529,7 +34978,7 @@ const PERSONAS_READ = Object.freeze([
 	{
 		agentName: "gemini-critic",
 		toolNameHttp: "gemini_critic",
-		model: "gemini-3.1-pro-preview",
+		model: GEMINI_REVIEW_DEFAULT_MODEL,
 		endpoint: "/v1/chat/completions",
 		description: "Adversarial third-lab critic backed by gemini-3.1-pro-preview (Google), strong on formal reasoning, invariants, proofs, and cross-checking another critic's conclusion. It reviews plans, designs, mathematical arguments, and large artifacts for assumption gaps or invariant failures, then returns a focused critique or no-material-objection style verdict. Use when codex_critic's result needs an independent lab check or when the artifact hinges on formal correctness. Not for line-level diff review, use gemini_reviewer or codex_reviewer; pass the artifact and constraints verbatim.",
 		baseInstructions: GEMINI_CRITIC_BASE,
@@ -34565,7 +35014,7 @@ const PERSONAS_READ = Object.freeze([
 	{
 		agentName: "gemini-reviewer",
 		toolNameHttp: "gemini_reviewer",
-		model: "gemini-3.1-pro-preview",
+		model: GEMINI_REVIEW_DEFAULT_MODEL,
 		endpoint: "/v1/chat/completions",
 		description: "Line-level code reviewer backed by gemini-3.1-pro-preview (Google), providing second-lab coverage that catches a different slice of concrete-code defects than codex_reviewer. It reviews diffs, files, or function bodies and returns severity-ranked findings with file:line citations and suggested fixes. Use alongside codex_reviewer when a non-trivial diff benefits from cross-lab code-review coverage, especially around invariants or edge cases. Not for architecture or product-design review, use codex_critic or gemini_critic; pass the code artifact verbatim.",
 		baseInstructions: GEMINI_REVIEWER_BASE,
@@ -34734,15 +35183,16 @@ function buildPeerAwarenessSnippet(opts) {
 	const powerBrowseAvailable = opts.browseAvailable && opts.powerBrowseAvailable === true;
 	const criticList = ["`codex_critic` (gpt-5.6-sol)", "`codex_reviewer` (gpt-5.3-codex)"];
 	if (opts.geminiAvailable) {
-		criticList.push("`gemini_reviewer` (gemini-3.1-pro, line-level code review)");
-		criticList.push("`gemini_critic` (gemini-3.1-pro)");
+		const geminiModel = opts.geminiModel ?? "gemini-3.1-pro-preview";
+		criticList.push(`\`gemini_reviewer\` (${geminiModel}, line-level code review)`);
+		criticList.push(`\`gemini_critic\` (${geminiModel})`);
 	}
 	criticList.push("`opus_critic` (Opus 5)");
 	const codexCliClause = opts.codexCli ? " `mcp__codex-cli__codex` dispatches to `codex-implementer` (gpt-5.3-codex with workspace-write) for end-to-end coding tasks." : "";
 	const para2Parts = [`\`mcp__${searchKey}__code\` is the one-stop code search (no extra model call). Its DEFAULT mode (or \`mode:"semantic"\`) ranks by MEANING via ColBERT over a per-workspace index, the first thing to reach for on intent/concept questions ("where is retry/backoff handled", "how does auth work"); when that index isn't ready it transparently falls back to lexical (the response \`source\` says which engine ran). Forced modes cover the rest: \`lexical\` (BM25F-ranked + tree-sitter, best for exact symbols), \`exact\`, \`regex\`, \`complete\` (exhaustive set), \`ast_pattern\`+\`ast_lang\` for multi-line AST shapes, \`scan\` for a whole-workspace symbol outline, \`multiline\` for cross-line regex. Multiple queries can run in a single turn. The index covers code-shaped files; for unstructured files (logs, \`.csv\`, \`.env*\`, config-only wiring), \`grep\`/\`glob\` still apply.`];
 	if (opts.workerToolsAvailable) para2Parts.push(`\`worker-*\` are background Agent subagents (subagent_type) that run the matching worker in its own context and deliver the result as a completion notification, so a long run never blocks the turn: \`worker-explore\` (read-only research), \`worker-review\` (reads the code to verify a change or claim), \`worker-plan\` (ordered implementation plan), \`worker-implement\` (edit/write/bash; ALWAYS runs in an isolated git worktree and returns the diff via a saved patch file; for in-place edits use the \`implementer\` subagent), \`worker-test\` (independent test author; also always worktree-isolated)${opts.browseAvailable ? ", `worker-browse` (autonomous browser agent driving a real browser)" : ""}. The raw \`mcp__${workersKey}__*\` tools they call are guarded (a direct main-thread call is redirected to the matching agent); Workers themselves have \`code_search\`.`);
 	const catchAllClause = opts.generalPurposeFastAvailable === false ? "" : " Catch-all on a fast, economical non-lead model for work no specialist fits: `general-purpose-fast`.";
-	para2Parts.push(`Native subagents (Task), each in its own context so heavy work never fills yours: \`implementer\` (coding changes needing judgment or with ambiguous scope)${opts.implementerFastAvailable === false ? "" : ", `implementer-fast` (well-specified, mechanical coding changes)"}, \`reviewer\` (something exists and you want it assessed, including reproducing and root-causing a failure), \`brainstorm\` (you do not yet know which approach to take)${opts.scoutAvailable === false ? "" : ", `scout` (find or understand something in the repo, cheap)"}, \`scribe\` (docs and ADRs that trail the code).${catchAllClause}`);
+	para2Parts.push(`Native subagents (Task), each in its own context so heavy work never fills yours: \`implementer\` (coding changes needing judgment or with ambiguous scope)${opts.implementerFastAvailable === false ? "" : ", `implementer-fast` (well-specified, mechanical coding changes)"}, \`reviewer\` (something exists and you want it assessed, including reproducing and root-causing a failure)${opts.reviewerFastAvailable === false ? "" : ", `reviewer-fast` (lower-stakes assessment on a cheaper cross-lab model)"}, \`brainstorm\` (you do not yet know which approach to take)${opts.scoutAvailable === false ? "" : ", `scout` (find or understand something in the repo, cheap)"}, \`scribe\` (docs and ADRs that trail the code).${catchAllClause}`);
 	if (opts.workerToolsAvailable) para2Parts.push(`For a bounded, well-scoped implementation, prefer the \`implementer\` subagent over \`worker-implement\`; reach for \`worker-implement\` only when you specifically need git-worktree isolation, parallel variants, or a throwaway experiment.`);
 	if (opts.workerToolsAvailable) para2Parts.push(`\`mcp__${orchestrateKey}__decompose\` composes an open-ended ask into a typed, VERIFIED workflow IR (a strong driver decorrelated by a cross-lab critic, so the decompose step isn't a single point of failure), and \`mcp__${orchestrateKey}__run_workflow\` executes that IR through a frozen kernel delivering max(orchestrated, baseline) over a sealed executable gate, so it never ships worse than a plain single-model run. \`mcp__${orchestrateKey}__verify_workflow\` checks an IR's floor invariants before you run it, and \`mcp__${orchestrateKey}__attest_step\` audits that a finished run's producers were each checked by a different lab. They suit non-trivial, role-separated asks; a trivial ask does not need them.`);
 	else para2Parts.push(`\`mcp__${orchestrateKey}__verify_workflow\` statically checks a workflow IR's floor invariants and \`mcp__${orchestrateKey}__attest_step\` audits a run's cross-lab lineage (the \`decompose\`/\`run_workflow\` composer + kernel need the worker backend, unavailable here).`);
@@ -34787,6 +35237,7 @@ function buildPeerAwarenessSummary(opts) {
 		renderNative("implementer"),
 		opts.implementerFastAvailable === false ? void 0 : renderNative("implementer-fast"),
 		renderNative("reviewer"),
+		opts.reviewerFastAvailable === false ? void 0 : renderNative("reviewer-fast"),
 		renderNative("brainstorm"),
 		opts.scoutAvailable === false ? void 0 : renderNative("scout"),
 		renderNative("scribe"),
@@ -34807,11 +35258,38 @@ function buildPeerAwarenessSummary(opts) {
 	lines.push(`Each tool's own description carries when to use it and when not. The full per-tool inventory (models, gating, workers, skills) is in the "Peer review and advisor" section of your CLAUDE.md project instructions.`);
 	return lines.join("\n");
 }
+/**
+* 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
+* actually backs the tool. A mismatch here is user-visible — `tools/list`
+* would advertise "backed by gemini-3.1-pro-preview" while dispatch actually
+* ran the flash fallback — so every call site that resolves a
+* `requiresGeminiCatalog` persona MUST go through this helper rather than
+* setting `.model` directly (a prior draft of this fix did exactly that in
+* `routes/mcp/handler.ts`'s `activePersonas()` and left the description
+* stale). Relies on every `requiresGeminiCatalog` persona's description
+* literally containing `GEMINI_REVIEW_DEFAULT_MODEL`'s exact string — true
+* for both current entries (gemini-critic, gemini-reviewer); keep it true for
+* any future one, or `replaceAll` silently no-ops.
+*/
+function resolveGeminiPersona(p, geminiModel) {
+	const model = geminiModel ?? "gemini-3.1-pro-preview";
+	return {
+		...p,
+		model,
+		description: p.description.replaceAll(GEMINI_REVIEW_DEFAULT_MODEL, model)
+	};
+}
 /** Convenience: every persona that should be registered for the given mode. */
 function personasFor(opts) {
 	const result = [];
 	for (const p of PERSONAS_READ) {
-		if (p.requiresGeminiCatalog && !opts.geminiAvailable) continue;
+		if (p.requiresGeminiCatalog) {
+			if (!opts.geminiAvailable) continue;
+			result.push(resolveGeminiPersona(p, opts.geminiModel));
+			continue;
+		}
 		result.push(p);
 	}
 	if (opts.codexCli) for (const p of PERSONAS_WRITE) result.push(p);
@@ -35997,6 +36475,6 @@ function enumerateInjectedMcpToolNames(groupKeys, opts = {}) {
 	return [...new Set(names)];
 }
 //#endregion
-export { handleMcpDelete as $, resolveLeadSlugArg as $t, satisfiesMinVersion as A, hasSupportedBrowserInstalled as At, rememberThinkingHistoryRepair as B, collapsePathKeys as Bt, availableToolCommands as C, resolveMcpToolTimeoutMs as Ct, vscodeRipgrepPath as D, readResponseBodyCapped as Dt, toolbeltSkipSet as E, MAX_RESPONSE_BODY_BYTES as Et, injectAdvisorTool as F, warmTreeSitterPool as Ft, isControllerClosedError as G, DEFAULT_CODEX_MODEL as Gt, repairRejectedThinkingHistory as H, BUDGET_SMALL_FAST_CATALOG_ID as Ht, isAdvisorRequested as I, provisionTreeSitterAssets as It, relayAnthropicStream as J, UPSTREAM_FETCH_TIMEOUT_MS as Jt, logStreamError as K, DEFAULT_CODEX_MODEL_FALLBACKS as Kt, resolveAdvisorEffort as L, CONDENSED_OPERATING_SEQUENCE as Lt, ADVISOR_INTERNAL_TOOL_NAME as M, provisionAndIndexColbert as Mt, ADVISOR_TOOL_INSTRUCTIONS as N, extractTarGzMember as Nt, TOOLBELT_TOOLS$1 as O, parseJsonOrDiagnose as Ot, buildAdvisorStream as P, extractZipMember as Pt, clampEffort as Q, pickClaudeDefault as Qt, resolveAdvisorModel as R, DEFINITION_OF_GREATNESS as Rt, buildEnv as S, warnOnTokenPriceDrift as St, toolbeltEnabled as T, createChatCompletions as Tt, buildAnthropicErrorEvent as U, BUDGET_SMALL_FAST_SLUG as Ut, repairKnownThinkingHistory as V, toolbeltPathOverride as Vt, buildOpenAIErrorEvent as W, DEFAULT_CLAUDE_MODEL_FALLBACKS as Wt, UNKNOWN_EFFORT_ANCHOR as X, generateRandomPort as Xt, EFFORT_ORDER as Y, UPSTREAM_INACTIVITY_TIMEOUT_MS as Yt, bucketEffort as Z, isBudgetClaudeLead as Zt, appendPlanReminder as _, shimDefaultsToXhigh as _t, buildPeerAwarenessSnippet as a, withInstallLock as an, browserCompoundToolsEnabled as at, resolveWorkerRunOpts as b, getTokenCount as bt, personasFor as c, geminiAvailable as ct, EXPLORE_DEFAULT_MODEL as d, nativeSubagentModel as dt, upstreamAllowH2 as en, handleMcpPost as et, EXPLORE_DEFAULT_THINKING as f, reviewerModel as ft, TEST_DEFAULT_MODEL as g, workerToolsEnabled as gt, REVIEW_DEFAULT_MODEL as h, standInToolEnabled as ht, buildAgentPrompt as i, withOneMSuffixForLead as in, browseAgentEnabled as it, searchWeb as j, colbertDegradedWarning as jt, assetFor as k, provisionBrowserAssets as kt, BROWSE_DEFAULT_MODEL as l, generalPurposeFastModel as lt, PLAN_DEFAULT_MODEL as m, scribeModel as mt, MCP_GROUPS as n, classifyMessagesRoute as nn, artifactToolsEnabled as nt, buildPeerAwarenessSummary as o, browserToolsEnabled as ot, IMPLEMENT_DEFAULT_MODEL as p, scoutModel as pt, readIteratorWithTimeout as q, DEFAULT_PORT as qt, assertMcpToolSurfaceConsistent as r, withOneMSuffix as rn, brainstormModel as rt, enumerateInjectedMcpToolNames as s, fleetToolsEnabled as st, GROUP_META as t, upstreamMaxConnections as tn, agentToolsEnabled as tt, DEFAULT_MODEL_CHAIN as u, implementerFastModel as ut, resolveDefaultModel as v, countTokens as vt, buildToolbeltAwareness as w, createResponses as wt, runWorkerAgent as x, assembleResponsesPayload as xt, resolveModeDefaults as y, createMessages as yt, formatThinkingRepairDecline as z, shouldUseInsecureTls as zt };
+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 };
 
-//# sourceMappingURL=peer-mcp-personas-V6stFvpq.js.map
+//# sourceMappingURL=peer-mcp-personas-Bd56EmiO.js.map