github-router 0.3.288 → 0.3.292

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

@@ -1,9 +1,10 @@
-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 { $t as CONDENSED_OPERATING_SEQUENCE, Sn as withOneMSuffix, a as buildAgentPrompt, en as DEFINITION_OF_GREATNESS, l as personasFor, n as MCP_GROUPS, t as GROUP_META, xn as oneMContextDisabled } from "./peer-mcp-personas-CHbl6MwM.js";
+import { a as isUnderClaudeConfigMirror, d as writeRuntimeFileSecure, t as PATHS } from "./paths-BH4J7slC.js";
+import { f as LUNA_IMPLEMENTER_ALIAS_ID, p as LUNA_SCOUT_ALIAS_ID } from "./server-setup-CqlaZukJ.js";
+import "./self-invocation-DhO1Z8iD.js";
+import { a as STRIPPED_AUTH_ROUTING_ENV_KEYS, n as buildCodexProviderConfigFlags } from "./provision-BYFd9nPK.js";
+import { n as buildWorkspaceHeaderHelperCommand } from "./mcp-workspace-header-q34H_4wL.js";
+import { a as dispatcherAgentName, c as dispatcherTools, n as activeDispatchModes, o as dispatcherDescription, s as dispatcherPrompt } from "./worker-dispatch-D5fGroNr.js";
 import consola from "consola";
 import path from "node:path";
 import { randomBytes } from "node:crypto";
@@ -267,6 +268,67 @@ function readOnlyToolAllowlist(searchKey) {
 		`mcp__${searchKey}__*`
 	];
 }
