github-router 0.3.275 → 0.3.282

package/dist/{peer-mcp-personas-TMOZJhfy.js → peer-mcp-personas-l4P4s1fK.js}

@@ -1,13 +1,14 @@
-import { t as getPackageVersion } from "./version-_Q1WpsQp.js";
-import { t as PATHS } from "./paths-Bg1_DWhi.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-Bz6HoH2H.js";
+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 { 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-0XrazT05.js";
-import { t as MCP_WORKSPACE_HEADER } from "./mcp-workspace-header-CGJbNeHb.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 { 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-AgNOtFRv.js";
-import { h as runGateChecks, m as sealedGateIds, p as resolveSealedGate } from "./stop-gate-hook-BqpumJtl.js";
-import { t as liveExec } from "./orchestration-B_Q3ncXI.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 { 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";
@@ -11888,6 +11889,123 @@ function objectProp(description, properties, required) {
 function anyProp(description) {
 	return { description };
 }
+//#endregion
+//#region src/lib/tree-sitter-assets/files.ts
+/** WASM assets code search loads from tree-sitter-wasms. */
+const TREE_SITTER_GRAMMAR_FILES = {
+	typescript: "tree-sitter-typescript.wasm",
+	tsx: "tree-sitter-tsx.wasm",
+	javascript: "tree-sitter-javascript.wasm",
+	python: "tree-sitter-python.wasm",
+	go: "tree-sitter-go.wasm",
+	rust: "tree-sitter-rust.wasm",
+	java: "tree-sitter-java.wasm",
+	c: "tree-sitter-c.wasm",
+	cpp: "tree-sitter-cpp.wasm"
+};
+const TREE_SITTER_RUNTIME_FILE = "tree-sitter.wasm";
+//#endregion
+//#region src/lib/tree-sitter-assets/provision.ts
+const PUBLISH_ATTEMPTS = 3;
+let _provisioned$1 = false;
+let _inFlight$1;
+/**
+* Materialize every required WASM asset. Single-flight and success-cached;
+* transient failures remain retryable. Never throws to the launcher.
+*/
+function provisionTreeSitterAssets() {
+	if (_provisioned$1) return Promise.resolve();
+	if (_inFlight$1) return _inFlight$1;
+	_inFlight$1 = Promise.resolve().then(() => provisionImpl()).then((complete) => {
+		if (complete) _provisioned$1 = true;
+	}).finally(() => {
+		_inFlight$1 = void 0;
+	});
+	return _inFlight$1;
+}
+function provisionImpl() {
+	try {
+		const require = createRequire(import.meta.url);
+		const grammarPackage = require.resolve("tree-sitter-wasms/package.json");
+		const grammarRoot = path.join(path.dirname(grammarPackage), "out");
+		const runtime = require.resolve("web-tree-sitter/tree-sitter.wasm");
+		const destination = PATHS.TREE_SITTER_ASSETS_DIR;
+		mkdirSync(destination, { recursive: true });
+		let complete = publishAsset(runtime, path.join(destination, TREE_SITTER_RUNTIME_FILE));
+		for (const filename of Object.values(TREE_SITTER_GRAMMAR_FILES)) complete = publishAsset(path.join(grammarRoot, filename), path.join(destination, filename)) && complete;
+		return complete;
+	} catch (err) {
+		consola.debug("[tree-sitter-assets] provisioning skipped:", err);
+		return false;
+	}
+}
+/**
+* Publish through a unique same-directory temporary file. Never remove the
+* destination first: a concurrent parser must see either the prior complete
+* file or the new complete file, never a missing/partial path. A losing racer
+* accepts the winner when its bytes match the source.
+*/
+function publishAsset(source, destination) {
+	let bytes;
+	try {
+		bytes = readFileSync(source);
+	} catch {
+		return false;
+	}
+	if (matchesContent(destination, bytes)) return true;
+	for (let attempt = 0; attempt < PUBLISH_ATTEMPTS; attempt++) {
+		const tmp = `${destination}.${process.pid}-${attempt}.tmp`;
+		try {
+			writeFileSync(tmp, bytes);
+			renameSync(tmp, destination);
+			return true;
+		} catch {
+			try {
+				rmSync(tmp, { force: true });
+			} catch {}
+			if (matchesContent(destination, bytes)) return true;
+		}
+	}
+	return false;
+}
+/**
+* Whether the published file is byte-identical to the source.
+*
+* Content, not size: a grammar upgrade that happens to keep the same byte
+* length would otherwise never propagate, and the stale copy would shadow the
+* package's newer file permanently — a silent, self-perpetuating wrong answer.
+* The size check first keeps the common case to one `stat`.
+*/
+function matchesContent(file, bytes) {
+	try {
+		const stat = statSync(file);
+		if (!stat.isFile() || stat.size !== bytes.byteLength) return false;
+		return readFileSync(file).equals(bytes);
+	} catch {
+		return false;
+	}
+}
+/**
+* Whether the stable directory holds the COMPLETE asset set: the runtime plus
+* every grammar.
+*
+* Callers must gate on the whole set, never on the one file they are about to
+* read. web-tree-sitter enforces a language-ABI version between the runtime and
+* the grammars, so adopting a stable runtime while grammars still come from the
+* package tree (or the reverse) can pair mismatched builds. That surfaces as a
+* caught `Language.load` failure, which silently disables structural ranking —
+* the exact silent degradation this whole change is meant to end.
+*/
+function stableTreeSitterAssetsComplete() {
+	const dir = PATHS.TREE_SITTER_ASSETS_DIR;
+	return [TREE_SITTER_RUNTIME_FILE, ...Object.values(TREE_SITTER_GRAMMAR_FILES)].every((name) => {
+		try {
+			return statSync(path.join(dir, name)).isFile();
+		} catch {
+			return false;
+		}
+	});
+}
 /**
 * Extension → grammar key. Grammars not in this map skip structural
 * parsing (the hit falls back to the regex SYMBOL_REGEX heuristic for
@@ -11915,22 +12033,11 @@ const EXTENSION_TO_LANG = {
 	".hxx": "cpp"
 };
 /**
-* Grammar key → wasm filename under `node_modules/tree-sitter-wasms/out/`.
-* Resolved at runtime from `node_modules`; the file paths are stable
-* because `tree-sitter-wasms` ships prebuilt binaries (no per-install
-* codegen).
+* Grammar key → wasm filename. The stable APP_DIR copy is preferred; the
+* original `node_modules/tree-sitter-wasms/out/` directory remains the
+* first-run fallback while background provisioning completes.
 */
-const GRAMMAR_FILES = {
-	typescript: "tree-sitter-typescript.wasm",
-	tsx: "tree-sitter-tsx.wasm",
-	javascript: "tree-sitter-javascript.wasm",
-	python: "tree-sitter-python.wasm",
-	go: "tree-sitter-go.wasm",
-	rust: "tree-sitter-rust.wasm",
-	java: "tree-sitter-java.wasm",
-	c: "tree-sitter-c.wasm",
-	cpp: "tree-sitter-cpp.wasm"
-};
+const GRAMMAR_FILES = TREE_SITTER_GRAMMAR_FILES;
 /**
 * Per-language definition-shape node types. When a matched identifier
 * sits inside one of these nodes AND is at the node's "name" position,
@@ -12064,12 +12171,16 @@ function getLanguageKeyForPath(filePath) {
 }
 let _grammarBundle;
 /**
-* Resolve the `tree-sitter-wasms/out/` directory at the package root.
-* `require.resolve` is used through a try/catch — the bundled-only
-* fallback runs in environments where node_modules has been pruned to
-* just runtime deps.
+* Resolve the grammar directory. The stable APP_DIR copy wins only when the
+* COMPLETE set is present; otherwise `require.resolve` supplies the
+* package-tree fallback for first launch or a best-effort provisioning failure.
+*
+* All-or-nothing on purpose — see `stableTreeSitterAssetsComplete()`: mixing a
+* stable runtime with package-tree grammars can pair mismatched ABI builds and
+* silently disable structural ranking.
 */
 function resolveGrammarRoot() {
+	if (stableTreeSitterAssetsComplete()) return PATHS.TREE_SITTER_ASSETS_DIR;
 	try {
 		const pkgPath = __require.resolve("tree-sitter-wasms/package.json");
 		return path$1.join(path$1.dirname(pkgPath), "out");
@@ -12078,6 +12189,15 @@ function resolveGrammarRoot() {
 	}
 }
 /**
+* web-tree-sitter normally resolves this sidecar relative to its JS module.
+* Prefer the durable copy, but only under the same all-present gate the
+* grammars use, so the runtime and the grammars always come from one install.
+*/
+function parserInitOptions() {
+	if (!stableTreeSitterAssetsComplete()) return void 0;
+	return { locateFile: () => path$1.join(PATHS.TREE_SITTER_ASSETS_DIR, TREE_SITTER_RUNTIME_FILE) };
+}
+/**
 * Pre-load all grammars at module-init time so the first search
 * doesn't pay a ~500ms cold-start cost. The Promise is captured at
 * import time and awaited per-call; per-grammar failures are caught
@@ -12088,7 +12208,7 @@ function getGrammarBundle() {
 	_grammarBundle = { ready: (async () => {
 		const out = /* @__PURE__ */ new Map();
 		try {
-			await Parser.init();
+			await Parser.init(parserInitOptions());
 		} catch (err) {
 			consola.warn(`[code_search] tree-sitter Parser.init failed; structural ranking disabled: ${err.message}`);
 			return out;
@@ -13271,16 +13391,19 @@ const STRUCTURAL_CACHE_MAX = 64;
 const SYMBOL_REGEX = /^(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:public\s+|private\s+|protected\s+|static\s+|abstract\s+|readonly\s+)*(?:function|class|interface|type|enum|def|fn|trait|impl|module|namespace|const|let|var)\s+[A-Za-z_$]/;
 let _rgResolution;
 /**
-* Tri-tier resolution. Memoized. Mirrors cc-backup
+* Four-tier resolution. Memoized. Mirrors cc-backup
 * `src/utils/ripgrep.ts:31-65`.
 *
 *   1. System rg on PATH — use the literal command name `"rg"` (NOT
 *      the absolute path). This leverages NoDefaultCurrentDirectory-
 *      InExePath on Windows, preventing PATH-hijacking via a
 *      malicious ./rg.exe in the proxy's cwd.
-*   2. Bundled via `@vscode/ripgrep` — falls back to the per-platform
+*   2. Router-owned toolbelt copy under APP_DIR. Its absolute path is
+*      safe because it cannot resolve to a planted binary in the cwd,
+*      and it survives a temp-hosted bunx package tree being reaped.
+*   3. Bundled via `@vscode/ripgrep` — falls back to the per-platform
 *      binary that `optionalDependencies` installed.
-*   3. Throw — surfaced to the caller as an MCP isError response.
+*   4. Throw — surfaced to the caller as an MCP isError response.
 */
 function resolveRipgrep() {
 	if (_rgResolution) return _rgResolution;
@@ -13291,6 +13414,14 @@ function resolveRipgrep() {
 		};
 		return _rgResolution;
 	}
+	const toolbeltPath = path$1.join(PATHS.TOOLBELT_BIN_DIR, process.platform === "win32" ? "rg.exe" : "rg");
+	if (existsSync(toolbeltPath)) {
+		_rgResolution = {
+			rgPath: toolbeltPath,
+			source: "toolbelt"
+		};
+		return _rgResolution;
+	}
 	try {
 		const mod = __require("@vscode/ripgrep");
 		if (mod.rgPath && existsSync(mod.rgPath)) {
@@ -17206,14 +17337,19 @@ function findPackageRoot(startDir, maxHops = 10) {
 	}
 }
 /**
-* Resolve the github-router package root. Uses two sources in order:
-*   1. process.argv[1] — the entrypoint script, walks up from there.
-*   2. import.meta.url of THIS module, walks up from there.
-*   3. process.cwd() as last resort.
+* Resolve the github-router package root. Uses sources in order:
+*   1. The explicit root baked into the relocated hook launcher's argv. From
+*      `<APP_DIR>/hooks/`, neither entrypoint walk can find the package and cwd
+*      is the user's workspace, so this source must win when present.
+*   2. process.argv[1] — the entrypoint script, walks up from there.
+*   3. import.meta.url of THIS module, walks up from there.
+*   4. process.cwd() as last resort.
 *
-* Robust across bun (src/main.ts) and node (dist/main.js) launch paths.
+* Robust across relocated hooks, bun (src/main.ts), and node (dist/main.js).
 */
 function packageRoot() {
+	const explicit = explicitPackageRoot();
+	if (explicit) return explicit;
 	const entryPath = typeof process$1?.argv?.[1] === "string" ? process$1.argv[1] : void 0;
 	if (entryPath) {
 		const fromEntry = findPackageRoot(path.dirname(entryPath));
@@ -18470,7 +18606,7 @@ function logAudit$1(record) {
 		try {
 			const fs = await import("node:fs/promises");
 			const path = await import("node:path");
-			const { PATHS } = await import("./paths-BbHtQAOs.js");
+			const { PATHS } = await import("./paths-CV9K7Xqm.js");
 			const dir = path.join(PATHS.APP_DIR, "browser-mcp");
 			await fs.mkdir(dir, { recursive: true });
 			const line = JSON.stringify({
@@ -22715,7 +22851,7 @@ const EMPTY_USAGE = {
 		total: 0
 	}
 };
-const DEFAULT_MODEL$1 = {
+const DEFAULT_MODEL = {
 	id: "unknown",
 	name: "unknown",
 	api: "unknown",
@@ -22737,7 +22873,7 @@ function createMutableAgentState(initialState) {
 	let messages = initialState?.messages?.slice() ?? [];
 	return {
 		systemPrompt: initialState?.systemPrompt ?? "",
-		model: initialState?.model ?? DEFAULT_MODEL$1,
+		model: initialState?.model ?? DEFAULT_MODEL,
 		thinkingLevel: initialState?.thinkingLevel ?? "off",
 		get tools() {
 			return tools;
@@ -23462,18 +23598,174 @@ function resolveModelAndThinking(opts) {
 	if (!clamp) clamp = allowed[0];
 	return mkOk(clamp);
 }
+const CATALOG_PRICE_SCALE = 1e9;
+const TOKENS_PER_MILLION = 1e6;
+/**
+* Last-resort per-1M-token prices, recorded from the live catalog on
+* 2026-08-12. The LIVE catalog always wins; this only fills in when
+* `state.models` is unpopulated, which in practice means the startup catalog
+* fetch failed. Without it the injected roster degrades to bare names and the
+* model loses the cost signal entirely for that session.
+*
+* A hardcoded copy of a value that HAS a live source is a second source of
+* truth, and this one has already been observed to drift: two figures written
+* from memory into a commit message (`gpt-5.3-codex` 400/1600, `gpt-5.5`
+* 500/2000) were both wrong against the live catalog (175/1400 and 500/3000).
+* That is exactly the silent-misroute failure this table risks, so
+* `warnOnTokenPriceDrift()` compares it against the live catalog once at
+* startup and logs any disagreement rather than letting a stale number sit
+* here indefinitely.
+*
+* This is NOT the same trade as `INDICATIVE_TOKENS_PER_SECOND`: throughput
+* cannot be derived from the catalog at all, so hardcoding is the only option
+* there. Price can, so hardcoding is strictly a degraded fallback.
+*/
+const FALLBACK_TOKEN_PRICES = Object.freeze({
+	"gpt-5.6-luna": {
+		in: 20,
+		out: 120
+	},
+	"gpt-5.6-terra": {
+		in: 200,
+		out: 1200
+	},
+	"gpt-5.4-mini": {
+		in: 75,
+		out: 450
+	},
+	"claude-sonnet-5": {
+		in: 200,
+		out: 1e3
+	},
+	"gpt-5.3-codex": {
+		in: 175,
+		out: 1400
+	},
+	"claude-haiku-4.5": {
+		in: 100,
+		out: 500
+	},
+	"claude-opus-5": {
+		in: 500,
+		out: 2500
+	},
+	"gpt-5.6-sol": {
+		in: 500,
+		out: 3e3
+	},
+	"grok-4.5": {
+		in: 200,
+		out: 600
+	},
+	"gpt-5.5": {
+		in: 500,
+		out: 3e3
+	},
+	"gemini-3.6-flash": {
+		in: 150,
+		out: 750
+	},
+	"gemini-3.5-flash": {
+		in: 150,
+		out: 900
+	},
+	"gemini-3.1-pro-preview": {
+		in: 200,
+		out: 1200
+	}
+});
+/**
+* Compare every `FALLBACK_TOKEN_PRICES` entry against the live catalog and warn
+* on disagreement. Call once after the catalog is populated. Makes fallback
+* staleness VISIBLE instead of silent: a stale entry only ever surfaces on the
+* degraded path, where nobody is looking, so without this it could be wrong for
+* months. Warn-only by design — a price mismatch must never block a launch.
+*/
+function warnOnTokenPriceDrift() {
+	for (const [id, hardcoded] of Object.entries(FALLBACK_TOKEN_PRICES)) {
+		const live = livePricesFor(id);
+		if (!live) continue;
+		if (live.in !== hardcoded.in || live.out !== hardcoded.out) consola.warn(`[model-resolve] FALLBACK_TOKEN_PRICES is stale for ${id}: hardcoded ${hardcoded.in}/${hardcoded.out}, live catalog ${live.in}/${live.out}. Update the table in src/lib/worker-agent/model-resolve.ts.`);
+	}
+}
+/** Live-catalog price lookup with no fallback. Split out so the drift check can
+*  compare against the catalog without the fallback masking a disagreement. */
+function livePricesFor(modelId) {
+	const prices = state.models?.data.find((model) => model.id === modelId)?.billing?.token_prices;
+	if (!prices || typeof prices.batch_size !== "number" || !Number.isSafeInteger(prices.batch_size) || prices.batch_size <= 0 || typeof prices.input_price !== "number" || !Number.isFinite(prices.input_price) || prices.input_price < 0 || typeof prices.output_price !== "number" || !Number.isFinite(prices.output_price) || prices.output_price < 0) return;
+	const toPerMillion = (price) => price / CATALOG_PRICE_SCALE * TOKENS_PER_MILLION / prices.batch_size;
+	return {
+		in: toPerMillion(prices.input_price),
+		out: toPerMillion(prices.output_price)
+	};
+}
+/**
+* A model's per-1M-token prices: live catalog first, then the dated fallback
+* table. Still returns undefined for a model in neither, so a caller never
+* mistakes a guess for a fact — the fallback covers models we have actually
+* recorded, not every id.
+*/
+function catalogTokenPrices(modelId) {
+	return livePricesFor(modelId) ?? FALLBACK_TOKEN_PRICES[modelId];
+}
+/**
+* Approximate output tokens/sec, median of n=3 per model, measured 2026-08-12
+* through this proxy. Reproduce with `bun scripts/bench-model-speed.ts` — the
+* harness is committed precisely so these numbers can be re-derived and
+* challenged instead of being trusted. Rounded coarsely on purpose: run-to-run
+* variance is large (`gpt-5.6-sol` measured 22 in an early n=1 pass and 74 at
+* n=3), so any digit beyond the leading one or two would be false precision.
+*
+* Wall clock includes time-to-first-token, which is why an early n=1 pass put
+* `gemini-3.1-pro-preview` at 9: that response emitted only 66 tokens, so TTFT
+* dominated. Reasoning tokens are timed but may not appear in `output_tokens`,
+* so heavy-reasoning models are penalised here.
+*
+* This is a deliberately hardcoded, coarse speed hint, indicative and never a
+* per-call benchmark: a recoverable speed retry is safer than a quality score
+* that silently misroutes.
+*
+* NOT the whole picture for agent work. The benchmark also measures p50 latency
+* to a trivial tool call, which is the workload an agent model actually spends
+* its turns on, and the ordering differs from raw generation: `gpt-5.6-sol`
+* generates at 75 but takes ~4.3s to reach a tool call, while `gpt-5.6-luna`
+* 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).
+*/
+const INDICATIVE_TOKENS_PER_SECOND = Object.freeze({
+	"gpt-5.6-luna": 120,
+	"gpt-5.6-terra": 100,
+	"gpt-5.4-mini": 100,
+	"claude-sonnet-5": 100,
+	"gpt-5.3-codex": 85,
+	"claude-haiku-4.5": 85,
+	"claude-opus-5": 80,
+	"gpt-5.6-sol": 75,
+	"grok-4.5": 70,
+	"gpt-5.5": 65,
+	"gemini-3.6-flash": 45,
+	"gemini-3.5-flash": 40,
+	"gemini-3.1-pro-preview": 25
+});
+/** Returns the approximate, indicative output speed when it was measured. */
+function indicativeTokensPerSecond(modelId) {
+	return INDICATIVE_TOKENS_PER_SECOND[modelId];
+}
 /** Worker-usable models need a big enough window to be worth delegating to. */
 const CATALOG_MIN_CONTEXT = 2e5;
 /**
 * Derived view of the live catalog: every model a worker could actually be
 * pointed at, with the metadata needed to choose between them.
 *
-* DERIVED ONLY, and that is the whole design. A one-liner like "strong
+* Derived facts only, with one explicitly-labelled exception:
+* `INDICATIVE_TOKENS_PER_SECOND` is a dated, coarse measurement whose speed
+* signal is recoverable by retrying a slow selection. A one-liner like "strong
 * reasoning, weak long-context recall" cannot be computed from catalog
 * metadata — it is editorial, it goes stale silently as vendors ship, and the
 * asymmetry is brutal: a MISSING characterization costs one suboptimal pick
 * the model recovers from, while a WRONG one misroutes invisibly at the call
-* site. So this ships facts and lets the caller judge.
+* site. So this ships facts, the recoverable speed hint, and no quality score.
 *
 * It exists because the hardcoded chains cannot discover anything. Models are
 * live in the catalog that appear nowhere in `src/` — nobody evaluated them
@@ -23499,13 +23791,16 @@ function buildCatalogView() {
 		if (ctx < CATALOG_MIN_CONTEXT) continue;
 		const efforts = (supports.reasoning_effort ?? []).filter((effort) => WORKER_THINKING_LEVELS.includes(effort));
 		if (efforts.length === 0) continue;
+		const prices = catalogTokenPrices(model.id);
+		const tps = indicativeTokensPerSecond(model.id);
 		rows.push({
 			id: model.id,
 			vendor: model.vendor,
 			ctx,
 			...limits?.max_output_tokens ? { maxOut: limits.max_output_tokens } : {},
 			efforts,
-			...model.model_picker_price_category ? { cost: model.model_picker_price_category } : {}
+			...prices ?? {},
+			...tps === void 0 ? {} : { tps }
 		});
 	}
 	return rows.sort((a, b) => a.id.localeCompare(b.id));
@@ -26501,13 +26796,22 @@ function geminiAvailable(source = state) {
 /**
 * First id in `chain` that is present in the live catalog. With
 * `requireToolCalls`, skips an entry whose catalog record does not advertise
-* `tool_calls` (strict `!== true`, so absent metadata fails closed). Returns
-* undefined when the catalog is unavailable or nothing in the chain matches, so
-* every caller degrades gracefully rather than throwing on a thin catalog.
+* `tool_calls` (strict `!== true`, so absent metadata fails closed). With
+* `minContextTokens`, skips an entry whose advertised context window is below
+* that floor (absent metadata likewise fails closed). Returns undefined when
+* the catalog is unavailable or nothing in the chain matches, so every caller
+* degrades gracefully rather than throwing on a thin catalog.
 *
 * Extracted from `resolveOpenAiFrontier` so the per-agent resolvers below share
 * one walk instead of hand-copying it. Ids are matched EXACTLY against
 * `catalog.id` — no slug translation, matching the pre-existing behavior.
+*
+* `minContextTokens` is OPT-IN because the constraint is genuinely per-agent:
+* the conditional cheaper-tier agents promise 1M end to end. Enforcing the
+* floor here rather than by comment is what stops a chain silently degrading
+* when an id's advertised window shrinks upstream — `withOneMSuffix` would then
+* just omit the `[1m]` bracket, and the agent would be budgeted at Claude Code's
+* 200K default with no signal that anything changed.
 */
 function firstPresentInCatalog(chain, opts) {
 	const models = state.models?.data;
@@ -26516,6 +26820,7 @@ function firstPresentInCatalog(chain, opts) {
 		const found = models.find((m) => m.id === id);
 		if (!found) continue;
 		if (opts?.requireToolCalls && found.capabilities?.supports?.tool_calls !== true) continue;
+		if (opts?.minContextTokens != null && (found.capabilities?.limits?.max_context_window_tokens ?? 0) < opts.minContextTokens) continue;
 		return id;
 	}
 }
@@ -26595,23 +26900,65 @@ function scribeModel() {
 * caller drop the agent instead, so the lead falls back to the CLI's `Explore`
 * (same behavior as before `scout` existed) rather than to an expensive
 * 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
+* 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.
+*
+* 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"]);
 function scoutModel() {
-	return firstPresentInCatalog([EXPLORE_DEFAULT_MODEL, DEFAULT_MODEL], { requireToolCalls: true });
+	return firstPresentInCatalog(SCOUT_MODEL_CHAIN, {
+		requireToolCalls: true,
+		minContextTokens: ONE_M_TOKENS
+	});
+}
+/** Model for `implementer-fast` — the cheaper implementation tier. Absent →
+*  the agent is dropped.
+*
+*  `gpt-5.6-sol` is deliberately NOT in this chain: changes needing frontier
+*  judgment already belong to `implementer`, while this agent handles
+*  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], {
+		requireToolCalls: true,
+		minContextTokens: ONE_M_TOKENS
+	});
+}
+/** Model for `general-purpose-fast` — the fast, cheapest catch-all. Absent →
+*  dropped.
+*
+*  Single-entry by design. `gpt-5.6-luna` is the cheapest model in the live
+*  catalog and measured fastest among the catch-all candidates, while carrying
+*  1.05M context and the full `none..max` effort ladder. No
+*  `-mini`/`-lite`/`-haiku` model in the catalog serves 1M, which is why this
+*  catch-all uses a `gpt-5.6-*` slug rather than a mini one. */
+function generalPurposeFastModel() {
+	return firstPresentInCatalog(["gpt-5.6-luna"], {
+		requireToolCalls: true,
+		minContextTokens: ONE_M_TOKENS
+	});
 }
 /**
 * Gate for the worker tools (`explore`, `review`, `implement`).
 *
 * Returns true iff BOTH:
-*   1. Copilot's live catalog (`state.models?.data`) contains the
-*      worker default model (`gpt-5.4-mini`, used by explore)
-*      AND that entry advertises `capabilities.supports.tool_calls ===
-*      true`. The worker loop is function-calling; a model that can't
-*      emit tool_calls is unusable, so dormant-register (omit from
-*      `tools/list`) keeps the surface honest. (The implement default
-*      `gpt-5.6-sol` is NOT gated here — if it's absent, implement calls
-*      surface a clean resolve error rather than disabling all worker
-*      tools, since explore/review still work.)
+*   1. Copilot's live catalog (`state.models?.data`) contains any model in the
+*      ordered worker gate chain (`gpt-5.6-luna` → `gpt-5.4-mini`) and that
+*      entry advertises `capabilities.supports.tool_calls === true`. Luna leads
+*      on qualifying tiers; mini preserves the worker surface on individual
+*      trial and education catalogs. The catalog is the entitlement signal.
+*      The worker loop is function-calling, so a model without tool calls is
+*      unusable. Per-mode defaults are NOT gated here — an absent mode default
+*      surfaces a clean resolve error rather than disabling all worker tools.
 *   2. The operator hasn't set `GH_ROUTER_DISABLE_WORKER_TOOLS=1`
 *      (opt-out — workers ship enabled by default per plan).
 *
@@ -26620,17 +26967,12 @@ function scoutModel() {
 * validation in the engine, which surfaces a clean `isError`
 * envelope with the catalog's eligible model ids on mismatch.
 *
-* `WORKER_DEFAULT_MODEL` is imported (aliased from `DEFAULT_MODEL`)
-* from `src/lib/worker-agent` so the engine owns the single source
-* of truth.
+* `WORKER_DEFAULT_MODEL_CHAIN` is imported from `src/lib/worker-agent` so the
+* engine owns the single source of truth for both gating and fallback order.
 */
 function workerToolsEnabled() {
 	if (process.env.GH_ROUTER_DISABLE_WORKER_TOOLS === "1") return false;
-	const models = state.models?.data;
-	if (!models) return false;
-	const found = models.find((m) => m.id === DEFAULT_MODEL);
-	if (!found) return false;
-	return found.capabilities?.supports?.tool_calls === true;
+	return firstPresentInCatalog(DEFAULT_MODEL_CHAIN, { requireToolCalls: true }) != null;
 }
 /**
 * Gate for the compound L2 browser tools (`browser_act`, `browser_observe`,
@@ -26737,10 +27079,10 @@ function artifactToolsEnabled() {
 *      browser is on disk. The browse agent drives the SAME Chrome/Edge
 *      bridge as the raw `browser_*` tools, so it can't be useful without
 *      that surface enabled.
-*   2. The browse default model (`BROWSE_DEFAULT_MODEL`, `gpt-5.4-mini`)
+*   2. The browse default model (`BROWSE_DEFAULT_MODEL`, `gpt-5.6-luna`)
 *      is in Copilot's live catalog AND `pickEndpoint()` resolves a
 *      reachable endpoint for it. Unlike `workerToolsEnabled()` (which
-*      checks `tool_calls` on the gemini default), the browse default is
+*      checks `tool_calls` on the shared gate sentinel), the browse default is
 *      a `/responses`-only gpt-5.x model — `pickEndpoint` is the right
 *      reachability probe (it returns undefined only when the model
 *      serves neither chat nor responses).
@@ -31493,32 +31835,33 @@ async function saveOverflowPatch(dir) {
 */
 const WORKTREE_REGISTRY = new WorktreeRegistry();
 registerExitHandlers$1(WORKTREE_REGISTRY);
-/** Worker-availability GATE sentinel + final fallback. `gpt-5.4-mini` — cheap,
-*  broadly-available, tool-call-capable, 400k-context, with tight
-*  function-calling-loop discipline (earlier gemini-flash cheap defaults
-*  early-stopped with empty turns on the function-calling loop; gpt-5.4-mini
-*  does not). Exported and aliased as `WORKER_DEFAULT_MODEL`:
-*  `workerToolsEnabled()` gates the ENTIRE worker surface on this id being
-*  present with `tool_calls`. It is no longer `explore`'s default (see
-*  `EXPLORE_DEFAULT_MODEL`) — it stays the gate sentinel because it's the
-*  cheapest broadly-present tool-caller, and the fallback for any unmatched
-*  mode. */
-const DEFAULT_MODEL = "gpt-5.4-mini";
+/** Worker-availability gate + unmatched-mode fallback chain. Luna leads where
+*  the live catalog grants access: it is cheaper, faster, and has a larger context
+*  window than mini. Mini remains the broad-tier fallback because individual-trial
+*  and education catalogs may omit Luna. The catalog itself is the entitlement
+*  signal; `billing.restricted_to` describes model policy, not the user's tier.
+*
+*  `workerToolsEnabled()` admits the worker surface when either entry is present
+*  with `tool_calls`. `resolveDefaultModel()` picks the first usable live entry for
+*  an unmatched worker mode. Per-mode defaults remain independent of the gate. */
+const DEFAULT_MODEL_CHAIN = Object.freeze(["gpt-5.6-luna", "gpt-5.4-mini"]);
 const DEFAULT_THINKING = "xhigh";
-/** Default model for the READ-ONLY `explore` mode. `gemini-3.6-flash` at `high`
-*  (via `EXPLORE_DEFAULT_THINKING`; flash advertises no xhigh) — a fast, cheap,
-*  1M-context tool-caller for read-only repo research. Routes over
-*  `/chat/completions` via the translation shim (the same proven path the
-*  `review` worker uses for gemini). Like `implement`'s gpt-5.6-sol this is NOT a
-*  `workerToolsEnabled` gate input — if absent (e.g. a non-enterprise tier)
-*  `explore` errors helpfully at call time rather than vanishing the whole worker
-*  surface. The caller (the main model) overrides BOTH the model and the reasoning
-*  per call via the `model` / `thinking` args — see the tier ladder (gpt-5.6-sol
-*  heavy / gpt-5.6-terra moderate / gemini-3.6-flash light) in the MCP tool desc. */
-const EXPLORE_DEFAULT_MODEL = "gemini-3.6-flash";
-/** Default thinking for `explore`. `high` (flash has no xhigh); explicit rather
-*  than inherited from `DEFAULT_THINKING` so the explore effort can't drift if the
-*  shared fallback changes. */
+function resolveDefaultModel() {
+	const models = state.models?.data ?? [];
+	return DEFAULT_MODEL_CHAIN.find((id) => models.some((model) => model.id === id && model.capabilities?.supports?.tool_calls === true)) ?? DEFAULT_MODEL_CHAIN[0];
+}
+/** Default model for the READ-ONLY `explore` mode. `gpt-5.6-luna` at `high`
+*  (via `EXPLORE_DEFAULT_THINKING`) is the measured strict improvement over the
+*  former Gemini Flash default: lower token cost, faster generation and tool-call
+*  latency, a larger context window, and the full reasoning-effort ladder. `high`
+*  is therefore a real selected tier rather than a clamp. Like `implement`'s
+*  gpt-5.6-sol this per-mode default is NOT a `workerToolsEnabled` gate input — if
+*  absent on a thin catalog, `explore` errors helpfully at call time rather than
+*  vanishing the whole worker surface. The caller can override model and thinking
+*  per call via the `model` / `thinking` args. */
+const EXPLORE_DEFAULT_MODEL = "gpt-5.6-luna";
+/** Default thinking for `explore`. Explicit rather than inherited from
+*  `DEFAULT_THINKING` so the explore effort cannot drift with the fallback. */
 const EXPLORE_DEFAULT_THINKING = "high";
 /** Default model + thinking for the READ-ONLY `review` mode.
 *  `gemini-3.1-pro-preview` at `xhigh` (clamped to `high` at call time — gemini
@@ -31535,41 +31878,44 @@ const EXPLORE_DEFAULT_THINKING = "high";
 const REVIEW_DEFAULT_MODEL = "gemini-3.1-pro-preview";
 const REVIEW_DEFAULT_THINKING = "xhigh";
 /** Default model + thinking for the READ+WRITE `implement` mode. `gpt-5.6-sol`
-*  at `xhigh` — the strongest reasoning tier in the catalog, 1M+ context,
-*  routed through `/responses` by the stream-fn endpoint split. Coding edits
-*  benefit from maximum reasoning; the higher per-call cost is justified for
-*  autonomous implementation. An explicit `opts.model` still wins. */
+*  at `high` — a time-to-outcome default for the 1M+ context model, routed
+*  through `/responses` by the stream-fn endpoint split. Any caller can restore
+*  a higher tier per call via `thinking` or per session via `worker_defaults`;
+*  precedence is per-call > session > built-in. */
 const IMPLEMENT_DEFAULT_MODEL = "gpt-5.6-sol";
-const IMPLEMENT_DEFAULT_THINKING = "xhigh";
-/** `test` starts with the same built-in pair as `implement`, but remains an
-* independent mode so either can be overridden without affecting the other. */
+const IMPLEMENT_DEFAULT_THINKING = "high";
+/** `test` starts with the same time-to-outcome built-in pair as `implement`, but
+* remains independent so either mode can restore a higher tier per call via
+* `thinking` or per session via `worker_defaults`. Resolution precedence is
+* per-call > session > built-in. */
 const TEST_DEFAULT_MODEL = "gpt-5.6-sol";
-const TEST_DEFAULT_THINKING = "xhigh";
-/** Default model for `browse` mode. `gpt-5.4-mini` — the Gate-B-winning
-*  browse model (small + fast enough to drive a tab at human pace, with
-*  enough tool-calling discipline to terminate). This is DISTINCT from the
-*  gemini worker `DEFAULT_MODEL`: browse is a different workload (drive a
-*  page, not read a repo) and was tuned separately. May be retuned after
-*  the flash-vs-mini eval settles. Routed through `/responses` by the
-*  stream-fn's endpoint split (it's a gpt-5.x model). Caller can override
+const TEST_DEFAULT_THINKING = "high";
+/** Default model for `browse` mode. `gpt-5.6-luna` has the same measured image
+*  ceiling as `gpt-5.4-mini`, so screenshot-heavy sessions retain their input
+*  capacity, and endpoint routing is derived from the live catalog. Luna's full
+*  reasoning-effort ladder preserves the independent `high` browse default.
+*  This is deliberately a per-mode default even though it also leads
+*  `DEFAULT_MODEL_CHAIN`; the general worker gate remains tier-adaptive while
+*  browse still applies its independent reachability gate. Caller can override
 *  per call via the `model` arg.
 *
 *  Exported so the MCP browse handler reads the same constant — drift
 *  between the two would ship a tool whose docs disagree with its runtime
 *  default. */
-const BROWSE_DEFAULT_MODEL = "gpt-5.4-mini";
+const BROWSE_DEFAULT_MODEL = "gpt-5.6-luna";
 /** Default thinking for `browse`. Higher than the page-driving workload
 *  strictly needs, but the termination discipline benefits from it. */
 const BROWSE_DEFAULT_THINKING = "high";
-/** Default model + thinking for the read-only `plan` mode. `claude-opus-4.8`
-*  at `xhigh` — planning is the highest-leverage read-only step (the plan
-*  shapes everything downstream), so it gets the strongest reasoning model
-*  rather than the lightweight `gemini-3.6-flash` explore default. Uses the DOTTED
-*  Copilot catalog id (the worker resolver exact-matches `catalog.id`, it does
-*  NOT translate the Anthropic dashed slug; `claude-opus-5` is a single-segment
-*  slug so dotted == dashed). Falls back to a helpful unknown-model error at call
-*  time if opus-5 isn't in the catalog (e.g. a non-enterprise tier), exactly like
-*  `implement`'s `gpt-5.6-sol`. Caller's `model` arg still wins. */
+/** Default model + thinking for the read-only `plan` mode. `claude-opus-5`
+*  at `high` favours time-to-outcome while retaining the strongest planning
+*  model rather than the lightweight `gpt-5.6-luna` explore default. Any
+*  caller can restore a higher tier per call via `thinking` or per session via
+*  `worker_defaults`; precedence is per-call > session > built-in. Uses the
+*  DOTTED Copilot catalog id (the worker resolver exact-matches `catalog.id`, it
+*  does NOT translate the Anthropic dashed slug; `claude-opus-5` is a
+*  single-segment slug so dotted == dashed). Falls back to a helpful unknown-model
+*  error at call time if opus-5 isn't in the catalog (e.g. a non-enterprise tier),
+*  exactly like `implement`'s `gpt-5.6-sol`. */
 const PLAN_DEFAULT_MODEL = "claude-opus-5";
 const BUILT_IN_MODE_DEFAULTS = Object.freeze({
 	explore: {
@@ -31582,7 +31928,7 @@ const BUILT_IN_MODE_DEFAULTS = Object.freeze({
 	},
 	plan: {
 		model: PLAN_DEFAULT_MODEL,
-		thinking: "xhigh"
+		thinking: "high"
 	},
 	implement: {
 		model: IMPLEMENT_DEFAULT_MODEL,
@@ -31597,10 +31943,10 @@ const BUILT_IN_MODE_DEFAULTS = Object.freeze({
 		thinking: BROWSE_DEFAULT_THINKING
 	}
 });
-/** Resolve the effective mode ladder without changing the gate sentinel. */
+/** Resolve the effective mode ladder without changing the worker gate. */
 function resolveModeDefaults(mode, ignoreSessionDefaults = false) {
 	const builtIn = BUILT_IN_MODE_DEFAULTS[mode] ?? {
-		model: "gpt-5.4-mini",
+		model: resolveDefaultModel(),
 		thinking: DEFAULT_THINKING
 	};
 	const override = ignoreSessionDefaults ? {} : getWorkerSessionDefault(mode);
@@ -33652,7 +33998,7 @@ const PERSONAS_READ = Object.freeze([
 		toolNameHttp: "codex_reviewer",
 		model: "gpt-5.3-codex",
 		endpoint: "/v1/responses",
-		description: "Line-level code reviewer backed by gpt-5.3-codex (OpenAI, ≈272K-token input window), a code-specialist reviewer that is fastest around high effort (~16s at high effort). It reviews concrete diffs, files, or function bodies and returns findings with severity, file:line locations, issue impact, and a minimal suggested fix. Use when the artifact is actual code and the goal is bug, edge-case, security, concurrency, resource, or idiom review. Not for architecture or tradeoff review, use codex_critic or gemini_critic; pass the diff or file content verbatim.",
+		description: "Line-level code reviewer backed by gpt-5.3-codex (OpenAI, ≈272K-token input window), a code specialist for line-level review. It reviews concrete diffs, files, or function bodies and returns findings with severity, file:line locations, issue impact, and a minimal suggested fix. Use when the artifact is actual code and the goal is bug, edge-case, security, concurrency, resource, or idiom review. Not for architecture or tradeoff review, use codex_critic or gemini_critic; pass the diff or file content verbatim.",
 		baseInstructions: REVIEWER_BASE,
 		agentPrompt: "",
 		writeCapable: false,
@@ -33843,8 +34189,9 @@ function buildPeerAwarenessSnippet(opts) {
 	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). 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\`.`);
-	para2Parts.push(`Native subagents (Task), each in its own context so heavy work never fills yours: \`implementer\` (you know what to build), \`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).`);
+	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}`);
 	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).`);
@@ -33877,13 +34224,30 @@ function buildPeerAwarenessSnippet(opts) {
 */
 function buildPeerAwarenessSummary(opts) {
 	const key = (g) => opts.groupKeys?.[g] ?? GROUP_META[g].preferredKey;
+	const renderNative = (name) => {
+		const modelId = opts.nativeAgentModels?.[name];
+		if (!modelId) return `\`${name}\``;
+		const prices = catalogTokenPrices(modelId);
+		const tps = indicativeTokensPerSecond(modelId);
+		if (!prices || tps == null) return `\`${name}\``;
+		return `\`${name}\` ${prices.in}/${prices.out} ~${tps}t/s`;
+	};
+	const summaryNativeNames = [
+		renderNative("implementer"),
+		opts.implementerFastAvailable === false ? void 0 : renderNative("implementer-fast"),
+		renderNative("reviewer"),
+		renderNative("brainstorm"),
+		opts.scoutAvailable === false ? void 0 : renderNative("scout"),
+		renderNative("scribe"),
+		opts.generalPurposeFastAvailable === false ? void 0 : renderNative("general-purpose-fast")
+	].filter((n) => n != null);
 	const lines = [
 		"## Injected capabilities (summary)",
 		"",
-		`Native subagents (Task), each in its own context: \`implementer\` (you know what to build), \`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), \`scout\` (find or understand something in the repo, cheap), \`scribe\` (docs and ADRs that trail the code). They read the repo and can run things; the peer critics below cannot, so reach for \`reviewer\` when an assessment needs execution or repo context and for a critic when you already hold the artifact.`,
+		`${summaryNativeNames.some((n) => /\d/.test(n)) ? "Native subagents (Task), own context. Cost is per 1M tokens in/out, tok/s approximate:" : "Native subagents (Task), each in its own context:"} ${summaryNativeNames.join(", ")}. Each agent's own description states when it applies. They read the repo and can run things; the peer critics below cannot, so reach for \`reviewer\` when an assessment needs execution or repo context and for a critic when you already hold the artifact.`,
 		`A layer of MCP tools, background workers, and skills is injected into this session. Cross-lab peer critics under \`mcp__${key("peers")}__*\` (plus the \`peer-review-coordinator\` subagent) review plans and diffs adversarially, and Claude Code's built-in \`advisor\` catches approach drift. \`mcp__${key("search")}__code\` is meaning-first code search and \`mcp__${key("search")}__web\` returns citable web sources.`
 	];
-	if (opts.workerToolsAvailable) lines.push(`Background \`worker-*\` agents (explore, review, plan, implement, test) run delegated work in their own context without blocking your turn, and \`mcp__${key("orchestrate")}__*\` composes, verifies, and runs floor-raising workflows.`);
+	if (opts.workerToolsAvailable) lines.push(`Background \`worker-*\` agents (explore, review, plan, implement, test${opts.browseAvailable ? ", browse" : ""}) run delegated work in their own context without blocking your turn, and \`mcp__${key("orchestrate")}__*\` composes, verifies, and runs floor-raising workflows.`);
 	if (opts.standInAvailable) lines.push(`\`mcp__${key("decide")}__stand_in\` returns a three-lab consensus for a decision when the user is unavailable.`);
 	if (opts.browseAvailable) lines.push(`\`mcp__${key("browser")}__*\` drives a real Chrome or Edge browser.`);
 	if (opts.fleetAvailable) lines.push(`\`mcp__${key("fleet")}__*\` drives remote ai-or-die coding sessions.`);
@@ -34183,7 +34547,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "explore",
 		group: "workers",
 		capability: "worker",
-		description: "Runs as the background `worker-explore` agent. Dispatch via the Agent tool (subagent_type: worker-explore) so the turn is never blocked; the result arrives as a completion notification. Read-only investigation by an autonomous worker (Pi runtime; default model `gemini-3.6-flash` at high reasoning, override via the `model` arg with any Copilot-catalog model that advertises `tool_calls`). It has read, glob, grep, semantic-first code search, web search, fetch_url, advisor, update_plan, and read-only toolbelt tools, and it returns a single text answer. Use for bounded research, repo discovery, dependency investigation, or multi-file reading that would otherwise consume the lead context window. Not for implementation, test authoring, or verification of a concrete diff; use implement, test, or review for those scopes. Brief the investigation goal and constraints, not step-by-step tool semantics. Strictly read-only: it changes nothing on disk, and its returned text is the only artifact it produces — route to `implement` or `test` when a file actually needs to change. If the result is too large to relay it is truncated to a preview and the FULL text is written to a file, whose absolute path is in the returned text; read that file rather than re-running the worker.",
+		description: "Runs as the background `worker-explore` agent. Dispatch via the Agent tool (subagent_type: worker-explore) so the turn is never blocked; the result arrives as a completion notification. Read-only investigation by an autonomous worker (Pi runtime; default model `gpt-5.6-luna` at high reasoning, override via the `model` arg with any Copilot-catalog model that advertises `tool_calls`). It has read, glob, grep, semantic-first code search, web search, fetch_url, advisor, update_plan, and read-only toolbelt tools, and it returns a single text answer. Use for bounded research, repo discovery, dependency investigation, or multi-file reading that would otherwise consume the lead context window. Not for implementation, test authoring, or verification of a concrete diff; use implement, test, or review for those scopes. Brief the investigation goal and constraints, not step-by-step tool semantics. Strictly read-only: it changes nothing on disk, and its returned text is the only artifact it produces — route to `implement` or `test` when a file actually needs to change. If the result is too large to relay it is truncated to a preview and the FULL text is written to a file, whose absolute path is in the returned text; read that file rather than re-running the worker.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -34195,7 +34559,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 				},
 				model: {
 					type: "string",
-					description: "Optional Copilot catalog model id (defaults to gemini-3.6-flash). Must advertise tool_calls support; the engine emits an isError envelope listing the eligible catalog models on mismatch. Override by task weight: `gpt-5.6-sol` (heavy/deep), `gpt-5.6-terra` (moderate), `gemini-3.6-flash` (light/cheap) — all 1M context; pair with thinking:'high'."
+					description: "Optional Copilot catalog model id (defaults to gpt-5.6-luna). Must advertise tool_calls support; the engine emits an isError envelope listing the eligible catalog models on mismatch. Override by task weight: `gpt-5.6-sol` (heavy/deep), `gpt-5.6-terra` (moderate), `gpt-5.6-luna` (light/cheap) — all 1M context; pair with thinking:'high'."
 				},
 				thinking: {
 					type: "string",
@@ -34224,7 +34588,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "implement",
 		group: "workers",
 		capability: "worker",
-		description: "Runs as the background `worker-implement` agent. Dispatch via the Agent tool (subagent_type: worker-implement) so the turn is never blocked; the result arrives as a completion notification. Delegates a scoped coding task to an autonomous worker (Pi runtime; default model `gpt-5.6-sol` at xhigh reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). It has the explore read-only tools plus edit, write, bash, and codex_review, and it returns its final text with any changed files or worktree diff. Use for bounded implementation work that may take a while or benefits from isolated worker context. Not for pure research, planning, review, or independent test authoring; use explore, plan, review, or test for those scopes. ALWAYS runs in an isolated git worktree and returns the diff via a saved patch file (a `--stat` summary + a bounded preview + the patch path; a small diff is inlined in full) — it never edits your working tree, and it HARD-ERRORS if the workspace is not a git repository. For in-place edits, use the native `implementer` subagent. If the result is too large to relay it is truncated to a preview and the FULL text is written to a file, whose absolute path is in the returned text; read that file rather than re-running the worker.",
+		description: "Runs as the background `worker-implement` agent. Dispatch via the Agent tool (subagent_type: worker-implement) so the turn is never blocked; the result arrives as a completion notification. Delegates a scoped coding task to an autonomous worker (Pi runtime; default model `gpt-5.6-sol` at high reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). It has the explore read-only tools plus edit, write, bash, and codex_review, and it returns its final text with any changed files or worktree diff. Use for bounded implementation work that may take a while or benefits from isolated worker context. Not for pure research, planning, review, or independent test authoring; use explore, plan, review, or test for those scopes. ALWAYS runs in an isolated git worktree and returns the diff via a saved patch file (a `--stat` summary + a bounded preview + the patch path; a small diff is inlined in full) — it never edits your working tree, and it HARD-ERRORS if the workspace is not a git repository. For in-place edits, use the native `implementer` subagent. If the result is too large to relay it is truncated to a preview and the FULL text is written to a file, whose absolute path is in the returned text; read that file rather than re-running the worker.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -34240,7 +34604,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 				},
 				model: {
 					type: "string",
-					description: "Optional Copilot catalog model id (defaults to gpt-5.6-sol). Must advertise tool_calls support; the engine emits an isError envelope listing the eligible catalog models on mismatch. Override by task weight: `gpt-5.6-sol` (heavy/deep), `gpt-5.6-terra` (moderate), `gemini-3.6-flash` (light/cheap) — all 1M context; pair with thinking:'high'."
+					description: "Optional Copilot catalog model id (defaults to gpt-5.6-sol). Must advertise tool_calls support; the engine emits an isError envelope listing the eligible catalog models on mismatch. Override by task weight: `gpt-5.6-sol` (heavy/deep), `gpt-5.6-terra` (moderate), `gpt-5.6-luna` (light/cheap) — all 1M context; pair with thinking:'high'."
 				},
 				thinking: {
 					type: "string",
@@ -34281,7 +34645,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 				},
 				model: {
 					type: "string",
-					description: "Optional Copilot catalog model id (defaults to gemini-3.1-pro-preview). Must advertise tool_calls support; the engine emits an isError envelope listing the eligible catalog models on mismatch. Override by task weight: `gpt-5.6-sol` (heavy/deep), `gpt-5.6-terra` (moderate), `gemini-3.6-flash` (light/cheap) — all 1M context; pair with thinking:'high'."
+					description: "Optional Copilot catalog model id (defaults to gemini-3.1-pro-preview). Must advertise tool_calls support; the engine emits an isError envelope listing the eligible catalog models on mismatch. Override by task weight: `gpt-5.6-sol` (heavy/deep), `gpt-5.6-terra` (moderate), `gpt-5.6-luna` (light/cheap) — all 1M context; pair with thinking:'high'."
 				},
 				thinking: {
 					type: "string",
@@ -34310,7 +34674,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "plan",
 		group: "workers",
 		capability: "worker",
-		description: "Runs as the background `worker-plan` agent. Dispatch via the Agent tool (subagent_type: worker-plan) so the turn is never blocked; the result arrives as a completion notification. Read-only implementation planning by an autonomous worker (Pi runtime; default model `claude-opus-5` at xhigh reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). It has the same read-only toolset as explore and returns a concrete, ordered implementation plan covering files, approach, risks, and how acceptance criteria will be verified. Use before coding when the task needs repo-grounded sequencing or acceptance criteria translated into implementation steps. Not for editing files, running an implementation, writing tests, or adversarial review; use implement, test, or review for those scopes. Strictly read-only: it changes nothing on disk, and its returned text is the only artifact it produces — route to `implement` or `test` when a file actually needs to change. If the result is too large to relay it is truncated to a preview and the FULL text is written to a file, whose absolute path is in the returned text; read that file rather than re-running the worker.",
+		description: "Runs as the background `worker-plan` agent. Dispatch via the Agent tool (subagent_type: worker-plan) so the turn is never blocked; the result arrives as a completion notification. Read-only implementation planning by an autonomous worker (Pi runtime; default model `claude-opus-5` at high reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). It has the same read-only toolset as explore and returns a concrete, ordered implementation plan covering files, approach, risks, and how acceptance criteria will be verified. Use before coding when the task needs repo-grounded sequencing or acceptance criteria translated into implementation steps. Not for editing files, running an implementation, writing tests, or adversarial review; use implement, test, or review for those scopes. Strictly read-only: it changes nothing on disk, and its returned text is the only artifact it produces — route to `implement` or `test` when a file actually needs to change. If the result is too large to relay it is truncated to a preview and the FULL text is written to a file, whose absolute path is in the returned text; read that file rather than re-running the worker.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -34351,7 +34715,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "test",
 		group: "workers",
 		capability: "worker",
-		description: "Runs as the background `worker-test` agent. Dispatch via the Agent tool (subagent_type: worker-test) so the turn is never blocked; the result arrives as a completion notification. Independent adversarial test authoring by an autonomous worker (Pi runtime; default model `gpt-5.6-sol` at xhigh reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). It has the same read/write toolset as implement and writes tests that try to break the implementation through edge cases, error paths, and acceptance criteria, then runs them and reports pass/fail. Use when a separate test author should challenge an implementation without modifying the production code to make tests pass. Not for implementing fixes, broad research, or code review; use implement, explore, or review for those scopes. ALWAYS runs in an isolated git worktree and returns the test diff via a saved patch file (a `--stat` summary + a bounded preview + the patch path; a small diff is inlined in full) — it never edits your working tree, and it HARD-ERRORS if the workspace is not a git repository. For in-place test authoring, use the native `implementer` subagent. If the result is too large to relay it is truncated to a preview and the FULL text is written to a file, whose absolute path is in the returned text; read that file rather than re-running the worker.",
+		description: "Runs as the background `worker-test` agent. Dispatch via the Agent tool (subagent_type: worker-test) so the turn is never blocked; the result arrives as a completion notification. Independent adversarial test authoring by an autonomous worker (Pi runtime; default model `gpt-5.6-sol` at high reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). It has the same read/write toolset as implement and writes tests that try to break the implementation through edge cases, error paths, and acceptance criteria, then runs them and reports pass/fail. Use when a separate test author should challenge an implementation without modifying the production code to make tests pass. Not for implementing fixes, broad research, or code review; use implement, explore, or review for those scopes. ALWAYS runs in an isolated git worktree and returns the test diff via a saved patch file (a `--stat` summary + a bounded preview + the patch path; a small diff is inlined in full) — it never edits your working tree, and it HARD-ERRORS if the workspace is not a git repository. For in-place test authoring, use the native `implementer` subagent. If the result is too large to relay it is truncated to a preview and the FULL text is written to a file, whose absolute path is in the returned text; read that file rather than re-running the worker.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -34598,7 +34962,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "browse",
 		group: "workers",
 		capability: "browse_agent",
-		description: "Runs as the background `worker-browse` agent. Dispatch via the Agent tool (subagent_type: worker-browse) so the turn is never blocked; the result arrives as a completion notification. A Pi-driven autonomous browser worker (default model `gpt-5.4-mini`) drives a real browser to accomplish `task`, keeps raw DOM and page snapshots inside its own context, and returns a single text result. Use for delegated multi-step web tasks such as comparing prices, logging into a dashboard, or summarizing pages when the lead does not need to steer each click. Not for direct in-context browser control, screenshots, or precise element interactions; use the `browser` MCP tools for those. Pass `sessionId` to continue a prior browse session, or omit it for a fresh isolated session; multiple calls run as parallel sessions on the shared browser. If the result is too large to relay it is truncated to a preview and the FULL text is written to a file, whose absolute path is in the returned text; read that file rather than re-running the worker.",
+		description: "Runs as the background `worker-browse` agent. Dispatch via the Agent tool (subagent_type: worker-browse) so the turn is never blocked; the result arrives as a completion notification. A Pi-driven autonomous browser worker (default model `gpt-5.6-luna`) drives a real browser to accomplish `task`, keeps raw DOM and page snapshots inside its own context, and returns a single text result. Use for delegated multi-step web tasks such as comparing prices, logging into a dashboard, or summarizing pages when the lead does not need to steer each click. Not for direct in-context browser control, screenshots, or precise element interactions; use the `browser` MCP tools for those. Pass `sessionId` to continue a prior browse session, or omit it for a fresh isolated session; multiple calls run as parallel sessions on the shared browser. If the result is too large to relay it is truncated to a preview and the FULL text is written to a file, whose absolute path is in the returned text; read that file rather than re-running the worker.",
 		inputSchema: {
 			type: "object",
 			required: ["task"],
@@ -35057,6 +35421,6 @@ function enumerateInjectedMcpToolNames(groupKeys, opts = {}) {
 	return [...new Set(names)];
 }
 //#endregion
-export { browserToolsEnabled as $, searchWeb as A, collapsePathKeys as At, buildAnthropicErrorEvent as B, upstreamAllowH2 as Bt, buildToolbeltAwareness as C, provisionAndIndexColbert as Ct, TOOLBELT_TOOLS$1 as D, CONDENSED_OPERATING_SEQUENCE as Dt, vscodeRipgrepPath as E, warmTreeSitterPool as Et, isAdvisorRequested as F, DEFAULT_PORT as Ft, relayAnthropicStream as G, isControllerClosedError as H, withOneMSuffix as Ht, formatThinkingRepairDecline as I, UPSTREAM_FETCH_TIMEOUT_MS as It, agentToolsEnabled as J, handleMcpDelete as K, rememberThinkingHistoryRepair as L, UPSTREAM_INACTIVITY_TIMEOUT_MS as Lt, ADVISOR_TOOL_INSTRUCTIONS as M, DEFAULT_CLAUDE_MODEL_FALLBACKS as Mt, buildAdvisorStream as N, DEFAULT_CODEX_MODEL as Nt, assetFor as O, DEFINITION_OF_GREATNESS as Ot, injectAdvisorTool as P, DEFAULT_CODEX_MODEL_FALLBACKS as Pt, browserCompoundToolsEnabled as Q, repairKnownThinkingHistory as R, generateRandomPort as Rt, availableToolCommands as S, colbertDegradedWarning as St, toolbeltSkipSet as T, extractZipMember as Tt, logStreamError as U, withInstallLock as Ut, buildOpenAIErrorEvent as V, upstreamMaxConnections as Vt, readIteratorWithTimeout as W, brainstormModel as X, artifactToolsEnabled as Y, browseAgentEnabled as Z, appendPlanReminder as _, MAX_RESPONSE_BODY_BYTES as _t, buildPeerAwarenessSnippet as a, scribeModel as at, runWorkerAgent as b, provisionBrowserAssets as bt, personasFor as c, shimDefaultsToXhigh as ct, EXPLORE_DEFAULT_MODEL as d, getTokenCount as dt, fleetToolsEnabled as et, EXPLORE_DEFAULT_THINKING as f, assembleResponsesPayload as ft, TEST_DEFAULT_MODEL as g, createChatCompletions as gt, REVIEW_DEFAULT_MODEL as h, createResponses as ht, buildAgentPrompt as i, scoutModel as it, ADVISOR_INTERNAL_TOOL_NAME as j, toolbeltPathOverride as jt, satisfiesMinVersion as k, shouldUseInsecureTls as kt, BROWSE_DEFAULT_MODEL as l, countTokens as lt, PLAN_DEFAULT_MODEL as m, pickEndpoint as mt, MCP_GROUPS as n, nativeSubagentModel as nt, buildPeerAwarenessSummary as o, standInToolEnabled as ot, IMPLEMENT_DEFAULT_MODEL as p, resolveMcpToolTimeoutMs as pt, handleMcpPost as q, assertMcpToolSurfaceConsistent as r, reviewerModel as rt, enumerateInjectedMcpToolNames as s, workerToolsEnabled as st, GROUP_META as t, geminiAvailable as tt, DEFAULT_MODEL as u, createMessages as ut, resolveModeDefaults as v, readResponseBodyCapped as vt, toolbeltEnabled as w, extractTarGzMember as wt, buildEnv as x, hasSupportedBrowserInstalled as xt, resolveWorkerRunOpts as y, parseJsonOrDiagnose as yt, repairRejectedThinkingHistory as z, pickClaudeDefault as zt };
+export { browserCompoundToolsEnabled as $, satisfiesMinVersion as A, warmTreeSitterPool as At, repairRejectedThinkingHistory as B, DEFAULT_PORT as Bt, availableToolCommands as C, parseJsonOrDiagnose as Ct, vscodeRipgrepPath as D, provisionAndIndexColbert as Dt, toolbeltSkipSet as E, colbertDegradedWarning as Et, injectAdvisorTool as F, collapsePathKeys as Ft, readIteratorWithTimeout as G, upstreamAllowH2 as Gt, buildOpenAIErrorEvent as H, UPSTREAM_INACTIVITY_TIMEOUT_MS as Ht, isAdvisorRequested as I, toolbeltPathOverride as It, handleMcpPost as J, withInstallLock as Jt, relayAnthropicStream as K, upstreamMaxConnections as Kt, formatThinkingRepairDecline as L, DEFAULT_CLAUDE_MODEL_FALLBACKS as Lt, ADVISOR_INTERNAL_TOOL_NAME as M, CONDENSED_OPERATING_SEQUENCE as Mt, ADVISOR_TOOL_INSTRUCTIONS as N, DEFINITION_OF_GREATNESS as Nt, TOOLBELT_TOOLS$1 as O, extractTarGzMember as Ot, buildAdvisorStream as P, shouldUseInsecureTls as Pt, browseAgentEnabled as Q, rememberThinkingHistoryRepair as R, DEFAULT_CODEX_MODEL as Rt, buildEnv as S, readResponseBodyCapped as St, toolbeltEnabled as T, hasSupportedBrowserInstalled as Tt, isControllerClosedError as U, generateRandomPort as Ut, buildAnthropicErrorEvent as V, UPSTREAM_FETCH_TIMEOUT_MS as Vt, logStreamError as W, pickClaudeDefault as Wt, artifactToolsEnabled as X, agentToolsEnabled as Y, brainstormModel as Z, appendPlanReminder as _, resolveMcpToolTimeoutMs as _t, buildPeerAwarenessSnippet as a, nativeSubagentModel as at, resolveWorkerRunOpts as b, createChatCompletions as bt, personasFor as c, scribeModel as ct, EXPLORE_DEFAULT_MODEL as d, shimDefaultsToXhigh as dt, browserToolsEnabled as et, EXPLORE_DEFAULT_THINKING as f, countTokens as ft, TEST_DEFAULT_MODEL as g, warnOnTokenPriceDrift as gt, REVIEW_DEFAULT_MODEL as h, assembleResponsesPayload as ht, buildAgentPrompt as i, implementerFastModel as it, searchWeb as j, provisionTreeSitterAssets as jt, assetFor as k, extractZipMember as kt, BROWSE_DEFAULT_MODEL as l, standInToolEnabled as lt, PLAN_DEFAULT_MODEL as m, getTokenCount as mt, MCP_GROUPS as n, geminiAvailable as nt, buildPeerAwarenessSummary as o, reviewerModel as ot, IMPLEMENT_DEFAULT_MODEL as p, createMessages as pt, handleMcpDelete as q, withOneMSuffix as qt, assertMcpToolSurfaceConsistent as r, generalPurposeFastModel as rt, enumerateInjectedMcpToolNames as s, scoutModel as st, GROUP_META as t, fleetToolsEnabled as tt, DEFAULT_MODEL_CHAIN as u, workerToolsEnabled as ut, resolveDefaultModel as v, pickEndpoint as vt, buildToolbeltAwareness as w, provisionBrowserAssets as wt, runWorkerAgent as x, MAX_RESPONSE_BODY_BYTES as xt, resolveModeDefaults as y, createResponses as yt, repairKnownThinkingHistory as z, DEFAULT_CODEX_MODEL_FALLBACKS as zt };
 
-//# sourceMappingURL=peer-mcp-personas-TMOZJhfy.js.map
+//# sourceMappingURL=peer-mcp-personas-l4P4s1fK.js.map