github-router 0.3.325 → 0.3.326

package/dist/{attribution-settings-IbcZgAEf.js → attribution-settings-17Ug_BaA.js}

@@ -1,6 +1,6 @@
 import { Ln as BALANCED_PROFILE_NATIVE_AGENT_NAMES, Nn as oneMContextDisabled, Pn as withOneMSuffix, Rn as BALANCED_PROFILE_NATIVE_EFFORTS, Un as CHEAPEST_PROFILE_NATIVE_AGENT_NAMES, Wn as CHEAPEST_PROFILE_NATIVE_EFFORTS, Xn as CHEAP_PROFILE_NATIVE_EFFORTS, Yn as CHEAP_PROFILE_NATIVE_AGENT_NAMES, a as buildAgentPrompt, fn as CONDENSED_OPERATING_SEQUENCE, l as maxPersonasFor, n as MCP_GROUPS, pn as DEFINITION_OF_GREATNESS, t as GROUP_META, u as personasFor } from "./peer-mcp-personas-DcAErb_d.js";
 import { a as isUnderClaudeConfigMirror, f as writeRuntimeFileSecure, t as PATHS } from "./paths-BnZwolac.js";
-import { C as CHEAP_REVIEWER_ALIAS_ID, S as CHEAP_PLAN_ALIAS_ID, _ as CHEAPEST_GENERAL_PURPOSE_ALIAS_ID, b as CHEAP_EXPLORE_ALIAS_ID, f as BALANCED_EXPLORE_ALIAS_ID, g as CHEAPEST_EXPLORE_ALIAS_ID, h as BALANCED_REVIEWER_ALIAS_ID, m as BALANCED_PLAN_ALIAS_ID, p as BALANCED_GENERAL_PURPOSE_ALIAS_ID, v as CHEAPEST_PLAN_ALIAS_ID, w as LUNA_SCOUT_ALIAS_ID, x as CHEAP_GENERAL_PURPOSE_ALIAS_ID, y as CHEAPEST_REVIEWER_ALIAS_ID } from "./server-setup-BfZEQOXB.js";
+import { C as CHEAP_REVIEWER_ALIAS_ID, S as CHEAP_PLAN_ALIAS_ID, _ as CHEAPEST_GENERAL_PURPOSE_ALIAS_ID, b as CHEAP_EXPLORE_ALIAS_ID, f as BALANCED_EXPLORE_ALIAS_ID, g as CHEAPEST_EXPLORE_ALIAS_ID, h as BALANCED_REVIEWER_ALIAS_ID, m as BALANCED_PLAN_ALIAS_ID, p as BALANCED_GENERAL_PURPOSE_ALIAS_ID, v as CHEAPEST_PLAN_ALIAS_ID, w as LUNA_SCOUT_ALIAS_ID, x as CHEAP_GENERAL_PURPOSE_ALIAS_ID, y as CHEAPEST_REVIEWER_ALIAS_ID } from "./server-setup-BfTjAZS2.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-DmsyQQrw.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-Bl7I_EOC.js";
 import "./self-invocation-opSXHEs0.js";
