github-router 0.3.275 → 0.3.282

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

@@ -1,8 +1,9 @@
-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 { 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 { Mt as CONDENSED_OPERATING_SEQUENCE, Nt as DEFINITION_OF_GREATNESS, c as personasFor, i as buildAgentPrompt, n as MCP_GROUPS, qt as withOneMSuffix, t as GROUP_META } from "./peer-mcp-personas-l4P4s1fK.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-DlT34zcf.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-4O3IWtP0.js";
 import consola from "consola";
 import path from "node:path";
 import { randomBytes } from "node:crypto";
@@ -130,11 +131,11 @@ function buildCoordinatorAgent(opts) {
 			"The lead's brief will include an artifact (plan, design, diff, or code) and a goal (e.g. 'review before exit-plan', 'review the commit I just made', 'cross-check codex-critic's verdict'). Pick the right peers for the artifact type:",
 			"",
 			"- **Plan / design / architecture choice** → fan out to `codex-critic` (gpt-5.6-sol, strongest reasoning, cross-lab)" + (opts.geminiAvailable ? " AND `gemini-critic` (third-lab triangulation, strong on formal reasoning) in parallel" : "") + ". codex-reviewer is the wrong tool for plans (it's a code-specialist, not an architecture critic).",
-			"- **Concrete diff or single file** → fan out to `codex-reviewer` (gpt-5.3-codex, line-level code specialist, fastest at ~16s)" + (opts.geminiAvailable ? " AND `gemini-reviewer` (gemini-3.1-pro, second-lab line-level review)" : "") + (opts.geminiAvailable ? " AND `gemini-critic` for cross-lab triangulation" : "") + ". For very small changes (<20 lines), one `codex-reviewer` call is enough.",
+			"- **Concrete diff or single file** → fan out to `codex-reviewer` (gpt-5.3-codex, line-level code specialist)" + (opts.geminiAvailable ? " AND `gemini-reviewer` (gemini-3.1-pro, second-lab line-level review)" : "") + (opts.geminiAvailable ? " AND `gemini-critic` for cross-lab triangulation" : "") + ". For very small changes (<20 lines), one `codex-reviewer` call is enough.",
 			"- **Large artifact** → the only peers that take a large artifact WHOLE are `codex-critic` (gpt-5.6-sol, ≈1M-token input window) and `opus-critic` (Opus-4.7-1M, ≈936K-token input on enterprise catalogs; ≈168K otherwise). Route the full artifact to those for cross-lab coverage. `codex-reviewer` (≈272K) and `gemini-critic` (≈136K) have small windows — see Decomposition below: never summarize or downsize the request to squeeze a large artifact into a small-window peer.",
 			"- **Formal reasoning, proofs, or invariants** → prefer `gemini-critic`" + (opts.geminiAvailable ? " (gemini-3.1-pro, strong on math and formally-stated properties)" : " (NOT REGISTERED in this session — gemini-3.x not in catalog)") + ".",
 			"- **Tie-breaker after codex-critic has weighed in** → call `gemini-critic`" + (opts.geminiAvailable ? "" : " (NOT REGISTERED in this session)") + " or `opus-critic` with the artifact AND codex-critic's verdict for cross-check.",
-			"- **Fast sanity check** → `opus-critic` (~22s, same lab as lead but fresh context — catches confabulation and motivated reasoning).",
+			"- **Fast sanity check** → `opus-critic` (same lab as lead but fresh context — catches confabulation and motivated reasoning).",
 			"",
 			"## Decomposition for large artifacts",
 			"",
@@ -303,11 +304,13 @@ function buildPeerAgentDefinitions(opts) {
 	const brainstormModel = nonEmptyModel(opts.brainstormModel);
 	const scoutModel = nonEmptyModel(opts.scoutModel);
 	const scribeModel = nonEmptyModel(opts.scribeModel);
+	const implementerFastModel = nonEmptyModel(opts.implementerFastModel);
+	const generalPurposeFastModel = nonEmptyModel(opts.generalPurposeFastModel);
 	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) } } : {};
 	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.`,
+		description: nativeModel ? `Bounded implementation subagent running ${nativeModel} (strong non-Claude coder, maximum reasoning). Use proactively for coding changes that need judgment or have ambiguous scope — edits, features, fixes — to keep the lead's context focused; use implementer-fast instead for well-specified, mechanical changes. 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 coding changes that need judgment or have ambiguous scope — edits, features, fixes — to keep the lead's context focused; use implementer-fast instead for well-specified, mechanical changes. 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. " + 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
 	};
