github-router 0.3.285 → 0.3.288

package/README.md

@@ -98,15 +98,18 @@ Each persona is exposed both as a Claude Code subagent (callable via the `Task`
 
 ### Native subagents
 
-The launcher also registers focused native subagents that run in their own contexts. `implementer`, `reviewer`, `brainstorm`, and `scribe` are always present. Each uses its preferred model when the live catalog provides one with tool calls, otherwise it inherits the lead model; `scout` is present only when its cheap-tier model chain resolves, so repository lookup does not silently run at the lead's model rate.
+The launcher also registers focused native subagents that run in their own contexts. `implementer`, `reviewer`, `brainstorm`, and `scribe` are always present. Each uses its preferred model when the live catalog provides one with tool calls, otherwise it inherits the lead model; `scout`, `implementer-fast`, `reviewer-fast`, and `general-purpose-fast` are present only when their cheap-tier model chains resolve, so the work they exist to make cheaper does not silently run at the lead's model rate.
 
 | Subagent | Use for | Preferred model chain | Tools |
 |---|---|---|---|
-| `implementer` | Well-scoped coding changes | gpt-5.6-sol → gpt-5.5 | Full inherited toolset |
-| `reviewer` | Assessing an existing diff, plan, document, or failure | gpt-5.6-sol → gpt-5.5 | Full inherited toolset |
-| `brainstorm` | Divergent approaches before selecting one | gemini-3.1-pro-preview → OpenAI frontier | Read-only allowlist |
-| `scout` | Low-cost repository exploration | gemini-3.6-flash → gpt-5.4-mini | Read-only allowlist |
+| `implementer` | Coding changes needing judgment or with ambiguous scope | gpt-5.6-sol → gpt-5.5 | Full inherited toolset |
+| `implementer-fast` | Well-specified, mechanical coding changes | gpt-5.6-terra → gemini-3.1-pro-preview | Full inherited toolset |
+| `reviewer` | Assessing an existing diff, plan, document, or failure | gemini-3.1-pro-preview → gemini-3.7-flash → OpenAI frontier | Full inherited toolset |
+| `reviewer-fast` | Lower-stakes assessment on a cheaper cross-lab model | gemini-3.7-flash | Full inherited toolset |
+| `brainstorm` | Divergent approaches before selecting one | gemini-3.1-pro-preview → gemini-3.7-flash → OpenAI frontier | Read-only allowlist |
+| `scout` | Low-cost repository exploration | gpt-5.6-luna → gemini-3.7-flash | Read-only allowlist |
 | `scribe` | Documentation that trails the code | gpt-5.6-terra → OpenAI frontier | Full inherited toolset |
+| `general-purpose-fast` | Work no specialist fits | gpt-5.6-luna | Full inherited toolset |
 
 For codex-side write capability (a `codex-implementer` persona that can mutate files via Codex's tool-use sandbox), pass `--codex-cli`. Requires `codex` CLI 0.129+ on `PATH`; falls back to HTTP-only with a warning if codex is missing or older. Pass `--codex-mcp-only` to also pass `--strict-mcp-config` to Claude Code so only the proxy's MCP servers are loaded (hides any MCP servers in your existing `~/.claude/mcp.json`).
 

package/dist/{attribution-settings-B8M2fvhz.js → attribution-settings-CofaqSzw.js}

@@ -1,9 +1,9 @@
-import { Lt as CONDENSED_OPERATING_SEQUENCE, Rt as DEFINITION_OF_GREATNESS, c as personasFor, i as buildAgentPrompt, n as MCP_GROUPS, rn as withOneMSuffix, t as GROUP_META } from "./peer-mcp-personas-V6stFvpq.js";
-import { a as isUnderClaudeConfigMirror, d as writeRuntimeFileSecure, t as PATHS } from "./paths-wLC0InjX.js";
-import "./self-invocation-CKMjcA5F.js";
-import { a as STRIPPED_AUTH_ROUTING_ENV_KEYS, n as buildCodexProviderConfigFlags } from "./provision-BpL6gZIt.js";
-import { n as buildWorkspaceHeaderHelperCommand } from "./mcp-workspace-header-ucs2SDST.js";
-import { a as dispatcherAgentName, c as dispatcherTools, n as activeDispatchModes, o as dispatcherDescription, s as dispatcherPrompt } from "./worker-dispatch-zW8Zi69V.js";
+import { Bt as CONDENSED_OPERATING_SEQUENCE, Vt as DEFINITION_OF_GREATNESS, c as personasFor, i as buildAgentPrompt, n as MCP_GROUPS, on as withOneMSuffix, t as GROUP_META } from "./peer-mcp-personas-B5Wp6wIn.js";
+import { a as isUnderClaudeConfigMirror, d as writeRuntimeFileSecure, t as PATHS } from "./paths-D7_SAaIQ.js";
+import "./self-invocation-CP_SOkrr.js";
+import { a as STRIPPED_AUTH_ROUTING_ENV_KEYS, n as buildCodexProviderConfigFlags } from "./provision-CUqPki1z.js";
+import { n as buildWorkspaceHeaderHelperCommand } from "./mcp-workspace-header-DRCCWlOi.js";
+import { a as dispatcherAgentName, c as dispatcherTools, n as activeDispatchModes, o as dispatcherDescription, s as dispatcherPrompt } from "./worker-dispatch-BCTMyNE-.js";
 import consola from "consola";
 import path from "node:path";
 import { randomBytes } from "node:crypto";
@@ -280,7 +280,8 @@ function buildPeerAgentDefinitions(opts) {
 	const out = {};
 	const personas = personasFor({
 		codexCli: opts.codexCli,
-		geminiAvailable: opts.geminiAvailable
+		geminiAvailable: opts.geminiAvailable,
+		geminiModel: opts.geminiModel
 	});
 	const peersKey = peersKeyOf(opts.groupKeys);
 	const peersMcp = opts.serverUrl ? { mcpServers: { [peersKey]: httpEntryFor(opts.serverUrl, "peers", opts.nonce, opts.workspaceHeaderCmd) } } : {};
@@ -301,6 +302,7 @@ function buildPeerAgentDefinitions(opts) {
 	};
 	const nativeModel = nonEmptyModel(opts.nativeSubagentModel);
 	const reviewerModel = nonEmptyModel(opts.reviewerModel);
+	const reviewerFastModel = nonEmptyModel(opts.reviewerFastModel);
 	const brainstormModel = nonEmptyModel(opts.brainstormModel);
 	const scoutModel = nonEmptyModel(opts.scoutModel);
 	const scribeModel = nonEmptyModel(opts.scribeModel);
@@ -314,11 +316,17 @@ function buildPeerAgentDefinitions(opts) {
 		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
 	};
+	const reviewerPrompt = "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.";
 	out.reviewer = {
 		description: reviewerModel ? `Feedback subagent running ${reviewerModel}, 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. It can also REVIEW SCREENSHOTS and other images: just point it at the file and it will look at them. 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.",
+		prompt: reviewerPrompt,
 		...reviewerModel ? { model: withOneMSuffix(reviewerModel) } : {}
 	};
+	if (reviewerFastModel) out["reviewer-fast"] = {
+		description: `Cheaper feedback subagent running ${reviewerFastModel} (1M context, typically faster than the pro-tier reviewer and cross-lab from the OpenAI-backed implementer). Use for lower-stakes assessments that still need repository access or execution; escalate higher-stakes review to reviewer. Full toolset, so it can read the repo and run builds, tests, and reproductions in its own context. Model is overridable at spawn.`,
+		prompt: reviewerPrompt,
+		model: withOneMSuffix(reviewerFastModel)
+	};
 	out.brainstorm = {
 		description: brainstormModel ? `Divergent-options subagent running ${brainstormModel} (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.",
@@ -673,6 +681,7 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 	const mcpConfig = buildPeerMcpConfig(serverUrl, {
 		codexCli: opts.codexCli,
 		geminiAvailable: opts.geminiAvailable,
+		geminiModel: opts.geminiModel,
 		groupKeys: opts.groupKeys,
 		nonce,
 		codexHome,
@@ -681,11 +690,13 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 	const agents = buildPeerAgentDefinitions({
 		codexCli: opts.codexCli,
 		geminiAvailable: opts.geminiAvailable,
+		geminiModel: opts.geminiModel,
 		groupKeys: opts.groupKeys,
 		workerToolsAvailable: opts.workerToolsAvailable,
 		browseAvailable: opts.browseAvailable,
 		nativeSubagentModel: opts.nativeSubagentModel,
 		reviewerModel: opts.reviewerModel,
+		reviewerFastModel: opts.reviewerFastModel,
 		brainstormModel: opts.brainstormModel,
 		scoutModel: opts.scoutModel,
 		scribeModel: opts.scribeModel,
@@ -709,7 +720,8 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 	});
 	const personas = personasFor({
 		codexCli: opts.codexCli,
-		geminiAvailable: opts.geminiAvailable
+		geminiAvailable: opts.geminiAvailable,
+		geminiModel: opts.geminiModel
 	});
 	const cleanup = async () => {
 		await Promise.allSettled([
@@ -1763,21 +1775,36 @@ function joinClauses(parts) {
 }
 /** The "Reach for X when Y" list, omitting any agent this launch did not emit.
 *
-*  On a budget lead the coding clauses swap order so the cheap tier leads and
-*  the frontier tier is named as the complexity escalation. Choosing a lighter
-*  lead is a decision to spend less while holding quality, and a roster that
-*  names the expensive `implementer` first works against exactly that. This is
-*  ORDERING AND WORDING ONLY: no agent's model changes, and `implementer` stays
-*  named so work beyond the fast tier still has somewhere to go. */
+*  On a budget lead the coding AND review clauses swap order so the cheap tier
+*  leads and the frontier tier is named as the complexity escalation. Choosing a
+*  lighter lead is a decision to spend less while holding quality, and a roster
+*  that names the expensive `implementer` / `reviewer` first works against
+*  exactly that. This is ORDERING AND WORDING ONLY: no agent's model changes,
+*  and both frontier tiers stay named so work beyond the fast tier still has
+*  somewhere to go.
+*
+*  Review gets the same treatment as implementation because the cost gap is the
+*  same shape: `reviewer` runs the pro tier (200/1200 per 1M) against
+*  `reviewer-fast`'s flash tier (75/375), and measured 2026-08-13 the flash
+*  model was also the FASTER of the two on every axis (tool-call p50 ~1.2s vs
+*  ~2.8s, TTFT ~1.9s vs ~3.7s, decode ~326 vs ~165 tok/s). So on a budget lead
+*  there is no quality-for-cost trade being hidden by leading with the cheap
+*  tier; reserve `reviewer` for the higher-stakes assessment it is there for. */
 function buildNativeReachClauses(opts) {
 	const clauses = [];
 	const implementerFast = opts.implementerFastAvailable !== false;
+	const reviewerFast = opts.reviewerFastAvailable !== false;
 	if (opts.budgetLead === true && implementerFast) clauses.push("`implementer-fast` first for coding changes, since it is the cheaper and faster tier and this session is running a lighter lead", "`implementer` when the change needs judgment, its scope is ambiguous, or its complexity is beyond what the fast tier can carry");
 	else {
 		clauses.push("`implementer` for coding changes that need judgment or have ambiguous scope");
 		if (implementerFast) clauses.push("`implementer-fast` for well-specified, mechanical coding changes");
 	}
-	clauses.push("`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");
+	if (opts.budgetLead === true && reviewerFast) clauses.push("`reviewer-fast` first when something exists and you want it assessed, since it is the cheaper and faster review tier", "`reviewer` when the assessment is higher-stakes or needs deeper reproduction and root-causing than the fast tier can carry");
+	else {
+		clauses.push("`reviewer` when something exists and you want it assessed (including reproducing and root-causing a failure)");
+		if (reviewerFast) clauses.push("`reviewer-fast` for lower-stakes assessments");
+	}
+	clauses.push("`brainstorm` when you do not yet know which approach to take");
 	if (opts.scoutAvailable !== false) clauses.push("`scout` to find or understand something in the repo");
 	clauses.push("`scribe` for docs and ADRs that trail the code");
 	if (opts.generalPurposeFastAvailable !== false) clauses.push(opts.budgetLead === true ? "`general-purpose-fast` for work no specialist fits, in preference to carrying it inline yourself" : "`general-purpose-fast` for work no specialist fits");
@@ -2359,4 +2386,4 @@ async function injectAttributionSuppressionIntoSettingsFile(settingsPath) {
 //#endregion
 export { injectPeerMcpIntoMirror as _, appendPeerAwarenessToMirroredClaudeMd as a, workersKeyOf as b, prependArtifactPanelDirectiveToMirroredClaudeMd as c, SEAMLESS_BUILTIN_TOOLS as d, configureServeDefaultPermissionMode as f, BUILTIN_SUBAGENT_DEFINITIONS as g, sanitizeServeSettingsEnv as h, OPERATING_DEFAULTS_DIGEST as i, prependOperatingDefaultsToMirroredClaudeMd as l, planModeAllowRules as m, INJECTED_SKILLS as n, appendToolbeltAwarenessToMirroredClaudeMd as o, injectAllowRules as p, writeInjectedSkill as r, buildOperatingDefaultsDirective as s, injectAttributionSuppressionIntoSettingsFile as t, prependStyleDirectiveToMirroredClaudeMd as u, resolveCodexCliBackend as v, writePeerMcpRuntimeFiles as x, resolveGroupKeysFromMirror as y };
 
-//# sourceMappingURL=attribution-settings-B8M2fvhz.js.map
+//# sourceMappingURL=attribution-settings-CofaqSzw.js.map