github-router 0.3.275 → 0.3.276

package/dist/{attribution-settings-ZOaCUrYY.js → attribution-settings-VOPvSn6v.js}

@@ -1,6 +1,6 @@
-import { Dt as CONDENSED_OPERATING_SEQUENCE, Ht as withOneMSuffix, Ot as DEFINITION_OF_GREATNESS, c as personasFor, i as buildAgentPrompt, n as MCP_GROUPS, t as GROUP_META } from "./peer-mcp-personas-TMOZJhfy.js";
-import { a as isUnderClaudeConfigMirror, d as writeRuntimeFileSecure, t as PATHS } from "./paths-Bg1_DWhi.js";
-import { a as STRIPPED_AUTH_ROUTING_ENV_KEYS, n as buildCodexProviderConfigFlags } from "./provision-BJ5vUpmp.js";
+import { At as CONDENSED_OPERATING_SEQUENCE, Gt as withOneMSuffix, c as personasFor, i as buildAgentPrompt, jt as DEFINITION_OF_GREATNESS, n as MCP_GROUPS, t as GROUP_META } from "./peer-mcp-personas-DRL_xT4h.js";
+import { a as isUnderClaudeConfigMirror, d as writeRuntimeFileSecure, t as PATHS } from "./paths-j2B7b0DZ.js";
+import { a as STRIPPED_AUTH_ROUTING_ENV_KEYS, n as buildCodexProviderConfigFlags } from "./provision-HzZ547dW.js";
 import { n as buildWorkspaceHeaderHelperCommand } from "./mcp-workspace-header-CGJbNeHb.js";
 import { a as dispatcherAgentName, c as dispatcherTools, n as activeDispatchModes, o as dispatcherDescription, s as dispatcherPrompt } from "./worker-dispatch-Bj1uYyG9.js";
 import consola from "consola";
