github-router 0.3.308 → 0.3.310

package/dist/{attribution-settings-C_ZLSCQ4.js → attribution-settings-n3zk0BR5.js}

@@ -1,10 +1,10 @@
-import { Cn as withOneMSuffix, Sn as oneMContextDisabled, a as buildAgentPrompt, l as maxPersonasFor, n as MCP_GROUPS, nn as DEFINITION_OF_GREATNESS, t as GROUP_META, tn as CONDENSED_OPERATING_SEQUENCE, u as personasFor } from "./peer-mcp-personas-DAd076hn.js";
+import { Cn as oneMContextDisabled, a as buildAgentPrompt, l as maxPersonasFor, n as MCP_GROUPS, nn as CONDENSED_OPERATING_SEQUENCE, rn as DEFINITION_OF_GREATNESS, t as GROUP_META, u as personasFor, wn as withOneMSuffix } from "./peer-mcp-personas-CBJbxpNT.js";
 import { a as isUnderClaudeConfigMirror, d as writeRuntimeFileSecure, t as PATHS } from "./paths-De1Qh9Q9.js";
-import { f as LUNA_SCOUT_ALIAS_ID } from "./server-setup-C7jSESEI.js";
-import { a as FAST_PROFILE_MODELS, c as FAST_PROFILE_NATIVE_MODELS, o as FAST_PROFILE_NATIVE_AGENT_NAMES, s as FAST_PROFILE_NATIVE_EFFORTS } from "./fast-profile-contract-BWCJy6iL.js";
-import { C as MAX_PARALLELISM_RULE, S as MAX_COORDINATOR_PROMPT, T as maxNativePrompt, a as MAX_PROFILE_NATIVE_AGENT_NAMES, i as MAX_PROFILE_MODELS, o as MAX_PROFILE_NATIVE_EFFORTS, s as MAX_PROFILE_NATIVE_MODELS, w as maxNativeDescription, x as MAX_COORDINATOR_DESCRIPTION } from "./max-profile-contract-v2Q6eN5w.js";
+import { f as LUNA_SCOUT_ALIAS_ID } from "./server-setup-m5vGQ3k8.js";
+import { c as FAST_PROFILE_MODELS, d as FAST_PROFILE_NATIVE_MODELS, l as FAST_PROFILE_NATIVE_AGENT_NAMES, u as FAST_PROFILE_NATIVE_EFFORTS } from "./fast-profile-contract-_DhIWank.js";
+import { C as MAX_PARALLELISM_RULE, S as MAX_COORDINATOR_PROMPT, T as maxNativePrompt, a as MAX_PROFILE_NATIVE_AGENT_NAMES, i as MAX_PROFILE_MODELS, o as MAX_PROFILE_NATIVE_EFFORTS, s as MAX_PROFILE_NATIVE_MODELS, w as maxNativeDescription, x as MAX_COORDINATOR_DESCRIPTION } from "./max-profile-contract-BcrMlrmo.js";
 import "./self-invocation-B84JCHps.js";
-import { a as STRIPPED_AUTH_ROUTING_ENV_KEYS, n as buildCodexProviderConfigFlags } from "./provision-Xcr-fJii.js";
+import { a as STRIPPED_AUTH_ROUTING_ENV_KEYS, n as buildCodexProviderConfigFlags } from "./provision-D_fn8Ry4.js";
 import { n as buildWorkspaceHeaderHelperCommand } from "./mcp-workspace-header-B60WSR1Y.js";
 import { a as dispatcherAgentName, c as dispatcherTools, n as activeDispatchModes, o as dispatcherDescription, s as dispatcherPrompt } from "./worker-dispatch-CH-NN5FW.js";
 import consola from "consola";
