planner-create

What this skill does

# Create Plans

You are now executing the planner-create skill. Follow these steps immediately:

**Agent Reference**: This skill uses the plan-creator agent (@agents/plan-creator.md) to perform the actual plan creation work.

**Template Reference**: The default plan template is available at @templates/plan.TEMPLATE.md

**Standards Reference**: Convention files are available at @templates/standards/

## Step 1: Read Smart Parallelism Configuration

Read the user's project configuration to understand the plan creation strategy:

1. **Read configuration file**: Read `plans/planner.config.json`

   - If successful and valid JSON:
     - Parse: `smart_parallelism`
     - Store the value and proceed to Step 2

2. **Use default**: If file not found or invalid:
   - `smart_parallelism = false`

**This affects dependency creation:**

- `true`: Aggressive parallelization (fewer dependencies, more parallel plans)
- `false`: Conservative dependencies (safer sequential execution)

## Step 2: Detect Plan Template

Check for a plan template to ensure consistent plan structure:

1. **Check user's project first**: Use Glob to check if `plans/plan.TEMPLATE.md` exists

   - If found: **Read the file** using Read tool and store as `template_content`
   - Set `template_source = "project"`

2. **Fall back to plugin default**: If not found in project:

   - Read the plugin's default template: `templates/plan.TEMPLATE.md` from plugin directory
   - Store as `template_content`
   - Set `template_source = "default"`

3. **Check for convention files**: Use Glob to check if `plans/standards/*.md` exists
   - If found: Store paths as `convention_files`
   - If not found: Agent will use built-in conventions

**Template affects plan structure:**

- Plans will follow the template's section structure
- Placeholders (`{{PLACEHOLDER}}`) guide content placement
- Convention `@mentions` are preserved for reference

## Step 3: Analyze Existing Plans

Understand the current project structure:

1. Use Glob: `plans/*.plan.md` (only plan files, not specs or templates)
2. Store as `existing_plans` for context
3. Detect naming conventions:
   - Prefix patterns (e.g., "auth-", "api-")
   - Numbering schemes (e.g., "01-", "02-")
   - Naming styles (e.g., kebab-case, descriptive names)

## Step 4: Spawn Plan-Creator Agent

**CRITICAL: You MUST spawn the plan-creator agent now using the Task tool.**

This is NOT optional - the agent performs the actual plan creation work.

Use the Task tool with these exact parameters:

```
Task tool parameters:
  description: "Create plans for: [short summary]"
  subagent_type: "planner:plan-creator"
  prompt: |
    description: "[user's full feature description]"
    prefix: "[provided prefix or inferred from description]"

    smart_parallelism: [true/false from Step 1]

    template_source: [project/default]
    template_content: |
      [TEMPLATE CONTENT IF FROM PROJECT, OR "use built-in default"]

    convention_files:
      [LIST OF CONVENTION FILE PATHS, OR "use built-in conventions"]

    existing_plans:
    [LIST OF EXISTING PLAN FILES]

    naming_conventions:
    [DETECTED PATTERNS FROM EXISTING PLANS]

    IMPORTANT: Follow the template structure when creating plans.
    Include @mentions to convention files in the Standards section.

    BEGIN CREATION.
```

**Important**: Do NOT just gather information - you MUST call the Task tool to spawn the agent.

## Step 5: Report Results

After the agent completes, show the creation result:

```
════════════════════════════════════════
Plans Created Successfully

Feature: [feature description]
Prefix: [prefix used]
Plans created: [N]
Template: [project custom / plugin default]

Plan Execution Order:
Round 1 (parallel): [list of independent plans]
Round 2: [plans depending on Round 1]
Round 3: [plans depending on Round 2]
...

Files created:
- plans/[plan-01].plan.md
- plans/[plan-02].plan.md
- plans/[plan-03].plan.md
- Updated plans/PROGRESS.md

To execute:
  /planner:batch --prefix=[prefix]
  OR
  /planner:batch [plan-01].plan.md [plan-02].plan.md ...

Smart Parallelism: [enabled/disabled]
════════════════════════════════════════
```