@@ -2074,23 +2074,33 @@ const GATHER_CONTEXT_SKILL = {
 	name: "gh-gather-context",
 	md: `---
 name: gh-gather-context
-description: Bounded context gathering for non-trivial asks: decomposes the ask, runs lexical code searches to identify relevant files, dispatches bounded parallel explore workers to gather evidence, stitches results into a freshness-stamped context brief plus a compact version. Use when grounded context is needed before planning or changing code.
+description: Gather grounded codebase context before planning. Use when unfamiliar code must be understood, files located, or claims verified against source. Returns a freshness-stamped brief with file:line citations. Not for trivial reads or already-known code.
 user-invocable: true
+requires: []
+produces: [context.md, context.compact.md, .complete]
+consumes: []
+excludes: [trivial tasks, already-known code, implementation]
 ---
 
 # gh-gather-context: bounded context gathering
 
 Use this skill when a non-trivial ask needs grounded context before planning.
-All reasoning runs at the 200K default window: the lead and every explore
-worker use the Luna model at high effort with bare slugs (no 1M accounting).
-Output is a durable full brief plus a compact downstream version.
+All reasoning runs at the 200K default window: the lead and every Explore
+subagent use the Luna model at high effort with bare slugs (no 1M accounting).
+Output is a durable full brief plus a compact downstream version. This skill
+dispatches ONLY native subagents present on the profile roster (Explore) via
+the Agent tool, never worker-* MCP dispatchers. No reviewer dispatch in this
+stage: Explore evidence plus targeted follow-up reads is the verification path.
 
 ## Hard bounds
 
 - Maximum rounds: 3.
-- Maximum parallel explore workers per round: 6.
+- Maximum parallel Explore subagents per round: 6.
 - Maximum lexical searches per round: 10.
 - Maximum follow-up reads per round: 5.
+- Advisory budget: keep each Explore dispatch under ~3 minutes of wall-clock;
+  the Task tool has no maxWallClockMs parameter, so count your own dispatches
+  and stop at saturation rather than running to a clock.
 - Terminate at the first of saturation or a cap.
 - On cap-hit, return with open unknowns flagged as residual. Do not loop forever.
 
@@ -2100,7 +2110,6 @@ Use these exact tags on every finding and claim:
 
 - verified-executable: reproduced the symptom, ran the failing test, or ran a check that directly proves the claim. This is the only deterministic confidence tag.
 - verified-source: read the actual source, config, logs, docs, or primary artifact and cited the relevant locations. This is model-mediated and can still be wrong.
-- cross-lab-agreed: a different-lab reviewer independently agreed with the claim. This reduces correlated blind spots but is advisory.
 - unverified: plausible but not confirmed; treat as residual risk.
 
 ## Procedure
@@ -2119,16 +2128,16 @@ Use these exact tags on every finding and claim:
    - Use git log and git blame when authorship, regression timing, or intent matters.
    - Use mcp__search__web for upstream APIs, package behavior, protocol docs, or public issues.
 
-4. Decompose into bounded explore workers.
+4. Decompose into bounded Explore subagents.
    - Cluster search results into at most 6 coherent investigation areas.
    - For each area, write a narrow brief: the specific question, the expected artifact, and the files to focus on.
-   - Dispatch ALL explore workers in a single turn via the Agent tool (subagent_type worker-explore). Each runs read-only at the 200K default window and returns a summary with an evidence table and file:line citations. Pass maxWallClockMs 180000 on every worker call so a hung worker is reaped after 3 minutes instead of blocking its slot.
-   - Keep worker results summarized; do not paste every detail into the main context.
+   - Dispatch ALL Explore subagents in a single turn via the Agent tool (subagent_type Explore). Each runs read-only at the 200K default window and returns a summary with an evidence table and file:line citations. Advisory: keep each dispatch under ~3 minutes; the Task tool enforces no wall-clock, so terminate at saturation.
+   - Keep Explore results summarized; do not paste every detail into the main context.
 
 5. Stitch and verify.
-   - Collect all explore results and deduplicate file references.
-   - Run at most 5 targeted follow-up reads for gaps, in parallel.
-   - Dispatch the worker-review subagent (via the Agent tool, maxWallClockMs 300000) to confirm source-reading for load-bearing claims.
+   - Collect all Explore results and deduplicate file references.
+   - Run at most 5 targeted follow-up reads for gaps, in parallel, using Read, Grep, and Glob directly; dispatch one more narrow Explore round only for gaps direct reads cannot close.
+   - Do NOT dispatch a reviewer in this stage. Verification here is Explore evidence plus your own follow-up reads: re-open the primary source for every load-bearing claim and confirm the citation is real before tagging it verified-source.
    - Form a root-cause hypothesis or integration map, and state what would falsify it.
 
 6. Run a completeness pass.
@@ -2138,38 +2147,44 @@ Use these exact tags on every finding and claim:
    - If no material unknowns remain and the root cause is at least verified-source, stop for saturation.
 
 7. Persist outputs under .github-router/context/<slug>/ and close the stage.
-   - context.md: full brief with the ask decomposition, searches run, worker reports, evidence table, hypothesis, freshness metadata (HEAD commit, working-tree diff hash, timestamp, repo path), residuals, and full citations.
+   - context.md: full brief with the ask decomposition, searches run, Explore reports, evidence table, hypothesis, freshness metadata (HEAD commit, working-tree diff hash, timestamp, repo path), residuals, and full citations.
    - context.compact.md: downstream consumable with a one-paragraph ask summary, key files with one-line purposes, critical constraints (APIs, types, patterns, forbidden changes), integration seams, and residual risks.
-   - .complete: stage-completion marker written ONLY after every dispatched explore worker has returned or been recorded as stopped, and both briefs are on disk. No downstream stage (/gh-plan, /gh-implement, /gh-swe-pipeline stage 2+) may start until this marker exists.
+   - .complete: stage-completion marker written ONLY after every dispatched Explore subagent has returned or been recorded as superseded, and both briefs are on disk. No downstream stage (/gh-plan, /gh-implement, /gh-swe-pipeline stage 2+) may start until this marker exists.
    - Downstream phases read by pointer and check freshness instead of re-injecting the whole brief.
 
 ## Waterfall rule
 
-This stage owns all explore workers until it completes. Do NOT return while
-any explore worker is still running unless you explicitly record it as
-stopped (saturation reached or its area superseded) with the reason. If the
-brief already saturates the ask, stop remaining workers first (no further
-follow-ups; treat partial output as superseded), then write the marker. A
-plan built on shifting evidence wastes more than a stopped worker costs.
+This stage owns all Explore dispatches until it completes. Do NOT return while
+any Explore subagent is still running unless you explicitly record it as
+superseded (saturation reached or its area covered) with the reason. Native
+subagents cannot be killed mid-run: record superseded areas and let them
+finish, but do not wait on or use their output. If the brief already saturates
+the ask, record remaining dispatches as superseded first (no further
+follow-ups), then write the marker. A plan built on shifting evidence wastes
+more than an idle subagent costs.
 
 ## Return format
 
-Return a compact brief, not the whole dump:
+Return a compact brief, not the whole dump. Output cost dominates: Luna output
+tokens cost 6x input, so return only file:line citations with one-line
+summaries, never full file contents or pasted source blocks.
 
 - Context files: paths to context.md and context.compact.md.
 - Freshness: HEAD commit, diff hash, timestamp.
 - Termination: saturated or cap-hit; if cap-hit, name the cap.
 - Summary: 3-8 bullets with confidence tags.
-- Evidence table: claim, tag, primary source or command, reviewer status.
+- Evidence table: claim, tag, primary source or command, verification status.
 - Residual unknowns: explicit list, or none.
 - Downstream guidance: recommended next action and what must be rechecked if the tree changes.
 
 ## Non-goals
 
-- Do not present verified-source or cross-lab-agreed as deterministic.
+- Do not present verified-source as deterministic.
 - Do not hide open unknowns because the answer looks useful.
 - Do not keep searching after the cap.
 - Do not paste the entire persisted brief into later turns unless the user asks.
+- Do not dispatch a reviewer from this stage; Explore evidence plus targeted follow-up reads is the verification path.
+- Do not return full file contents in briefs, summaries, or evidence tables; cite file:line plus one line of purpose.
 - Do not finish without the .complete marker: a marker-less brief is not a completed stage.
 `
 };
