# plan

> Strategic orchestration planning with multi-agent coordination analysis, workflow decomposition, and execution strategy design for complex cross-team initiatives

- Author: Nash Gao
- Repository: nashgao/mqtt-client
- Version: 20260210001543
- Stars: 3
- Forks: 1
- Last Updated: 2026-02-09
- Source: https://github.com/nashgao/mqtt-client
- Web: https://mule.run/skillshub/@@nashgao/mqtt-client~plan:20260210001543

---

---
allowed-tools: all
description: Strategic orchestration planning with multi-agent coordination analysis, workflow decomposition, and execution strategy design for complex cross-team initiatives
---

# 🔍🔍🔍 CRITICAL REQUIREMENT: ORCHESTRATION PLANNING PHASE! 🔍🔍🔍

**THIS IS NOT IMPLEMENTATION - THIS IS STRATEGIC ORCHESTRATION PLANNING!**

When you run `/orchestrate/plan`, you are REQUIRED to:

1. **ANALYZE** complete coordination scope and multi-agent complexity assessment
2. **DECOMPOSE** orchestration into strategic coordination phases and agent roles
3. **DESIGN** workflow patterns with inter-agent communication protocols
4. **CREATE** orchestration session structure and agent coordination templates
5. **USE MULTIPLE AGENTS** for comprehensive orchestration analysis:
   - Spawn one agent for scope analysis and workflow mapping
   - Spawn another for agent role definition and coordination patterns
   - Spawn more agents for dependency analysis and communication design
   - Say: "I'll spawn multiple agents to analyze this orchestration from different coordination perspectives"

## 🎯 USE MULTIPLE AGENTS

**MANDATORY AGENT SPAWNING FOR ORCHESTRATION COMPLEXITY:**
```
"I'll spawn multiple agents to handle comprehensive orchestration planning:
- Workflow Agent: Analyze coordination requirements and task dependencies
- Architecture Agent: Design agent roles and communication patterns
- Dependency Agent: Map inter-task dependencies and critical paths
- Communication Agent: Design coordination protocols and state synchronization
- Strategy Agent: Define orchestration execution phases and checkpoints"
```

## 🚨 FORBIDDEN BEHAVIORS

**NEVER:**
- ❌ Create implementation tasks → NO! Strategic orchestration planning only!
- ❌ "Let's start coordinating immediately" → NO! Planning before orchestration!
- ❌ Skip workflow analysis → NO! Full coordination understanding required!
- ❌ Use arbitrary agent assignments → NO! Research-based role design!
- ❌ Ignore communication patterns → NO! Map all inter-agent protocols!
- ❌ "We'll figure out coordination later" → NO! Comprehensive planning first!

**MANDATORY WORKFLOW:**
```
1. Orchestration scope analysis → Understand full coordination complexity
2. IMMEDIATELY spawn agents for parallel orchestration analysis
3. Strategic workflow decomposition → Break into coordination phases
4. Agent role design with communication protocols → Research-based assignment
5. Create orchestration session structure → Persistent coordination framework
6. VERIFY orchestration planning completeness and feasibility
```

**YOU ARE NOT DONE UNTIL:**
- ✅ Complete orchestration scope analyzed and documented
- ✅ Strategic coordination phases defined with clear boundaries
- ✅ Agent roles designed with communication protocols
- ✅ Workflow dependencies mapped with critical path analysis
- ✅ Orchestration session structure created with templates
- ✅ Coordination-specific configuration generated

---

🛑 **MANDATORY ORCHESTRATION PLANNING CHECK** 🛑
1. Re-read ~/.claude/CLAUDE.md RIGHT NOW
2. Check coordination requirements and existing orchestration patterns
3. Verify you understand scope requiring strategic orchestration planning

Execute comprehensive orchestration planning with ZERO tolerance for implementation shortcuts.

**FORBIDDEN SHORTCUT PATTERNS:**
- "Let's create basic coordination" → NO, strategic orchestration required
- "We can coordinate as we go" → NO, comprehensive planning first
- "Simple agent assignment is enough" → NO, protocol-aware design needed
- "One coordination template fits all" → NO, task-specific templates required
- "Skip communication design for now" → NO, protocol planning is critical