@@ -303,6 +303,9 @@ function buildPeerAgentDefinitions(opts) {
 	const brainstormModel = nonEmptyModel(opts.brainstormModel);
 	const scoutModel = nonEmptyModel(opts.scoutModel);
 	const scribeModel = nonEmptyModel(opts.scribeModel);
+	const genericModel = nonEmptyModel(opts.genericModel);
+	const genericFastModel = nonEmptyModel(opts.genericFastModel);
+	const genericCheapModel = nonEmptyModel(opts.genericCheapModel);
 	const modelField = nativeModel ? { model: withOneMSuffix(nativeModel) } : {};
 	const searchKey = opts.groupKeys.search ?? GROUP_META.search.preferredKey;
 	const searchMcp = opts.serverUrl ? { mcpServers: { [searchKey]: httpEntryFor(opts.serverUrl, "search", opts.nonce, opts.workspaceHeaderCmd) } } : {};
@@ -331,10 +334,26 @@ function buildPeerAgentDefinitions(opts) {
 		...searchMcp
 	};
 	out.scribe = {
-		description: scribeModel ? `Documentation subagent running ${scribeModel}. 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.`,
+		description: scribeModel ? `Documentation subagent running ${scribeModel} (the mid tier: documentation is verifiable prose, not frontier reasoning). 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 ? { model: withOneMSuffix(scribeModel) } : {}
 	};
+	const genericPromptFor = (role) => `You are a general-purpose subagent handling ${role} the lead has delegated to keep its own context free. Work out what the task actually requires, then do it end to end. Verify against the real repository and the real runtime rather than assuming — read the code, run the command, check the exit code. ` + fileToolSteer("builds") + " Do the work yourself — do not spawn further subagents. Report what you did, what you verified, and anything you could not settle.";
+	if (genericModel) out.generic = {
+		description: `Catch-all subagent running ${genericModel} (1M context, broad general capability). Use for work that no specialist native fits and that you would otherwise do inline: multi-step tasks, mixed read-and-edit work, one-off investigations that end in a change. Runs in its own context on a non-lead model. Model is overridable at spawn.`,
+		prompt: genericPromptFor("general work"),
+		model: withOneMSuffix(genericModel)
+	};
+	if (genericFastModel) out["generic-fast"] = {
+		description: `Catch-all subagent running ${genericFastModel} (1M context, Gemini flash tier — low cost, reasoning effort tops out at high). Use for well-specified work that does not need a frontier model's reasoning. Full toolset, so it can finish the work rather than only research it. Runs in its own context on a non-lead model. Model is overridable at spawn.`,
+		prompt: genericPromptFor("light, well-specified work"),
+		model: withOneMSuffix(genericFastModel)
+	};
+	if (genericCheapModel) out["generic-cheap"] = {
+		description: `Catch-all subagent running ${genericCheapModel} (1M context, the lowest-cost model in the catalog, and unlike the flash tier it carries the full reasoning-effort ladder so an effort selection above high still applies). Use for high-volume or long-running work where cost dominates. Full toolset, so it can finish the work rather than only research it. Runs in its own context on a non-lead model. Model is overridable at spawn.`,
+		prompt: genericPromptFor("cost-sensitive work"),
+		model: withOneMSuffix(genericCheapModel)
+	};
 	if (opts.workerToolsAvailable) {
 		const workersKey = workersKeyOf(opts.groupKeys);
 		const workersMcp = opts.serverUrl ? { mcpServers: { [workersKey]: httpEntryFor(opts.serverUrl, "workers", opts.nonce, opts.workspaceHeaderCmd) } } : {};
@@ -675,6 +694,9 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 		brainstormModel: opts.brainstormModel,
 		scoutModel: opts.scoutModel,
 		scribeModel: opts.scribeModel,
+		genericModel: opts.genericModel,
+		genericFastModel: opts.genericFastModel,
+		genericCheapModel: opts.genericCheapModel,
 		nonce,
 		codexHome,
 		serverUrl,
@@ -1739,51 +1761,45 @@ You are running inside an ai-or-die tab, so the \`${toolPrefix}*\` tools drive a
 * dashes and does not mention any Claude / Anthropic attribution.
 */
 const STYLE_DIRECTIVE = "Write concisely without losing detail. Use a natural human voice. Avoid em dashes. Do not attribute work to Claude, AI, LLM, or Anthropic anywhere (commits, PRs, issues, code, comments, docs).";
+/** Oxford-comma join: "a", "a and b", "a, b, and c". */
+function joinClauses(parts) {
+	if (parts.length <= 1) return parts[0] ?? "";
+	if (parts.length === 2) return `${parts[0]} and ${parts[1]}`;
+	return `${parts.slice(0, -1).join(", ")}, and ${parts[parts.length - 1]}`;
+}
+/** The "Reach for X when Y" list, omitting any agent this launch did not emit. */
+function buildNativeReachClauses(opts) {
+	const clauses = [
+		"`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"
+	];
+	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");
+	const catchAlls = [
+		opts.genericAvailable === false ? void 0 : "`generic`",
+		opts.genericFastAvailable === false ? void 0 : "`generic-fast`",
+		opts.genericCheapAvailable === false ? void 0 : "`generic-cheap`"
+	].filter((c) => c != null);
+	if (catchAlls.length > 0) clauses.push(`${joinClauses(catchAlls)} for work no specialist fits, picking the tier that matches the work's weight`);
+	return joinClauses(clauses);
+}
 /**
-* Operating-defaults directive injected at the TOP of the mirrored CLAUDE.md.
-* The main agent's system prompt (`--append-system-prompt`) gets
-* OPERATING_DEFAULTS_DIGEST instead, with this full statement available through
-* CLAUDE.md. Three defaults, each explicitly overridden by the user's own
-* direction and the domain's standards:
+* Build the operating-defaults directive for one launch, naming only the
+* natives that launch actually emitted.
 *
-*   1. Orchestrate (strong default): delegate the heavy / parallel /
-*      context-heavy work to the right subagent / worker / model, keeping the
-*      main context free to reason and collaborate with the user, while still
-*      doing trivial / surgical / last-mile work directly (delegating that
-*      would only add relay-fidelity loss + latency).
-*   2. Adversarial review: WHEN a peer critic earns its keep and, equally
-*      important, when reaching for one is ritual rather than review. Same
-*      failure shape the delegation default had: "consult a critic for
-*      non-trivial changes" is unfalsifiable in advance, so it collapses into
-*      either never (four of four unprimed agents) or always (worse than
-*      never). The discriminator is whether the conclusion still turns on
-*      judgment once the direct evidence is in: a consequential recommendation
-*      cannot be run, which is exactly where confabulation hides, while a
-*      tracing question a search already proved gains nothing from a second
-*      model re-deriving it. The roster, the lens-to-artifact match, the
-*      advisor-complements-rather-than-substitutes distinction, and the
-*      do-not-anchor-the-critic rule live here; the digest carries only the
-*      trigger and the ritual exclusion.
-*   3. Excellence lens: the principles stated plainly and concretely (radical
-*      simplicity + real-user focus; whole-system first-principles thinking that
-*      anticipates scale; work back from the customer outcome). Named exemplars
-*      were dropped per the injected-surface review: a named entity is a dense,
-*      high-variance vector that pulls in persona mannerisms at top salience, and
-*      the guidance favors specific functional framing over comparison, so
-*      specificity carries the vividness instead.
-*   4. Engineering excellence: quality / robustness / maintainability over
-*      development cost; reproduce a bug end-to-end (as a real user hits it)
-*      before fixing so the fix targets the real cause; a pixel-perfect UI bar;
-*      and fix any lint error / test failure / flake on sight, whoever caused it,
-*      folded into the current work rather than derailing the user's task (the
-*      scope guardrail keeps proactive quality from becoming yak-shaving). The
-*      digest carries a one-line form; the full statement lives here so it does
-*      not cost the context window every turn.
-*
-* Self-referentially compliant with the style directive: no em dashes, no
-* Claude / Anthropic attribution.
+* Callers must pass the SAME availability booleans they used for the `.md`
+* generation and `buildPeerAwarenessSnippet`, so the three surfaces cannot
+* disagree about which agents exist.
 */