@@ -2179,23 +2194,40 @@ const IMPLEMENT_SKILL = {
 	name: "gh-implement",
 	md: `---
 name: gh-implement
-description: Parallel implementation of an approved plan using bounded Luna workers with isolated worktrees: each worker implements its task, self-tests, self-reviews, and returns a patch; the lead aggregates into a unified diff, runs staged review, and returns the final diff with a report. Use when a user-approved plan is ready for execution.
+description: Execute an approved plan with parallel subagents and self-validation. Use when a user-approved plan.md is ready for execution. Reviewer only on low-confidence or risky changes. Not for unapproved plans or exploration.
 user-invocable: true
+requires: [approved plan.md with .complete marker]
+produces: [unified diff, implementation-report.md]
+consumes: [plan.md]
+excludes: [unapproved plans, exploration, trivial changes]
 ---
 
 # gh-implement: bounded parallel implementation with staged review
 
 Use this skill only after /gh-plan produced a user-approved plan.md. All
-implementation runs at the 200K default window: the lead and every task worker
-use the Luna model at max effort with bare slugs (no 1M accounting). Review is
-staged: a Luna max pass first, then a Sol medium pass only for major issues.
+implementation runs at the 200K default window with bare slugs (no 1M
+accounting): the lead dispatches native subagents present on the profile
+roster. If an implementer subagent exists (max profile), use it first for
+implementation tasks, then General-Purpose for handoffs; otherwise use
+General-Purpose for all tasks. Review is conditional, never staged by default:
+each task subagent self-tests, self-reviews, and reports an explicit confidence
+verdict; the lead dispatches a reviewer only on low-confidence validation or
+complex and risky changes, then a General-Purpose fix pass only for major
+reviewer findings. This skill dispatches ONLY native subagents via the Agent
+tool, never worker-* MCP dispatchers.
 
 ## Hard bounds
 
-- Maximum concurrent implement workers: 8.
+- Maximum concurrent implementation subagents: 8 (advisory; the Task tool
+  enforces no concurrency cap, so count your own dispatches).
 - Maximum retries per task: 2.
 - Maximum review-fix cycles: 2.
-- Worktrees are auto-removed on success and retained on failure for debugging.
+- Advisory budget: keep each task under ~10 minutes; the Task tool enforces
+  no wall-clock, so terminate at acceptance, not at a clock.
+- Worktrees are opt-in, not default: pass worktree:true to
+  General-Purpose when parallel tasks require isolation or git-history
+  protection. In-place tasks must be sequentialized to avoid collisions;
+  parallel in-place edits to the same files will conflict.
 
 ## Stage gate 0 (do this BEFORE any implementation)
 
@@ -2205,40 +2237,42 @@ staged: a Luna max pass first, then a Sol medium pass only for major issues.
    re-invoke planning first.
 2. Check freshness: if HEAD or the working-tree diff hash moved since the
    plan was approved, re-verify stale load-bearing assumptions before
-   dispatching workers.
-3. Stop the previous stage: send no further follow-ups to any lingering plan
-   workers (worker-plan follow-ups) and record them as stopped with the
-   reason. Implementing while planning still runs builds on a moving target
-   and wastes both stages. Only advance once every plan worker has returned
-   or is recorded as stopped.
+   dispatching subagents.
+3. Close the previous stage: send no further follow-ups to any lingering Plan
+   dispatches (Explore follow-ups) and record them as superseded with the
+   reason. Native subagents cannot be killed mid-run: let them finish but do
+   not wait on or use their output. Implementing while planning still runs
+   builds on a moving target and wastes both stages. Only advance once every
+   Plan dispatch has returned or is recorded as superseded.
 
 ## Procedure
 
 1. Parse the approved plan.
    - Read plan.md fully.
    - Group tasks by parallelGroup; order groups by dependency.
-   - For each group, prepare an isolated git worktree per task plus a narrow task brief (task spec, relevant context excerpt, acceptance criteria, verification commands).
+   - For each group, prepare a narrow task brief (task spec, relevant context excerpt, acceptance criteria, verification commands). Write every brief as plain directives, never reflective first-person prose: Gemini-run subagents may suppress tool calls when the prompt contains reflective text. If parallel tasks in the group require isolation, prepare one git worktree per task and pass worktree:true; otherwise tasks run in-place and must be sequentialized within shared files.
 
-2. Dispatch bounded implement workers, one parallel batch per group.
-   - Dispatch ALL tasks in the group in a single turn via the Agent tool (subagent_type worker-implement, with worktree isolation, maxWallClockMs 600000 per task so a hung worker is reaped after 10 minutes instead of blocking its slot).
-   - Each worker runs at the 200K default window and must self-contain its work:
+2. Dispatch bounded implementation subagents, one parallel batch per group.
+   - Dispatch ALL tasks in the group in a single turn via the Agent tool. Use subagent_type implementer first where the profile provides one (max), otherwise subagent_type General-Purpose for every task. Advisory: keep each task under ~10 minutes; the Task tool enforces no wall-clock.
+    - Each subagent runs at the 200K default window and must self-contain its work:
      a. Implement the change.
      b. Run the task verification commands (tests, typecheck, lint).
      c. Self-review against the acceptance criteria.
      d. Fix any self-found issues (at most 2 internal fix cycles).
-     e. Return the patch plus test results and self-review notes.
+     e. Return the patch plus test results, self-review notes, and an explicit confidence verdict (high or low) with reasons. Low confidence means the subagent itself doubts the result: flaky or incomplete verification, untested edge cases, or behavior it could not directly observe. Keep the return compact: patch plus results, no full-file echoes; output tokens cost several times input on every profile.
    - Do NOT dispatch the same task twice (no dedup exists); a retry is a new dispatch only after a recorded failure.
-   - For a big artifact, have the worker write it to a file and return the path.
+   - For a big artifact, have the subagent write it to a file and return the path.
 
 3. Aggregate and validate.
-   - Collect all patches and apply them sequentially to the main worktree (or merge the worktrees).
+   - Collect all patches and apply them sequentially to the main worktree (or merge the worktrees when worktree isolation was used).
    - Run the full relevant validation: test suite, typecheck, and lint.
-   - If any task fails validation, route it back to an implement worker (at most 2 retries per task). If it still fails, checkpoint with the failure as residual risk instead of pretending it is solved.
+   - If any task fails validation, route it back to a General-Purpose subagent (at most 2 retries per task). If it still fails, checkpoint with the failure as residual risk instead of pretending it is solved.
 
-4. Run staged review.
-   - Pass 1 (always): dispatch the worker-review subagent (via the Agent tool, maxWallClockMs 300000) over the unified diff for correctness against acceptance criteria, code quality and consistency, security and performance regressions, and test coverage. Categorize findings as minor (style, nits) or major (logic, architecture).
-   - If pass 1 finds no major issues, finish here.
-   - Pass 2 (major issues only): dispatch a fix worker (via the Agent tool, maxWallClockMs 300000) at the 200K default window using the Sol model at medium effort with the flagged areas, the failing checks, and the pass-1 findings. It returns fixed patches or an explicit escalate-to-user with reasons.
+4. Decide whether external review is warranted (default: skip it).
+   - Skip the reviewer when every task reports high confidence AND full validation (tests, typecheck, lint) passes AND the change avoids high-risk areas (auth, user input, database queries, crypto, serialization, data migration, cross-boundary contracts) AND the lead judges the change non-complex. Record the skip with reasons in the implementation report; self-validation plus green checks is the default path, not a shortcut.
+   - Dispatch the reviewer subagent (via the Agent tool, subagent_type reviewer) ONLY when a task reports low confidence, validation is incomplete or unconvincing, the change touches high-risk areas, or the lead explicitly requested review. Scope the brief to the uncertain areas, the acceptance criteria, and the failing or insufficient checks. Categorize findings as minor (style, nits) or major (logic, architecture). Advisory: keep the review under ~5 minutes.
+   - If the reviewer finds no major issues (or review was skipped with recorded reasons), finish here.
+   - Fix pass (major reviewer findings only): dispatch a General-Purpose subagent (via the Agent tool) at the 200K default window with the flagged areas, the failing checks, and the reviewer findings. It returns fixed patches or an explicit escalate-to-user with reasons. At most 2 review-fix cycles.
 
 5. Finalize.
    - Apply any review fixes and re-run full validation.
@@ -2253,15 +2287,16 @@ Return:
 - Implementation report path.
 - Task completion status per task id.
 - Test, typecheck, and lint results.
-- Review summary (pass 1 findings; pass 2 findings and fixes if used).
+- Review summary (skipped with recorded reasons, or reviewer findings; fix-pass findings and fixes if used).
 - Final residual risks and next action.
 
 ## Non-goals
 
 - Do not start without a user-approved plan.md plus its .complete approval record.
-- Do not start while plan workers still run; stop them first.
-- Do not serialize work that has no data dependency; independent tasks in a group run concurrently.
-- Do not nest workflow invocations: workers are internal sessions and must not re-invoke /gh-implement (or any /gh-* pipeline skill).
+- Do not start while Plan dispatches still run; record them superseded first.
+- Do not dispatch a reviewer by default; self-validation plus green checks is the default path.
+- Do not serialize work that has no data dependency; independent tasks in a group run concurrently (sequentialize only in-place edits to shared files).
+- Do not nest workflow invocations: subagents must not re-invoke /gh-implement (or any /gh-* pipeline skill).
 - Do not claim completeness when retries or review cycles are exhausted with open failures.
 `
 };
