kimchi:plan

# Kimchi Plan

<command_purpose>
Planning pipeline orchestrator. Takes a vague idea and produces a draft plan ready for cross-model analysis. With --full-auto, also runs beads + validate.
</command_purpose>

## Pre-flight Check

**Before doing anything else**, check if a `.kimchi/` directory already exists:

1. Look for `.kimchi/` in the working directory
2. 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:
1. Run `/kimchi:plan-revise` in Claude, Codex, Gemini (or other models) 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

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:

1. **Clarify** → Execute the clarify command logic with the feature idea
2. **Requirements** → Execute requirements command logic reading CONTEXT.md
3. **Research** → Execute research command logic (skip if --skip-research)
4. **Generate** → Execute generate command logic
5. **Review** → Execute review command logic (skip if --skip-review)
6. **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