github-router 0.3.276 → 0.3.282

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

@@ -1,8 +1,9 @@
-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 { 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,14 +304,13 @@ 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 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
 	};
@@ -339,20 +339,15 @@ function buildPeerAgentDefinitions(opts) {
 		...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 (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 (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 (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);
@@ -622,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);
@@ -681,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,
@@ -694,13 +689,12 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 		brainstormModel: opts.brainstormModel,
 		scoutModel: opts.scoutModel,
 		scribeModel: opts.scribeModel,
-		genericModel: opts.genericModel,
-		genericFastModel: opts.genericFastModel,
-		genericCheapModel: opts.genericCheapModel,
+		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(() => {});
@@ -1769,19 +1763,12 @@ function joinClauses(parts) {
 }
 /** 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"
-	];
+	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");
-	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`);
+	if (opts.generalPurposeFastAvailable !== false) clauses.push("`general-purpose-fast` for work no specialist fits");
 	return joinClauses(clauses);
 }
 /**
@@ -1793,7 +1780,7 @@ function buildNativeReachClauses(opts) {
 * disagree about which agents exist.
 */
 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.";
+	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
@@ -1816,7 +1803,7 @@ const OPERATING_DEFAULTS_DIRECTIVE = buildOperatingDefaultsDirective();
 * 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.
@@ -2360,4 +2347,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-VOPvSn6v.js.map
+//# sourceMappingURL=attribution-settings-srL3gBR9.js.map