@@ -85,7 +85,7 @@ function buildPeerMcpConfig(serverUrl, opts) {
 	for (const group of MCP_GROUPS) {
 		const key = opts.groupKeys[group];
 		if (!key) continue;
-		mcpServers[key] = httpEntryFor(serverUrl, group, opts.nonce, workspaceHeaderCmd);
+		mcpServers[key] = httpEntryFor(serverUrl, group, opts.parentGroupNonceOverrides?.[group] ?? opts.nonce, workspaceHeaderCmd);
 	}
 	if (opts.codexCli) mcpServers["codex-cli"] = {
 		command: "codex",
@@ -408,16 +408,16 @@ function buildFastProfileAgentDefinitions(opts) {
 	const effort = (name) => FAST_PROFILE_NATIVE_EFFORTS[name];
 	const out = {
 		Explore: {
-			description: `Fast-profile read-only exploration subagent running ${exploreModel}. Use proactively and in parallel for multi-file discovery, mapping architecture, tracing call graphs, or inventorying conventions. Returns concise file:line evidence; not for single-file lookups or editing.`,
-			prompt: "You are the fast-profile read-only exploration subagent. Investigate the repository to answer the question: cast a wide net across semantic and lexical searches, follow call chains, and return a structured evidence packet (Answer, Inventory with file:line, Entry Points, Conventions, Gaps). Do not plan, edit, or spawn agents. " + readOnlyToolSteer(),
+			description: `Fast-profile cheap read-only exploration subagent running ${exploreModel}. Invoke proactively and in parallel for fast multi-file discovery, mapping architecture, tracing call graphs, or inventorying conventions across independent areas. Returns concise file:line evidence; not for editing.`,
+			prompt: "You are the fast-profile codebase exploration specialist. Your mission is to rapidly map repository architecture, discover implementation patterns, trace call chains, and locate relevant files and declarations with precision. This is a read-only exploration task: do not propose code changes, edit files, or spawn agents. Combine semantic and lexical search to discover entry points and conventions. Read surrounding context to confirm usages and call chains. Focus on concrete evidence. Conclude with a structured evidence summary: Answer, Inventory (with file:line citations), Key Entry Points, Existing Conventions, and Gaps or Unknowns. " + readOnlyToolSteer(),
 			tools: readSearchTools,
 			model: decorateGuaranteedOneM(LUNA_SCOUT_ALIAS_ID),
 			effort: effort("Explore"),
 			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
 		},
 		Plan: {
-			description: `Fast-profile plan architect running ${planModel} at high effort. Best suited to non-trivial changes where sequencing, interface contracts, invariants, or acceptance criteria benefit from a separate planning view.`,
-			prompt: "You are the fast-profile planning subagent. Given the goal, constraints, and available evidence, return an ordered implementation plan (Objective, Invariants, Interface Boundaries, Steps with parallel markings, Runnable Acceptance Criteria, Risks). You do not have Advisor. Use Oracle only when one precise consequential uncertainty remains after your own investigation and available repository evidence cannot settle it. The Task/Agent capability is restricted by the fast in-session ACL: you may invoke only `Explore` or `reviewer`; do not invoke any other role. " + readOnlyToolSteer(),
+			description: `Fast-profile plan architect running ${planModel} at high effort. Use proactively in plan mode, or when sequencing, cross-boundary interfaces, invariants, migration risk, or acceptance criteria benefit from a dedicated planning view. Returns an ordered implementation plan with acceptance criteria.`,
+			prompt: "You are the fast-profile software architect and planning specialist. Your mission is to design clear, verifiable implementation architectures for complex tasks, sequencing changes and establishing strict invariants before implementation begins. This is a read-only planning task: do not modify repository files. In plan mode, produce the architecture, sequencing, and acceptance criteria for the lead to review. Ground every step in existing repository patterns and dependencies. If a conceptual or architectural trade-off has multiple viable designs and repository evidence cannot settle it, consult Oracle with a self-contained brief; if Oracle leaves it unresolved, return the options and remaining gap to the lead. Under fast mode delegation rules, you may invoke `Explore` for discovery or `reviewer` for verification; do not invoke any other subagent. Structure the plan with: Objective, Architectural Invariants, Interface Contracts, Execution Steps (marking independent steps that can run concurrently), Runnable Acceptance Criteria, and Critical Files. " + readOnlyToolSteer(),
 			tools: planTools,
 			model: oneM(planModel),
 			effort: effort("Plan"),
@@ -428,21 +428,21 @@ function buildFastProfileAgentDefinitions(opts) {
 		},
 		"general-purpose": {
 			description: `Fast-profile general-purpose execution subagent running ${generalModel} at maximum effort. Best suited to mixed, multi-step, or open-ended execution tasks that span investigation, tool workflows, and code changes.`,
-			prompt: "You are the fast-profile general-purpose execution subagent. Work out what the task requires and deliver the outcome end to end using dedicated file tools, builds, tests, and git. Iterate against concrete feedback, check error output, and return (Outcome, Actions with trimmed output, Side Effects changed, Evidence, Open items). For verification, you may invoke only `reviewer`. The lead owns final integration. " + fileToolSteer("builds, tests, and git"),
+			prompt: "You are the fast-profile general-purpose execution specialist. Your mission is to autonomously drive mixed, multi-step tasks to completion across investigation, tool workflows, and code changes. Deliver end-to-end task completion while preserving surrounding repository conventions. The lead owns final integration. Investigate first to confirm assumptions. Check command outputs and error messages after each action, iterating against concrete feedback. Run relevant builds and tests to verify intermediate state. When executing independently you may invoke `reviewer` to verify behavior-changing changes; when invoked directly by the lead, report your changes and test results directly as post-integration review is owned by the lead. Conclude with: Outcome Summary, Actions Taken (with trimmed output), Changed Files (file:line), Verification Evidence, and Remaining Items. " + fileToolSteer("builds, tests, and git"),
 			model: oneM(generalModel),
 			effort: effort("general-purpose"),
 			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
 		},
 		implementer: {
 			description: `Fast-profile implementation subagent running ${implementerModel} at high effort. Best suited to surgical, bounded coding changes with settled scope that match repository conventions.`,
-			prompt: "You are the fast-profile implementation subagent. Implement the change surgically, matching surrounding code style, minimizing unrelated churn, and running builds/tests. Report (Changes with file:line, Verification commands and trimmed output, Not Done/Assumed). For verification, you may invoke only `reviewer`; do not invoke any other role. Report exact changes and risks. " + fileToolSteer("builds, tests, and git"),
+			prompt: "You are the fast-profile implementation specialist. Your mission is to execute surgical, bounded code modifications that cleanly satisfy settled requirements while matching existing code idioms. Keep changes minimal, focused, and free of unrelated churn or style drift. Do not expand scope beyond the requested modification. Inspect target files and existing conventions before editing. Use dedicated file tools for edits and run relevant builds, linters, and tests to confirm changes pass cleanly without regressions. When executing independently you may invoke `reviewer` to verify risk-sensitive changes; when invoked directly by the lead, report your changes and test results directly as post-integration review is owned by the lead. Conclude with: Modified Files (with file:line), Verification Commands and Output, and Assumptions or Deferred Work. " + fileToolSteer("builds, tests, and git"),
 			model: oneM(implementerModel),
 			effort: effort("implementer"),
 			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
 		},
 		reviewer: {
-			description: `Fast-profile repository-aware reviewer running ${reviewerModel} at xhigh effort. Use proactively for independent adversarial verification, test authoring, failure reproduction, or runtime checks.`,
-			prompt: "You are the fast-profile repository-aware reviewer. Verify what is actually true by reading code and running builds, tests, or reproductions. Return on line one: VERDICT: SHIP | FIX | BLOCK, followed by Must Fix (file:line), Should Fix, Evidence run, and Not Verified. You do not have Advisor. " + reviewerToolSteer() + " Do not spawn further agents.",
+			description: `Fast-profile repository-aware reviewer running ${reviewerModel} at xhigh effort. Use proactively after implementation for behavior-changing, cross-boundary, or risk-sensitive changes. Run build/tests first; review post-integration before declaring done.`,
+			prompt: "You are the fast-profile adversarial repository reviewer. Your mission is to independently verify code correctness, catch regressions, and ensure changes meet the repository's quality bar. Do not modify source code or spawn further subagents. Base every finding on reproducible evidence rather than speculation. Read changed files and surrounding call sites thoroughly. Use Bash to execute relevant builds, test suites, and reproduction commands to verify runtime behavior. Look for edge cases, type errors, race conditions, and contract breaks. Return on line one: VERDICT: SHIP | FIX | BLOCK, followed by Must Fix (severity, file:line, failure scenario), Should Fix, Evidence Run (commands and output), and Unverified Surface. " + reviewerToolSteer(),
 			model: oneM(reviewerModel),
 			effort: effort("reviewer"),
 			tools: readSearchTools,
@@ -896,6 +896,7 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 		geminiModel: opts.geminiModel,
 		groupKeys: opts.groupKeys,
 		nonce,
+		parentGroupNonceOverrides: opts.parentGroupNonceOverrides,
 		codexHome,
 		workspaceHeaderCmd: buildWorkspaceHeaderHelperCommand(opts.selfInvocation)
 	});
@@ -2176,9 +2177,10 @@ function buildOperatingDefaultsDirective(opts = {}) {
 		const browserClause = opts.browserToolsAvailable ?? opts.browseAvailable ? ` \`mcp__${browserKey}__*\` provides direct browser control.` : "";
 		const workerBrowseClause = opts.browseAvailable ? ` \`worker-browse\` runs delegated autonomous browsing tasks through \`mcp__${workersKey}__browse\`.` : "";
 		const artifactClause = opts.artifactAvailable ? ` \`mcp__${peersKey}__artifact_*\` provides human review in the artifact panel with auto-open on plan completion.` : "";
-		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 launch profile. The lead coordinates execution across specialized native roles: " + buildNativeReachClauses(opts) + `. \`Plan\` is an advisory planning capability for nontrivial sequencing, interfaces, migration risk, or acceptance criteria, not an approval gate. Delegate only when work is wide, slow, or benefits from context isolation; do trivial, surgical, and narrow work directly. Independent Task subagents may run in parallel. Delegation graph: the lead may invoke all five; \`Plan\` may invoke \`Explore\` and \`reviewer\`; \`implementer\` and \`general-purpose\` may invoke \`reviewer\`; \`Explore\`, \`reviewer\`, and \`worker-browse\` cannot invoke native subagents.
+		const astraClause = opts.astraAvailable ? ` \`mcp__${peersKey}__astra\` (GPT-6 Astra 200K/high) is the terminal escalation consultant for the lead only, reserved strictly for the hardest dead ends when direct evidence, Advisor, and Oracle have all failed to produce a defensible path (consulted at most 1-2 times per decision with concise context and specific questions).` : "";
+		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 launch profile. The lead coordinates execution across specialized native roles: " + buildNativeReachClauses(opts) + `. In plan mode or when designing changes with complex sequencing, interface contracts, or acceptance criteria, delegate architectural planning to \`Plan\` (in plan mode, produce the plan and acceptance criteria; do not edit files). After behavior-changing, cross-boundary, or risk-sensitive implementation, run relevant build/tests then invoke \`reviewer\` before declaring done. Handle trivial, surgical, single-file, or single-command tasks directly; you do not need to justify skipping delegation. \`Explore\` is cheap and may be launched in parallel across independent discovery questions. Send independent subagent calls in parallel within a single turn. Delegation graph: the lead may invoke all five; \`Plan\` may invoke \`Explore\` and \`reviewer\`; \`implementer\` and \`general-purpose\` may invoke \`reviewer\`; \`Explore\`, \`reviewer\`, and \`worker-browse\` cannot invoke native subagents.
 
-Advisor is an optional, non-binding, lead-only transcript-aware sounding board for consequential unresolved uncertainty, conflicting evidence, or a genuinely stuck path; never use it for routine progress, waiting, directly verifiable facts, or completion ritual. \`mcp__${peersKey}__oracle\` is exact Opus 5 (1M/high), a stateless last-resort consultant available to the lead and \`Plan\` when required; \`reviewer\` and other subagents cannot call Oracle. \`mcp__${searchKey}__code\` provides semantic-first code search and \`mcp__${searchKey}__web\` provides citable sources.${browserClause}${workerBrowseClause}${artifactClause}\n\nVerify claims with concrete repository evidence and tests before declaring work done. Stop named teammates when finished.`;
+Consultation guidance: Follow an evidence-first escalation ladder. Direct empirical evidence (search, code, tests, builds) settles factual questions first. Advisor is an optional, non-binding, lead-only transcript-aware sounding board for trajectory guidance or framing checks (direction, not dictation), and never use it for routine progress, waiting, directly verifiable facts, or completion ritual. \`mcp__${peersKey}__oracle\` is exact Opus 5 (1M/high), an expert consultant available to the lead and \`Plan\`, preferred over advisor for difficult conceptual, algorithmic, spec/protocol, or architectural tradeoffs evaluated in a self-contained brief; \`reviewer\` and other subagents cannot call Oracle. \`Plan\` may consult Oracle on unresolved trade-offs, and reports any remaining tie-breaking gap to the lead.${astraClause} \`mcp__${searchKey}__code\` provides semantic-first code search and \`mcp__${searchKey}__web\` provides citable sources.${browserClause}${workerBrowseClause}${artifactClause}\n\nVerify claims with concrete repository evidence and tests before declaring work done. User instructions outrank delegation triggers. 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.";
 }
@@ -2190,7 +2192,7 @@ const OPERATING_DEFAULTS_DIRECTIVE = buildOperatingDefaultsDirective();
 const STANDARD_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.";
 function buildOperatingDefaultsDigest(opts = {}) {
 	if (opts.profile === "max") return "## Operating defaults (the user's explicit direction and the domain's standards always override)\n\nMax launch profile. The lead owns the outcome. Start with direct repository or runtime evidence. Do narrow, obvious, surgical, and single-command work directly; delegate bounded work that is broad, slow, context-heavy, or independently valuable. " + MAX_PARALLELISM_RULE + " Give delegated workstreams non-overlapping scopes and state the outcome, constraints, evidence, and verification expected.\n\nSynthesize and verify: run the code, inspect outputs, and check tests. Agent count and agreement are not evidence. Use a fresh-context peer only for consequential judgment that remains after direct checks, and use the coordinator only when several distinct lenses could change the decision. Advisor is optional, non-binding, primary-lead-only counsel for one focused consequential uncertainty; it is not an approval or completion gate.";
-	if (opts.profile === "fast") return "## Operating defaults (the user's explicit direction and the domain's standards always override)\n\nFast launch profile. The lead coordinates execution across `Explore` (broad discovery, convention mapping), `Plan` (sequencing, interfaces, migration risk, acceptance criteria), `general-purpose` (mixed execution), `implementer` (bounded coding), and `reviewer` (repository-aware verification). `Plan` is an advisory planning capability, not an approval gate. Delegate when work is wide or slow to protect main-thread context; do trivial and surgical work directly. Send independent subagent calls in parallel within a single turn. Stop named teammates when finished.\n\nVerify claims against real evidence: run relevant commands and tests. Advisor is optional, non-binding, transcript-aware, and lead-only for consequential unresolved uncertainty, not routine progress or workflow gates. `oracle` (Opus 5 1M/high) is a stateless last resort for the lead and `Plan` when normal paths remain stuck.";
+	if (opts.profile === "fast") return "## Operating defaults (the user's explicit direction and the domain's standards always override)\n\nFast launch profile. The lead coordinates execution across specialized roles: delegate to `Plan` in plan mode or when structuring complex multi-step sequencing (`Plan` is an advisory planning capability, not an approval gate); delegate to `reviewer` after behavior-changing or risk-sensitive implementation to verify correctness before declaring done; `Explore` is cheap and may be launched in parallel for broad discovery; use `implementer` or `general-purpose` for execution; handle trivial and surgical edits directly. Send independent subagent calls in parallel within a single turn. Stop named teammates when finished.\n\nVerify claims against real evidence: run relevant commands and tests. Follow a disciplined consultation ladder for unresolved decisions: (1) direct code inspection, search, builds, and tests settle factual questions; (2) `advisor` (Sol/high, lead-only) for transcript-aware framing checks or trajectory guidance; (3) `oracle` (Opus 5 1M/high, lead and Plan) for self-contained technical/architectural trade-offs" + (opts.astraAvailable ? "; (4) `astra` (GPT-6 Astra 200K/high, lead-only) only as a last resort when direct evidence, Advisor, and Oracle cannot produce a defensible path (at most 1-2 calls per decision)." : ".");
 	return STANDARD_OPERATING_DEFAULTS_DIGEST;
 }
 /**
@@ -2742,4 +2744,4 @@ async function injectAttributionSuppressionIntoSettingsFile(settingsPath) {
 //#endregion
 export { writePeerMcpRuntimeFiles as C, workersKeyOf as S, sanitizeServeSettingsEnv as _, appendPeerAwarenessToMirroredClaudeMd as a, resolveCodexCliBackend as b, buildOperatingDefaultsDirective as c, prependStyleDirectiveToMirroredClaudeMd as d, buildArtifactReviewSkill as f, planModeAllowRules as g, injectAllowRules as h, writeInjectedSkill as i, prependArtifactPanelDirectiveToMirroredClaudeMd as l, configureServeDefaultPermissionMode as m, INJECTED_SKILLS as n, appendToolbeltAwarenessToMirroredClaudeMd as o, SEAMLESS_BUILTIN_TOOLS as p, injectedSkillsForLaunch as r, buildOperatingDefaultsDigest as s, injectAttributionSuppressionIntoSettingsFile as t, prependOperatingDefaultsToMirroredClaudeMd as u, BUILTIN_SUBAGENT_DEFINITIONS as v, resolveGroupKeysFromMirror as x, injectPeerMcpIntoMirror as y };
 
-//# sourceMappingURL=attribution-settings-C_ZLSCQ4.js.map
+//# sourceMappingURL=attribution-settings-n3zk0BR5.js.map