+function decorateGuaranteedOneM(id) {
+	if (oneMContextDisabled() || /\[1m\]$/i.test(id)) return id;
+	return `${id}[1m]`;
+}
+/** Build the literal `-m fast` native roster. This is intentionally separate
+* from the standard definitions: the names overlap, but their role bodies,
+* fixed model assignments, and efforts are profile contracts. */
+function buildFastProfileAgentDefinitions(opts) {
+	const scoutModel = nonEmptyModel(opts.scoutModel);
+	const implementerModel = nonEmptyModel(opts.nativeSubagentModel);
+	const reviewerModel = nonEmptyModel(opts.reviewerModel);
+	const plannerModel = nonEmptyModel(opts.plannerModel);
+	if (!scoutModel || !implementerModel || !reviewerModel || !plannerModel) throw new Error("fast profile requires resolved scout, implementer, reviewer, and planner models");
+	const searchKey = opts.groupKeys.search ?? GROUP_META.search.preferredKey;
+	const peersKey = peersKeyOf(opts.groupKeys);
+	const searchMcp = opts.serverUrl ? { mcpServers: { [searchKey]: httpEntryFor(opts.serverUrl, "search", opts.nonce, opts.workspaceHeaderCmd) } } : {};
+	const peersMcp = opts.serverUrl && opts.groupKeys.peers ? { mcpServers: { [peersKey]: httpEntryFor(opts.serverUrl, "peers", opts.nonce, opts.workspaceHeaderCmd) } } : {};
+	const oracleTool = opts.groupKeys.peers ? `mcp__${peersKey}__oracle` : void 0;
+	const readOnlyTools = readOnlyToolAllowlist(searchKey);
+	const consultTools = oracleTool ? [...readOnlyTools, oracleTool] : readOnlyTools;
+	const reviewerPrompt = "You are the fast profile's repository-aware reviewer. Verify what is actually true by reading the code and running the relevant build, tests, or end-to-end reproduction. Find root causes rather than symptoms. Do not modify production code. Report severity-ranked findings with `file:line` evidence and a clear go/no-go. Use Oracle only as a last resort after your own investigation and Advisor have not resolved one precise question. " + fileToolSteer("builds and reproductions") + " Do not spawn further agents.";
+	const out = {
+		scout: {
+			description: `Read-only exploration subagent running ${scoutModel}. Use for broad repository discovery before the lead drafts a plan; return conclusions with file:line evidence, not file dumps.`,
+			prompt: "Investigate the repository read-only. Cast a wide net, then return a concise evidence packet for the lead: conclusions, load-bearing `file:line` citations, commands checked, and explicit gaps. Do not plan, edit, or spawn agents. " + readOnlyToolSteer(),
+			tools: readOnlyTools,
+			model: decorateGuaranteedOneM(LUNA_SCOUT_ALIAS_ID),
+			effort: opts.scoutEffort ?? "high",
+			...searchMcp
+		},
+		implementer: {
+			description: `Implementation subagent running ${implementerModel}. Use for well-specified mechanical changes after the plan is approved; implement and verify end to end in its own context.`,
+			prompt: "Implement the approved, well-specified change surgically. Match surrounding style, minimize unrelated churn, use dedicated file tools, and run the relevant build/tests. Do not redesign the plan or spawn more agents. Report changes, verification, and unresolved risk. " + fileToolSteer("builds"),
+			model: decorateGuaranteedOneM(LUNA_IMPLEMENTER_ALIAS_ID),
+			effort: opts.implementerEffort ?? "max"
+		},
+		reviewer: {
+			description: `Repository-aware reviewer running ${reviewerModel} at medium effort. Use after implementation or for failures that need reproduction, runtime checks, or repository context.`,
+			prompt: reviewerPrompt,
+			model: reviewerModel,
+			effort: opts.reviewerEffort ?? "medium",
+			...peersMcp
+		},
+		planner: {
+			description: `Plan consultant and approver running ${plannerModel}. Invoke only after Luna has done the repository legwork and drafted a plan; pass a handcrafted evidence packet and the complete draft. The lead must not implement until this agent returns APPROVE.`,
+			prompt: "You are the fast profile's final plan consultant and approver, not a first-pass planner. The caller must provide the user goal, acceptance criteria, repository/domain constraints, Luna's `file:line` and command/test evidence, the complete draft plan, settled decisions, and one focused review question. Selectively verify disputed citations or narrow evidence gaps with read/search tools, but do not repeat broad discovery, edit files, or execute the plan. Return exactly one leading verdict: `APPROVE`, `REVISE`, or `NEED_MORE_CONTEXT`. APPROVE only when the plan is safe, ordered, complete, and verifiable. REVISE must give concrete corrections. NEED_MORE_CONTEXT must name the exact evidence Luna should collect. Use Oracle only as a last resort for one precise unresolved question after your own review and Advisor are insufficient. Do not spawn further agents. " + readOnlyToolSteer(),
+			tools: consultTools,
+			model: decorateGuaranteedOneM(plannerModel),
+			effort: opts.plannerEffort ?? "high",
+			mcpServers: {
+				...searchMcp.mcpServers ?? {},
+				...peersMcp.mcpServers ?? {}
+			}
+		}
+	};
+	const roster = opts.nativeRoster == null ? void 0 : opts.nativeRoster instanceof Set ? opts.nativeRoster : new Set(opts.nativeRoster);
+	if (roster) {
+		for (const name of Object.keys(out)) if (!roster.has(name)) delete out[name];
+	}
+	return out;
+}
 /**
 * Build the JSON payload for `claude --agents <path>`.
 *
@@ -277,11 +339,13 @@ function readOnlyToolAllowlist(searchKey) {
 * per Phase 2A of the peer-MCP plan.
 */
 function buildPeerAgentDefinitions(opts) {
+	if (opts.fastProfile) return buildFastProfileAgentDefinitions(opts);
 	const out = {};
-	const personas = personasFor({
+	const personas = opts.fastProfile ? [] : personasFor({
 		codexCli: opts.codexCli,
 		geminiAvailable: opts.geminiAvailable,
-		geminiModel: opts.geminiModel
+		geminiModel: opts.geminiModel,
+		agentAllowlist: opts.personaAllowlist
 	});
 	const peersKey = peersKeyOf(opts.groupKeys);
 	const peersMcp = opts.serverUrl ? { mcpServers: { [peersKey]: httpEntryFor(opts.serverUrl, "peers", opts.nonce, opts.workspaceHeaderCmd) } } : {};
@@ -293,13 +357,15 @@ function buildPeerAgentDefinitions(opts) {
 		}),
 		...peersMcp
 	};
-	out["peer-review-coordinator"] = {
+	if (opts.includeCoordinator !== false) out["peer-review-coordinator"] = {
 		...buildCoordinatorAgent({
 			codexCli: opts.codexCli,
 			geminiAvailable: opts.geminiAvailable
 		}),
 		...peersMcp
 	};
+	const rosterSet = opts.nativeRoster == null ? void 0 : opts.nativeRoster instanceof Set ? opts.nativeRoster : new Set(opts.nativeRoster);
+	const rosterAllows = (name) => !rosterSet || rosterSet.has(name);
 	const nativeModel = nonEmptyModel(opts.nativeSubagentModel);
 	const reviewerModel = nonEmptyModel(opts.reviewerModel);
 	const reviewerFastModel = nonEmptyModel(opts.reviewerFastModel);
@@ -308,51 +374,59 @@ function buildPeerAgentDefinitions(opts) {
 	const scribeModel = nonEmptyModel(opts.scribeModel);
 	const implementerFastModel = nonEmptyModel(opts.implementerFastModel);
 	const generalPurposeFastModel = nonEmptyModel(opts.generalPurposeFastModel);
+	const hasImplementer = rosterAllows("implementer");
+	const hasReviewer = rosterAllows("reviewer");
 	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 = {
+	if (rosterAllows("implementer")) out.implementer = {
 		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
 	};
 	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 = {
+	if (rosterAllows("reviewer")) 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: 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 = {
+	if (reviewerFastModel && rosterAllows("reviewer-fast")) {
+		const isGrok = reviewerFastModel === "grok-4.6";
+		out["reviewer-fast"] = {
+			description: `Cheaper feedback subagent running ${reviewerFastModel} (${isGrok ? "500K total context, 372K max prompt" : "1M context"}${isGrok ? "" : ", typically faster than the pro-tier reviewer"}${!isGrok && hasImplementer ? " and cross-lab from the OpenAI-backed implementer" : ""}). ${hasReviewer ? "Use for lower-stakes assessments that still need repository access or execution; escalate higher-stakes review to reviewer." : "Use for lower-stakes assessments that still need repository access or execution."} 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),
+			...opts.reviewerFastEffort ? { effort: opts.reviewerFastEffort } : {}
+		};
+	}
+	if (rosterAllows("brainstorm")) 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.",
 		tools: readOnlyToolAllowlist(searchKey),
 		...brainstormModel ? { model: withOneMSuffix(brainstormModel) } : {},
 		...searchMcp
 	};
-	if (scoutModel) out.scout = {
+	if (scoutModel && rosterAllows("scout")) out.scout = {
 		description: `Read-only exploration subagent running ${scoutModel} (fast and cheap, so repository lookups do not run at the lead's model rates). Use proactively to find or understand something in the codebase: it sweeps widely and returns conclusions with file:line references rather than file dumps. Model is overridable at spawn.`,
 		prompt: "You are a read-only exploration subagent. Answer the question by investigating the repository: cast a wide net, then narrow. Return the conclusion, not the raw material — cite `file:line` for anything load-bearing and quote only the lines that matter. If the answer is that something does not exist, say so explicitly and describe where you looked. " + readOnlyToolSteer() + " Do the work yourself — do not spawn further subagents.",
 		tools: readOnlyToolAllowlist(searchKey),
 		model: withOneMSuffix(scoutModel),
+		...opts.scoutEffort ? { effort: opts.scoutEffort } : {},
 		...searchMcp
 	};
-	out.scribe = {
+	if (rosterAllows("scribe")) out.scribe = {
 		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.`,
+	if (implementerFastModel && rosterAllows("implementer-fast")) out["implementer-fast"] = {
+		description: `Implementation subagent running ${implementerFastModel} (1M context, ${implementerFastModel === "gpt-5.6-terra" ? "the cheaper, faster implementation tier" : implementerFastModel === "gpt-5.6-luna" ? "the fast, low-cost tier for this launch profile" : "a non-lead implementation model"}). Use proactively for well-specified, mechanical coding changes${hasImplementer ? "; 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)
+		model: withOneMSuffix(implementerFastModel),
+		...opts.implementerFastEffort ? { effort: opts.implementerFastEffort } : {}
 	};
-	if (generalPurposeFastModel) out["general-purpose-fast"] = {
+	if (generalPurposeFastModel && rosterAllows("general-purpose-fast")) 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)
@@ -459,6 +533,7 @@ function buildAgentMd(spec) {
 		`description: ${escapeYamlString(spec.description)}`
 	];
 	if (spec.model) lines.push(`model: ${escapeYamlString(spec.model)}`);
+	if (spec.effort) lines.push(`effort: ${escapeYamlString(spec.effort)}`);
 	if (spec.tools && spec.tools.length > 0) lines.push(`tools: [${spec.tools.map((t) => JSON.stringify(t)).join(", ")}]`);
 	if (spec.mcpServers && Object.keys(spec.mcpServers).length > 0) lines.push(...emitMcpServersYaml(spec.mcpServers));
 	lines.push("---", "", spec.prompt, "");
@@ -495,6 +570,7 @@ async function writePeerAgentMdFiles(agents, opts) {
 				description: def.description,
 				prompt: def.prompt,
 				model: def.model,
+				effort: def.effort,
 				tools: def.tools,
 				mcpServers: def.mcpServers
 			}));
@@ -702,6 +778,17 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 		scribeModel: opts.scribeModel,
 		implementerFastModel: opts.implementerFastModel,
 		generalPurposeFastModel: opts.generalPurposeFastModel,
+		nativeRoster: opts.nativeRoster,
+		personaAllowlist: opts.personaAllowlist,
+		includeCoordinator: opts.includeCoordinator,
+		scoutEffort: opts.scoutEffort,
+		implementerFastEffort: opts.implementerFastEffort,
+		reviewerFastEffort: opts.reviewerFastEffort,
+		fastProfile: opts.fastProfile,
+		plannerModel: opts.plannerModel,
+		implementerEffort: opts.implementerEffort,
+		reviewerEffort: opts.reviewerEffort,
+		plannerEffort: opts.plannerEffort,
 		nonce,
 		codexHome,
 		serverUrl,
@@ -718,10 +805,11 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 		agentsDir: opts.agentsDir,
 		fileSuffix
 	});
-	const personas = personasFor({
+	const personas = opts.fastProfile ? [] : personasFor({
 		codexCli: opts.codexCli,
 		geminiAvailable: opts.geminiAvailable,
-		geminiModel: opts.geminiModel
+		geminiModel: opts.geminiModel,
+		agentAllowlist: opts.personaAllowlist
 	});
 	const cleanup = async () => {
 		await Promise.allSettled([
@@ -1791,6 +1879,12 @@ function joinClauses(parts) {
 *  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) {
+	if (opts.profile === "fast") return joinClauses([
+		"`scout` to find or understand something in the repo",
+		"`implementer` for approved mechanical coding changes",
+		"`reviewer` for repository-aware verification, reproduction, and root-causing",
+		"`planner` as the Sol plan consultant and approver after Luna has drafted with evidence"
+	]);
 	const clauses = [];
 	const implementerFast = opts.implementerFastAvailable !== false;
 	const reviewerFast = opts.reviewerFastAvailable !== false;
@@ -1810,15 +1904,11 @@ function buildNativeReachClauses(opts) {
 	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");
 	return joinClauses(clauses);
 }
-/**
-* Build the operating-defaults directive for one launch, naming only the
-* natives that launch actually emitted.
-*
-* 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.
-*/
 function buildOperatingDefaultsDirective(opts = {}) {
+	if (opts.profile === "fast") {
+		if (opts.fastRuntimeAvailable === false) 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\nFast profile runtime wiring is unavailable, so no injected Task roster, search, or Oracle is available. Work directly, use only tools actually listed in this session, verify with the repository's relevant build/tests before declaring done, report uncertainty, and do not invent unavailable capabilities.";
+		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, and review to the right subagent. Reach for " + buildNativeReachClauses(opts) + "; Task subagents run in parallel. That keeps your own context free to reason and collaborate with the user. Delegate only when work is wide or slow; do trivial and surgical work directly. Luna investigates and drafts. The lead must give `planner` a handcrafted evidence packet and must not implement until `planner` returns `APPROVE`. Advisor is the transcript-aware brainstorming, sounding-board, fresh-look, uncertainty, and stuck path. `oracle` is exact Opus 5 (1M/high), stateless and last resort after the normal paths remain stuck. Before declaring work done, run the relevant build/tests and ask `reviewer` for repository-aware verification. Verify claims, report uncertainty, and stop named teammates when finished.";
+	}
 	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
@@ -2386,4 +2476,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-CofaqSzw.js.map
+//# sourceMappingURL=attribution-settings-CpLUCi8R.js.map