@@ -331,10 +334,21 @@ 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 (implementerFastModel) out["implementer-fast"] = {
+		description: `Implementation subagent running ${implementerFastModel} (1M context, ${implementerFastModel === "gpt-5.6-terra" ? "the cheaper, faster implementation tier" : "a non-lead implementation model"}). Use proactively for well-specified, mechanical coding changes; use implementer instead when the change needs judgment or its scope is ambiguous. Full toolset, so it can implement and verify the change end to end in its own context. Model is overridable at spawn.`,
+		prompt: genericPromptFor("a well-specified, mechanical coding change"),
+		model: withOneMSuffix(implementerFastModel)
+	};
+	if (generalPurposeFastModel) out["general-purpose-fast"] = {
+		description: `Catch-all subagent running ${generalPurposeFastModel} (1.05M context, the lowest-cost model in the catalog and the fastest measured catch-all candidate, with the full reasoning-effort ladder). Use proactively for work no specialist fits when a fast, economical non-lead model can finish it. Full toolset, so it can complete the work rather than only research it. Runs in its own context. Model is overridable at spawn.`,
+		prompt: genericPromptFor("work no specialist fits"),
+		model: withOneMSuffix(generalPurposeFastModel)
+	};
 	if (opts.workerToolsAvailable) {
 		const workersKey = workersKeyOf(opts.groupKeys);
 		const workersMcp = opts.serverUrl ? { mcpServers: { [workersKey]: httpEntryFor(opts.serverUrl, "workers", opts.nonce, opts.workspaceHeaderCmd) } } : {};
@@ -603,7 +617,7 @@ async function injectPeerMcpIntoMirror(serverUrl, opts) {
 		groupKeys: opts.groupKeys,
 		nonce: opts.nonce,
 		codexHome: opts.codexHome ?? PATHS.CODEX_HOME,
-		workspaceHeaderCmd: buildWorkspaceHeaderHelperCommand(process.execPath, process.argv[1])
+		workspaceHeaderCmd: buildWorkspaceHeaderHelperCommand(opts.selfInvocation)
 	});
 	const conflicts = [];
 	for (const name of Object.keys(peerConfig.mcpServers)) if (mcpServers[name] !== void 0) conflicts.push(name);
@@ -662,7 +676,7 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 		groupKeys: opts.groupKeys,
 		nonce,
 		codexHome,
-		workspaceHeaderCmd: buildWorkspaceHeaderHelperCommand(process.execPath, process.argv[1])
+		workspaceHeaderCmd: buildWorkspaceHeaderHelperCommand(opts.selfInvocation)
 	});
 	const agents = buildPeerAgentDefinitions({
 		codexCli: opts.codexCli,
@@ -675,10 +689,12 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 		brainstormModel: opts.brainstormModel,
 		scoutModel: opts.scoutModel,
 		scribeModel: opts.scribeModel,
+		implementerFastModel: opts.implementerFastModel,
+		generalPurposeFastModel: opts.generalPurposeFastModel,
 		nonce,
 		codexHome,
 		serverUrl,
-		workspaceHeaderCmd: buildWorkspaceHeaderHelperCommand(process.execPath, process.argv[1])
+		workspaceHeaderCmd: buildWorkspaceHeaderHelperCommand(opts.selfInvocation)
 	});
 	await fs.unlink(mcpConfigPath).catch(() => {});
 	await fs.unlink(agentsPath).catch(() => {});
