/create-plan <request>                    # Full workflow: create + review + agents + iterate
/create-plan <request> --draft            # Just create draft, skip review
/create-plan <request> --no-agents        # Multi-LLM only, skip domain agents
/create-plan <request> --output <file>    # Save to specific file
/create-plan <request> --minimal          # Lightweight plan for small features
/create-plan <request> --generic          # Force generic template

<project-root>/implementation-plans/YY-MM-DD-<feature-name>.md

/create-plan "Add page reordering"
→ Write(implementation-plans/26-02-15-page-reordering.md, <full plan content>)
→ Read(implementation-plans/26-02-15-page-reordering.md)  # verify
→ "Plan saved to implementation-plans/26-02-15-page-reordering.md"
→ ExitPlanMode

❌ User: "Implement the plan"
❌ Claude: [Uses plan text from conversation memory]

✅ User: "Implement the plan"
✅ Claude: "Let me read the saved plan first."
✅ Claude: Read(implementation-plans/26-02-15-page-reordering.md)
✅ Claude: "Implementing from implementation-plans/26-02-15-page-reordering.md"

/create-plan "Add OAuth2 support"
         │
         ▼
┌─────────────────────────────────────────┐
│  Step 1: RESEARCH                       │
│  - Explore codebase for similar features│
│  - Identify patterns to follow          │
└─────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────┐
│  Step 2: DRAFT PLAN                     │
│  - Use template for consistency         │
│  - Fill in all sections                 │
└─────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────┐
│  Step 3: MULTI-LLM REVIEW               │
│  - Spec review (requirements)           │
│  - Technical review (feasibility)       │
│  - 80/20 filter for blockers            │
└─────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────┐
│  Step 4: AGENT REVIEW                   │
│                                         │
│  MUST RUN (every plan):                 │
│  - design-flaw-finder                   │
│  - simplicity-reviewer                  │
│                                         │
│  OPTIONAL (based on domain):            │
│  - api-contract-reviewer (if API)       │
│  - database-architecture-reviewer (DB)  │
│  - ux-design-reviewer (if UI)           │
│  - threat-modeler (security-sensitive)  │
│  - rest-api-expert (if REST API)        │
└─────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────┐
│  Step 5: ITERATE (if needed)            │
│  - Fix MUST FIX blockers in plan        │
│  - Max 2 iterations                     │
└─────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────┐
│  Step 6: WRITE FILE (MANDATORY!)        │
│  - Call Write tool NOW, not later       │
│  - Write to implementation-plans/       │
│  - Call Read to verify file exists      │
│  - Tell user the saved location         │
│  DO NOT SKIP OR DEFER THIS STEP        │
└─────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────┐
│  Step 7: EXIT PLAN MODE                 │
│  - STOP: Did you call Write in Step 6?  │
│  - If NO → go back and write the file   │
│  - If YES → Call ExitPlanMode tool      │
│  - User approves or requests changes    │
└─────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────┐
│  Step 8: IMPLEMENTATION (after approve) │
│  - READ from saved file (not memory!)   │
│  - "Implementing from <file>"           │
│  - Execute tasks from file              │
└─────────────────────────────────────────┘

# 1. Design flaws
Task(subagent_type="design-flaw-finder", prompt="Review this plan for logical flaws: [plan]")

# 2. Over-engineering
Task(subagent_type="simplicity-reviewer", prompt="Review this plan for YAGNI violations: [plan]")

# Multi-component features
Task(subagent_type="system-design-reviewer", prompt="Review architecture: [plan]")

# Frontend+backend changes
Task(subagent_type="client-server-alignment", prompt="Check alignment: [plan]")

# Layer responsibility
Task(subagent_type="separation-of-concerns-reviewer", prompt="Check layers: [plan]")

# Pseudo-logic for agent selection
domains = []

if plan contains ["API", "endpoint", "REST", "/api/v4"]:
    domains.append("api")

if plan contains ["database", "schema", "migration", "table", "index"]:
    domains.append("database")

if plan contains ["UI", "component", "modal", "button", "user interface"]:
    domains.append("ui")

if plan contains ["permission", "role", "RBAC", "authorization", "access control"]:
    domains.append("permissions")

if plan contains ["type", "struct", "interface", "model"]:
    domains.append("types")

# Select agents based on domains
agents = ["design-flaw-finder", "simplicity-reviewer"]  # MUST RUN

if "api" in domains:
    agents.extend(["api-contract-reviewer", "rest-api-expert"])
if "database" in domains:
    agents.append("database-architecture-reviewer")
if "ui" in domains:
    agents.extend(["ux-design-reviewer", "edge-case-ux-analyst"])
if "permissions" in domains:
    agents.append("threat-modeler")
if "types" in domains:
    agents.append("type-design-analyzer")

## Component Structure
- Folder-by-feature: `my_component/`, `my_component.tsx`, `my_component.scss`, `my_component.test.tsx`
- Functional components with hooks (`useSelector`, `useDispatch`, `useCallback`, `useMemo`)
- Code splitting with `makeAsyncComponent` for heavy routes

## Styling Requirements
- Co-located SCSS files imported in component
- BEM naming: `.MyComponent`, `.MyComponent__title`
- CSS variables for colors: `var(--center-channel-color)`
- No `!important`

