core-planner（核心规划师）

Core Planner Skill

Strategic planning specialist responsible for breaking down complex tasks into manageable components and creating actionable execution plans.

Quick Start

// Spawn planner agent
Task("Planner agent", "Break down [task] into actionable subtasks with dependencies", "planner")

// Orchestrate task execution
  task: "Implement [feature]",
  strategy: "parallel",
  priority: "high",
  maxAgents: 5
}

When to Use

• Breaking down complex features into tasks
• Creating sprint/iteration plans
• Mapping task dependencies
• Allocating resources and agents
• Risk assessment and mitigation planning

Prerequisites

• Clear understanding of project goals
• Access to project requirements/specifications
• Knowledge of available agents and their capabilities
• Understanding of technical constraints

Core Concepts

Planning Process

1. Initial Assessment: Analyze scope, objectives, success criteria
2. Task Decomposition: Break into concrete, measurable subtasks
3. Dependency Analysis: Map inter-task dependencies
4. Resource Allocation: Assign agents and estimate time
5. Risk Mitigation: Identify failure points and contingencies

Task Properties

• Specific: Clear, unambiguous description
• Measurable: Has defined completion criteria
• Achievable: Within capability constraints
• Relevant: Contributes to objectives
• Time-bound: Has estimated duration

Implementation Pattern

Plan Output Format

plan:
  objective: "Clear description of the goal"
  phases:
    - name: "Phase Name"
      tasks:
        - id: "task-1"
          description: "What needs to be done"
          agent: "Which agent should handle this"
          dependencies: ["task-ids"]
          estimated_time: "15m"
          priority: "high|medium|low"

  critical_path: ["task-1", "task-3", "task-7"]

  risks:
    - description: "Potential issue"
      mitigation: "How to handle it"

  success_criteria:
    - "Measurable outcome 1"
    - "Measurable outcome 2"

Task Decomposition Example

# Example: Implement User Authentication
plan:
  objective: "Implement secure user authentication system"
  phases:
    - name: "Research & Design"
      tasks:
        - id: "auth-1"
          description: "Research authentication best practices"
          agent: "researcher"
          dependencies: []
          estimated_time: "1h"
          priority: "high"

        - id: "auth-2"
          description: "Design authentication flow"
          agent: "architect"
          dependencies: ["auth-1"]
          estimated_time: "2h"
          priority: "high"

    - name: "Implementation"
      tasks:
        - id: "auth-3"
          description: "Implement auth service"
          agent: "coder"
          dependencies: ["auth-2"]
          estimated_time: "4h"
          priority: "high"

        - id: "auth-4"
          description: "Write auth tests"
          agent: "tester"
          dependencies: ["auth-3"]
          estimated_time: "2h"
          priority: "high"

    - name: "Review"
      tasks:
        - id: "auth-5"
          description: "Security review"
          agent: "reviewer"
          dependencies: ["auth-4"]
          estimated_time: "1h"
          priority: "high"

  critical_path: ["auth-1", "auth-2", "auth-3", "auth-4", "auth-5"]

  risks:
    - description: "OAuth provider API changes"
      mitigation: "Abstract provider layer for easy switching"

    - description: "Session management complexity"
      mitigation: "Use proven library (passport.js)"

  success_criteria:
    - "Users can register and login"
    - "Passwords are securely hashed"
    - "Sessions expire after 24h"
    - "All security tests pass"

Configuration

Priority Levels

Agent Allocation

agent_capabilities:
  researcher: ["research", "analysis", "documentation"]
  coder: ["implementation", "api_design", "refactoring"]
  tester: ["unit_tests", "integration_tests", "e2e_tests"]
  reviewer: ["code_review", "security_audit", "performance"]
  planner: ["task_decomposition", "dependency_mapping", "risk_assessment"]

Usage Examples

Example 1: Feature Planning

// Spawn planner for feature breakdown
Task("Planner", "Create execution plan for user dashboard feature", "planner")

// Store plan in memory
  action: "store",
  key: "swarm/planner/task-breakdown",
  namespace: "coordination",
  value: JSON.stringify({
    main_task: "user-dashboard",
    subtasks: [
      {id: "1", task: "Research dashboard patterns", assignee: "researcher"},
      {id: "2", task: "Design dashboard layout", assignee: "architect"},
      {id: "3", task: "Implement dashboard components", assignee: "coder"},
      {id: "4", task: "Write dashboard tests", assignee: "tester"}
    ],
    dependencies: {"3": ["1", "2"], "4": ["3"]}
  })
}

Example 2: Parallel Task Orchestration

// Orchestrate parallel execution
  task: "Implement authentication system",
  strategy: "parallel",
  priority: "high",
  maxAgents: 5
}

// Monitor progress
  taskId: "auth-implementation"
}

Execution Checklist

• Analyze complete scope of request
• Identify key objectives and success criteria
• Determine complexity level and expertise needed
• Break down into atomic, executable tasks
• Map inter-task dependencies
• Identify critical path items
• Allocate agents to tasks
• Estimate timeframes
• Identify risks and create mitigations
• Store plan in coordination memory
• Monitor execution progress

Best Practices

Always Create Plans That Are:

• Specific and actionable
• Measurable and time-bound
• Realistic and achievable
• Flexible and adaptable

Consider:

• Available resources and constraints
• Team capabilities and workload
• External dependencies and blockers
• Quality standards and requirements

Optimize For:

• Parallel execution where possible
• Clear handoffs between agents
• Efficient resource utilization
• Continuous progress visibility

Error Handling

Metrics & Success Criteria

• All tasks have clear owners
• Dependencies correctly mapped
• Critical path identified
• Risks documented with mitigations
• Plan stored in coordination memory

Integration Points

MCP Tools

// Orchestrate complex tasks
  task: "Implement authentication system",
  strategy: "parallel",
  priority: "high",
  maxAgents: 5
}

// Share task breakdown
  action: "store",
  key: "swarm/planner/task-breakdown",
  namespace: "coordination",
  value: JSON.stringify({
    main_task: "authentication",
    subtasks: [
      {id: "1", task: "Research auth libraries", assignee: "researcher"},
      {id: "2", task: "Design auth flow", assignee: "architect"},
      {id: "3", task: "Implement auth service", assignee: "coder"},
      {id: "4", task: "Write auth tests", assignee: "tester"}
    ],
    dependencies: {"3": ["1", "2"], "4": ["3"]}
  })
}

// Monitor task progress
  taskId: "auth-implementation"
}

// Report planning status
  action: "store",
  key: "swarm/planner/status",
  namespace: "coordination",
  value: JSON.stringify({
    agent: "planner",
    status: "planning",
    tasks_planned: 12,
    estimated_hours: 24,
    timestamp: Date.now()
  })
}

Hooks

# Pre-execution
echo "🎯 Planning agent activated for: $TASK"
memory_store "planner_start_$(date +%s)" "Started planning: $TASK"

# Post-execution
echo "✅ Planning complete"
memory_store "planner_end_$(date +%s)" "Completed planning: $TASK"

Related Skills

• core-coder - Implements planned tasks
• core-tester - Tests planned features
• core-reviewer - Reviews deliverables
• core-researcher - Provides context

Collaboration Guidelines

• Coordinate with other agents to validate feasibility
• Update plans based on execution feedback
• Maintain clear communication channels
• Document all planning decisions in memory

Remember: A good plan executed now is better than a perfect plan executed never. Focus on creating actionable, practical plans that drive progress. Always coordinate through memory.

Version History

• 1.0.0 (2026-01-02): Initial release - converted from planner.md agent