**If extra sections were needed:**

```
Note: The following sections were added beyond the template:
- [section name]: [reason]
```

---

## Reference Information

### What This Skill Does

When creating plans for a feature, this skill:

1. **Reads Configuration**: Gets smart parallelism setting from `plans/planner.config.json`
2. **Detects Templates**: Checks for custom template or uses plugin default
3. **Analyzes Requirements**: Breaks down the feature into manageable plans
4. **Creates Plan Files**: Each plan is self-contained (~40% context usage)
5. **Determines Dependencies**: Identifies sequential vs. parallel execution needs
6. **Updates Tracking**: Adds new plans to `plans/PROGRESS.md`

### Key Features

- **Template Support**: Uses project template or plugin default for consistent structure
- **Convention References**: Includes @mentions to coding standards
- **Smart Breakdown**: Splits complex features into small, focused plans
- **Dependency Analysis**: Identifies which plans must run sequentially vs. in parallel
- **Context Optimization**: Each plan uses ~40% context to leave room for implementation
- **Naming Conventions**: Follows existing project patterns or creates sensible defaults
- **Automatic Tracking**: Updates PROGRESS.md with all new plans
- **Configurable Strategy**: Uses smart parallelism setting for dependency decisions

### Template System

The planner uses a template system for consistent plan creation:

**Project Template** (`plans/plan.TEMPLATE.md`):

- Custom template for your project
- Created via `/planner:eject-template plan`
- Takes priority over plugin default

**Plugin Default Template**:

- Built into the plan-creator agent
- Used when no project template exists
- Includes all standard sections

**Convention Files** (`plans/standards/*.md`):

- Referenced via `@templates/standards/[name].md`
- Provide coding standards and best practices
- Can be customized per project

### Smart Parallelism

The `smart_parallelism` setting in `plans/planner.config.json` affects how aggressively plans are parallelized:

**When `true` (Aggressive):**

- Minimizes dependencies
- Maximizes parallel execution
- Faster overall execution
- Requires careful conflict management

**When `false` (Conservative):**

- More sequential dependencies
- Safer execution order
- Slower but more predictable
- Better for complex interdependencies

### Plan Structure

Each created plan follows the template structure and includes:

```markdown
# Configuration

depends_on: "prefix-00-setup.md"

# Plan: prefix-01-database.md

## Objective

[What this plan accomplishes]

## Context

[Relevant codebase context]

## Implementation Steps

### Step 1: [Title]

[Details]

## Files to Modify

| File | Action | Description |
| ---- | ------ | ----------- |

## Standards & Conventions

@templates/standards/coding-style.md
@templates/standards/error-handling.md

## Testing Instructions

[How to verify the changes work]

## Completion

Update plans/PROGRESS.md to mark this plan as COMPLETED.
```

### Example

```
User: Create plans for user authentication with JWT

Step 1: Read smart_parallelism
→ Found: smart_parallelism: true

Step 2: Detect template
→ Found: plans/plan.TEMPLATE.md (project custom)
→ Found: plans/standards/*.md (8 convention files)

Step 3: Analyze existing plans
→ Found naming pattern: "feature-NN-name.plan.md"
→ Detected numbering scheme: 00, 01, 02, etc.

Step 4: Spawn plan-creator agent
→ Passes config, description, template, and conventions

Agent creates:
→ auth-00-setup.plan.md (no deps)
→ auth-01-database.plan.md (depends on: 00)
→ auth-02-jwt-service.plan.md (depends on: 01)
→ auth-03-api.plan.md (depends on: 02)
→ auth-04-tests.plan.md (no deps - can run in parallel)

Updates PROGRESS.md:
→ Added 5 new plans

Report:
→ Round 1: auth-00-setup.plan.md, auth-04-te