@@ -2409,18 +2444,27 @@ const PLAN_SKILL = {
 	name: "gh-plan",
 	md: `---
 name: gh-plan
-description: Holistic planning from gathered context: ingests the context brief, creates a scoped modular ordered implementation plan with explicit tasks for cheap implementation workers, surfaces open questions for user approval, and persists plan.md. Use when a non-trivial change needs a reviewed plan before implementation.
+description: Create an implementation plan from gathered context. Use when a non-trivial change needs a reviewed, ordered task list with acceptance criteria before implementing. Requires user approval. Not for trivial changes or missing context.
 user-invocable: true
+requires: [fresh context.md with .complete marker]
+produces: [plan.md, .complete]
+consumes: [context.md, context.compact.md]
+excludes: [trivial changes, implementation, missing context]
 ---
 
-# gh-plan: holistic planning for cheap implementation
+# gh-plan: native Plan-subagent planning
 
 Use this skill after /gh-gather-context (or when equivalent context is already
-available) and before any implementation. The planner runs at the 200K default
-window using the Sol model at medium effort. The plan must be scoped, modular,
-non-overlapping, and ordered, with enough detail for Luna implementation
-workers to execute each task in isolation. User approval is mandatory before
-implementation.
+available) and before any implementation. For non-trivial work, dispatch the
+native Plan subagent (subagent_type Plan) present on every pipeline profile
+roster; profile frontmatter pins its model and effort (Sol at the 200K default
+window). The plan must be scoped, modular, non-overlapping, and ordered, with
+enough detail for a native General-Purpose (or implementer, where the profile
+provides one) subagent to execute each task in isolation. User approval is
+mandatory before implementation. This skill dispatches ONLY the native Plan
+subagent via the Agent tool, never worker-* MCP dispatchers. Plan self-serves
+Explore follow-ups per its delegation graph; the skill does not dispatch
+Explore directly.
 
 ## Prerequisites
 
@@ -2434,47 +2478,74 @@ implementation.
    Finish or re-invoke gathering first.
 2. Check freshness: if HEAD or the working-tree diff hash moved since the
    brief's stamp, re-verify stale load-bearing claims before using them.
-3. Stop the previous stage: send no further follow-ups to any lingering
-   gather-context explore workers and record them as stopped with the reason.
-   Planning while explore workers still run builds on shifting evidence and
-   wastes both stages. Only advance once every gather worker has returned or
-   is recorded as stopped.
+3. Close the previous stage: send no further follow-ups to any lingering
+   gather-context Explore dispatches and record them as superseded with the
+   reason. Native subagents cannot be killed mid-run: let them finish but do
+   not wait on or use their output. Planning while Explore subagents still run
+   builds on shifting evidence and wastes both stages. Only advance once every
+   Explore dispatch has returned or is recorded as superseded.
+
+## Triviality reassessment (do this AFTER gate 0, BEFORE dispatching Plan)
+
+1. Reassess with fresh context: if the ask is trivial (typo, one-line config
+   read, obvious change of at most a few lines, pure explanation) or the
+   context shows no multi-file, risky, uncertain, or high-impact work, STOP.
+   Do NOT dispatch Plan. Do NOT write plan.md or .complete.
+2. Return a trivial verdict: one-sentence reason, the recommended direct
+   action, and an explicit statement that no downstream stage (/gh-implement,
+   /gh-swe-pipeline stage 3) may run. A trivial ask must never pay planning
+   cost as ritual.
 
 ## Hard bounds
 
 - Maximum tasks: 20.
 - Maximum parallel groups: 5.
 - Keep planner input well under the 200K window (target at most around 150K tokens of context) so there is headroom for reasoning and output. This is self-discipline, not an enforced cap: prefer the compact brief and read full sections only on demand.
+- Advisory budget: keep the Plan dispatch under ~5 minutes; the Task tool enforces no wall-clock. At most 2 bounded follow-up rounds to the same Plan dispatch for gaps.
 
-## Procedure
+## Procedure (non-trivial work only)
 
 1. Ingest context.
    - Read context.compact.md fully.
    - Read the evidence table and residual unknowns from context.md.
    - Identify acceptance criteria, constraints, integration seams, and forbidden changes.
 
-2. Build a blind-spot table before decomposing.
-   - Wrong-spec risk: judgment-only, mitigated only by user-blessed acceptance criteria.
-   - Root-cause risk: executable-checkable if reproduced or covered by a failing test; otherwise advisory.
-   - Integration risk: usually source-verified plus tests where possible.
-   - Regression risk: executable-checkable when tests, typecheck, or lint cover it.
-   - Review risk: advisory cross-lab review reduces correlated blind spots.
-   - Concurrency or merge risk: source-verified and sometimes executable-checkable.
-   - Missing-test risk: executable-checkable only after a test exists and runs.
-   - Tag every blind spot as executable-checkable or judgment-only.
-
-3. Decompose into minimal safe increments.
-   - Each task touches a single file or a tightly coupled file group.
-   - Each task states input artifacts, output artifact, acceptance criteria, verification commands, and rollback concern.
-   - Order tasks by dependency (topological sort); tasks with no data dependency share a parallel group.
-   - Keep each task small enough for one Luna worker at the 200K window (target at most 50K context tokens of relevant files per task).
-   - If the ask needs discovery follow-ups, delegate them to worker-explore background subagents (via the Agent tool, maxWallClockMs 180000) rather than bloating the plan.
-
-4. Surface open questions before finalizing.
-   - Ask about ambiguous acceptance criteria, design decisions with multiple valid approaches, risk tolerance, and test strategy.
-   - Present a short candidate list for confirmation where possible.
-
-5. Persist the plan to .github-router/plans/<slug>/plan.md.
+2. Compose the Plan dispatch brief. Include every item below; a vague brief
+   produces a vague plan, and a vague plan fails downstream:
+   - Ask summary and acceptance criteria (or candidates where ambiguous).
+   - Constraints, integration seams, and forbidden changes.
+   - Context pointers: context.compact.md path, the evidence table and
+     residual sections of context.md, plus the freshness stamp.
+   - Required output shape: objective; architectural invariants; interface
+     contracts; execution steps with files touched plus a done condition per
+     step; acceptance commands with the observable pass result; critical files
+     as file:line; a blind-spot table tagging each risk executable-checkable
+     or judgment-only (wrong-spec, root-cause, integration, regression,
+     review, concurrency or merge, missing-test); open questions as options
+     with a recommendation; cost estimate (task count, parallel groups,
+     context tokens).
+   - Plan-mode rule: plan and acceptance criteria only, no implementation
+     file edits.
+   - Permission to use Explore and reviewer per the delegation graph.
+   - Write the brief as plain directives, never reflective first-person prose:
+     Gemini-run subagents may suppress tool calls when the prompt contains
+     reflective text.
+   - Demand compact output: file:line plus one-line purposes, never pasted
+     source blocks. Output tokens cost several times input on every profile.
+   - Advisory ~5 minute budget.
+
+3. Dispatch ONE Plan subagent via the Agent tool (subagent_type Plan) with
+   that brief, then WAIT for its full return. Do not plan inline in parallel
+   and do not dispatch implementation subagents while it runs.
+
+4. Validate the returned plan. Every task must name files, state the change
+   and its done condition, and carry runnable acceptance commands;
+   trade-offs must appear as options with a recommendation. If gaps remain,
+   send ONE bounded follow-up to the same Plan dispatch naming the exact gaps
+   (at most 2 follow-up rounds total). If still underspecified, checkpoint
+   with the gaps as residual risk instead of pretending the plan is complete.
+
+5. Persist the validated plan to .github-router/plans/<slug>/plan.md.
    - Ask summary and user-blessed acceptance criteria.
    - Blind-spot table with executable-checkable or judgment-only tags.
    - Ordered task list with ids, files, dependencies, parallel groups, acceptance criteria, verification commands, rollback concerns, and estimated context tokens.
@@ -2492,6 +2563,7 @@ implementation.
 
 Return:
 
+- Trivial exit: yes with the recommended direct action and no plan file, or no with the plan below.
 - Plan file: path to the durable plan.md.
 - Task count and parallel groups.
 - Open questions and user answers.
@@ -2500,11 +2572,12 @@ Return:
 
 ## Non-goals
 
+- Do not dispatch Plan for a trivial ask; exit with a trivial verdict instead.
 - Do not edit implementation files while planning; in plan mode, produce the plan and acceptance criteria only.
 - Do not present judgment-only conclusions as executable guarantees.
 - Do not hide open unknowns because the plan looks complete.
-- Do not start planning while gather-context workers still run; stop them first.
-- Do not dispatch implement workers from planning: stages never overlap.
+- Do not start planning while gather-context Explore subagents still run; record them superseded first.
+- Do not dispatch implementation subagents from planning: stages never overlap.
 `
 };
 //#endregion