You are planning orchestration for: $ARGUMENTS

Let me ultrathink about the strategic orchestration architecture and coordination framework.

🚨 **REMEMBER: Strategic orchestration planning prevents coordination failures and deadlocks!** 🚨

**Comprehensive Orchestration Planning Protocol:**

**Step 0: Orchestration Scope Analysis**
- Analyze complete coordination requirements and success criteria
- Map functional and coordination dependencies comprehensively
- Identify technical constraints and communication boundaries
- Assess agent capabilities and resource availability
- Document coordination expectations and execution deadlines
- Review existing coordination patterns and architectural constraints

**Step 1: Strategic Workflow Decomposition**
- Break complex orchestration into logical coordination phases
- Ensure each phase delivers standalone coordination value
- Define clear completion criteria and synchronization points
- Map workflow interdependencies and critical coordination paths
- Validate phase scope fits manageable execution windows
- Identify phase-specific success metrics and coordination KPIs

**Step 2: Agent Role Design and Communication Protocols**

**Research-Based Agent Assignment Process:**
```
Agent role factors to analyze:
- Task complexity and specialization requirements
- Communication patterns and coordination frequency
- Resource dependencies and shared state management
- Failure recovery and redundancy requirements
- Performance constraints and execution boundaries
- Synchronization points and checkpoint requirements
```

**Communication Protocol Framework:**
```yaml
coordination_patterns:
  synchronous_patterns:
    - request_response: ["task-coordination", "status-queries"]
    - broadcast_sync: ["state-updates", "phase-transitions"]
    - consensus_based: ["decision-making", "conflict-resolution"]
  
  asynchronous_patterns:
    - event_driven: ["progress-updates", "completion-notifications"]
    - queue_based: ["task-distribution", "work-scheduling"]
    - publish_subscribe: ["status-broadcasting", "coordination-events"]
  
  state_management:
    - shared_state: ["coordination-context", "progress-tracking"]
    - session_state: ["execution-context", "resource-allocation"]
    - checkpoint_state: ["recovery-points", "rollback-capabilities"]
```

**Step 3: Orchestration Session Structure Creation**

**Generate Coordination-Specific Structure:**
```
.orchestration/
├── config/
│   ├── orchestration-config.yaml    # Coordination-specific configuration
│   ├── agent-roles.yaml             # Agent assignments and capabilities
│   ├── communication-protocols.yaml # Inter-agent communication design
│   └── workflow-definition.yaml     # Coordination workflow specification
├── planning/
│   ├── scope-analysis.md            # Detailed coordination scope breakdown
│   ├── workflow-decomposition.md    # Orchestration phase breakdown rationale
│   ├── agent-design.md              # Agent role and protocol design
│   └── coordination-requirements.md # Requirements traceability
├── templates/
│   ├── coordination-template.yaml   # Standard coordination structure
│   ├── agent-template.yaml          # Agent definition template
│   └── session-tracking.yaml        # Session measurement template
└── sessions/
    ├── session-001.yaml             # Ready for orchestration
    ├── session-002.yaml             # Planned next session
    └── coordination-state.yaml      # Active coordination tracking
```

**Step 4: Workflow Dependency Analysis and Critical Path Mapping**

**Comprehensive Dependency Analysis:**
```yaml
dependency_categories:
  task_dependencies:
    - sequential_dependencies:
        type: "blocking"
        examples: ["data-preparation → analysis → reporting"]
        coordination: "synchronous handoff"
    - parallel_dependencies:
        type: "concurrent"
        examples: ["ui-development || api-development"]
        coordination: "asynchronous with sync points"
  
  resource_dependencies:
    - shared_resources:
        type: "exclusive"
        examples: ["database-migration", "deployment-environment"]
        coordination: "resource locking protocol"
    - agent_capabilities:
        type: "specialization"
        examples: ["security-expert", "performance-specialist"]
        coordination: "capability-based routing"
  
  communication_dependencies:
    - data_flow:
        type: "information"
        examples: ["config → all-agents", "results → coordinator"]
        coordination: "publish-subscribe pattern"
    - control_flow:
        type: "coordination"
        examples: ["start-signal", "completion-checkpoint"]
        coordination: "event-driven orchestration"
```

