Developer: Implementation Planning

Router command that infers work type and delegates to the appropriate planning skill.

Input Handling

The argument can be:

Input Type	Example	Handling
Folder path	.hefesto/features/.../stories/001-login	Read all relevant files in folder
File path	specs/issue-123/description.md	Read the file directly
Text prompt	"Add user authentication with OAuth"	Use as the work description

If a path is provided, read its contents to understand the work. If it's a prompt, use it directly as the description.

Routing

Input	Action
<path|prompt>	Infer type from content
feature <path|prompt>	Force feature planning
bug <path|prompt>	Force bug planning
chore <path|prompt>	Force chore planning

Type Inference

Work type is inferred from content, not stored explicitly.

Inference Rules

Type	Title/Description Patterns	Content Indicators
feature	Add, Create, Implement, Enable, Support, Build	New capability, "I want to", "allow users to"
bug	Fix, Resolve, Correct, Handle, Repair, Error	Expected vs actual, error conditions, "should work but"
chore	Refactor, Update, Upgrade, Migrate, Clean, Remove	Developer-focused, technical debt, "no behavior change"

Inference Process

1. Read input (path contents or prompt text)
2. Extract title/description
3. Score each type:
   • Title/first line match: weight 3
   • Body keywords: weight 2
   • Requirements/criteria indicators: weight 1
4. Select type with highest score
5. Default to feature if ambiguous

Confidence Levels

• High (score >= 4): Proceed automatically
• Medium (score 2-3): Proceed, note in output
• Low (score < 2): Warn, suggest explicit type

Strategy Skills

Each type delegates to a specialized planning skill:

Type	Skill	Focus
feature	planning-feature	Multi-phase, user value
bug	planning-bug	Root cause, minimal fix
chore	planning-chore	No behavior change

Read and apply the corresponding skill from /skills/planning-{type}/SKILL.md.

---

Workflow

Phase 1: Parse Input

1. Determine if argument is a path or text prompt
2. If path (file or folder): read contents
3. If prompt: use directly as work description
4. Extract title and body content

Phase 2: Infer Type

1. Analyze title/description
2. Apply inference rules
3. Report: Inferred type: {type} (confidence: {level})

If explicit type provided (dev:plan bug <input>), skip inference.

Phase 3: Gather Context

1. If path provided, explore surrounding context:
   • Parent folder structure
   • Related configuration files
   • Existing patterns in the codebase
2. If prompt provided, explore codebase for relevant patterns

Phase 4: Code Analysis

Explore existing codebase:

• Files to be modified
• Existing patterns to follow
• Related implementations

Create Impact Matrix:

File	Change Type	Risk	Dependencies

Phase 5: Conflict Detection

Check for potential conflicts:

• Same files being modified elsewhere
• Uncommitted dependencies
• Shared resources

Create Conflict Matrix (if conflicts found):

Conflict	With	Resolution

Phase 6: Apply Strategy Skill

Read the appropriate skill and follow its guidance:

• planning-feature: Multi-phase approach, user value focus
• planning-bug: Root cause analysis, minimal surgical fix
• planning-chore: Behavioral preservation, metrics focus

Phase 7: Plan Generation

Write plan file following the skill's template format.

Output location:

• If input was a folder: write {folder}/plan.md
• If input was a file: write {file_dir}/plan.md
• If input was a prompt: write to current directory or ask user

Phase 8: Validation

Verify:

• Plan file is complete
• All requirements have verification methods
• Impact matrix covers all affected files
• Template matches inferred type

---

Output

✅ Implementation Plan Created

Title: {title}
Type: {type} (inferred|explicit)
Path: {plan_path}

Summary:
- Phases: {count}
- Steps: {count}
- Files Affected: {count}
- Complexity: {Low/Medium/High}

Conflicts: {count}

→ Next: dev:code {path}