@@ -2624,7 +2697,7 @@ const SWE_PIPELINE_SKILL = {
 	name: "gh-swe-pipeline",
 	md: `---
 name: gh-swe-pipeline
-description: Strict sequential SWE pipeline for non-trivial code changes: runs gather-context to completion, then plan with user approval, then implement with staged review. Each stage waits for the previous to finish fully, stopping leftover workers before advancing. Use when the user wants the full structured engineering workflow in one command.
+description: Strict sequential SWE pipeline for non-trivial code changes: runs gather-context to completion, then plan with user approval, then implement with conditional review. Each stage waits for the previous to finish fully, superseding leftover subagents before advancing. Use when the user wants the full structured engineering workflow in one command.
 user-invocable: true
 ---
 
@@ -2632,25 +2705,28 @@ user-invocable: true
 
 Use this skill when the user invokes /gh-swe-pipeline for a non-trivial code
 change. It coordinates the three pipeline stages in STRICT SEQUENCE. No two
-stages ever overlap: each stage runs to completion, its workers are all
-finished or explicitly stopped, and its completion artifact exists before the
-next stage starts.
+stages ever overlap: each stage runs to completion, its subagents are all
+finished or explicitly superseded, and its completion artifact exists before
+the next stage starts. Every stage dispatches ONLY native subagents present on
+the profile roster (Explore, Plan, General-Purpose, reviewer, implementer
+where provided) via the Agent tool, never worker-* MCP dispatchers.
 
-All work runs at the 200K default window with bare slugs (no 1M accounting):
-gather-context uses Luna high, plan uses Sol medium, implement and review
-pass 1 use Luna max, review pass 2 uses Sol medium.
+All work runs at the 200K default window with bare slugs (no 1M accounting).
+Advisory budgets (the Task tool enforces no wall-clock): gather ~3 minutes
+per round, plan ~5 minutes total, implement ~10 minutes per task.
 
 ## The one rule
 
 WATERFALL ONLY. Never start a stage while the previous stage still has running
-workers or an unwritten completion artifact. If a stage already has enough
-evidence to proceed, FIRST stop every still-running worker from the previous
-stage (let their maxWallClockMs reap them or send no further follow-ups and
-treat their partial output as superseded), record what was stopped and why,
-THEN advance. Overlapping stages waste money and produce plans built on
-shifting evidence. This is the failure the pipeline exists to prevent.
+subagents or an unwritten completion artifact. If a stage already has enough
+evidence to proceed, FIRST record every still-running subagent from the
+previous stage as superseded (native subagents cannot be killed mid-run: send
+no further follow-ups, let them finish, and do not use their output), record
+what was superseded and why, THEN advance. Overlapping stages waste money and
+produce plans built on shifting evidence. This is the failure the pipeline
+exists to prevent.
 
-## Stage 0: triage (no workers)
+## Stage 0: triage (no subagents)
 
 1. Restate the ask in one sentence.
 2. Decide trivial versus non-trivial. Trivial (typo, one-line config read,
@@ -2663,47 +2739,56 @@ shifting evidence. This is the failure the pipeline exists to prevent.
 ## Stage 1: gather context (to completion)
 
 1. Invoke the gh-gather-context skill and WAIT for its full return. Do not
-   plan, sketch tasks, or dispatch plan workers while it runs.
+   plan, sketch tasks, or dispatch Plan subagents while it runs.
 2. Its completion artifact is
    .github-router/context/<slug>/context.md plus context.compact.md and a
    .complete marker. If the marker is missing, the stage is NOT complete:
    keep waiting or re-invoke; never advance on a partial brief.
 3. Early-stop rule: if the returned brief already saturates the ask (root
-   cause at least verified-source, no material unknowns), stop any
-   still-running explore workers (no follow-ups; record them as stopped),
-   accept the brief, and advance. Do not keep searching after saturation.
+   cause at least verified-source, no material unknowns), record any
+   still-running Explore dispatches as superseded (no follow-ups), accept the
+   brief, and advance. Do not keep searching after saturation.
 4. Cap-hit rule: if the brief reports cap-hit with residuals, surface the
    residuals in run.md and ask the user whether to proceed to planning with
    the gap or to spend one more bounded round. Do not silently treat a
    cap-hit brief as complete.
 
-## Stage 2: plan (to user approval)
+## Stage 2: plan (to user approval, or trivial exit)
 
 1. Precondition check BEFORE invoking gh-plan: the context .complete marker
-   exists AND every gather-context explore worker has returned or been
-   recorded as stopped. If either is false, do not invoke planning. Fix
+   exists AND every gather-context Explore dispatch has returned or been
+   recorded as superseded. If either is false, do not invoke planning. Fix
    stage 1 first.
-2. Invoke the gh-plan skill and WAIT for its full return. Do not dispatch
-   implement workers, sketch diffs, or edit implementation files while it
-   runs. Plan mode means plan and acceptance criteria only.
-3. Its completion artifact is .github-router/plans/<slug>/plan.md with a
+2. Invoke the gh-plan skill and WAIT for its full return. For non-trivial
+   work gh-plan dispatches the native Plan subagent with an
+   implementation-ready brief; do not dispatch implementation subagents,
+   sketch diffs, or edit implementation files while it runs. Plan mode means
+   plan and acceptance criteria only.
+3. Trivial exit: if gh-plan returns a trivial verdict (no plan.md, no
+   .complete), STOP the pipeline here. Record the verdict and the recommended
+   direct action in run.md and do NOT advance to implementation.
+4. Its completion artifact is .github-router/plans/<slug>/plan.md with a
    user-approval record (.complete marker written only after explicit
    approval). A plan without explicit user approval is NOT complete.
-4. Present the goal, acceptance criteria, task-to-group map, residual risks,
+5. Present the goal, acceptance criteria, task-to-group map, residual risks,
    and cost estimate. Wait for explicit approval. If the user rejects scope
    or cost, downshift to the smallest plan that kills the important blind
    spots and re-seek approval. NEVER advance to implementation without
    approval recorded in run.md.
 
-## Stage 3: implement (to reviewed diff)
+## Stage 3: implement (to validated diff, reviewed only when warranted)
 
 1. Precondition check BEFORE invoking gh-implement: plan.md exists, its
    .complete marker exists, and run.md records explicit user approval. If
    any is missing, do not invoke implementation. Fix stage 2 first.
-2. Stop any lingering plan workers (worker-plan follow-ups) before the
-   first implement dispatch; record them as stopped.
+2. Record any lingering Plan dispatches (Explore follow-ups) as superseded
+   before the first implement dispatch.
 3. Invoke the gh-implement skill and WAIT for its full return: unified diff,
-   implementation report, test/typecheck/lint results, and review summary.
+   implementation report, test/typecheck/lint results, and review summary
+   (or recorded skip when self-validation plus green checks sufficed).
+   gh-implement dispatches a reviewer only on low-confidence validation or
+   complex and risky changes; do not demand a review that the stage skipped
+   with recorded reasons.
 4. If retries or review cycles exhaust with open failures, checkpoint with
    the failure as residual risk instead of pretending it is solved.
 
@@ -2717,15 +2802,15 @@ Return:
 - Plan file: path to plan.md, task count, parallel groups, open questions
   and user answers, cost estimate, approval record.
 - Implement output: unified diff path, report path, per-task status, test
-  results, review summary.
+  results, review summary or recorded skip.
 - Residual risks and next action.
 
 ## Non-goals
 
-- Do not run stages in parallel or overlap workers across stages.
+- Do not run stages in parallel or overlap subagents across stages.
 - Do not advance past a missing completion artifact or a missing approval.
-- Do not nest pipeline invocations: workers are internal sessions and must
-  not re-invoke /gh-swe-pipeline or any /gh-* pipeline skill.
+- Do not nest pipeline invocations: subagents must not re-invoke
+  /gh-swe-pipeline or any /gh-* pipeline skill.
 - Do not present judgment-only conclusions as executable guarantees.
 `
 };
