Look for .kimchi/ in the working directory
If it exists and contains any planning artifacts (CONTEXT.md, REQUIREMENTS.md, PLAN*.md, etc.):
- Warn the user:
```
⚠️  Existing kimchi plan detected in .kimchi/
```
- Summarize the existing plan using a haiku agent (model: haiku) to read the highest-stage artifact found and produce a 2-3 sentence summary of what was being planned
- Show the summary and list which artifacts exist
- Suggest reset:
```
Run /kimchi:reset to clear the previous plan before starting fresh.
Or continue if you intend to build on this existing work.
```
- Ask the user whether to proceed or reset. Do NOT continue the pipeline until the user confirms.

Input

Feature idea from $ARGUMENTS.

Parse options:

--depth minimal|standard|comprehensive (default: standard)
--skip-research: Skip codebase research stage
--skip-review: Skip multi-persona review stage
--no-push: Don't offer to push to beads-sync
--max-refine-loops N: Max refinement iterations (default: 3)
--max-bead-validation-loops N: Max bead enrichment iterations (default: 3)
--full-auto: After refine, also run beads + validate (for when user has already done revise/synthesize)

If no idea provided, ask: "What feature or change would you like to plan?"

Pipeline

Depth Levels

minimal: Quick planning for small, clear features

clarify → requirements → generate → refine

standard: Full pipeline (default)

clarify → requirements → research → generate → review → refine

comprehensive: Deep planning for complex features

clarify (extra questions) → requirements → research (deep) → generate → review → refine (5 loops)

After refine, the pipeline stops. The user should then:

Run /kimchi:plan-revise in Claude, Codex, Gemini (or other models) for cross-model analysis
Run /kimchi:plan-synthesize to blend all revisions
Run /kimchi:beads to convert to bead specifications
Run /kimchi:validate to verify beads

With --full-auto, stages 9-10 (beads + validate) run automatically after refine.

Execution

Run each stage as a slash command invocation. Between stages, show progress:

Starting Kimchi planning pipeline...

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
STAGE 1/6: Clarification
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[Run /kimchi:clarify with the idea]

✓ Clarification complete → .kimchi/CONTEXT.md

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
STAGE 2/6: Requirements
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[Run /kimchi:requirements]

✓ Requirements extracted → .kimchi/REQUIREMENTS.md

[... continue through all stages ...]

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
DRAFT PLAN COMPLETE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Draft plan ready at .kimchi/PLAN-DRAFT.md

Next steps:
  1. Run /kimchi:plan-revise in Claude, Codex, and Gemini for cross-model analysis
  2. Run /kimchi:plan-synthesize to blend all revisions
  3. Run /kimchi:beads to convert to bead specifications
  4. Run /kimchi:validate to verify beads

Stage Orchestration

For each stage, follow the instructions in the corresponding command file:

Clarify → Execute the clarify command logic with the feature idea
Requirements → Execute requirements command logic reading CONTEXT.md
Research → Execute research command logic (skip if --skip-research)
Generate → Execute generate command logic
Review → Execute review command logic (skip if --skip-review)
Refine → Execute refine command logic (skip if --skip-review, uses --max-refine-loops)

Pipeline stops here. User runs plan-revise and plan-synthesize manually across models.

If --full-auto is set, also run: 7. Beads → Execute beads command logic 8. Validate → Execute validate command logic (uses --max-bead-validation-loops)

Error Handling

If any stage fails:

Report which stage failed and why
Save whatever artifacts were produced
Tell user they can resume from the failed stage (e.g., "Run /kimchi:research to retry")

Key Principles

Each stage reads from the previous stage's output file — not from memory
Progress is visible between stages
Interruption is safe — artifacts are written after each stage completes
User interaction happens during clarify and review — other stages are autonomous

kimchi:plan

Kimchi Plan

Pre-flight Check