**Step 5: Communication Protocol and State Synchronization Design**

**Protocol Design Framework:**
```yaml
# Generated based on coordination complexity and requirements
communication_design:
  synchronization_points:
    phase_transitions:
      protocol: "two-phase-commit"
      participants: ["all-agents"]
      timeout: "30s"
      rollback: "previous-checkpoint"
    
    progress_checkpoints:
      protocol: "heartbeat-based"
      frequency: "every-5-minutes"
      failure_detection: "3-missed-heartbeats"
      recovery: "agent-restart"
    
    completion_validation:
      protocol: "consensus-based"
      quorum: "majority"
      validation: "cross-agent-verification"
      finalization: "state-commitment"
  
  state_management:
    shared_context:
      storage: "coordination-session"
      access_pattern: "read-write-all"
      consistency: "eventual"
      
    agent_state:
      storage: "agent-specific"
      access_pattern: "exclusive-write"
      consistency: "strong"
      
    coordination_log:
      storage: "append-only"
      access_pattern: "write-all-read-coordinator"
      consistency: "sequential"
```

**Step 6: Multi-Agent Planning Execution**

**Agent Spawning Strategy for Complex Orchestration:**
```
"I'll coordinate specialized planning agents for comprehensive orchestration analysis:

1. **Workflow Analysis Agent**: 'Analyze coordination requirements and decompose into orchestration phases'
2. **Agent Design Agent**: 'Research optimal agent roles and communication patterns'
3. **Dependency Mapping Agent**: 'Map task dependencies and identify critical coordination paths'
4. **Protocol Design Agent**: 'Design inter-agent communication protocols and state management'
5. **Session Planning Agent**: 'Create orchestration-specific templates and session structures'

Each agent will provide detailed analysis for strategic orchestration planning."
```

**Planning Quality Checklist:**
- [ ] Orchestration scope fully analyzed and documented
- [ ] Coordination phases provide clear orchestration value
- [ ] Agent roles designed based on research and coordination patterns
- [ ] Dependencies mapped across task, resource, and communication domains
- [ ] Communication protocols designed with specific synchronization strategies
- [ ] Orchestration session structure created with coordination-specific templates
- [ ] Configuration files generated with appropriate orchestration parameters
- [ ] Planning documentation provides clear coordination implementation roadmap

**Orchestration Planning Anti-Patterns:**
- ❌ Creating coordination tasks during planning phase
- ❌ Designing agent roles without communication research
- ❌ Ignoring dependency complexity and coordination constraints
- ❌ Using generic templates without orchestration customization
- ❌ Skipping protocol design for "simple" coordination
- ❌ Planning orchestration without clear success criteria
- ❌ Creating agent assignments without capability analysis

**Final Planning Verification:**
Before completing orchestration planning:
- Have I analyzed the complete coordination scope?
- Are orchestration phases logical and valuable?
- Are agent roles research-based and protocol-aware?
- Have I mapped all critical coordination dependencies?
- Are communication protocols comprehensive with state management?
- Is the session structure orchestration-appropriate?
- Do templates match coordination requirements?

**Final Commitment:**
- **I will**: Execute comprehensive scope analysis before decomposition
- **I will**: Create strategic orchestration phases with clear coordination value
- **I will**: Use research-based agent role and protocol design methodology
- **I will**: Map dependencies across all coordination domains comprehensively
- **I will**: Generate orchestration-specific templates and configurations
- **I will NOT**: Create coordination tasks during planning
- **I will NOT**: Use arbitrary agent assignments or protocols
- **I will NOT**: Skip communication design or dependency mapping

**REMEMBER:**
This is ORCHESTRATION PLANNING mode - strategic analysis, workflow decomposition, and preparation for coordinated execution. The goal is to create a comprehensive coordination roadmap that enables successful multi-agent orchestration through well-planned coordination execution.

Executing strategic orchestration planning protocol for coordination success...