github-router 0.3.229 → 0.3.238

package/dist/main.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { $ as searchWeb, $t as UPSTREAM_FETCH_TIMEOUT_MS, A as trustRepo, At as createResponses, Bt as warmTreeSitterPool, C as fileLastPromptStore, Cn as copilotBaseUrl, Ct as shimDefaultsToXhigh, D as repoRoot, Dt as assembleResponsesPayload, E as repoFingerprint, En as state, Et as getTokenCount, Ft as provisionBrowserAssets, G as buildEnv, Gt as buildWorkspaceHeaderHelperCommand, Ht as DEFINITION_OF_GREATNESS, It as hasSupportedBrowserInstalled, J as toolbeltEnabled, Jt as toolbeltPathOverride, K as availableToolCommands, Kt as buildWorkspaceHeaderJson, Lt as provisionAndIndexColbert, M as resolveSealedGate, Mt as MAX_RESPONSE_BODY_BYTES, Nt as readResponseBodyCapped, O as stopGateEnabledForRepo, Ot as resolveMcpToolTimeoutMs, Pt as parseJsonOrDiagnose, Q as assetFor, Qt as DEFAULT_PORT, Rt as extractTarGzMember, S as fileFindingsStore, Sn as GITHUB_API_BASE_URL, St as workerToolsEnabled, T as isSubagentContext, Tn as githubHeaders, Tt as createMessages, Ut as shouldUseInsecureTls, Vt as CONDENSED_OPERATING_SEQUENCE, Wt as ArtifactClient, X as vscodeRipgrepPath, Xt as DEFAULT_CODEX_MODEL, Y as toolbeltSkipSet, Yt as DEFAULT_CLAUDE_MODEL_FALLBACKS, Z as TOOLBELT_TOOLS, Zt as DEFAULT_CODEX_MODEL_FALLBACKS, _ as stopGateDisabled, _n as getModels, _t as browserToolsEnabled, a as buildPeerAwarenessSnippet, an as setupCopilotToken, at as buildAnthropicErrorEvent, b as stopReviewEnabled, bn as HTTPError, bt as nativeSubagentModel, c as personasFor, cn as tryRefreshAndRetry, ct as logStreamError, d as buildStopHookCommand, dn as cacheVSCodeVersion, dt as handleMcpDelete, en as UPSTREAM_INACTIVITY_TIMEOUT_MS, et as ADVISOR_INTERNAL_TOOL_NAME, f as captureLaunchBaseline, fn as filterBetaHeader, ft as handleMcpPost, g as launchBaselineKey, gn as sleep$1, gt as browserCompoundToolsEnabled, h as injectStopHookIntoSettingsFile, hn as resolveModel, ht as browseAgentEnabled, i as buildAgentPrompt, in as withInstallLock, it as isAdvisorRequested, j as liveExec, jt as createChatCompletions, k as stopReviewStateDir, kt as pickEndpoint, l as buildArtifactOpenHookCommand, ln as cacheCopilotVersion, lt as readIteratorWithTimeout, m as fileBlockBudget, mn as resolveCodexModel, mt as artifactToolsEnabled, n as MCP_GROUPS, nn as pickClaudeDefault, nt as buildAdvisorStream, o as buildPeerAwarenessSummary, on as setupGitHubAgentToken, ot as buildOpenAIErrorEvent, p as decideStopHook, pn as isNullish, pt as agentToolsEnabled, q as buildToolbeltAwareness, qt as collapsePathKeys, r as assertMcpToolSurfaceConsistent, rn as getPackageVersion, rt as injectAdvisorTool, s as enumerateInjectedMcpToolNames, sn as setupGitHubToken, st as isControllerClosedError, t as GROUP_META, tn as generateRandomPort, tt as ADVISOR_TOOL_INSTRUCTIONS, u as buildSessionBindHookCommand, un as cacheModels, ut as relayAnthropicStream, v as stopGateId, vn as getGitHubUser, vt as fleetToolsEnabled, w as fileReviewDebounce, wn as copilotHeaders, wt as countTokens, x as fileBaselineStore, xn as forwardError, xt as standInToolEnabled, y as stopGatePlanMode, yn as fetchWithTransientRetry, yt as geminiAvailable, zt as extractZipMember } from "./peer-mcp-personas-BKwMCOsl.js";
-import { a as isUnderClaudeConfigMirror, d as writeRuntimeFileSecure, i as ensurePaths, o as removeOwnClaudeConfigMirror, r as ensureClaudeConfigMirror, t as PATHS, u as writeArtifactCredsToMirror } from "./paths-BO22pMUb.js";
-import { c as killManagedTree, d as runCommandCapture, f as runCommandVoid, l as parseBoolEnv, s as killChildProcessTree, u as resolveExecutable } from "./lifecycle-D-1CYr1Y.js";
-import { a as sweepRegistry } from "./lifecycle-bPdiXjYB.js";
+import { $ as searchWeb, $t as DEFAULT_CLAUDE_MODEL_FALLBACKS, A as trustRepo, An as state, At as getTokenCount, Bt as hasSupportedBrowserInstalled, C as fileLastPromptStore, Cn as fetchWithTransientRetry, Ct as scoutModel, D as repoRoot, Dn as copilotBaseUrl, Dt as shimDefaultsToXhigh, E as repoFingerprint, En as GITHUB_API_BASE_URL, Et as workerToolsEnabled, Ft as createChatCompletions, G as buildEnv, Gt as CONDENSED_OPERATING_SEQUENCE, Ht as extractTarGzMember, It as MAX_RESPONSE_BODY_BYTES, J as toolbeltEnabled, Jt as ArtifactClient, K as availableToolCommands, Kt as DEFINITION_OF_GREATNESS, Lt as readResponseBodyCapped, M as resolveSealedGate, Mt as resolveMcpToolTimeoutMs, Nt as pickEndpoint, O as stopGateEnabledForRepo, On as copilotHeaders, Ot as countTokens, Pt as createResponses, Q as assetFor, Qt as toolbeltPathOverride, Rt as parseJsonOrDiagnose, S as fileFindingsStore, Sn as getGitHubUser, St as reviewerModel, T as isSubagentContext, Tn as forwardError, Tt as standInToolEnabled, Ut as extractZipMember, Vt as provisionAndIndexColbert, Wt as warmTreeSitterPool, X as vscodeRipgrepPath, Xt as buildWorkspaceHeaderJson, Y as toolbeltSkipSet, Yt as buildWorkspaceHeaderHelperCommand, Z as TOOLBELT_TOOLS, Zt as collapsePathKeys, _ as stopGateDisabled, _n as isNullish, _t as browserCompoundToolsEnabled, a as buildPeerAwarenessSnippet, an as generateRandomPort, at as buildAnthropicErrorEvent, b as stopReviewEnabled, bn as sleep$1, bt as geminiAvailable, c as personasFor, cn as withInstallLock, ct as logStreamError, d as buildStopHookCommand, dn as setupGitHubToken, dt as handleMcpDelete, en as DEFAULT_CODEX_MODEL, et as ADVISOR_INTERNAL_TOOL_NAME, f as captureLaunchBaseline, fn as tryRefreshAndRetry, ft as handleMcpPost, g as launchBaselineKey, gn as filterBetaHeader, gt as browseAgentEnabled, h as injectStopHookIntoSettingsFile, hn as cacheVSCodeVersion, ht as brainstormModel, i as buildAgentPrompt, in as UPSTREAM_INACTIVITY_TIMEOUT_MS, it as isAdvisorRequested, j as liveExec, jt as assembleResponsesPayload, k as stopReviewStateDir, kn as githubHeaders, kt as createMessages, l as buildArtifactOpenHookCommand, ln as setupCopilotToken, lt as readIteratorWithTimeout, m as fileBlockBudget, mn as cacheModels, mt as artifactToolsEnabled, n as MCP_GROUPS, nn as DEFAULT_PORT, nt as buildAdvisorStream, o as buildPeerAwarenessSummary, on as pickClaudeDefault, ot as buildOpenAIErrorEvent, p as decideStopHook, pn as cacheCopilotVersion, pt as agentToolsEnabled, q as buildToolbeltAwareness, qt as shouldUseInsecureTls, r as assertMcpToolSurfaceConsistent, rn as UPSTREAM_FETCH_TIMEOUT_MS, rt as injectAdvisorTool, s as enumerateInjectedMcpToolNames, sn as getPackageVersion, st as isControllerClosedError, t as GROUP_META, tn as DEFAULT_CODEX_MODEL_FALLBACKS, tt as ADVISOR_TOOL_INSTRUCTIONS, u as buildSessionBindHookCommand, un as setupGitHubAgentToken, ut as relayAnthropicStream, v as stopGateId, vn as resolveCodexModel, vt as browserToolsEnabled, w as fileReviewDebounce, wn as HTTPError, wt as scribeModel, x as fileBaselineStore, xn as getModels, xt as nativeSubagentModel, y as stopGatePlanMode, yn as resolveModel, yt as fleetToolsEnabled, zt as provisionBrowserAssets } from "./peer-mcp-personas-CDja7arT.js";
+import { a as isUnderClaudeConfigMirror, d as writeRuntimeFileSecure, i as ensurePaths, o as removeOwnClaudeConfigMirror, r as ensureClaudeConfigMirror, t as PATHS, u as writeArtifactCredsToMirror } from "./paths-Srxs-aR-.js";
+import { c as killManagedTree, d as resolveExecutable, f as runCommandCapture, l as parseBoolEnv, p as runCommandVoid, s as killChildProcessTree, u as parseIntEnv } from "./lifecycle-C-9_vhyM.js";
+import { a as sweepRegistry } from "./lifecycle-Cuuj40CW.js";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
@@ -979,7 +979,7 @@ function dispatcherDescription(mode) {
 	return `${{
 		explore: "Non-blocking `explore` worker: dispatches a read-only autonomous worker (its own context) in the background and delivers its summary as a completion notification.",
 		implement: "Non-blocking `implement` worker: dispatches an autonomous coding worker (read/write/bash) that ALWAYS runs in an isolated git worktree and returns the diff (for in-place edits use the `implementer` subagent), in the background, and delivers its result as a completion notification.",
-		review: "Non-blocking `review` worker: dispatches a read-only reviewer that reads the code itself to verify a change or claim, in the background, and delivers findings as a completion notification.",
+		review: "Non-blocking `review` worker: the backgrounded counterpart of the `reviewer` subagent, running a cross-lab model. In a git workspace it takes an isolated worktree and can therefore VERIFY rather than only read: reproduce a failure, run the build or suite to check a claim, and author a throwaway probe test. Outside git it degrades to read-only rather than failing. Returns severity-ranked findings with file:line and a go/no-go, as a completion notification. Use `explore` instead when you just need to find or understand something.",
 		plan: "Non-blocking `plan` worker: dispatches a read-only planner that returns an ordered implementation plan, in the background, and delivers it as a completion notification.",
 		test: "Non-blocking `test` worker: dispatches an independent test author (in an isolated git worktree) that writes tests trying to break the implementation, in the background, and delivers pass/fail as a completion notification.",
 		browse: "Non-blocking `browse` worker: dispatches an autonomous browser agent in the background and delivers its result as a completion notification."
@@ -1243,6 +1243,75 @@ const BUILTIN_SUBAGENT_DEFINITIONS = {
 		prompt: "You are a planning agent. Read the codebase (read-only — do not modify files) to design a concrete, ordered implementation plan for the task: the approach, the specific files to change, reuse of existing utilities, risks, and how the result will be verified. Return the plan as your final message."
 	}
 };
+/** Empty-string-safe read of an optional model id. */
+function nonEmptyModel(id) {
+	return id && id.length > 0 ? id : void 0;
+}
+/**
+* The shared "prefer the dedicated tools over shell" steer, appended to every
+* native subagent prompt. `bashUses` names the work that legitimately belongs in
+* Bash for that agent (`builds` for a coder, `repros` for an investigator), the
+* only token that ever differed across the three hand-copied variants this
+* replaces.
+*
+* Deliberately NOT merged with `FILE_TOOL_GUIDANCE` in
+* `anthropic-translate/anthropic-request.ts`: that one is injected at the shim
+* boundary and therefore only reaches shim-routed (non-Claude) models. When a
+* native falls back to the lead's Claude model the shim is bypassed entirely, so
+* this prompt-level copy is the only coverage that survives. Two layers, two
+* different reasons to exist.
+*/
+function fileToolSteer(bashUses) {
+	return `Use the dedicated Edit/Write/Read tools for file changes and Grep/Glob for search; reserve Bash for running ${bashUses}, tests, and git. Do not shell out (sed/awk/python/here-docs) to read or edit files.`;
+}
+/** The read-only half of `fileToolSteer`, for agents that never write. */
+function readOnlyToolSteer() {
+	return "Use Read to read files and Grep/Glob plus the semantic code search tool to find them; Bash is for read-only inspection such as git log, git blame, and git show. Do not modify any file, and do not run mutating commands.";
+}
+/**
+* `tools:` allowlist for the read-only natives (`scout`, `brainstorm`), modelled
+* on Claude Code's own `Explore`/`Plan` built-ins, which run with every tool
+* EXCEPT Agent / Artifact / ExitPlanMode / Edit / Write / NotebookEdit — note
+* that Anthropic's own read-only agent keeps Bash, which is what makes `git log`
+* and `git blame` reachable.
+*
+* Two deliberate deviations, both forced by the frontmatter format:
+*
+*  1. `tools:` is a POSITIVE allowlist with no "all except" form, so the
+*     complement has to be spelled out. Rather than enumerate every harness tool
+*     (which varies by Claude Code version, and would silently drop anything
+*     added later), this lists the read / search / shell core that a read-only
+*     agent actually uses. Tools added by a future release are NOT inherited by
+*     these two agents; that is the price of real enforcement over a prompt that
+*     merely asks nicely.
+*  2. The workers and orchestrate MCP groups are excluded on the same reasoning
+*     that makes `Explore` drop `Agent`: both spawn further agents, so leaving
+*     them in would reintroduce exactly the recursion that exclusion prevents.
+*
+* NOT A SANDBOX. `Bash` is retained because Anthropic's own read-only built-in
+* retains it, and without it an explorer cannot run `git log` / `git blame` /
+* `git show`, which is most of what repository archaeology needs. A shell is a
+* general write primitive, so "read-only" here means the agent has no dedicated
+* mutation tool and is instructed not to mutate, NOT that mutation is
+* impossible. Dropping Edit/Write still removes the path a model reaches for by
+* default. If a future change needs a hard guarantee, this allowlist is not
+* where it can be made.
+*
+* `searchKey` is the RESOLVED group key, not the bare literal: a user-side
+* `mcpServers` collision renames the group (`gh-router-search`, …), and a
+* hardcoded `mcp__search__*` would then grant nothing at all.
+*/
+function readOnlyToolAllowlist(searchKey) {
+	return [
+		"Read",
+		"Grep",
+		"Glob",
+		"Bash",
+		"WebFetch",
+		"WebSearch",
+		`mcp__${searchKey}__*`
+	];
+}
 /**
 * Build the JSON payload for `claude --agents <path>`.
 *
@@ -1275,22 +1344,42 @@ function buildPeerAgentDefinitions(opts) {
 		}),
 		...peersMcp
 	};
-	const nativeModel = opts.nativeSubagentModel && opts.nativeSubagentModel.length > 0 ? opts.nativeSubagentModel : void 0;
+	const nativeModel = nonEmptyModel(opts.nativeSubagentModel);
+	const reviewerModel$1 = nonEmptyModel(opts.reviewerModel);
+	const brainstormModel$1 = nonEmptyModel(opts.brainstormModel);
+	const scoutModel$1 = nonEmptyModel(opts.scoutModel);
+	const scribeModel$1 = nonEmptyModel(opts.scribeModel);
 	const modelField = nativeModel ? { model: nativeModel } : {};
+	const searchKey = opts.groupKeys.search ?? GROUP_META.search.preferredKey;
+	const searchMcp = opts.serverUrl ? { mcpServers: { [searchKey]: httpEntryFor(opts.serverUrl, "search", opts.nonce, opts.workspaceHeaderCmd) } } : {};
 	out.implementer = {
 		description: nativeModel ? `Bounded implementation subagent running ${nativeModel} (strong non-Claude coder, maximum reasoning). Use proactively for well-scoped coding tasks — edits, small features, fixes — to keep the lead's context focused; runs in its own context. Model is overridable at spawn.` : `Bounded implementation subagent (native tools, runs on the lead's model in its own context). Use proactively for well-scoped coding tasks — edits, small features, fixes — to keep the lead's context focused. Model is overridable at spawn.`,
