ralplan

The non-negotiable invariant is adversarial blind-spot elimination = author ≠ attacker: the agent that authors a candidate is never the agent that attacks it, and the synthesizer is distinct from every attacker. This separation is enforced by dispatch topology (different subagent_type in different Task calls). What that structurally guarantees is narrow but real — no single context ever authors and then approves its own work. Independence beyond that (that the separate attacker/synthesizer does not share the author's systematic blind spots) is strengthened by orthogonal lenses + model diversity, but is a prose-enforced convention, not a harness-level code gate.

<Use_When>

• A spec (.dt-handoff/<slug>/spec.md, or an ad-hoc description) needs a vetted implementation plan before any code is written.
• User invokes /ralplan, says "ralplan", "plan this with consensus", "합의 계획 잡아줘".
• The work involves architectural choices, migrations, or high-risk areas (auth, security, destructive changes) and warrants a wider panel + pre-mortem + expanded test planning (auto-detected → HIGH tier).
• autopilot Phase 2 (Planning) calls this skill as a sub-step. </Use_When>

<Do_Not_Use_When>

• The user wants execution, not planning — route to ralph or autopilot.
• The user wants requirements capture (WHAT, not HOW) rather than a plan — clarify the requirements into a spec first, then return to ralplan.
• The user wants a one-shot bug fix or trivial change with no design choice — delegate to executor directly (ralplan will still run a minimal N=1 panel if invoked, but it is overkill).
• The user wants free-form brainstorming with no committed artifact — answer directly without invoking ralplan.
• The user wants severity-rated review of an existing plan — use code-review or critic directly. </Do_Not_Use_When>

<Why_This_Exists> Plans written by one author and approved by the same author share that author's blind spots — they overweight the chosen approach and underweight alternatives. The classic fix (one draft, then a reviewer) only weakens this; the draft still anchors the whole deliberation. A panel of independent candidates, each grown from a different starting framing and each attacked by a separate adversary, eliminates blind spots structurally rather than behaviorally: there is no single draft to anchor on, and no agent ever grades its own work.

Two corrections make the separation real rather than cosmetic. First, candidate authorship belongs to architect, not planner: planner explicitly refuses design judgment and delegates it, while architect is the agent that produces multi-option/trade-off analysis. Second, decorrelation must be real — identical-weight models share systematic blind spots ("capability symmetry ≠ judgment independence"), so the attacker is decorrelated from the author by an orthogonal attack lens and, when the runtime allows per-dispatch model selection, by a different model tier.

Risk-proportional depth replaces the old cost machinery (mode-gate / Critic-input-set / model-routing / Dispatch Ledger), whose savings were never observed in practice. A single dial — risk tier — sets panel width, attack depth, and whether a pre-mortem runs. Cost is controlled by three visible knobs (N, attack-lens count, model tier), not by conditional fast-paths.