@@ -3047,14 +3132,18 @@ const STYLE_DIRECTIVE = "Write concisely without losing detail. Use a natural hu
 * `/gh-swe-pipeline`) injected ONLY for `--swe` launches on pinned profiles
 * (fast, max, cheap, cheap1m, cheapest, balanced). Standard is intentionally
 * excluded. Without `--swe` the skill files are not written and this text is
-* not referenced. All skill models run at the 200K default window (bare
-* slugs, no 1M accounting): gatherContext uses Luna high for the lead and
-* every explore worker (bounded: 3 rounds, 6 workers per round); plan uses
-* Sol medium; implement uses Luna max for the lead and every task worker
-* (bounded: 8 concurrent, 2 retries per task, isolated worktrees); review is
-* staged Luna max then Sol medium for major issues only.
+* not referenced. Stages dispatch ONLY native subagents present on the
+* profile roster (Explore, Plan, General-Purpose, reviewer, implementer
+* where provided), never worker-* MCP dispatchers. All roles run at the
+* 200K default window (bare slugs, no 1M accounting) with advisory budgets:
+* gather ~3 min per round (3 rounds max, 6 Explore per round); plan ~5 min
+* via the profile-pinned Plan subagent (trivial asks exit planless);
+* implement ~10 min per task (8 concurrent max, worktree:true only when
+* parallel tasks need isolation); reviewer only on low-confidence or complex
+* and risky changes, plus a General-Purpose fix pass for major reviewer
+* findings.
 */
