Initial commit
This commit is contained in:
Zhongwei Li
475
skills/dependency-orchestration/SKILL.md
Normal file
475
skills/dependency-orchestration/SKILL.md
Normal file
@@ -0,0 +1,475 @@
|
||||
---
|
||||
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
|
||||
Reference in New Issue
Block a user