cc-mirror 1.0.3 → 1.1.0

package/dist/skills/multi-agent-orchestrator/references/project-management.md

@@ -0,0 +1,345 @@
+# Project Management Orchestration Patterns
+
+## Table of Contents
+1. [Epic Breakdown](#epic-breakdown)
+2. [Sprint Planning](#sprint-planning)
+3. [Progress Tracking](#progress-tracking)
+4. [Dependency Management](#dependency-management)
+5. [Team Coordination](#team-coordination)
+
+---
+
+## Epic Breakdown
+
+### Pattern: Hierarchical Decomposition
+
+```
+User Request: "Break down the authentication epic"
+
+Phase 1: EXPLORE
+└─ Explore agent: Understand requirements, existing system
+
+Phase 2: PLAN
+└─ Plan agent: Design high-level feature breakdown
+
+Phase 3: FAN-OUT (Parallel story creation)
+├─ Agent A: User stories for login/logout
+├─ Agent B: User stories for registration
+├─ Agent C: User stories for password management
+├─ Agent D: User stories for session management
+└─ Agent E: User stories for OAuth integration
+
+Phase 4: REDUCE
+└─ General-purpose agent: Organize into coherent backlog
+```
+
+**Task Management Implementation:**
+```
+# Create epic
+TaskCreate(subject="Epic: User Authentication", description="Complete auth system")
+
+# Create stories
+TaskCreate(subject="Story: Login flow", description="...")
+TaskCreate(subject="Story: Registration", description="...")
+TaskCreate(subject="Story: Password reset", description="...")
+
+# Set dependencies
+TaskUpdate(taskId="3", addBlockedBy=["2"])  # Reset after registration
+```
+
+### Pattern: Vertical Slice Breakdown
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Map feature touchpoints (UI, API, DB)
+
+Phase 2: FAN-OUT (Slice by user value)
+├─ Agent A: Define slice 1 (minimal viable feature)
+├─ Agent B: Define slice 2 (enhanced feature)
+└─ Agent C: Define slice 3 (complete feature)
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Estimate, prioritize, sequence
+```
+
+### Pattern: Spike-First Breakdown
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Identify unknowns and risks
+
+Phase 2: FAN-OUT (Parallel spikes)
+├─ Agent A: Technical spike - feasibility
+├─ Agent B: Technical spike - performance
+└─ Agent C: UX spike - user research
+
+Phase 3: REDUCE
+└─ General-purpose agent: Use spike findings to refine breakdown
+```
+
+---
+
+## Sprint Planning
+
+### Pattern: Capacity-Based Planning
+
+```
+User Request: "Plan the next sprint"
+
+Phase 1: FAN-OUT (Gather context)
+├─ Explore agent: Review backlog priority
+├─ Explore agent: Check team capacity
+├─ Explore agent: Review blockers and dependencies
+└─ Explore agent: Check carryover from last sprint
+
+Phase 2: REDUCE
+└─ Plan agent: Propose sprint scope
+
+Phase 3: FAN-OUT (Task breakdown)
+├─ Agent A: Break down story 1 into tasks
+├─ Agent B: Break down story 2 into tasks
+└─ Agent C: Break down story 3 into tasks
+
+Phase 4: PIPELINE
+└─ General-purpose agent: Finalize sprint backlog
+```
+
+**Task Structure:**
+```
+# Sprint-level task
+TaskCreate(subject="Sprint 14: Auth Implementation", description="...")
+
+# Stories within sprint
+TaskCreate(subject="Login API endpoint", description="...")
+TaskCreate(subject="Login UI component", description="...")
+TaskUpdate(taskId="2", addBlockedBy=["1"])  # UI needs API first
+
+# Sub-tasks
+TaskCreate(subject="Write login validation", description="...")
+TaskCreate(subject="Add rate limiting", description="...")
+```
+
+### Pattern: Risk-Adjusted Planning
+
+```
+Phase 1: FAN-OUT
+├─ Agent A: Identify technical risks
+├─ Agent B: Identify dependency risks
+└─ Agent C: Identify scope risks
+
+Phase 2: REDUCE
+└─ Plan agent: Adjust estimates with risk buffer
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Create contingency tasks
+```
+
+---
+
+## Progress Tracking
+
+### Pattern: Multi-Dimension Status
+
+```
+User Request: "What's the project status?"
+
+Phase 1: FAN-OUT (Parallel status gathering)
+├─ Agent A: Task completion status (from TaskList)
+├─ Agent B: Blocker analysis
+├─ Agent C: Timeline vs plan
+├─ Agent D: Quality metrics
+└─ Agent E: Risk status
+
+Phase 2: REDUCE
+└─ General-purpose agent: Executive status summary
+```
+
+**Using TaskList:**
+```
+# Get current state
+TaskList()  # Returns all tasks with status
+
+# Update progress
+TaskUpdate(taskId="5", addComment={
+  author: "agent-id",
+  content: "50% complete, blocked on API review"
+})
+
+# Mark complete
+TaskUpdate(taskId="5", status="resolved")
+```
+
+### Pattern: Burndown Tracking
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Calculate completed vs remaining work
+
+Phase 2: PIPELINE
+├─ General-purpose agent: Project completion trajectory
+├─ General-purpose agent: Identify velocity trends
+└─ General-purpose agent: Flag at-risk items
+
+Phase 3: REDUCE
+└─ General-purpose agent: Burndown report
+```
+
+### Pattern: Blocker Resolution
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Identify all blocked tasks
+
+Phase 2: FAN-OUT (Parallel resolution paths)
+├─ Agent A: Investigate blocker 1
+├─ Agent B: Investigate blocker 2
+└─ Agent C: Investigate blocker 3
+
+Phase 3: REDUCE
+└─ General-purpose agent: Resolution plan, escalation needs
+```
+
+---
+
+## Dependency Management
+
+### Pattern: Dependency Graph Construction
+
+```
+User Request: "Map project dependencies"
+
+Phase 1: EXPLORE
+└─ Explore agent: List all tasks and their relationships
+
+Phase 2: FAN-OUT
+├─ Agent A: Map technical dependencies
+├─ Agent B: Map team/resource dependencies
+└─ Agent C: Map external dependencies
+
+Phase 3: REDUCE
+└─ General-purpose agent: Dependency graph, critical path
+```
+
+**Implementation:**
+```
+# Create dependency chain
+TaskCreate(subject="Database schema", description="...")
+TaskCreate(subject="API models", description="...")
+TaskCreate(subject="API endpoints", description="...")
+TaskCreate(subject="Frontend integration", description="...")
+
+TaskUpdate(taskId="2", addBlockedBy=["1"])
+TaskUpdate(taskId="3", addBlockedBy=["2"])
+TaskUpdate(taskId="4", addBlockedBy=["3"])
+
+# Cross-team dependency
+TaskCreate(subject="External API access", description="Waiting on partner")
+TaskUpdate(taskId="3", addBlockedBy=["5"])  # Blocked by external
+```
+
+### Pattern: Critical Path Analysis
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Map all task dependencies
+
+Phase 2: PIPELINE
+├─ General-purpose agent: Calculate path lengths
+├─ General-purpose agent: Identify critical path
+└─ General-purpose agent: Find parallel opportunities
+
+Phase 3: REDUCE
+└─ General-purpose agent: Optimization recommendations
+```
+
+### Pattern: Dependency Resolution
+
+```
+Phase 1: FAN-OUT
+├─ Agent A: Identify circular dependencies
+├─ Agent B: Identify unnecessary dependencies
+└─ Agent C: Identify dependency bottlenecks
+
+Phase 2: PIPELINE
+└─ General-purpose agent: Restructure to unblock work
+```
+
+---
+
+## Team Coordination
+
+### Pattern: Work Distribution
+
+```
+User Request: "Assign work for this sprint"
+
+Phase 1: FAN-OUT
+├─ Explore agent: Analyze task requirements
+├─ Explore agent: Review team skills/capacity
+└─ Explore agent: Check current assignments
+
+Phase 2: REDUCE
+└─ Plan agent: Optimal assignment recommendations
+
+Phase 3: FAN-OUT (Parallel task assignment)
+├─ Agent A: Create task assignments for dev 1
+├─ Agent B: Create task assignments for dev 2
+└─ Agent C: Create task assignments for dev 3
+```
+
+### Pattern: Handoff Coordination
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Identify tasks requiring handoffs
+
+Phase 2: PIPELINE
+├─ General-purpose agent: Document handoff requirements
+├─ General-purpose agent: Create handoff checklist
+└─ General-purpose agent: Schedule coordination points
+```
+
+### Pattern: Multi-Team Sync
+
+```
+Phase 1: FAN-OUT
+├─ Agent A: Gather Team A status
+├─ Agent B: Gather Team B status
+└─ Agent C: Identify cross-team dependencies
+
+Phase 2: REDUCE
+└─ General-purpose agent: Cross-team status, blockers, needs
+```
+
+---
+
+## TodoWrite Integration
+
+For session-based project tracking:
+```
+TodoWrite([
+  {content: "Review current backlog", status: "in_progress", activeForm: "Reviewing backlog"},
+  {content: "Identify priorities", status: "pending", activeForm: "Identifying priorities"},
+  {content: "Break down into tasks", status: "pending", activeForm: "Breaking down tasks"},
+  {content: "Set dependencies", status: "pending", activeForm: "Setting dependencies"},
+  {content: "Assign and communicate", status: "pending", activeForm: "Assigning work"}
+])
+```
+
+## Task vs Todo Selection
+
+| Scenario | Use TaskCreate | Use TodoWrite |
+|----------|---------------|---------------|
+| Multi-session project | Yes | No |
+| Quick session work | No | Yes |
+| Team visibility needed | Yes | No |
+| Dependencies to track | Yes | Maybe |
+| Persistent record | Yes | No |
+
+## Best Practices
+
+1. **Break down early** - Large tasks are hard to track
+2. **Set dependencies explicitly** - Prevents blocked work
+3. **Update status frequently** - Real-time visibility
+4. **Comment on blockers** - Context for resolution
+5. **Close completed tasks immediately** - Accurate progress

package/dist/skills/multi-agent-orchestrator/references/research.md

@@ -0,0 +1,285 @@
+# Research Orchestration Patterns
+
+## Table of Contents
+1. [Codebase Exploration](#codebase-exploration)
+2. [Technical Investigation](#technical-investigation)
+3. [Dependency Analysis](#dependency-analysis)
+4. [Documentation Research](#documentation-research)
+5. [Competitive Analysis](#competitive-analysis)
+
+---
+
+## Codebase Exploration
+
+### Pattern: Breadth-First Discovery
+
+```
+User Request: "Help me understand this codebase"
+
+Phase 1: FAN-OUT (Parallel surface scan)
+├─ Explore agent: Project structure, entry points
+├─ Explore agent: Package.json/requirements/build files
+├─ Explore agent: README, docs folder
+└─ Explore agent: Test structure and patterns
+
+Phase 2: REDUCE
+└─ General-purpose agent: Synthesize codebase overview
+
+Phase 3: FAN-OUT (Deep dive areas of interest)
+├─ Explore agent: Deep dive area 1
+├─ Explore agent: Deep dive area 2
+└─ Explore agent: Deep dive area 3
+```
+
+### Pattern: Feature Tracing
+
+```
+User Request: "How does user authentication work?"
+
+Phase 1: EXPLORE
+└─ Explore agent: Find auth-related files (grep patterns)
+
+Phase 2: PIPELINE (Follow the flow)
+├─ Explore agent: Entry point (login route/component)
+├─ Explore agent: Middleware/validation layer
+├─ Explore agent: Session/token handling
+└─ Explore agent: Database/storage layer
+
+Phase 3: REDUCE
+└─ General-purpose agent: Document complete auth flow
+```
+
+### Pattern: Impact Analysis
+
+```
+User Request: "What would break if I change UserService?"
+
+Phase 1: EXPLORE
+└─ Explore agent: Find UserService definition and interface
+
+Phase 2: FAN-OUT
+├─ Explore agent: Find all imports of UserService
+├─ Explore agent: Find all usages of each method
+└─ Explore agent: Find tests depending on UserService
+
+Phase 3: REDUCE
+└─ General-purpose agent: Impact report with risk assessment
+```
+
+---
+
+## Technical Investigation
+
+### Pattern: Root Cause Analysis
+
+```
+User Request: "Why is the API slow?"
+
+Phase 1: FAN-OUT (Parallel hypothesis generation)
+├─ Explore agent: Check database query patterns
+├─ Explore agent: Check API middleware chain
+├─ Explore agent: Check external service calls
+└─ Explore agent: Check caching implementation
+
+Phase 2: REDUCE
+└─ General-purpose agent: Ranked hypotheses with evidence
+
+Phase 3: PIPELINE (Validate top hypothesis)
+└─ General-purpose agent: Instrument/test to confirm
+```
+
+### Pattern: Technology Evaluation
+
+```
+User Request: "Should we use Redis or Memcached?"
+
+Phase 1: FAN-OUT (Parallel research)
+├─ Agent A (WebSearch): Redis features, use cases, benchmarks
+├─ Agent B (WebSearch): Memcached features, use cases, benchmarks
+└─ Explore agent: Current caching patterns in codebase
+
+Phase 2: REDUCE
+└─ Plan agent: Comparison matrix, recommendation with rationale
+```
+
+### Pattern: Bug Archaeology
+
+```
+User Request: "When did this bug get introduced?"
+
+Phase 1: EXPLORE
+└─ Explore agent: Identify relevant files and functions
+
+Phase 2: BACKGROUND
+└─ Background agent: Git bisect or log analysis
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Timeline of changes, root cause commit
+```
+
+---
+
+## Dependency Analysis
+
+### Pattern: Dependency Graph
+
+```
+User Request: "Map all dependencies for the auth module"
+
+Phase 1: EXPLORE
+└─ Explore agent: Find auth module entry points
+
+Phase 2: FAN-OUT (Parallel tracing)
+├─ Explore agent: Trace internal dependencies
+├─ Explore agent: Trace external package dependencies
+└─ Explore agent: Trace database/service dependencies
+
+Phase 3: REDUCE
+└─ General-purpose agent: Dependency graph visualization
+```
+
+### Pattern: Upgrade Impact
+
+```
+User Request: "What happens if we upgrade lodash?"
+
+Phase 1: FAN-OUT
+├─ Explore agent: Find all lodash usages
+├─ Agent (WebSearch): lodash changelog, breaking changes
+└─ Explore agent: Find tests covering lodash functionality
+
+Phase 2: REDUCE
+└─ General-purpose agent: Impact assessment, migration guide
+```
+
+### Pattern: Dead Code Detection
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Build export/import graph
+
+Phase 2: FAN-OUT
+├─ Explore agent: Find unreferenced exports
+├─ Explore agent: Find unused internal functions
+└─ Explore agent: Find commented/disabled code
+
+Phase 3: REDUCE
+└─ General-purpose agent: Dead code report with safe removal list
+```
+
+---
+
+## Documentation Research
+
+### Pattern: API Discovery
+
+```
+User Request: "Document all API endpoints"
+
+Phase 1: EXPLORE
+└─ Explore agent: Find route definitions (express routes, decorators, etc.)
+
+Phase 2: MAP (Per endpoint)
+├─ Agent A: Document endpoint group 1 (params, responses)
+├─ Agent B: Document endpoint group 2
+└─ Agent C: Document endpoint group 3
+
+Phase 3: REDUCE
+└─ General-purpose agent: Unified API documentation
+```
+
+### Pattern: Cross-Reference
+
+```
+User Request: "Find all documentation for the payment system"
+
+Phase 1: FAN-OUT
+├─ Explore agent: Search code comments
+├─ Explore agent: Search markdown files
+├─ Explore agent: Search wiki/confluence (if accessible)
+└─ Explore agent: Search inline JSDoc/docstrings
+
+Phase 2: REDUCE
+└─ General-purpose agent: Consolidated documentation index
+```
+
+---
+
+## Competitive Analysis
+
+### Pattern: Feature Comparison
+
+```
+User Request: "Compare our auth to Auth0"
+
+Phase 1: FAN-OUT
+├─ Explore agent: Document our auth capabilities
+├─ Agent (WebSearch): Auth0 features and pricing
+└─ Agent (WebSearch): Auth0 limitations and reviews
+
+Phase 2: REDUCE
+└─ Plan agent: Feature matrix, gap analysis
+```
+
+### Pattern: Best Practices Research
+
+```
+User Request: "What are best practices for rate limiting?"
+
+Phase 1: FAN-OUT
+├─ Agent (WebSearch): Industry rate limiting patterns
+├─ Agent (WebSearch): Framework-specific implementations
+├─ Explore agent: Current rate limiting in codebase
+└─ Agent (WebSearch): Case studies and failure modes
+
+Phase 2: REDUCE
+└─ General-purpose agent: Best practices guide with recommendations
+```
+
+---
+
+## Research Output Formats
+
+### Investigation Report Template
+
+```markdown
+## Question
+[Original question/request]
+
+## Summary
+[1-2 sentence answer]
+
+## Evidence
+1. [Finding 1 with file:line references]
+2. [Finding 2 with file:line references]
+
+## Analysis
+[Interpretation of evidence]
+
+## Recommendations
+1. [Actionable recommendation]
+
+## Open Questions
+- [What wasn't answered]
+```
+
+### TodoWrite for Research
+
+```
+TodoWrite([
+  {content: "Define research scope and questions", status: "in_progress", activeForm: "Defining scope"},
+  {content: "Gather relevant sources and code", status: "pending", activeForm: "Gathering sources"},
+  {content: "Analyze findings", status: "pending", activeForm: "Analyzing findings"},
+  {content: "Synthesize conclusions", status: "pending", activeForm: "Synthesizing conclusions"},
+  {content: "Document recommendations", status: "pending", activeForm: "Documenting recommendations"}
+])
+```
+
+## Agent Selection for Research
+
+| Research Type | Primary Agent | Secondary Agents |
+|---------------|---------------|------------------|
+| Codebase questions | Explore | General-purpose for synthesis |
+| External research | WebSearch-enabled | Explore for local context |
+| Architecture | Plan | Explore for discovery |
+| Impact analysis | Explore (parallel) | General-purpose for aggregation |