@@ -1739,51 +1755,38 @@ 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` for coding changes that need judgment or have ambiguous scope"];
+	if (opts.implementerFastAvailable !== false) 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.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("`general-purpose-fast` for work no specialist fits");
+	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:
-*
-*   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.
+* Build the operating-defaults directive for one launch, naming only the
+* natives that launch actually emitted.
 *
-* 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. Launch independent agents concurrently in a single message rather than serially. 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. A named teammate persists after it reports so you can send it follow-ups, and nothing reaps it for you: its idle notice means available, not finished. Stop it once you are done with it.\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
@@ -1800,7 +1803,7 @@ const OPERATING_DEFAULTS_DIRECTIVE = "## Operating defaults (apply when the user
 * the reasoning stay in the directive; the always-resident copy carries only
 * the trigger and the ritual exclusion.
 */
-const OPERATING_DEFAULTS_DIGEST = "## Operating defaults (the user's explicit direction and the domain's standards always override)\n\nDelegate when the work is WIDE (many files or sources to sweep) or SLOW and you need only the conclusion, to protect the main thread's finite context and keep it free for reasoning and interacting with the user; prefer parallel delegation for independent work. Do NOT delegate merely because a sub-question is separable: a narrow, deep question whose value is file:line fidelity loses exactly that through a summarization layer, and one answerable in a single command is cheaper done directly. Do trivial, surgical, and last-mile work yourself.\n\nVerify, do not assert. Run the code, read the file, check the exit code. A claim in prose is worth nothing against state you did not check, and a check that cannot fail proves nothing. Reproduce a bug end to end, the way a real user hits it, before fixing it. Fix a lint error, failing test, or flake the moment you see it, whoever introduced it, without letting it derail the task at hand. Prefer quality and long-term maintainability over development cost.\n\nVerification has a blind spot: a consequential recommendation, a design or trade-off call, or a hard-to-reverse decision that still turns on judgment among plausible alternatives once the direct evidence is in. That is where confabulation hides, so put it past a peer critic before you ship it and budget the wait even under delivery pressure. When a test, a run, a reproduction, or a search would settle the claim, settle it that way instead; a critic asked to re-derive what you can already prove is ritual, not review.\n\nThe agent roster, the tool surface, and the reasoning behind these defaults are in your CLAUDE.md project instructions. Read them when choosing HOW to work; the rules above apply without a lookup.";
+const OPERATING_DEFAULTS_DIGEST = "## Operating defaults (the user's explicit direction and the domain's standards always override)\n\nDelegate when the work is WIDE (many files or sources to sweep) or SLOW and you need only the conclusion, to protect the main thread's finite context and keep it free for reasoning and interacting with the user; prefer parallel delegation for independent work. Do NOT delegate merely because a sub-question is separable: a narrow, deep question whose value is file:line fidelity loses exactly that through a summarization layer, and one answerable in a single command is cheaper done directly. Do trivial, surgical, and last-mile work yourself. Stop a named teammate once you are done with it: it persists for follow-ups, its idle notice means available rather than finished, and nothing reaps it for you.\n\nVerify, do not assert. Run the code, read the file, check the exit code. A claim in prose is worth nothing against state you did not check, and a check that cannot fail proves nothing. Reproduce a bug end to end, the way a real user hits it, before fixing it. Fix a lint error, failing test, or flake the moment you see it, whoever introduced it, without letting it derail the task at hand. Prefer quality and long-term maintainability over development cost.\n\nVerification has a blind spot: a consequential recommendation, a design or trade-off call, or a hard-to-reverse decision that still turns on judgment among plausible alternatives once the direct evidence is in. That is where confabulation hides, so put it past a peer critic before you ship it and budget the wait even under delivery pressure. When a test, a run, a reproduction, or a search would settle the claim, settle it that way instead; a critic asked to re-derive what you can already prove is ritual, not review.\n\nThe agent roster, the tool surface, and the reasoning behind these defaults are in your CLAUDE.md project instructions. Read them when choosing HOW to work; the rules above apply without a lookup.";
 /**
 * Skip the helper if the user's `~/.claude/CLAUDE.md` (or, equivalently,
 * the would-be post-write file) has grown past this size.
@@ -2342,6 +2345,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-srL3gBR9.js.map