---
skill: dependency-orchestration
description: Advanced dependency analysis, critical path identification, bottleneck detection, and parallel opportunity discovery using MCP tool orchestration patterns.
---

# Dependency Orchestration Skill

Comprehensive dependency analysis and resolution strategies for optimizing task execution workflows through systematic MCP tool usage.

## When to Use This Skill

**Activate for:**
- "Analyze dependencies for feature X"
- "What's blocking task Y?"
- "Find bottlenecks in feature Z"
- "Show critical path"
- "Find parallel opportunities"
- "Resolve circular dependencies"

**This skill handles:**
- Systematic dependency analysis using query patterns
- Critical path identification through recursive queries
- Bottleneck detection by analyzing outgoing dependencies
- Parallel opportunity discovery
- Circular dependency detection
- Resolution strategy recommendations

## Tools Available

- `query_dependencies` - Query task dependencies
- `query_container` - Read tasks and features
- `manage_dependency` - Create/delete dependencies

## Core Workflows

### 1. Analyze Feature Dependencies

**Tool Orchestration Pattern:**

```
Step 1: Get all tasks in feature
query_container(operation="search", containerType="task", featureId="...")

Step 2: For each task, get dependencies
query_dependencies(taskId="...", direction="all", includeTaskInfo=true)

Step 3: Build dependency understanding
For each task, track:
- Incoming dependencies (what blocks this task)
- Outgoing dependencies (what this task blocks)
- Dependency status (complete/incomplete)

Step 4: Identify patterns
- Tasks with no incoming deps = can start immediately
- Tasks with many outgoing deps = potential bottlenecks
- Tasks blocked by incomplete deps = currently blocked
```

**Example:**

```
User: "Analyze dependencies for authentication feature"

Actions:
1. query_container(operation="search", containerType="task", featureId="auth-feature-id")
   Returns: 8 tasks

2. For each of 8 tasks:
   query_dependencies(taskId="...", direction="all", includeTaskInfo=true)

3. Analysis results:
   - 2 tasks have no incoming dependencies (can start now)
   - 1 task blocks 4 other tasks (BOTTLENECK)
   - 3 tasks are blocked by incomplete dependencies
   - 2 tasks are independent (can run in parallel)

4. Report:
   "Feature has 8 tasks with 1 critical bottleneck.
   Recommend completing 'Implement auth API' first (unblocks 4 tasks).
   2 tasks can start immediately in parallel."
```

### 2. Critical Path Identification

**Tool Orchestration Pattern:**

```
Step 1: Get all tasks
query_container(operation="search", containerType="task", featureId="...")

Step 2: Build dependency chains recursively
For each task with no outgoing dependencies (end tasks):
  Work backwards using incoming dependencies
  Track: task1 ← task2 ← task3 ← task4

Step 3: Calculate path lengths
Sum complexity values along each path

Step 4: Identify longest path
Path with highest total complexity = critical path

Step 5: Report findings
"Critical path: [tasks] with total complexity X"
```

**Example:**

```
User: "Show critical path for feature X"

Actions:
1. query_container(operation="search", containerType="task", featureId="...")
   Returns: Tasks T1, T2, T3, T4

2. For each task: query_dependencies(taskId="...", direction="incoming", includeTaskInfo=true)

3. Trace paths:
   Path A: T1 (complexity 5) → T2 (complexity 7) → T4 (complexity 5) = 17
   Path B: T3 (complexity 6) → T4 (complexity 5) = 11

4. Report:
   "Critical path: T1 → T2 → T4 (total complexity: 17, 68% of work)
   This path determines minimum feature completion time."
```

### 3. Bottleneck Detection

**Tool Orchestration Pattern:**

```
Step 1: Get all incomplete tasks
query_container(operation="search", containerType="task", featureId="...", status="pending,in-progress")

Step 2: For each task, count outgoing dependencies
query_dependencies(taskId="...", direction="outgoing", includeTaskInfo=true)
Count how many tasks are blocked by this task

Step 3: Identify high-impact tasks
Tasks blocking 3+ other tasks = HIGH impact bottleneck
Tasks blocking 2 other tasks = MEDIUM impact

Step 4: Prioritize by impact and status
- In-progress bottlenecks = highest priority (complete ASAP)
- Pending bottlenecks = high priority (start soon)
- Include task complexity in recommendations

Step 5: Report with actions
"Bottleneck: [Task X] blocks [N] tasks. Complete this first."
```

**Example:**