-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. Delegation pays when the work is WIDE (many files or sources to sweep) or SLOW, and you need only the conclusion: the main thread is where you think with and respond to the user, and its context window is a finite shared resource. It does NOT pay merely because a sub-question is separable. A narrow, deep question whose whole value is file:line fidelity loses exactly that through a summarization layer, and a sub-question you could answer in one command is cheaper done directly than paying a subagent's startup. Do trivial, surgical, and last-mile work yourself.\n\nAdversarial review. The peer critics (`codex_critic` and `codex_reviewer`, `gemini_critic` and `gemini_reviewer`, `opus_critic`, and the `peer-review-coordinator` that fans out to several of them) are fresh-context models, so what they add is a blind spot that whoever produced the work cannot reach by thinking harder about it; prefer a critic from a different lab than the producer, since blind spots correlate within a lab. The `advisor` is a complement and not a substitute: it sees your transcript, so it catches your own drift and momentum, but it inherits your framing, which is exactly what a fresh-context critic does not. They earn their keep on consequential design choices, recommendations, and hard-to-reverse decisions: the cases where plausible alternatives remain and the conclusion rests on judgment rather than on something you can verify directly. That is where confabulation hides, so budget the wait even under delivery pressure. Always consult one when the change touches auth, user input, database queries, crypto, or serialization. They do NOT pay for read-only tracing, ordinary repository lookup, or a conclusion that a focused test, a direct reproduction, or unambiguous code evidence already settles. Asking a critic to re-derive a proven fact returns a confident answer either way, which is ritual skepticism rather than review, and skipping them there is the right call and not a shortcut. Match the lens to the artifact: a strategic critic for plans and trade-offs, a code reviewer for a concrete diff, the coordinator only when the risk warrants several independent lenses. Give whichever you pick the artifact and the constraints and not your rationale, since justification anchors the review and dulls it.\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.";
+function buildOperatingDefaultsDirective(opts = {}) {
+	return "## 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 " + buildNativeReachClauses(opts) + "; 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. Delegation pays when the work is WIDE (many files or sources to sweep) or SLOW, and you need only the conclusion: the main thread is where you think with and respond to the user, and its context window is a finite shared resource. It does NOT pay merely because a sub-question is separable. A narrow, deep question whose whole value is file:line fidelity loses exactly that through a summarization layer, and a sub-question you could answer in one command is cheaper done directly than paying a subagent's startup. Do trivial, surgical, and last-mile work yourself.\n\nAdversarial review. The peer critics (`codex_critic` and `codex_reviewer`, `gemini_critic` and `gemini_reviewer`, `opus_critic`, and the `peer-review-coordinator` that fans out to several of them) are fresh-context models, so what they add is a blind spot that whoever produced the work cannot reach by thinking harder about it; prefer a critic from a different lab than the producer, since blind spots correlate within a lab. The `advisor` is a complement and not a substitute: it sees your transcript, so it catches your own drift and momentum, but it inherits your framing, which is exactly what a fresh-context critic does not. They earn their keep on consequential design choices, recommendations, and hard-to-reverse decisions: the cases where plausible alternatives remain and the conclusion rests on judgment rather than on something you can verify directly. That is where confabulation hides, so budget the wait even under delivery pressure. Always consult one when the change touches auth, user input, database queries, crypto, or serialization. They do NOT pay for read-only tracing, ordinary repository lookup, or a conclusion that a focused test, a direct reproduction, or unambiguous code evidence already settles. Asking a critic to re-derive a proven fact returns a confident answer either way, which is ritual skepticism rather than review, and skipping them there is the right call and not a shortcut. Match the lens to the artifact: a strategic critic for plans and trade-offs, a code reviewer for a concrete diff, the coordinator only when the risk warrants several independent lenses. Give whichever you pick the artifact and the constraints and not your rationale, since justification anchors the review and dulls it.\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.";
+}
+/** The all-available form of the directive. Prefer
+*  `buildOperatingDefaultsDirective` on any path that knows which natives
+*  resolved; this const is the default for callers and tests that do not model
+*  a thin catalog. */
+const OPERATING_DEFAULTS_DIRECTIVE = buildOperatingDefaultsDirective();
 /**
 * Condensed digest of OPERATING_DEFAULTS_DIRECTIVE for the spawned session's
 * system prompt (--append-system-prompt). The FULL directive is prepended to
@@ -2342,6 +2358,6 @@ async function injectAttributionSuppressionIntoSettingsFile(settingsPath) {
 	return { written: true };
 }
 //#endregion
-export { injectPeerMcpIntoMirror as _, OPERATING_DEFAULTS_DIRECTIVE 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, appendPeerAwarenessToMirroredClaudeMd as o, injectAllowRules as p, writeInjectedSkill as r, appendToolbeltAwarenessToMirroredClaudeMd as s, injectAttributionSuppressionIntoSettingsFile as t, prependStyleDirectiveToMirroredClaudeMd as u, resolveCodexCliBackend as v, writePeerMcpRuntimeFiles as x, resolveGroupKeysFromMirror as y };
+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-ZOaCUrYY.js.map
+//# sourceMappingURL=attribution-settings-VOPvSn6v.js.map