-		prompt: "You are a bounded implementation subagent for well-scoped coding tasks. Implement the requested change surgically, matching the surrounding code style and minimizing unrelated churn. Use the dedicated Edit/Write/Read tools for file changes and Grep/Glob for search; reserve Bash for running builds, tests, and git — do not shell out (sed/awk/python/here-docs) to read or edit files. Verify with the project's build or tests where applicable. Do the work yourself — do not spawn further subagents. Report exactly what changed and any risks.",
+		prompt: "You are a bounded implementation subagent for well-scoped coding tasks. Implement the requested change surgically, matching the surrounding code style and minimizing unrelated churn. " + fileToolSteer("builds") + " Verify with the project's build or tests where applicable. Do the work yourself — do not spawn further subagents. Report exactly what changed and any risks.",
 		...modelField
 	};
-	out.debugger = {
-		description: nativeModel ? `Root-cause & debugging subagent running ${nativeModel} at maximum reasoning. Use proactively for reproducing a bug end to end, isolating the true root cause, and proposing a minimal fix — investigation-heavy work best kept off the lead's context; runs in its own context. Model is overridable at spawn.` : `Root-cause & debugging subagent (native tools, runs on the lead's model in its own context). Use proactively for reproducing a bug end to end, isolating the true root cause, and proposing a minimal fix — kept off the lead's context. Model is overridable at spawn.`,
-		prompt: "You are a root-cause debugging subagent. Reproduce the failure end to end first — as close to how a real user hits it as you can — before theorizing. Form hypotheses and test them against the actual code and runtime: read the code, run the repro with Bash, and add temporary instrumentation only if needed (remove it after). Identify the true root cause, not a symptom; if a fix is in scope, make it minimal and verify the repro now passes. Use the dedicated Edit/Write/Read tools for file changes and Grep/Glob for search; reserve Bash for running repros, tests, and git — do not shell out (sed/awk/python/here-docs) to read or edit files. Do the work yourself — do not spawn further subagents. Report the root cause with evidence, the fix (if any), and any residual risks.",
-		...modelField
+	out.reviewer = {
+		description: reviewerModel$1 ? `Feedback subagent running ${reviewerModel$1}, a DIFFERENT lab from both the lead and the implementer, so its blind spots are decorrelated from whoever produced the work. Use proactively when something already exists and you want it assessed: a diff, a plan, a document, a failing test. Unlike the stateless peer critics, it reads the repo and can RUN things, so prefer it whenever the assessment needs execution or repo context (reproduce a failure, run the suite, bisect); prefer a peer critic when you already hold the artifact and want a fresh-context opinion on it. Model is overridable at spawn.` : `Feedback subagent (native tools, runs on the lead's model in its own context). Use proactively when something already exists and you want it assessed: a diff, a plan, a document, a failing test. Unlike the stateless peer critics, it reads the repo and can RUN things, so prefer it whenever the assessment needs execution or repo context; prefer a peer critic when you already hold the artifact and want a fresh-context opinion on it. Model is overridable at spawn.`,
+		prompt: "You are a feedback subagent. Your job is to tell the caller what is actually true about the artifact you are given — code, a plan, a document, a failure report — and what is wrong with it. Verify against the ACTUAL code by reading it; never assume. Do whatever the assessment requires: reproduce a failure end to end as close to how a real user hits it as you can, form hypotheses and test them against the code and runtime, and isolate the true root cause rather than a symptom. Where the change warrants it, author tests that try to BREAK the implementation (edge cases, error paths, and the acceptance criteria as executable checks), run them, and report which pass and which fail; do NOT modify production code just to make tests pass. " + fileToolSteer("builds") + " Do the work yourself — do not spawn further subagents. Report severity-ranked findings with `file:line` citations, the evidence behind each, and end with a clear go/no-go.",
+		...reviewerModel$1 ? { model: reviewerModel$1 } : {}
 	};
-	out["qa-engineer"] = {
-		description: nativeModel ? `Review, testing & QA subagent running ${nativeModel} at maximum reasoning. Use proactively to review a change for correctness, author and run tests that try to break it, and give a severity-ranked go/no-go while keeping the lead's context focused; runs in its own context. Model is overridable at spawn.` : `Review, testing & QA subagent (native tools, runs on the lead's model in its own context). Use proactively to review a change for correctness, author and run tests that try to break it, and give a severity-ranked go/no-go. Model is overridable at spawn.`,
-		prompt: "You are a review, testing, and QA subagent. Verify correctness against the ACTUAL code by reading it — never assume. Where the change warrants it, author tests that try to BREAK the implementation (edge cases, error paths, and the acceptance criteria as executable checks), then run them and report which pass and which fail; do NOT modify production code just to make tests pass. Use the dedicated Edit/Write/Read tools for file changes and Grep/Glob for search; reserve Bash for running builds, tests, and git — do not shell out (sed/awk/python/here-docs) to read or edit files. Do the work yourself — do not spawn further subagents. Report severity-ranked findings with `file:line` citations and end with a clear go/no-go.",
-		...modelField
+	out.brainstorm = {
+		description: brainstormModel$1 ? `Divergent-options subagent running ${brainstormModel$1} (third lab, for approaches the lead would not generate). Use proactively BEFORE an approach is chosen. Pass the decision, the constraints, what you have already ruled out, and the cost of being wrong; pass your current leading approach too if you have one, and it will try to beat it rather than restate it. Read-only; it proposes, then hands off to implementer. Model is overridable at spawn.` : `Divergent-options subagent (runs on the lead's model in its own context). Use proactively BEFORE an approach is chosen. Pass the decision, the constraints, what you have already ruled out, and the cost of being wrong; pass your current leading approach too if you have one, and it will try to beat it rather than restate it. Read-only; it proposes, then hands off to implementer. Model is overridable at spawn.`,
+		prompt: "You are a divergent-options subagent: the lead's sounding board while an approach is still open. Your job is to surface the option the lead would not have reached on its own. If the caller states its current leading approach, your job is to try to beat it, and you close with one verdict: `replace`, `retain`, or `insufficient evidence`. `replace` requires naming a concrete alternative that dominates it and the evidence that decides between them. `retain` is a real answer and a useful one: say it plainly when the approach survives a genuine attempt to beat it. Manufactured disagreement is as useless as agreement; do neither. If the caller states no leading approach, generate independently and let the lead compare. Return 3 to 5 approaches that differ in MECHANISM, not in phrasing. For each: how it works, what it costs, what would have to be true for it to be the right answer, and the failure mode that would kill it. Near-duplicate options are the failure mode to avoid — if only one real approach exists, say so plainly and explain why the alternatives are dead, because one honest option beats four padded ones. Screen EVERY candidate against this repository and this environment before you rank them, then verify the one you are about to recommend can actually run here: read the code path it depends on, the guard that would refuse it, the artifact it assumes exists. A recommendation that cannot execute is worse than no recommendation. If checking kills your front-runner, rerank and say so. Ground every option in what the repository actually contains, and prefer reusing what is already there over inventing something new. " + readOnlyToolSteer() + " Do the work yourself — do not spawn further subagents.",
+		tools: readOnlyToolAllowlist(searchKey),
+		...brainstormModel$1 ? { model: brainstormModel$1 } : {},
+		...searchMcp
+	};
+	if (scoutModel$1) out.scout = {
+		description: `Read-only exploration subagent running ${scoutModel$1} (fast and cheap, so repository lookups do not run at the lead's model rates). Use proactively to find or understand something in the codebase: it sweeps widely and returns conclusions with file:line references rather than file dumps. Model is overridable at spawn.`,
+		prompt: "You are a read-only exploration subagent. Answer the question by investigating the repository: cast a wide net, then narrow. Return the conclusion, not the raw material — cite `file:line` for anything load-bearing and quote only the lines that matter. If the answer is that something does not exist, say so explicitly and describe where you looked. " + readOnlyToolSteer() + " Do the work yourself — do not spawn further subagents.",
+		tools: readOnlyToolAllowlist(searchKey),
+		model: scoutModel$1,
+		...searchMcp
+	};
+	out.scribe = {
+		description: scribeModel$1 ? `Documentation subagent running ${scribeModel$1}. Use proactively for prose that trails the code: docs, ADRs, CLAUDE.md sections, changelog entries, and README updates that have gone stale. Keeps low-glamour upkeep off the lead's context. Model is overridable at spawn.` : `Documentation subagent (runs on the lead's model in its own context). Use proactively for prose that trails the code: docs, ADRs, CLAUDE.md sections, changelog entries, and README updates that have gone stale. Model is overridable at spawn.`,
+		prompt: "You are a documentation subagent. Write and maintain the prose that trails the code: docs, ADRs, CLAUDE.md sections, changelog entries, README rows. Read the code before describing it — every claim you write must be checkable against the repository as it is now, not as a summary said it was. Match the surrounding document's voice, structure, and level of detail. Prefer updating an existing document over adding a new one, and delete what has become false rather than layering a correction on top of it. " + fileToolSteer("builds") + " Do the work yourself — do not spawn further subagents. Report which documents changed and any claim you could not verify.",
+		...scribeModel$1 ? { model: scribeModel$1 } : {}
 	};
 	if (opts.workerToolsAvailable) {
 		const workersKey = workersKeyOf(opts.groupKeys);
@@ -1628,6 +1717,10 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 		workerToolsAvailable: opts.workerToolsAvailable,
 		browseAvailable: opts.browseAvailable,
 		nativeSubagentModel: opts.nativeSubagentModel,
+		reviewerModel: opts.reviewerModel,
+		brainstormModel: opts.brainstormModel,
+		scoutModel: opts.scoutModel,
+		scribeModel: opts.scribeModel,
 		nonce,
 		codexHome,
 		serverUrl,
@@ -2894,7 +2987,7 @@ async function discoverGateCommands(cwd, opts) {
 	if (files.length === 0) return null;
 	let result;
 	try {
-		const { runWorkerAgent } = await import("./engine-v9-pEKoD.js");
+		const { runWorkerAgent } = await import("./engine-5VxiBAdY.js");
 		result = await runWorkerAgent({
 			mode: "explore",
 			workspace: root,
@@ -4079,7 +4172,7 @@ const STYLE_DIRECTIVE = "Write concisely without losing detail. Use a natural hu
 * Self-referentially compliant with the style directive: no em dashes, no
 * Claude / Anthropic attribution.
 */
-const OPERATING_DEFAULTS_DIRECTIVE = "## Operating defaults (apply when the user has not specified otherwise; the user's explicit direction and the domain's own standards always override)\n\nOrchestrate. Delegate research, implementation, review, and large reads to the right subagent, worker, or model (the `implementer`, `debugger`, and `qa-engineer` native subagents for bounded implementation, root-cause debugging, and review/testing respectively; worker-* agents for background non-blocking runs; Task subagents for parallel work; peer critics for review) so your own context stays free to reason and collaborate with the user. Prefer parallel delegation for independent work. Do trivial, surgical, and last-mile work directly; delegate the rest rather than doing it yourself and filling your own context. Delegate to a subagent by default whenever one can do the work without loss of quality: the main thread is where you think with and respond to the user, and its context window is a finite shared resource, so protect it by pushing heavy or exploratory work outward and keeping only the conclusions.\n\nAim high. Default to radical simplicity and a relentless focus on the user's real experience: design for the person and the job to be done, not the demo. Reason about the whole system from first principles, anticipating scale and the long arc rather than patching the surface. Work backwards from the outcome the user actually needs. Question every assumption and prefer what you can derive, reproduce, or test.\n\nEngineering excellence. When making technical decisions, give little weight to development cost; prefer quality, simplicity, robustness, scalability, and long-term maintainability. Fix a bug by first reproducing it end to end, as close to how a real user hits it as you can, so you solve the real problem and not a symptom. When testing a product end to end, be picky about the UI and obsessed with pixel perfection: if something clearly looks off, even when it is unrelated to your task, get it fixed along the way. Hold that same bar for the codebase itself: a lint error, a failing test, or a flaky test is worth fixing the moment you see it, whoever introduced it. Fold it into your current work rather than letting it derail the task the user actually asked for.";
+const OPERATING_DEFAULTS_DIRECTIVE = "## Operating defaults (apply when the user has not specified otherwise; the user's explicit direction and the domain's own standards always override)\n\nOrchestrate. Delegate research, implementation, review, and large reads to the right subagent, worker, or model. Reach for `implementer` when you know what to build, `reviewer` when something exists and you want it assessed (including reproducing and root-causing a failure), `brainstorm` when you do not yet know which approach to take, `scout` to find or understand something in the repo, and `scribe` for docs and ADRs that trail the code; worker-* agents for background non-blocking runs; Task subagents for parallel work; peer critics for review. That keeps your own context free to reason and collaborate with the user. Prefer parallel delegation for independent work. Do trivial, surgical, and last-mile work directly; delegate the rest rather than doing it yourself and filling your own context. Delegate to a subagent by default whenever one can do the work without loss of quality: the main thread is where you think with and respond to the user, and its context window is a finite shared resource, so protect it by pushing heavy or exploratory work outward and keeping only the conclusions.\n\nAim high. Default to radical simplicity and a relentless focus on the user's real experience: design for the person and the job to be done, not the demo. Reason about the whole system from first principles, anticipating scale and the long arc rather than patching the surface. Work backwards from the outcome the user actually needs. Question every assumption and prefer what you can derive, reproduce, or test.\n\nEngineering excellence. When making technical decisions, give little weight to development cost; prefer quality, simplicity, robustness, scalability, and long-term maintainability. Fix a bug by first reproducing it end to end, as close to how a real user hits it as you can, so you solve the real problem and not a symptom. When testing a product end to end, be picky about the UI and obsessed with pixel perfection: if something clearly looks off, even when it is unrelated to your task, get it fixed along the way. Hold that same bar for the codebase itself: a lint error, a failing test, or a flaky test is worth fixing the moment you see it, whoever introduced it. Fold it into your current work rather than letting it derail the task the user actually asked for.";
 /**
 * Condensed digest of OPERATING_DEFAULTS_DIRECTIVE for the spawned session's
 * system prompt (--append-system-prompt). The FULL directive is prepended to
@@ -4820,8 +4913,27 @@ function keepDisplayOn() {
 const ES_CONTINUOUS = 2147483648;
 const ES_SYSTEM_REQUIRED = 1;
 const ES_DISPLAY_REQUIRED = 2;
-/** Default time to wait for the helper's `OK` readiness line. */
-const DEFAULT_READY_TIMEOUT_MS = 5e3;
+/** Default time to wait for the helper's `OK` readiness line.
+*
+*  Sized for the slowest LEGITIMATE path, not the typical one. The script's
+*  `Add-Type -MemberDefinition` compiles a C# P/Invoke shim through csc.exe on
+*  first use, and that compile happens BEFORE the `OK` line is printed. On a
+*  cold machine (a fresh CI runner, a laptop that just booted, a host with
+*  aggressive on-access AV scanning) it routinely takes well over five seconds.
+*
+*  CORRECTION to the rationale this constant shipped with. An earlier version of
+*  this comment (and the commit that raised the value) claimed a short timeout
+*  made the user "silently lose keep-awake". That is wrong, and a cross-lab
+*  reviewer caught it: `startKeepAwake` does nothing with `ready` but
+*  `consola.debug` it (`index.ts:128`). The handle is retained and the child
+*  keeps running, so the assertion is still set, just later than we observed it.
+*
+*  The real cost of a tight value is therefore a LYING LOG, not a lost feature:
+*  we report "inactive" for a helper that is about to work. That is still worth
+*  fixing, because a false negative in a diagnostic is how you lose an afternoon
+*  chasing a working feature. Waiting longer costs nothing either way, since the
+*  readiness promise is awaited in the background and never blocks launch. */
+const DEFAULT_READY_TIMEOUT_MS = 2e4;
 /**
 * The execution-state flags to assert. Always `ES_CONTINUOUS |
 * ES_SYSTEM_REQUIRED` (machine stays awake); adds `ES_DISPLAY_REQUIRED`
@@ -5222,7 +5334,7 @@ function initProxyFromEnv() {
 //#endregion
 //#region package.json
 var name = "github-router";
-var version$1 = "0.3.229";
+var version$1 = "0.3.238";
 
 //#endregion
 //#region src/lib/approval.ts
@@ -5347,7 +5459,7 @@ function detectCapabilityMismatch(info, model) {
 * that should get a probe row added.
 *
 * Format (single line, deterministic-ish key order):
-*   [fields] path=<P> body_keys=<csv> tool_field_keys=<csv> beta_values=<csv>
+*   [fields] path=<P> body_keys=<csv> tool_field_keys=<csv> beta_values=<csv> agent=<id|->
 *
 * Where:
 *   - `body_keys` is the alphabetical union of top-level keys in the
@@ -5357,13 +5469,19 @@ function detectCapabilityMismatch(info, model) {
 *   - `beta_values` is the comma-split anthropic-beta header value as
 *     received (NOT filtered) — captures what the client sends, not
 *     what we forward
+*   - `agent` is Claude Code's `x-claude-code-agent-id` header, or `-` for
+*     main-loop traffic. Without it a capture cannot tell a subagent request
+*     from a main-loop one, which is exactly the question you need answered
+*     when reasoning about per-agent request shape (does a subagent send a
+*     `thinking` block?). The header value is opaque to us and is logged
+*     verbatim.
 */
 function logRequestFields(opts) {
 	if (process.env.GH_ROUTER_LOG_FIELDS !== "1") return;
 	const bodyKeys = collectTopLevelKeys(opts.body);
 	const toolFieldKeys = collectToolFieldKeys(opts.body);
 	const betaValues = (opts.betaHeader ?? "").split(",").map((v) => v.trim()).filter(Boolean);
-	consola.info(`[fields] path=${opts.path} body_keys=${bodyKeys.join(",")} tool_field_keys=${toolFieldKeys.join(",")} beta_values=${betaValues.join(",")}`);
+	consola.info(`[fields] path=${opts.path} body_keys=${bodyKeys.join(",")} tool_field_keys=${toolFieldKeys.join(",")} beta_values=${betaValues.join(",")} agent=${opts.agentId && opts.agentId.length > 0 ? opts.agentId : "-"}`);
 }
 function collectTopLevelKeys(body) {
 	if (!body || typeof body !== "object" || Array.isArray(body)) return [];
@@ -6306,20 +6424,29 @@ function parseDisableParallelToolUse(toolChoice) {
 	return toolChoice.disable_parallel_tool_use === true ? false : void 0;
 }
 /** Default absent Anthropic `thinking` to an effort, clamped by the model.
-*  OpenAI-frontier shim models (gpt-5.6-sol/gpt-5.5) default to xhigh so the
-*  native gpt-5.6-sol subagents (implementer/debugger/qa-engineer) and any
-*  `-m gpt-5.6-sol` main-loop session reason at max when the client sends no
-*  `thinking` block; every other shim model stays high. The
-*  `supported.includes("xhigh")` guard makes the intent explicit rather than
-*  trusting clampEffort to silently degrade. Opt out with
-*  `GH_ROUTER_DISABLE_FRONTIER_XHIGH_DEFAULT=1`. Returns undefined for a model
-*  that advertises NO `reasoning_effort` allowlist (may not support reasoning;
-*  forcing an effort could 400). Note: an explicit client `thinking` budget is
-*  handled by parseReasoningEffort and is NOT affected by this default. */
+*  Every shim model defaults to `high`, so a client level maps to the identical
+*  provider level (low→low, medium→medium, high→high, xhigh→xhigh) and `high` is
+*  the only value the router injects on its own. There is deliberately NO floor:
+*  an explicit client budget that buckets to `medium` yields `medium`, because a
+*  one-directional max() would mean the router silently overriding the level the
+*  user chose.
+*
+*  Opt in to the previous behavior (xhigh for the OpenAI frontier models when no
+*  thinking is sent) with `GH_ROUTER_FRONTIER_XHIGH_DEFAULT=1`. This replaces the
+*  old opt-OUT `GH_ROUTER_DISABLE_FRONTIER_XHIGH_DEFAULT`, whose meaning would
+*  have inverted under the new default.
+*
+*  Two honest limits, both pre-existing: the level is bucketed from a token
+*  budget so the mapping is lossy at the boundaries, and `clampEffort` moves a
+*  level the model does not advertise (gemini has no `xhigh`). Returns undefined
+*  for a model that advertises NO `reasoning_effort` allowlist, which leaves the
+*  provider's own default rather than `high` — forcing an effort there could 400.
+*  An explicit client `thinking` budget is handled by parseReasoningEffort and is
+*  NOT affected by this default. */
 function defaultReasoningEffort(model) {
 	const supported = model?.capabilities?.supports?.reasoning_effort;
 	if (!(Array.isArray(supported) && supported.length > 0)) return void 0;
-	return clampEffort(parseBoolEnv(process.env.GH_ROUTER_DISABLE_FRONTIER_XHIGH_DEFAULT) !== true && model?.id != null && shimDefaultsToXhigh(model.id) && supported.includes("xhigh") ? "xhigh" : "high", supported);
+	return clampEffort(parseBoolEnv(process.env.GH_ROUTER_FRONTIER_XHIGH_DEFAULT) === true && model?.id != null && shimDefaultsToXhigh(model.id) && supported.includes("xhigh") ? "xhigh" : "high", supported);
 }
 /**
 * Map Anthropic `thinking` to a Responses reasoning effort, clamped to the
@@ -7367,7 +7494,8 @@ async function handleCompletion(c) {
 		logRequestFields({
 			path: c.req.path,
 			body: parsedForLog,
-			betaHeader: c.req.header("anthropic-beta")
+			betaHeader: c.req.header("anthropic-beta"),
+			agentId: c.req.header("x-claude-code-agent-id")
 		});
 	}
 	if (state.manualApprove) await awaitApproval();
@@ -9014,7 +9142,11 @@ const claude = defineCommand({
 				groupKeys,
 				workerToolsAvailable: workerToolsEnabled(),
 				browseAvailable: browseAgentEnabled(),
-				nativeSubagentModel: nativeSubagentModel()
+				nativeSubagentModel: nativeSubagentModel(),
+				reviewerModel: reviewerModel(),
+				brainstormModel: brainstormModel(),
+				scoutModel: scoutModel(),
+				scribeModel: scribeModel()
 			});
 			state.peerMcpNonce = runtime.nonce;
 			envVars.GH_ROUTER_HOOK_MCP_URL = serverUrl;
@@ -9217,6 +9349,7 @@ const claude = defineCommand({
 				powerBrowseAvailable: state.powerBrowseEnabled,
 				fleetAvailable: fleetToolsEnabled(),
 				agentToolsAvailable: agentToolsEnabled(),
+				scoutAvailable: scoutModel() != null,
 				groupKeys
 			});
 			peerAwarenessSnippet = peerSnippet;
@@ -10147,7 +10280,7 @@ const internalStopHook = defineCommand({
 		} catch {}
 		let decision;
 		try {
-			const timeoutEnv = Number.parseInt(process.env.GH_ROUTER_STOP_GATE_TIMEOUT_MS ?? "", 10);
+			const timeoutEnv = parseIntEnv(process.env.GH_ROUTER_STOP_GATE_TIMEOUT_MS);
 			const mode = dynamicMode();
 			decision = await decideStopHook({
 				stdin,
@@ -10159,7 +10292,7 @@ const internalStopHook = defineCommand({
 				baseline: fileBaselineStore(nodePath.join(tmpdir(), "gh-router-stopgate-baseline")),
 				isEnabledForRepo: (cwd) => stopGateEnabledForRepo(cwd),
 				resolveChecks: mode ? buildResolveChecks(mode) : void 0,
-				timeoutMs: Number.isFinite(timeoutEnv) && timeoutEnv > 0 ? timeoutEnv : void 0,
+				timeoutMs: timeoutEnv,
 				planMode: stopGatePlanMode(),
 				reviewDebounce: reviewEnabled ? fileReviewDebounce(stopReviewStateDir()) : void 0,
 				spawnReview: reviewEnabled ? (ctx) => spawnStopReview(ctx, {
@@ -11007,6 +11140,10 @@ async function provisionServeEnhancements(serverUrl, opts = {}) {
 			workerToolsAvailable: workerToolsEnabled(),
 			browseAvailable: browseAllowed && browseAgentEnabled(),
 			nativeSubagentModel: nativeSubagentModel(),
+			reviewerModel: reviewerModel(),
+			brainstormModel: brainstormModel(),
+			scoutModel: scoutModel(),
+			scribeModel: scribeModel(),
 			builtinSubagents: BUILTIN_SUBAGENT_DEFINITIONS
 		});
 		state.peerMcpNonce = runtime.nonce;
@@ -11025,6 +11162,7 @@ async function provisionServeEnhancements(serverUrl, opts = {}) {
 			compoundBrowseAvailable: browseAllowed && browserCompoundToolsEnabled(),
 			powerBrowseAvailable: browseAllowed && state.powerBrowseEnabled,
 			agentToolsAvailable: firstMateAllowed,
+			scoutAvailable: scoutModel() != null,
 			groupKeys
 		})).catch((err) => consola.warn(`Peer-awareness CLAUDE.md append failed: ${String(err)}`));
 		await prependStyleDirectiveToMirroredClaudeMd().catch((err) => consola.warn(`Style-directive CLAUDE.md prepend failed: ${String(err)}`));