```
User: "Find bottlenecks in feature Y"

Actions:
1. query_container(operation="search", containerType="task", featureId="...", status="pending,in-progress")
   Returns: 6 active tasks

2. For each task: query_dependencies(taskId="...", direction="outgoing", includeTaskInfo=true)
   Results:
   - Task A: blocks 4 tasks (HIGH IMPACT)
   - Task B: blocks 2 tasks (MEDIUM IMPACT)
   - Task C-F: block 0-1 tasks (LOW IMPACT)

3. Report:
   "HIGH IMPACT BOTTLENECK:
   'Implement auth API' (in-progress, complexity 7) blocks 4 tasks.
   Recommend: Prioritize completion immediately.

   MEDIUM IMPACT:
   'Setup database' (pending, complexity 5) blocks 2 tasks.
   Recommend: Start after auth API."
```

### 4. Parallel Opportunity Discovery

**Tool Orchestration Pattern:**

```
Step 1: Get all pending tasks
query_container(operation="search", containerType="task", featureId="...", status="pending")

Step 2: For each task, check if unblocked
query_dependencies(taskId="...", direction="incoming", includeTaskInfo=true)
If all incoming dependencies are complete → task is ready

Step 3: Group ready tasks by domain
Using task tags, group by:
- database tasks
- backend tasks
- frontend tasks
- testing tasks

Step 4: Calculate parallelism benefit
Tasks in different domains = can run truly parallel
Sum complexity: serial vs parallel time savings

Step 5: Report opportunities
"Can run in parallel: [tasks] - saves X% time"
```

**Example:**

```
User: "Find parallel opportunities in feature Z"

Actions:
1. query_container(operation="search", containerType="task", featureId="...", status="pending")
   Returns: 5 pending tasks

2. For each: query_dependencies(taskId="...", direction="incoming", includeTaskInfo=true)
   Results:
   - T1 (Database): no incomplete dependencies (READY)
   - T2 (Backend): blocked by T5
   - T3 (Frontend): no incomplete dependencies (READY)
   - T4 (Tests): blocked by T2, T3
   - T5 (Backend): in-progress

3. Identify parallel group: T1 and T3
   - Different domains (database + frontend)
   - No interdependencies
   - Total complexity: 11
   - Parallel time: max(5, 6) = 6
   - Time saved: 5 units (45%)

4. Report:
   "Parallel opportunity: Run 'Database schema' and 'UI components' simultaneously.
   Saves 45% time (11 → 6 complexity units)."
```

### 5. Circular Dependency Detection

**Tool Orchestration Pattern:**

```
Step 1: Get all tasks
query_container(operation="search", containerType="task", featureId="...")

Step 2: For each task, trace dependency chain
query_dependencies(taskId="...", direction="outgoing", includeTaskInfo=true)
For each blocked task, recursively query its outgoing dependencies

Step 3: Track visited tasks
If you encounter a task already in current chain → circular dependency found

Step 4: Identify the cycle
Report: TaskA → TaskB → TaskC → TaskA

Step 5: Suggest resolution
Analyze which dependency is weakest/most recent
Recommend removal to break cycle
```

**Example:**

```
User: "Check for circular dependencies in feature W"

Actions:
1. query_container(operation="search", containerType="task", featureId="...")
   Returns: 6 tasks

2. For T1: query_dependencies(taskId="T1", direction="outgoing")
   T1 blocks T3

3. For T3: query_dependencies(taskId="T3", direction="outgoing")
   T3 blocks T5

4. For T5: query_dependencies(taskId="T5", direction="outgoing")
   T5 blocks T1 → CIRCULAR DEPENDENCY DETECTED!

5. Report:
   "⚠️ Circular dependency detected:
   T1 → T3 → T5 → T1

   Tasks involved:
   - T1: Implement API
   - T3: Add caching
   - T5: Update API for cache

   Resolution options:
   1. Remove T5 → T1 (most recent dependency)
   2. Reorder: Complete T1, then T5 won't need to depend on T1
   3. Split T5 into two tasks to break cycle"
```

### 6. Generate Resolution Strategy

**Tool Orchestration Pattern:**

```
Step 1: Identify blocked tasks
Use patterns from Workflow 1 and 3

Step 2: Prioritize bottlenecks
Use pattern from Workflow 3

Step 3: Find parallel opportunities
Use pattern from Workflow 4

Step 4: Create execution plan
Priority 1: Bottlenecks on critical path
Priority 2: High-impact bottlenecks off critical path
Priority 3: Tasks with parallel opportunities

Step 5: Report actionable strategy
"Execute in this order: [sequence] for optimal completion time"
```

**Example:**