## Accessibility (MANDATORY)
- Semantic HTML (`<button>`, `<input>`) over `<div>` with roles
- Keyboard support for all interactive elements
- Use `GenericModal`, `Menu`, `WithTooltip` primitives

## Internationalization (MANDATORY)
- All UI strings via `<FormattedMessage>` or `useIntl()`

## Actions
- Return `{data}` on success, `{error}` on failure
- Use `bindClientFunc` for simple API calls
- Call Client4 ONLY from actions, never components
- Handle errors with `forceLogoutIfNecessary` + `logError`

## Selectors
- Memoize with `createSelector` when returning arrays/objects
- First param is selector name: `createSelector('getSomething', ...)`
- Use `makeGet*` factory for parameterized selectors
- Use `useMemo(makeGetX, [])` in components

## Reducers
- Immutable updates (spread operator)
- Always handle `UserTypes.LOGOUT_SUCCESS` to clear state
- `state.entities.*` for server data, `state.views.*` for UI

- RTL tests alongside components (`*.test.tsx`)
- Use `userEvent` and `getByRole` queries
- No snapshots - assert visible behavior
- Mock store with `renderWithRedux`

# Use Explore agent for thorough research
Task(subagent_type="Explore", prompt="Find how the codebase handles [feature area].
Look for similar features. Return:
1. File:line references for patterns to follow
2. Conventions used (state management, action patterns, etc.)
3. Anti-patterns to avoid")

# [Feature Name]

## Overview
[1-2 sentence summary]

## Problem Statement
[What problem does this solve? Why is it needed now?]

## Current State
[How does it work today? What hooks/components exist?]

### Current Gaps
- [Gap 1: e.g., No cancellation support]
- [Gap 2: e.g., No progress tracking]

## Design Principles
| Pattern | Our Approach | Avoid | Reference |
|---------|-------------|--------|-----------|
| [e.g., Navigation] | Allow freely, never block | useBlocker, Prompt dialogs | - |
| [e.g., Async tracking] | Redux state `{[id]: data}` | Local component state | `marketplace.installing` |
| [e.g., Cancellation] | `AbortController.abort()` | Just ignore results | `file_upload.tsx:570` |
| [e.g., Notifications] | Toast component | Modal popup | `toast/toast.tsx` |

## Reference Patterns
Similar features to follow:
- `[file:line]` - [what pattern it demonstrates]
- `[file:line]` - [what pattern it demonstrates]

## Requirements
- [ ] Requirement 1
- [ ] Requirement 2

## Out of Scope
- NOT doing X
- NOT doing Y

## Technical Approach
[How we'll build it - aligned with design principles above]

## Decisions
| Question | Decision | Rationale |
|----------|----------|-----------|
| [e.g., State complexity?] | [Minimal] | [Only track active ops] |
| [e.g., Error structure?] | [Simple string] | [Typed errors add complexity] |

## Files to Modify
| File | Change |
|------|--------|

## Tasks
1. [ ] Task 1
2. [ ] Task 2

## Risks & Mitigations
| Risk | Mitigation |
|------|------------|

## UX Summary (for UI features)
| Scenario | Behavior |
|----------|----------|
| [User starts operation] | [Progress bar appears] |
| [User clicks cancel] | [Operation dismissed, server may complete] |
| [Operation completes] | [Toast with action link] |

## Testing Plan
**Unit**: [e.g., Reducer state transitions, selector logic]
**Integration**: [e.g., Cancel during progress, navigation away/back]
**E2E**: [e.g., Full flow: start → progress → complete → navigate]

## Acceptance Criteria
- [ ] Criterion 1
- [ ] Criterion 2

## Phase Strategy

| Phase | Focus | Value |
|-------|-------|-------|
| **Phase 1** | Core MVP: [key deliverables] | **80% of value** |
| **Phase 2** | Polish: [edge cases, cleanup] | Robustness |
| **Phase 3** | Enhanced: [nice-to-haves] | Optional |
| **Phase 4** | Future: [out of scope for now] | Deferred |

### Phase 1 Scope (this plan)
[Details for Phase 1 only - keep focused]

### Deferred to Phase 2+
- [Item] - Phase 2
- [Item] - Phase 3

# MUST RUN
Task(subagent_type="design-flaw-finder", prompt="[plan]")
Task(subagent_type="simplicity-reviewer", prompt="[plan]")

# Domain-specific (if API plan)
Task(subagent_type="api-contract-reviewer", prompt="[plan]")
Task(subagent_type="rest-api-expert", prompt="[plan]")

## Plan Review Summary

### Status: READY / NEEDS ATTENTION

### Multi-LLM Review
- [Resolved blockers]
- [Remaining SHOULD FIX]

### Agent Review
| Agent | Verdict | Key Findings |
|-------|---------|--------------|
| design-flaw-finder | PASS/FAIL | [summary] |
| simplicity-reviewer | PASS/FAIL | [summary] |
| [domain agents] | PASS/FAIL | [summary] |

### Resolved Blockers
- [What was fixed]

### Remaining SHOULD FIX
- [Item] - [recommendation]

---

[Full plan content]

# Full workflow - create, multi-LLM review, agent review, iterate
/create-plan "Add OAuth2 support with Google and GitHub providers"

# Skip agents (faster, less thorough)
/create-plan "Add OAuth2 support" --no-agents

# Just draft, no review at all
/create-plan "Add loading spinner" --draft

# Minimal plan for small feature
/create-plan "Fix pagination bug" --minimal