-const PIPELINE_SKILLS_AWARENESS = "Pipeline skills (all 200K default context). Prefer `/gh-swe-pipeline`: it runs the stages below in strict sequence, each completing before the next starts, with user approval before implementation. Stages in order: (1) `/gh-gather-context` BEFORE planning when grounded context is needed: decomposes the ask, runs lexical search, fans out to bounded Luna-high explore workers, writes context.md plus context.compact.md; (2) `/gh-plan` AFTER context and BEFORE implementation: ingests the brief with Sol-medium, produces a scoped modular ordered plan.md, surfaces open questions, waits for user approval; (3) `/gh-implement` AFTER plan approval: bounded parallel Luna-max task workers in isolated worktrees (each self-tests and self-reviews), aggregates a unified diff, runs staged review (Luna max, then Sol medium for major issues only). Skip for trivial work. Never implement without an approved plan. Never overlap stages.";
+const PIPELINE_SKILLS_AWARENESS = "Pipeline skills (all 200K default context, native subagents only, never worker-*). Prefer `/gh-swe-pipeline`: strict sequence, each stage completing before the next starts, user approval before implementation. Stages in order: (1) `/gh-gather-context` BEFORE planning when grounded context is needed: lexical search plus bounded Explore subagents (~3 min each, 3 rounds max), writes context.md plus context.compact.md; (2) `/gh-plan` AFTER context and BEFORE implementation: native Plan subagent plans non-trivial asks (trivial exits planless), ordered plan.md (~5 min), open questions, waits for user approval; (3) `/gh-implement` AFTER plan approval: bounded parallel General-Purpose subagents (implementer first on max; worktree:true if parallel tasks need isolation), reviewer only on low-confidence or risky changes, plus fix pass for major findings. Skip for trivial work. Never implement without an approved plan. Never overlap stages.";
 /** Oxford-comma join: "a", "a and b", "a, b, and c". */
 function joinClauses(parts) {
 	if (parts.length <= 1) return parts[0] ?? "";
@@ -3159,7 +3248,7 @@ ${profileLabel} profile runtime wiring is unavailable. Work directly, use only t
 const OPERATING_DEFAULTS_DIRECTIVE = buildOperatingDefaultsDirective();
 const STANDARD_OPERATING_DEFAULTS_DIGEST = "## Operating defaults (these layer with the user's direction and the domain's standards as addons: follow all three; on a direct conflict the user's direction wins, then the domain standard, then the default below)\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 = {}) {
-	const digestPipelineSentence = opts.sweEnabled === false ? "" : "Pipeline skills (all 200K default): `/gh-gather-context` before planning when context is needed, `/gh-plan` before implementation (waits for user approval), `/gh-implement` after approval with bounded parallel workers and staged review. Skip for trivial work.\n\n";
+	const digestPipelineSentence = opts.sweEnabled === false ? "" : "Pipeline skills (all 200K default, native subagents only): `/gh-gather-context` before planning when context is needed, `/gh-plan` before implementation (trivial exits planless, waits for user approval), `/gh-implement` after approval with parallel subagents and conditional reviewer. Skip for trivial work.\n\n";
 	if (opts.profile === "max") return "## Operating defaults (these layer with the user's direction and the domain's standards as addons: follow all three; on a direct conflict the user's direction wins, then the domain standard, then the default below)\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\n" + digestPipelineSentence + "Synthesize 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" || opts.profile === "cheap" || opts.profile === "cheap1m" || opts.profile === "cheapest" || opts.profile === "balanced") {
 		const isCheap = opts.profile === "cheap" || opts.profile === "cheap1m";
@@ -3748,4 +3837,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-IbcZgAEf.js.map
+//# sourceMappingURL=attribution-settings-17Ug_BaA.js.map