```
User: "What's the best way to complete feature X?"

Actions:
1. Analyze dependencies (Workflow 1)
2. Find critical path (Workflow 2): T1 → T2 → T4
3. Find bottlenecks (Workflow 3): T2 blocks 4 tasks
4. Find parallel opportunities (Workflow 4): T1 and T3 can run parallel

5. Strategy:
   "Optimal execution strategy:

   Phase 1 (Parallel):
   - Start T1 (Database) and T3 (Frontend) simultaneously
   - These have no dependencies

   Phase 2 (Critical):
   - Start T2 (Backend API) after T1 completes
   - T2 is critical bottleneck blocking 4 tasks

   Phase 3 (Parallel):
   - After T2 completes, 4 tasks become available
   - Launch T4, T5, T6, T7 in parallel

   Expected benefit: 40% faster than sequential execution"
```

## Best Practices

### 1. Always Query Dependencies with includeTaskInfo

```
✅ Good:
query_dependencies(taskId="...", direction="all", includeTaskInfo=true)

❌ Bad:
query_dependencies(taskId="...")
```

**Reason:** You need task status to determine if dependencies are complete

### 2. Use Direction Parameter Appropriately

- `direction="incoming"` - Find what blocks this task (for unblocking analysis)
- `direction="outgoing"` - Find what this task blocks (for bottleneck analysis)
- `direction="all"` - Full picture (for comprehensive analysis)

### 3. Filter by Status for Relevance

```
✅ For active bottlenecks:
query_container(operation="search", containerType="task", status="pending,in-progress")

❌ Including completed tasks:
query_container(operation="search", containerType="task")
```

**Reason:** Completed tasks aren't bottlenecks

### 4. Consider Task Complexity in Analysis

- Critical path = sum of complexity values
- Bottleneck priority = (tasks_blocked × priority) - complexity
- Parallel benefit = sum_complexity - max_complexity

### 5. Report Actionable Recommendations

Don't just describe problems:
- ❌ "Task X has 5 dependencies"
- ✅ "Complete these 2 tasks to unblock Task X: [list]"

## Response Templates

### Dependency Analysis Summary
```
Dependency Analysis for "[Feature Name]":

Total Tasks: [N]
Tasks ready to start: [M] ([list])
Tasks blocked: [K] ([list with blocking tasks])

Bottlenecks:
- [Task A] blocks [X] tasks
- [Task B] blocks [Y] tasks

Recommendations:
1. Start [ready tasks] in parallel
2. Prioritize [bottleneck] completion
3. Monitor [blocked tasks] for automatic unblocking
```

### Critical Path Report
```
Critical Path Analysis:

Path: [T1] → [T2] → [T3] → [T4]
Total complexity: [N] ([X]% of all work)
Estimated time: [N] units

Parallel opportunities:
- [Tasks] can run alongside critical path
- Expected time savings: [X]%

Recommendation: Focus resources on critical path tasks
```

### Bottleneck Alert
```
⚠️ Bottleneck Detected:

Task: "[Task Name]"
Status: [status]
Complexity: [N]/10
Blocks: [M] tasks

Blocked tasks:
- [Task 1]
- [Task 2]
...

Action required: Prioritize completion of "[Task Name]" immediately
Impact: Unblocking this will enable [M] tasks to proceed
```

## Integration with Other Skills

**Works alongside:**
- **Dependency Analysis Skill** - Provides foundational blocked task queries
- **Task Orchestration Skill** - Uses this analysis for batching decisions
- **Feature Orchestration Skill** - Informs feature progress assessment

**Complements:**
- Planning Specialist subagent - Informs initial task breakdown
- Task completion workflows - Identifies cascade effects

## Token Efficiency

This skill is more token-intensive than others due to recursive querying:

- Simple dependency check: ~200 tokens
- Full feature analysis: ~800-1200 tokens
- Critical path analysis: ~400-600 tokens
- Bottleneck detection: ~300-500 tokens

**Optimization tips:**
- Use `status` filters to reduce task counts
- Query dependencies only for relevant tasks
- Cache results during analysis session
- Use `includeTaskInfo=true` once, reuse data

## Success Metrics

- 100% circular dependency detection
- Accurate critical path identification
- Bottleneck recommendations reduce completion time by 20-40%
- Parallel opportunity discovery achieves 30-50% time savings
- Zero false positives in blocking analysis

## See Also

- **Dependency Analysis Skill**: Basic dependency checking patterns
- **Task Orchestration Skill**: Applying dependency analysis to execution
- **examples.md**: Detailed usage scenarios