github-router 0.3.297 → 0.3.303

package/dist/{attribution-settings-B70GmZ68.js → attribution-settings-dta8MTnd.js}

@@ -1,10 +1,11 @@
-import { Ft as LUNA_IMPLEMENTER_ALIAS_ID, Lt as LUNA_SCOUT_ALIAS_ID, Mt as FAST_CRITIC_ALIAS_ID, Rn as oneMContextDisabled, _n as CONDENSED_OPERATING_SEQUENCE, a as buildAgentPrompt, l as personasFor, n as MCP_GROUPS, t as GROUP_META, vn as DEFINITION_OF_GREATNESS, zn as withOneMSuffix } from "./peer-mcp-personas-ce6_YMnX.js";
-import { a as isUnderClaudeConfigMirror, d as writeRuntimeFileSecure, t as PATHS } from "./paths-Ci485qSJ.js";
-import { o as FAST_PROFILE_NATIVE_AGENT_NAMES } from "./fast-profile-contract-K3P58nj3.js";
-import "./self-invocation-DAB_od0C.js";
-import { a as STRIPPED_AUTH_ROUTING_ENV_KEYS, n as buildCodexProviderConfigFlags } from "./provision-BhCtm3md.js";
-import { n as buildWorkspaceHeaderHelperCommand } from "./mcp-workspace-header-dERl2YTT.js";
-import { a as dispatcherAgentName, c as dispatcherTools, n as activeDispatchModes, o as dispatcherDescription, s as dispatcherPrompt } from "./worker-dispatch-BEHkTbnH.js";
+import { Cn as withOneMSuffix, On as LUNA_SCOUT_ALIAS_ID, 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-BU5dNLxQ.js";
+import { a as isUnderClaudeConfigMirror, d as writeRuntimeFileSecure, t as PATHS } from "./paths-IcZW8gZx.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-B6xn-Rzo.js";
+import { a as MAX_PROFILE_NATIVE_AGENT_NAMES, i as MAX_PROFILE_MODELS, o as MAX_PROFILE_NATIVE_EFFORTS, s as MAX_PROFILE_NATIVE_MODELS } from "./max-profile-contract-Ct62mtAR.js";
+import "./self-invocation-BJWbA8ka.js";
+import { a as STRIPPED_AUTH_ROUTING_ENV_KEYS, n as buildCodexProviderConfigFlags } from "./provision-qNJgF5XD.js";
+import { n as buildWorkspaceHeaderHelperCommand } from "./mcp-workspace-header-NzFD0Wgd.js";
+import { a as dispatcherAgentName, c as dispatcherTools, n as activeDispatchModes, o as dispatcherDescription, s as dispatcherPrompt } from "./worker-dispatch-DgP5yT26.js";
 import consola from "consola";
 import path from "node:path";
 import { randomBytes } from "node:crypto";
@@ -272,89 +273,196 @@ function decorateGuaranteedOneM(id) {
 	if (oneMContextDisabled() || /\[1m\]$/i.test(id)) return id;
 	return `${id}[1m]`;
 }
+/** Build the literal `-m max` native roster. Max shadows the client built-ins
+* and every emitted role carries an explicit model and effort. */
+function buildMaxProfileAgentDefinitions(opts) {
+	const modelFor = (value, fallback) => nonEmptyModel(value) ?? fallback;
+	const exploreModel = modelFor(opts.maxExploreModel, MAX_PROFILE_NATIVE_MODELS.Explore);
+	const planModel = modelFor(opts.maxPlanModel, MAX_PROFILE_NATIVE_MODELS.Plan);
+	const generalModel = modelFor(opts.maxGeneralPurposeModel, MAX_PROFILE_NATIVE_MODELS["general-purpose"]);
+	const implementerModel = modelFor(opts.maxImplementerModel, MAX_PROFILE_NATIVE_MODELS.implementer);
+	const reviewerModel = modelFor(opts.maxReviewerModel, MAX_PROFILE_NATIVE_MODELS.reviewer);
+	const brainstormModel = modelFor(opts.maxBrainstormModel, modelFor(opts.maxGrokModel, modelFor(opts.maxGeminiModel, MAX_PROFILE_NATIVE_MODELS.brainstorm)));
+	const peersKey = peersKeyOf(opts.groupKeys);
+	const searchKey = opts.groupKeys.search ?? GROUP_META.search.preferredKey;
+	const searchMcpServers = opts.serverUrl ? { [searchKey]: httpEntryFor(opts.serverUrl, "search", opts.nonce, opts.workspaceHeaderCmd) } : void 0;
+	const peersMcpServers = opts.serverUrl ? { [peersKey]: httpEntryFor(opts.serverUrl, "peers", opts.nonce, opts.workspaceHeaderCmd) } : void 0;
+	const oneM = (model) => model === MAX_PROFILE_MODELS.grok ? model : decorateGuaranteedOneM(model);
+	const effort = (name) => MAX_PROFILE_NATIVE_EFFORTS[name];
+	const base = (name, model, roleEffort) => ({
+		description: `Max-profile ${name} subagent running ${model}. This model is the deliberate default for the role; use it first and override only after a concrete failure or task-model mismatch. Max dispatch strips Claude Code's required built-in model placeholder so the roster model remains authoritative; clients that can send catalog ids may override only to Luna, Gemini 3.7 Flash, or Grok 4.6.`,
+		prompt: `You are the max-profile ${name} subagent. Work from the supplied brief, verify against the actual repository, and return concrete evidence with file:line references. You do not have Advisor. Do not spawn further agents.`,
+		model: oneM(model),
+		effort: roleEffort
+	});
+	const researchTools = [
+		"Read",
+		"Grep",
+		"Glob",
+		"Bash",
+		"WebFetch",
+		"WebSearch",
+		`mcp__${searchKey}__*`
+	];
+	const peerList = (opts.maxPersonaNames ?? maxPersonasFor({
+		solModel: opts.maxPeerModels?.sol,
+		lunaModel: opts.maxPeerModels?.luna,
+		opusModel: opts.maxPeerModels?.opus,
+		geminiModel: opts.maxPeerModels?.gemini ?? opts.maxGeminiModel,
+		grokModel: opts.maxPeerModels?.grok ?? opts.maxGrokModel
+	}).map((persona) => persona.toolNameHttp)).map((name) => `\`${name}\``).join(", ");
+	const out = {
+		Explore: {
+			...base("Explore", exploreModel, opts.maxExploreEffort ?? effort("Explore")),
+			description: `Max-profile read-only exploration subagent running ${exploreModel}. Best suited to broad, multi-file discovery that should return conclusions and file:line evidence without filling the lead's context.`,
+			prompt: "Role: read-only repository exploration. Answer the supplied question with a concise evidence packet: conclusions, load-bearing file:line citations, relevant commands or sources checked, and explicit gaps. The caller retains planning and implementation. " + readOnlyToolSteer(),
+			tools: researchTools,
+			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
+		},
+		Plan: {
+			...base("Plan", planModel, opts.maxPlanEffort ?? effort("Plan")),
+			description: `Max-profile plan consultant running ${planModel} at high effort. Best suited to non-trivial changes where sequencing, interfaces, migration risk, or explicit acceptance criteria benefit from a separate planning view.`,
+			prompt: "Role: implementation planning. Given the goal, constraints, and available evidence, return a coherent plan with affected files or symbols, important invariants and risks, acceptance criteria, and useful verification. Surface assumptions or missing decisions; the lead owns plan acceptance and execution. " + readOnlyToolSteer(),
+			tools: researchTools,
+			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
+		},
+		"general-purpose": {
+			...base("general-purpose", generalModel, opts.maxGeneralPurposeEffort ?? effort("general-purpose")),
+			description: `Max-profile general-purpose execution subagent running ${generalModel}. Best suited to mixed or unusual work that does not fit the narrower discovery, planning, implementation, review, or ideation roles.`,
+			prompt: "Role: catch-all execution for the supplied bounded task. Deliver the requested outcome within its stated scope and return the files or artifacts changed, verification evidence, and unresolved risks. The lead owns integration and final decisions. " + fileToolSteer("builds, tests, and git"),
+			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
+		},
+		implementer: {
+			...base("implementer", implementerModel, opts.maxImplementerEffort ?? effort("implementer")),
+			description: `Max-profile implementation subagent running ${implementerModel} at high effort. Best suited to a bounded coding change whose desired outcome and constraints are known but whose implementation still needs judgment.`,
+			prompt: "Role: coding implementation for a settled desired outcome. Make a coherent, scoped change consistent with repository conventions and acceptance criteria. Return the files changed, observable behavior, checks and results, and unresolved risks; surface material ambiguity rather than silently deciding product or architecture questions. " + fileToolSteer("builds, tests, and git"),
+			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
+		},
+		reviewer: {
+			...base("reviewer", reviewerModel, opts.maxReviewerEffort ?? effort("reviewer")),
+			description: `Max-profile repository-aware verifier running ${reviewerModel}. Best suited to assessing an implementation or reproducing a failure when code execution and surrounding repository context matter.`,
+			prompt: "Role: independent repository-aware verification. Assess the supplied artifact against its intent and the actual repository or runtime state. Return verified or clearly plausible findings, severity, file:line evidence, concrete failure scenarios, checks run and results, and a go/no-go; distinguish no findings from checks not run. The lead owns remediation and approval. " + fileToolSteer("builds, tests, and reproductions"),
+			tools: researchTools,
+			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
+		},
+		brainstorm: {
+			...base("brainstorm", brainstormModel, opts.maxBrainstormEffort ?? effort("brainstorm")),
+			description: `Max-profile divergent-options subagent running ${brainstormModel}. Best suited to an open decision where materially different repository-feasible approaches remain plausible.`,
+			prompt: "Role: divergent option generation. Return materially distinct, repository-feasible alternatives with trade-offs, assumptions, failure modes, and evidence that would discriminate among them. A recommendation is useful when the available evidence supports one; the lead owns the decision and planning. " + readOnlyToolSteer(),
+			tools: researchTools,
+			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
+		},
+		"peer-review-coordinator": {
+			description: `Max-profile peer-review coordinator running ${MAX_PROFILE_MODELS.luna} at maximum effort. Best suited to consequential plans or diffs where several independent, cross-family lenses are likely to add value beyond one review.`,
+			prompt: `Role: synthesize independent fresh-context review of the supplied artifact and constraints. Available peers: ${peerList || "(none)"}. Select a risk-proportionate set with distinct useful lenses, preserving independence and avoiding redundant same-model calls unless their scopes differ. Return deduplicated, severity-ranked findings with sources, file:line evidence where applicable, concrete failure scenarios, disagreements, confidence, and evidence gaps. Peer output is advisory; the lead owns go/no-go and remediation.`,
+			model: oneM(MAX_PROFILE_MODELS.luna),
+			effort: opts.maxCoordinatorEffort ?? effort("peer-review-coordinator"),
+			tools: [`mcp__${peersKey}__*`],
+			...peersMcpServers ? { mcpServers: peersMcpServers } : {}
+		}
+	};
+	if (opts.browseAvailable && opts.groupKeys.workers) {
+		const workersKey = workersKeyOf(opts.groupKeys);
+		out["worker-browse"] = {
+			description: dispatcherDescription("browse"),
+			prompt: dispatcherPrompt("browse", workersKey),
+			model: oneM(MAX_PROFILE_MODELS.luna),
+			effort: "high",
+			tools: dispatcherTools("browse", workersKey),
+			...opts.serverUrl ? { mcpServers: { [workersKey]: httpEntryFor(opts.serverUrl, "workers", opts.nonce, opts.workspaceHeaderCmd) } } : {}
+		};
+	}
+	const roster = opts.nativeRoster == null ? new Set(MAX_PROFILE_NATIVE_AGENT_NAMES) : opts.nativeRoster instanceof Set ? opts.nativeRoster : new Set(opts.nativeRoster);
+	for (const name of Object.keys(out)) if (name !== "worker-browse" && !roster.has(name)) delete out[name];
+	return out;
+}
 /** 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);
-	const criticModel = nonEmptyModel(opts.criticModel);
-	if (!scoutModel || !implementerModel || !reviewerModel || !plannerModel || !criticModel) throw new Error("fast profile requires resolved Explore, implementer, reviewer, planner, and critic models");
+	const modelFor = (value, fallback) => nonEmptyModel(value) ?? fallback;
+	const exploreModel = modelFor(opts.fastExploreModel, FAST_PROFILE_NATIVE_MODELS.Explore);
+	const planModel = modelFor(opts.fastPlanModel, FAST_PROFILE_NATIVE_MODELS.Plan);
+	const generalModel = modelFor(opts.fastGeneralPurposeModel, FAST_PROFILE_NATIVE_MODELS["general-purpose"]);
+	const implementerModel = modelFor(opts.fastImplementerModel, FAST_PROFILE_NATIVE_MODELS.implementer);
+	const reviewerModel = modelFor(opts.fastReviewerModel, FAST_PROFILE_NATIVE_MODELS.reviewer);
 	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 searchMcpServers = opts.serverUrl ? { [searchKey]: httpEntryFor(opts.serverUrl, "search", opts.nonce, opts.workspaceHeaderCmd) } : void 0;
+	const peersMcpServers = opts.serverUrl && opts.groupKeys.peers ? { [peersKey]: httpEntryFor(opts.serverUrl, "peers", opts.nonce, opts.workspaceHeaderCmd) } : void 0;
 	const oracleTool = opts.groupKeys.peers ? `mcp__${peersKey}__oracle` : void 0;
 	const readSearchTools = [
 		"Read",
 		"Grep",
 		"Glob",
-		"Bash"
-	];
-	const scoutTools = [...readSearchTools, `mcp__${searchKey}__*`];
-	const reviewerTools = [...scoutTools, ...oracleTool ? [oracleTool] : []];
-	const plannerTools = [
-		...readSearchTools,
+		"Bash",
 		"WebFetch",
 		"WebSearch",
-		`mcp__${searchKey}__*`,
+		`mcp__${searchKey}__*`
+	];
+	const planTools = [
+		...readSearchTools,
 		...oracleTool ? [oracleTool] : [],
 		"Agent"
 	];
-	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. You do not have Advisor; independently reach your verdict from repository evidence. Use Oracle only as a last resort for one precise unresolved question after your own investigation. " + fileToolSteer("builds and reproductions") + " Do not spawn further agents.";
-	const criticPrompt = "You are the fast profile's fresh-context cross-lab critic. Assess the supplied plan, design, diff, or decision against its stated constraints. Look for overlooked failure modes, unsupported assumptions, and simpler safer alternatives. Do not modify files, run mutating commands, or spawn agents. Return concise severity-ranked findings with `file:line` evidence where applicable. " + readOnlyToolSteer();
+	const oneM = (model) => model === FAST_PROFILE_MODELS.grok ? model : decorateGuaranteedOneM(model);
+	const effort = (name) => FAST_PROFILE_NATIVE_EFFORTS[name];
 	const out = {
 		Explore: {
-			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: scoutTools,
+			description: `Fast-profile read-only exploration subagent running ${exploreModel}. Use for broad repository discovery; return conclusions with file:line evidence, not file dumps.`,
+			prompt: "You are the fast-profile read-only exploration subagent. Investigate the repository to answer the question: cast a wide net, then return a concise evidence packet with file:line citations and checked commands. Do not plan, edit, or spawn agents. " + readOnlyToolSteer(),
+			tools: readSearchTools,
 			model: decorateGuaranteedOneM(LUNA_SCOUT_ALIAS_ID),
-			effort: opts.scoutEffort ?? "high",
-			...searchMcp
+			effort: effort("Explore"),
+			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
 		},
-		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. For verification, you may invoke only the fast-profile `reviewer` or `critic` native subagent; do not invoke any other role or redesign the plan. 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",
-			tools: reviewerTools,
+		Plan: {
+			description: `Fast-profile plan architect running ${planModel} at high effort. Best suited to non-trivial changes where sequencing, interfaces, or verification 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 with affected files, invariants, risks, acceptance criteria, and verification. 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(),
+			tools: planTools,
+			model: oneM(planModel),
+			effort: effort("Plan"),
 			mcpServers: {
-				...searchMcp.mcpServers ?? {},
-				...peersMcp.mcpServers ?? {}
+				...searchMcpServers ?? {},
+				...peersMcpServers ?? {}
 			}
 		},
-		critic: {
-			description: `Fresh-context cross-lab critic running ${criticModel} at medium effort. Use to challenge a plan, design, diff, or decision against its stated constraints and expose overlooked failure modes.`,
-			prompt: criticPrompt,
-			model: decorateGuaranteedOneM(FAST_CRITIC_ALIAS_ID),
-			effort: opts.criticEffort ?? "medium",
-			tools: scoutTools,
-			...searchMcp
+		"general-purpose": {
+			description: `Fast-profile general-purpose execution subagent running ${generalModel} at maximum effort. Best suited to mixed or multi-step execution tasks that do not fit narrower roles.`,
+			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. For verification, you may invoke only `reviewer`. The lead owns final integration. " + fileToolSteer("builds, tests, and git"),
+			model: oneM(generalModel),
+			effort: effort("general-purpose"),
+			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
 		},
-		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. You do not have Advisor; independently reach your verdict from the evidence packet and selective verification. Use Oracle only as a last resort for one precise unresolved question after your own review. The Task/Agent capability is restricted by the fast in-session ACL: you may invoke only `reviewer`, `Explore`, or `critic`; do not invoke any other role. Bash is for evidence commands only; this is not a shell sandbox. " + readOnlyToolSteer(),
-			tools: plannerTools,
-			model: decorateGuaranteedOneM(plannerModel),
-			effort: opts.plannerEffort ?? "high",
-			mcpServers: {
-				...searchMcp.mcpServers ?? {},
-				...peersMcp.mcpServers ?? {}
-			}
+		implementer: {
+			description: `Fast-profile implementation subagent running ${implementerModel} at high effort. Best suited to bounded coding changes consistent with 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. For verification, you may invoke only `reviewer`; do not invoke any other role. Report exact changes and risks. " + fileToolSteer("builds, tests, and git"),
+			model: oneM(implementerModel),
+			effort: effort("implementer"),
+			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
+		},
+		reviewer: {
+			description: `Fast-profile repository-aware reviewer running ${reviewerModel} at medium effort. Use for independent 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. Report severity-ranked findings with `file:line` evidence and a clear go/no-go. You do not have Advisor. " + fileToolSteer("builds, tests, and reproductions") + " Do not spawn further agents.",
+			model: oneM(reviewerModel),
+			effort: effort("reviewer"),
+			tools: readSearchTools,
+			...searchMcpServers ? { mcpServers: searchMcpServers } : {}
 		}
 	};
-	const roster = opts.nativeRoster == null ? new Set(FAST_PROFILE_NATIVE_AGENT_NAMES) : 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];
+	if (opts.browseAvailable && opts.groupKeys.workers) {
+		const workersKey = workersKeyOf(opts.groupKeys);
+		out["worker-browse"] = {
+			description: dispatcherDescription("browse"),
+			prompt: dispatcherPrompt("browse", workersKey),
+			model: oneM(FAST_PROFILE_MODELS.luna),
+			effort: "high",
+			tools: dispatcherTools("browse", workersKey),
+			...opts.serverUrl ? { mcpServers: { [workersKey]: httpEntryFor(opts.serverUrl, "workers", opts.nonce, opts.workspaceHeaderCmd) } } : {}
+		};
 	}
+	const roster = opts.nativeRoster == null ? new Set(FAST_PROFILE_NATIVE_AGENT_NAMES) : opts.nativeRoster instanceof Set ? opts.nativeRoster : new Set(opts.nativeRoster);
+	for (const name of Object.keys(out)) if (name !== "worker-browse" && !roster.has(name)) delete out[name];
 	return out;
 }
 /**
@@ -367,9 +475,10 @@ function buildFastProfileAgentDefinitions(opts) {
 * per Phase 2A of the peer-MCP plan.
 */
 function buildPeerAgentDefinitions(opts) {
+	if (opts.maxProfile) return buildMaxProfileAgentDefinitions(opts);
 	if (opts.fastProfile) return buildFastProfileAgentDefinitions(opts);
 	const out = {};
-	const personas = opts.fastProfile ? [] : personasFor({
+	const personas = personasFor({
 		codexCli: opts.codexCli,
 		geminiAvailable: opts.geminiAvailable,
 		geminiModel: opts.geminiModel,
@@ -806,6 +915,11 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 		scribeModel: opts.scribeModel,
 		implementerFastModel: opts.implementerFastModel,
 		generalPurposeFastModel: opts.generalPurposeFastModel,
+		fastExploreModel: opts.fastExploreModel,
+		fastPlanModel: opts.fastPlanModel,
+		fastGeneralPurposeModel: opts.fastGeneralPurposeModel,
+		fastImplementerModel: opts.fastImplementerModel,
+		fastReviewerModel: opts.fastReviewerModel,
 		nativeRoster: opts.nativeRoster,
 		personaAllowlist: opts.personaAllowlist,
 		includeCoordinator: opts.includeCoordinator,
@@ -813,12 +927,26 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 		implementerFastEffort: opts.implementerFastEffort,
 		reviewerFastEffort: opts.reviewerFastEffort,
 		fastProfile: opts.fastProfile,
-		plannerModel: opts.plannerModel,
 		implementerEffort: opts.implementerEffort,
 		reviewerEffort: opts.reviewerEffort,
-		plannerEffort: opts.plannerEffort,
-		criticModel: opts.criticModel,
-		criticEffort: opts.criticEffort,
+		maxProfile: opts.maxProfile,
+		maxExploreModel: opts.maxExploreModel,
+		maxPlanModel: opts.maxPlanModel,
+		maxGeneralPurposeModel: opts.maxGeneralPurposeModel,
+		maxImplementerModel: opts.maxImplementerModel,
+		maxReviewerModel: opts.maxReviewerModel,
+		maxBrainstormModel: opts.maxBrainstormModel,
+		maxGeminiModel: opts.maxGeminiModel,
+		maxGrokModel: opts.maxGrokModel,
+		maxExploreEffort: opts.maxExploreEffort,
+		maxPlanEffort: opts.maxPlanEffort,
+		maxGeneralPurposeEffort: opts.maxGeneralPurposeEffort,
+		maxImplementerEffort: opts.maxImplementerEffort,
+		maxReviewerEffort: opts.maxReviewerEffort,
+		maxBrainstormEffort: opts.maxBrainstormEffort,
+		maxCoordinatorEffort: opts.maxCoordinatorEffort,
+		maxPersonaNames: opts.maxPersonaNames,
+		maxPeerModels: opts.maxPeerModels,
 		nonce,
 		codexHome,
 		serverUrl,
@@ -844,7 +972,13 @@ async function writePeerMcpRuntimeFiles(serverUrl, opts) {
 	}
 	const completeMdResult = mdResult;
 	if (!completeMdResult) throw new Error("peer MCP agent files were not generated");
-	const personas = opts.fastProfile ? [] : personasFor({
+	const personas = opts.maxProfile ? maxPersonasFor({
+		solModel: opts.maxPeerModels?.sol,
+		lunaModel: opts.maxPeerModels?.luna,
+		opusModel: opts.maxPeerModels?.opus,
+		geminiModel: opts.maxPeerModels?.gemini,
+		grokModel: opts.maxPeerModels?.grok
+	}) : opts.fastProfile ? [] : personasFor({
 		codexCli: opts.codexCli,
 		geminiAvailable: opts.geminiAvailable,
 		geminiModel: opts.geminiModel,
@@ -1857,6 +1991,83 @@ The dispatcher calls the worker once and relays its result verbatim.
 `
 };
 //#endregion
+//#region src/lib/injected-skills/artifact-review-skill.ts
+function buildArtifactReviewSkill(peersKey = "peers") {
+	const toolPrefix = `mcp__${peersKey}__artifact_`;
+	return {
+		name: "gh-artifact-review",
+		md: `---
+name: gh-artifact-review
+description: Reviews plans and artifacts in the ai-or-die panel. Defaults to authoring a self-contained HTML artifact (rich, annotatable, optionally interactive) and opening THAT for the human, then drains feedback with artifact_await, revises, and ends the loop. Use when running inside an ai-or-die tab and there is a plan, comparison, diagram, table, diff, or report the user should see before proceeding.
+user-invocable: true
+---
+
+# gh-artifact-review: human review in the ai-or-die panel
+
+Use this when you finish a plan or produce something a user should review and you are inside an ai-or-die tab (the \`${toolPrefix}*\` tools drive a live panel). The human can click any block or select text to attach a comment, and can click declarative action controls you emit — both come back to you as typed events.
+
+## Default: present HTML, not raw markdown
+
+HTML is the canonical review artifact — it renders richly and is annotatable element-by-element. When the content is anything visual or structured (a comparison, table, diagram, diff, dashboard, or a plan you want to look polished), **author a self-contained \`.html\` file** (inline CSS, no external deps, readable typography) and open THAT.
+
+- Plan-mode plans: the panel auto-opens them already rendered to HTML — you do not need to convert them by hand.
+- Do not paste raw markdown into an \`.html\`; write real HTML (headings, lists, tables, \`<pre>\` for code). Opening a raw \`.md\` still renders, but a purpose-built HTML artifact reads better and annotates cleanly.
+
+## When to reach for an artifact
+
+Default to one for anything easier to grasp visually than as terminal prose: plans, design proposals, comparisons / trade-offs, decisions that need the user's input, diagrams / architecture, tables, code diffs, reports. Skip it only for trivial one-line answers.
+
+## Playbooks (what a good artifact of each type contains)
+
+- **plan**: goal, current state, the proposed approach (high-level decisions, not every line), then risks and open questions at the end.
+- **comparison**: options as columns, trade-offs as rows, current-vs-target where relevant, and an explicit recommendation. Do not make the reader infer the winner.
+- **table**: scannable rows, a sticky header, aligned numeric columns; group/section dense records rather than one flat wall.
+- **diagram**: boxes + arrows. Mermaid when automatic layout matters; positioned SVG/CSS when each node needs prose, code, or controls.
+- **code / diff**: \`<pre>\` with before/after or unified-diff styling; keep line context tight; call out the changed lines.
+- **report / dashboard**: lead with the headline number / verdict, then supporting detail; keep one idea per section.
+
+## Design system
+
+Artifacts stay portable (they must render identically opened standalone), so do not depend on a server-injected theme. Pick the look in priority order: (1) a look the user named; (2) the **subject project's** own design system, its Tailwind / theme config, CSS variables / tokens, component library, or existing styled pages, especially when the artifact previews that app's UI; (3) only when both come up empty, clean readable defaults (system font stack, generous spacing, a single accent).
+
+## Loop
+
+1. Open: \`${toolPrefix}open\` with the absolute path of the \`.html\` (or the file). Pass \`mode:"interactive"\` when the HTML carries \`data-aod-*\` action controls (below). Relay the returned \`viewUrl\` and tell the user to review in the panel.
+2. Drain: \`${toolPrefix}await\`. It long-holds for the human's next events and returns \`{events, status, cursor}\`. **Pass the returned \`cursor\` on your next call** so you only receive newer events; if \`events\` is empty, call again with that cursor.
+3. Act on each event by \`kind\`:
+   - \`comment\` — a free-text note anchored to the artifact (\`selector\`, quoted \`text\`, \`sourceLine\`); apply the requested change at that exact spot.
+   - \`action\` — the human clicked a control you emitted (\`action\` verb, \`elementId\`, optional \`value\`; a multi-select submit arrives as one action carrying the selected set). Do what the verb means (approve a step, choose an option, apply a toggle set).
+4. Reply: \`${toolPrefix}reply\` with a concise summary of what you changed. Optionally \`${toolPrefix}update({file})\` or \`({html})\` to replace the artifact content in place, or \`${toolPrefix}refresh\` to reload it from disk.
+5. Repeat 2-4 until the user is satisfied; then \`${toolPrefix}end\`. Use \`${toolPrefix}dismiss\` to hide the panel while keeping the review alive (queued feedback preserved) if the user wants it out of the way without ending.
+
+### Push arrival (you do not have to be polling)
+
+When you are idle at the prompt, panel feedback can arrive on its own as a new turn (the tab injects it). Structured actions that answer a pending decision are routed to you directly. Either way, the durable record is the \`${toolPrefix}await\` drain, so when in doubt call \`${toolPrefix}await\` (with your last cursor) to reconcile — it replays anything you missed.
+
+### \`artifact_poll\` (frozen legacy)
+
+\`${toolPrefix}poll\` still resolves for back-compat but returns the OLD payload (human comments only, no structured actions). Prefer \`${toolPrefix}await\`.
+
+## Interactive controls (data-aod-* authoring)
+
+To let the human act on the artifact (not just comment), emit declarative controls; the panel wires them and delivers a typed \`action\` event. No JS in the artifact.
+
+- **choose-one (fires immediately):** each option is a button that posts the moment it is clicked.
+  \`<button data-aod-action="choose" data-aod-group="decision-1" data-aod-id="opt-jwt" data-aod-value="jwt">JWT</button>\`
+- **multi-select (toggle then submit):** checkboxes sharing a \`data-aod-group\`, plus one submit button with the same group. The submit delivers ONE action carrying \`{group, selected:[{elementId, value?}]}\`.
+  \`<input type="checkbox" data-aod-action="check" data-aod-group="opts" data-aod-id="a" data-aod-value="a">\` … \`<button data-aod-action="submit" data-aod-group="opts" data-aod-id="opts-submit">Apply</button>\`
+- **plan steps:** \`<li class="aod-step" data-aod-id="plan-step-3" data-source-line="14">\` with per-step \`data-aod-action="approve"/"skip"\` buttons.
+- **Required attrs:** \`data-aod-action\` (verb), \`data-aod-id\` (stable, echoed back as \`elementId\`; a control missing it is ignored), optional \`data-aod-value\`. Keep \`data-source-line\` for comment mapping.
+
+## Honest limits
+
+- If a tool errors (e.g. \`NOT_IN_AIORDIE_TAB\`, \`UNREACHABLE\`, \`INVALID_REQUEST\`), report the code/message verbatim; do not claim the panel opened.
+- The panel is a review surface, not an approver: outward/irreversible actions still need explicit user confirmation.
+`
+	};
+}
+buildArtifactReviewSkill();
+//#endregion
 //#region src/lib/claude-md-injection.ts
 /**
 * Marker fences for each injection block. The literal text of each
@@ -1919,11 +2130,11 @@ function joinClauses(parts) {
 *  tier; reserve `reviewer` for the higher-stakes assessment it is there for. */
 function buildNativeReachClauses(opts) {
 	if (opts.profile === "fast") return joinClauses([
-		"`Explore` 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",
-		"`critic` for a fresh-context cross-lab challenge to a plan, design, diff, or decision"
+		"`Explore` for broad discovery and repo investigation",
+		"`Plan` for non-trivial sequencing, interfaces, migration risk, or acceptance criteria",
+		"`general-purpose` for mixed execution tasks",
+		"`implementer` for bounded coding changes",
+		"`reviewer` for repository-aware verification, reproduction, and root-causing"
 	]);
 	const clauses = [];
 	const implementerFast = opts.implementerFastAvailable !== false;
@@ -1944,10 +2155,31 @@ 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 === "max") {
+		const peersKey = opts.peersKey ?? opts.groupKeys?.peers ?? "peers";
+		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\nMax launch profile. The lead owns the outcome and may use the roster as a set of complementary capabilities, not a required sequence: direct tools suit narrow facts; `Explore` broad discovery; `brainstorm` open design choices; `Plan` changes where sequencing, interfaces, or acceptance criteria benefit from a separate view; `implementer` bounded coding; `general-purpose` mixed work; and `reviewer` (Grok 4.6/high with Luna 1M/max fallback) repository-aware verification. Independent work can run in parallel when that improves context isolation or latency. A fresh-context peer from another model family can be useful where correlated blind spots matter and deterministic evidence does not settle the issue; `peer-review-coordinator` is available when the risk justifies several lenses. Small or obvious tasks are often better handled directly, and model output remains evidence to synthesize rather than a vote. Each role's configured model is the deliberate default for role fit and diversity; overrides are most useful after a concrete mismatch. On every retained max surface, Gemini 3.1 Pro is replaced by Grok 4.6/high when available, otherwise Gemini 3.7 Flash 1M/high. Advisor is optional, non-binding counsel for one focused consequential uncertainty that the normal evidence and roles cannot settle; it has no approval or workflow authority, and a further consultation is useful only when materially new evidence changes the question." + (opts.artifactAvailable ? ` Live human review is available in the artifact panel via \`mcp__${peersKey}__artifact_*\`.` : "");
+	}
 	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 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, planner approval, reviewer verification, or completion ritual. `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.";
+		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. 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.";
+		const peersKey = opts.peersKey ?? opts.groupKeys?.peers ?? "peers";
+		const searchKey = opts.groupKeys?.search ?? "search";
+		const browserKey = opts.groupKeys?.browser ?? "browser";
+		const workersKey = opts.groupKeys?.workers ?? "workers";
+		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.
+
+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.`;
 	}
 	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.";
 }
@@ -1956,23 +2188,12 @@ function buildOperatingDefaultsDirective(opts = {}) {
 *  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
-* the mirrored CLAUDE.md (read by the main agent and descendants); this digest
-* keeps both behavioral directives at top salience without duplicating the full
-* ~310-token block in the context window every turn. Points to the full copy.
-*
-* The unverifiable-claim rule is here rather than in CLAUDE.md alone because it
-* fires at a moment that suppresses lookups: an agent racing to deliver a
-* recommendation is precisely the one that will not stop to consult its project
-* instructions, which is how the check got crowded out in the first place. It
-* also closes a hole in the rule above it, which only covers claims that direct
-* evidence CAN settle. The roster of critics, the lens-to-artifact match, and
-* 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. 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.";
+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 and may use the roster as complementary capabilities: direct tools for narrow facts, `Explore` for broad discovery, `brainstorm` for open choices, `Plan` for a separate planning view, `implementer` and `general-purpose` for execution, and `reviewer` (Grok 4.6/high with Luna 1M/max fallback) for repository-aware verification. Delegate when work is wide or slow to protect the main thread's finite context; do trivial and surgical work directly. Prefer parallel delegation for independent work. Stop named teammates when finished.\n\nVerify claims against real evidence: run the code, check outputs and test results. Model output is evidence to synthesize rather than a vote. A fresh-context peer or `peer-review-coordinator` can reduce correlated blind spots on consequential decisions where judgment remains after direct evidence is in.\n\nAdvisor is optional, non-binding, primary-lead-only counsel for focused consequential uncertainty that direct evidence, Plan, reviewer, or peers cannot settle. It has no approval or workflow authority.";
+	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), `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. Independent subagents may run in parallel. 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.";
+	return STANDARD_OPERATING_DEFAULTS_DIGEST;
+}
 /**
 * Skip the helper if the user's `~/.claude/CLAUDE.md` (or, equivalently,
 * the would-be post-write file) has grown past this size.
@@ -2449,6 +2670,12 @@ const INJECTED_SKILLS = [
 	FIRST_MATE_OPERATE_SKILL,
 	FIRST_MATE_CONDUCT_SKILL
 ];
+function injectedSkillsForLaunch(selection) {
+	if (selection.profileId === "fast") return [];
+	if (selection.profileId === "max") return selection.firstMateEnabled ? INJECTED_SKILLS.filter((skill) => skill.name.startsWith("gh-first-mate")) : [];
+	if (!selection.workerSkillsActive) return [];
+	return INJECTED_SKILLS.filter((skill) => selection.firstMateEnabled || !skill.name.startsWith("gh-first-mate"));
+}
 //#endregion
 //#region src/lib/attribution-settings.ts
 /**
@@ -2514,6 +2741,6 @@ async function injectAttributionSuppressionIntoSettingsFile(settingsPath) {
 	return { written: true };
 }
 //#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 };
+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-B70GmZ68.js.map
+//# sourceMappingURL=attribution-settings-dta8MTnd.js.map