claude-code-templates 1.20.3 → 1.21.1

package/cli-tool/components/commands/sync/sync-linear-to-issues.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [sync-scope] | --team | --project | --priority | --states
+description: Sync Linear tasks to GitHub issues with state mapping and attachment handling
+model: sonnet
+---
+
+# Sync Linear to Issues
+
+Sync Linear tasks to GitHub issues with comprehensive state and field mapping: **$ARGUMENTS**
+
+## Current Linear Context
+
+- Linear teams: Available teams and project assignments
+- Task count: Linear task query to determine scope
+- Target repository: !`gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || echo "No repo context"`
+- User mappings: Linear email to GitHub username correspondence
+
+## Task
+
+Execute comprehensive synchronization of Linear tasks to GitHub issues:
+
+**Sync Scope**: Use $ARGUMENTS to filter by Linear team, project, priority levels, or task states
+
+**Synchronization Framework**:
+1. **Task Discovery** - Query Linear tasks with filters, extract metadata, validate requirements, prioritize sync
+2. **State Mapping** - Transform Linear states to GitHub equivalents, handle priority conversion, map project assignments
+3. **Content Transformation** - Build GitHub issue body, preserve formatting, handle attachments, maintain structure
+4. **GitHub Integration** - Create issues with proper labels, assign users, set milestones, manage relationships
+5. **Attachment Migration** - Download Linear attachments, upload to GitHub, update references, maintain accessibility
+6. **Comment Synchronization** - Transfer comments with attribution, preserve context, handle mentions, maintain threading
+
+**Advanced Features**: Intelligent state mapping, attachment handling, comment threading, user mention translation, comprehensive validation.
+
+**Data Fidelity**: Preserve Linear formatting, maintain task relationships, keep timestamps, ensure reference integrity.
+
+**Output**: Complete synchronization results with created issues, attachment migrations, comment transfers, and comprehensive sync reporting.

package/cli-tool/components/commands/sync/sync-migration-assistant.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [migration-type] | --github-to-linear | --linear-to-github | --bidirectional | --validate
+description: Comprehensive migration assistant for large-scale GitHub-Linear data transitions with validation and rollback
+model: sonnet
+---
+
+# Sync Migration Assistant
+
+Execute comprehensive data migration between GitHub and Linear with enterprise-grade capabilities: **$ARGUMENTS**
+
+## Current Migration Environment
+
+- Source system: !`gh --version 2>/dev/null && echo "GitHub CLI available" || echo "GitHub CLI needed"`
+- Target system: Linear MCP server connectivity and authentication status
+- Migration scope: Analysis of data volume and complexity for planning
+- Infrastructure: Database, queue services, and processing capacity assessment
+
+## Task
+
+Implement large-scale data migration with comprehensive validation and enterprise features:
+
+**Migration Type**: Use $ARGUMENTS to specify GitHub-to-Linear, Linear-to-GitHub, bidirectional setup, or validation mode
+
+**Migration Framework**:
+1. **Pre-Migration Assessment** - Data volume analysis, dependency mapping, risk assessment, resource planning
+2. **Migration Planning** - Phased approach design, rollback strategy, validation checkpoints, timeline estimation
+3. **Data Extraction** - Comprehensive data harvesting, relationship preservation, metadata capture, error handling
+4. **Transformation Engine** - Field mapping, format conversion, validation rules, data enrichment
+5. **Migration Execution** - Batch processing, progress tracking, error recovery, quality assurance
+6. **Post-Migration Validation** - Data integrity verification, relationship validation, performance testing, rollback readiness
+
+**Enterprise Features**: Large-scale batch processing, comprehensive error recovery, detailed audit trails, rollback capabilities, performance optimization.
+
+**Quality Assurance**: Multi-stage validation, data integrity checks, relationship verification, comprehensive testing, enterprise monitoring.
+
+**Output**: Complete migration system with phased execution, comprehensive validation, detailed reporting, and enterprise-grade reliability for large-scale data transitions.

package/cli-tool/components/commands/sync/sync-pr-to-task.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [pr-number] | --task | --auto-detect | --enable-auto | --update-state
+description: Link GitHub pull requests to Linear tasks with automated state synchronization and workflow integration
+model: sonnet
+---
+
+# Sync PR to Task
+
+Link GitHub pull requests to Linear tasks with comprehensive workflow integration: **$ARGUMENTS**
+
+## Current PR Context
+
+- Repository: !`gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || echo "No repo context"`
+- PR details: Based on $ARGUMENTS PR number or auto-detection criteria
+- Linear references: Detection of task IDs in PR content and branch names
+- Webhook status: Current automation configuration for PR-task synchronization
+
+## Task
+
+Implement comprehensive pull request to Linear task linking with automated workflow integration:
+
+**PR Target**: Use $ARGUMENTS to specify PR number, task assignment, auto-detection mode, or automation configuration
+
+**Integration Framework**:
+1. **Reference Detection** - Extract Linear task IDs from PR title, body, branch names, commit messages
+2. **PR Analysis** - Fetch complete PR data, analyze state, review status, change metrics, timeline
+3. **State Synchronization** - Map PR states to Linear equivalents, handle review cycles, merge events
+4. **Task Updates** - Update Linear task status, add PR references, create comments, sync metadata
+5. **GitHub Enhancement** - Add Linear context to PR, create labels, post task summaries, maintain links
+6. **Workflow Automation** - Configure webhooks, enable real-time sync, implement event handlers, maintain consistency
+
+**Advanced Features**: Smart branch detection, automated state mapping, review integration, commit analysis, comprehensive validation.
+
+**Workflow Integration**: Real-time updates, bidirectional sync, event-driven automation, comprehensive monitoring.
+
+**Output**: Complete PR-task integration with automated synchronization, workflow enhancement, state management, and comprehensive relationship tracking.

package/cli-tool/components/commands/sync/sync-status.md

@@ -0,0 +1,391 @@
+---
+allowed-tools: Read, Bash
+argument-hint: [--detailed] | [--health-check] | [--diagnostics]
+description: Monitor GitHub-Linear sync health status with performance metrics and diagnostics
+model: sonnet
+---
+
+# Sync Status Monitor
+
+Monitor GitHub-Linear sync health: $ARGUMENTS
+
+## Current Sync State
+
+- Sync configuration: @.sync-config.json or @sync/ (if exists)
+- Recent sync logs: !`find . -name "*sync*.log" | head -3`
+- GitHub status: !`gh api rate_limit` (if GitHub CLI available)
+- Process status: !`ps aux | grep -i sync | head -3`
+
+## Task
+
+Analyze synchronization status between GitHub and Linear. When checking synchronization status:
+
+1. **Sync State Overview**
+   ```javascript
+   async function getSyncOverview() {
+     const state = await loadSyncState();
+     
+     return {
+       lastFullSync: state.lastFullSync,
+       lastIncrementalSync: state.lastIncremental,
+       totalSyncedItems: Object.keys(state.entities).length,
+       pendingSync: state.queue.length,
+       failedSync: state.failures.length,
+       syncEnabled: state.config.enabled,
+       syncDirection: state.config.direction,
+       webhooksActive: await checkWebhooks()
+     };
+   }
+   ```
+
+2. **Health Metrics**
+   ```javascript
+   const healthMetrics = {
+     // Performance metrics
+     avgSyncTime: calculateAverage(syncTimes),
+     maxSyncTime: Math.max(...syncTimes),
+     syncSuccessRate: (successful / total) * 100,
+     
+     // Data quality metrics
+     conflictRate: (conflicts / syncs) * 100,
+     duplicateRate: (duplicates / total) * 100,
+     orphanedItems: countOrphaned(),
+     
+     // API health
+     githubRateLimit: await getGitHubRateLimit(),
+     linearRateLimit: await getLinearRateLimit(),
+     apiErrors: recentErrors.length,
+     
+     // Sync lag
+     avgSyncLag: calculateSyncLag(),
+     maxSyncLag: findMaxLag(),
+     itemsOutOfSync: findOutOfSync().length
+   };
+   ```
+
+3. **Consistency Checks**
+   ```javascript
+   async function checkConsistency() {
+     const issues = [];
+     
+     // Check GitHub → Linear
+     const githubIssues = await fetchAllGitHubIssues();
+     for (const issue of githubIssues) {
+       const linearTask = await findLinearTask(issue);
+       if (!linearTask) {
+         issues.push({
+           type: 'MISSING_IN_LINEAR',
+           github: issue.number,
+           severity: 'high'
+         });
+       } else {
+         const diffs = compareFields(issue, linearTask);
+         if (diffs.length > 0) {
+           issues.push({
+             type: 'FIELD_MISMATCH',
+             github: issue.number,
+             linear: linearTask.identifier,
+             differences: diffs,
+             severity: 'medium'
+           });
+         }
+       }
+     }
+     
+     return issues;
+   }
+   ```
+
+4. **Sync History Analysis**
+   ```javascript
+   function analyzeSyncHistory(days = 7) {
+     const history = loadSyncHistory(days);
+     
+     return {
+       totalSyncs: history.length,
+       byType: groupBy(history, 'type'),
+       byDirection: groupBy(history, 'direction'),
+       successRate: calculateRate(history, 'success'),
+       
+       patterns: {
+         peakHours: findPeakSyncHours(history),
+         commonErrors: findCommonErrors(history),
+         slowestOperations: findSlowestOps(history)
+       },
+       
+       trends: {
+         syncVolume: calculateTrend(history, 'volume'),
+         errorRate: calculateTrend(history, 'errors'),
+         performance: calculateTrend(history, 'duration')
+       }
+     };
+   }
+   ```
+
+5. **Real-time Monitoring**
+   ```javascript
+   class SyncMonitor {
+     constructor() {
+       this.metrics = new Map();
+       this.alerts = [];
+     }
+     
+     track(operation) {
+       const start = Date.now();
+       
+       return {
+         complete: (success, details) => {
+           const duration = Date.now() - start;
+           this.metrics.set(operation.id, {
+             ...operation,
+             duration,
+             success,
+             details,
+             timestamp: new Date()
+           });
+           
+           // Check for alerts
+           if (duration > SLOW_SYNC_THRESHOLD) {
+             this.alert('SLOW_SYNC', operation);
+           }
+           if (!success) {
+             this.alert('SYNC_FAILURE', operation);
+           }
+         }
+       };
+     }
+   }
+   ```
+
+6. **Webhook Status**
+   ```bash
+   # Check GitHub webhooks
+   gh api repos/:owner/:repo/hooks --jq '.[] | select(.config.url | contains("linear"))'
+   
+   # Validate webhook health
+   gh api repos/:owner/:repo/hooks/:id/deliveries --jq '.[0:10] | .[] | {id, status_code, delivered_at}'
+   ```
+
+7. **Queue Management**
+   ```javascript
+   async function getQueueStatus() {
+     const queue = await loadSyncQueue();
+     
+     return {
+       size: queue.length,
+       oldest: queue[0]?.createdAt,
+       byPriority: groupBy(queue, 'priority'),
+       estimatedTime: estimateProcessingTime(queue),
+       
+       blocked: queue.filter(item => item.retries >= MAX_RETRIES),
+       processing: queue.filter(item => item.status === 'processing'),
+       pending: queue.filter(item => item.status === 'pending')
+     };
+   }
+   ```
+
+8. **Diagnostic Reports**
+   ```javascript
+   function generateDiagnostics() {
+     return {
+       systemInfo: {
+         version: SYNC_VERSION,
+         githubCLI: checkGitHubCLI(),
+         linearMCP: checkLinearMCP(),
+         config: loadSyncConfig()
+       },
+       
+       connectivity: {
+         github: testGitHubAPI(),
+         linear: testLinearAPI(),
+         webhooks: testWebhooks()
+       },
+       
+       dataIntegrity: {
+         orphanedGitHub: findOrphanedGitHubIssues(),
+         orphanedLinear: findOrphanedLinearTasks(),
+         duplicates: findDuplicates(),
+         conflicts: findConflicts()
+       },
+       
+       recommendations: generateRecommendations()
+     };
+   }
+   ```
+
+9. **Alert Configuration**
+   ```yaml
+   alerts:
+     - name: high_conflict_rate
+       condition: conflict_rate > 10%
+       severity: warning
+       action: notify
+     
+     - name: sync_failure
+       condition: success_rate < 95%
+       severity: critical
+       action: pause_sync
+     
+     - name: api_rate_limit
+       condition: rate_limit_remaining < 100
+       severity: warning
+       action: throttle
+   ```
+
+10. **Performance Visualization**
+    ```
+    Sync Performance (Last 24h)
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━
+    
+    Sync Volume:
+    00:00 ▁▁▂▁▁▁▂▃▄▅▆▇█▇▆▅▄▃▂▁▁▁▂▁ 23:59
+    
+    Success Rate: 98.5%
+    ████████████████████░ 
+    
+    Avg Duration: 2.3s
+    ████████░░░░░░░░░░░░ (Target: 5s)
+    ```
+
+## Examples
+
+### Basic Status Check
+```bash
+# Get current sync status
+claude sync-status
+
+# Detailed status with history
+claude sync-status --detailed
+
+# Check specific sync types
+claude sync-status --type="issue-to-linear"
+```
+
+### Health Monitoring
+```bash
+# Run health check
+claude sync-status --health-check
+
+# Continuous monitoring
+claude sync-status --monitor --interval=5m
+
+# Generate diagnostic report
+claude sync-status --diagnostics
+```
+
+### Troubleshooting
+```bash
+# Check for sync issues
+claude sync-status --check-issues
+
+# Verify specific items
+claude sync-status --verify="gh-123,ABC-456"
+
+# Queue management
+claude sync-status --queue --clear-failed
+```
+
+## Output Format
+
+```
+GitHub-Linear Sync Status
+=========================
+Last Updated: 2025-01-16 10:45:00
+
+Overview:
+✓ Sync Enabled: Bidirectional
+✓ Webhooks: Active (GitHub: ✓, Linear: ✓)
+✓ Last Full Sync: 2 hours ago
+✓ Last Activity: 5 minutes ago
+
+Statistics:
+- Total Synced Items: 1,234
+- Items in Queue: 3
+- Failed Items: 1
+
+Health Metrics:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Success Rate    █████████████████░░░ 96.5%
+Conflict Rate   ███░░░░░░░░░░░░░░░░  8.2%
+Sync Lag        ████░░░░░░░░░░░░░░░ ~2min
+
+API Status:
+- GitHub: 4,832/5,000 requests remaining
+- Linear: 1,245/1,500 requests remaining
+
+Recent Activity:
+10:44 ✓ Issue #123 → ABC-789 (1.2s)
+10:42 ✓ ABC-788 → Issue #122 (0.8s)
+10:40 ⚠ Issue #121 → Conflict detected
+10:38 ✓ PR #456 → ABC-787 linked
+
+Alerts:
+⚠ High conflict rate in last hour (12%)
+⚠ 1 item failed after max retries
+
+Recommendations:
+1. Review and resolve conflict for Issue #121
+2. Retry failed sync for ABC-456
+3. Consider increasing sync frequency
+```
+
+## Advanced Features
+
+### Sync Analytics Dashboard
+```
+═══════════════════════════════════════════════════════
+                 SYNC ANALYTICS DASHBOARD
+═══════════════════════════════════════════════════════
+
+Daily Sync Volume         │ Sync Types
+─────────────────────────┼─────────────────────────
+     150 ┤               │ Issues → Linear  45%
+     120 ┤    ╭─╮        │ Linear → Issues  30%
+      90 ┤   ╱  ╲        │ PR → Task        20%
+      60 ┤  ╱    ╲       │ Comments          5%
+      30 ┤ ╱      ╲___   │
+       0 └─────────────   │
+         Mon  Wed  Fri    │
+
+Error Distribution        │ Performance Trends
+─────────────────────────┼─────────────────────────
+Network      ████ 40%     │ Avg Time  ▂▄▆█▆▄▂ 2.3s
+Rate Limit   ███  30%     │ P95 Time  ▃▅▇█▇▅▃ 5.1s
+Conflicts    ██   20%     │ P99 Time  ▄▆███▆▄ 8.2s
+Other        █    10%     │
+```
+
+### Predictive Analysis
+```javascript
+function predictSyncIssues() {
+  const patterns = analyzeHistoricalData();
+  
+  return {
+    likelyConflicts: predictConflicts(patterns),
+    peakLoadTimes: predictPeakLoad(patterns),
+    rateLimitRisk: calculateRateLimitRisk(),
+    recommendations: {
+      optimalSyncInterval: calculateOptimalInterval(),
+      suggestedBatchSize: calculateOptimalBatch(),
+      conflictPrevention: suggestConflictStrategies()
+    }
+  };
+}
+```
+
+## Best Practices
+
+1. **Regular Monitoring**
+   - Set up automated health checks
+   - Review sync metrics daily
+   - Act on alerts promptly
+
+2. **Proactive Maintenance**
+   - Clear failed items regularly
+   - Optimize sync intervals
+   - Update conflict strategies
+
+3. **Documentation**
+   - Log all sync issues
+   - Document resolution steps
+   - Track performance trends

package/cli-tool/components/commands/sync/task-from-pr.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [pr-number] | --team | --estimate | --batch-process | --auto-create
+description: Create Linear tasks from GitHub pull requests with intelligent content extraction and task sizing
+model: sonnet
+---
+
+# Task from PR
+
+Create Linear tasks from GitHub pull requests with intelligent analysis: **$ARGUMENTS**
+
+## Current PR Environment
+
+- Repository: !`gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || echo "No repo context"`
+- PR status: Based on $ARGUMENTS PR number or batch processing criteria
+- Linear teams: Available teams for task assignment
+- User mappings: GitHub username to Linear user correspondence
+
+## Task
+
+Generate Linear tasks from GitHub pull requests with comprehensive content analysis:
+
+**PR Source**: Use $ARGUMENTS to specify PR number, team assignment, size estimation, or batch processing mode
+
+**Task Generation Framework**:
+1. **PR Analysis** - Extract comprehensive PR data, parse description structure, identify key components, analyze changes
+2. **Content Extraction** - Parse structured sections, extract checklists, identify technical details, capture requirements
+3. **Intelligent Sizing** - Estimate task complexity from code changes, file count, review comments, testing requirements
+4. **Task Construction** - Build Linear task with proper formatting, preserve PR context, maintain references, structure content
+5. **Team Assignment** - Map to appropriate Linear team, assign based on code areas, set priorities from labels
+6. **Validation & Creation** - Check for duplicates, validate task structure, create in Linear, establish bidirectional links
+
+**Advanced Features**: Smart content parsing, automated size estimation, intelligent team mapping, comprehensive validation, batch processing.
+
+**Quality Assurance**: Duplicate detection, content validation, proper formatting, relationship maintenance, comprehensive error handling.
+
+**Output**: Successfully created Linear tasks with comprehensive PR context, accurate sizing estimates, proper team assignments, and complete bidirectional linking.

package/cli-tool/components/commands/team/architecture-review.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Glob, Grep, Bash
+argument-hint: [scope] | --modules | --patterns | --dependencies | --security
+description: Comprehensive architecture review with design patterns analysis and improvement recommendations
+model: sonnet
+---
+
+# Architecture Review
+
+Perform comprehensive system architecture analysis and improvement planning: **$ARGUMENTS**
+
+## Current Architecture Context
+
+- Project structure: !`find . -name "*.js" -o -name "*.ts" -o -name "*.py" -o -name "*.go" | head -5 && echo "..."`
+- Package dependencies: !`[ -f package.json ] && echo "Node.js project" || [ -f requirements.txt ] && echo "Python project" || [ -f go.mod ] && echo "Go project" || echo "Multiple languages"`
+- Testing framework: !`find . -name "*.test.*" -o -name "*spec.*" | head -3 && echo "..." || echo "No test files found"`
+- Documentation: !`find . -name "README*" -o -name "*.md" | wc -l` documentation files
+
+## Task
+
+Execute comprehensive architectural analysis with actionable improvement recommendations:
+
+**Review Scope**: Use $ARGUMENTS to focus on specific modules, design patterns, dependency analysis, or security architecture
+
+**Architecture Analysis Framework**:
+1. **System Structure Assessment** - Map component hierarchy, identify architectural patterns, analyze module boundaries, assess layered design
+2. **Design Pattern Evaluation** - Identify implemented patterns, assess pattern consistency, detect anti-patterns, evaluate pattern effectiveness
+3. **Dependency Architecture** - Analyze coupling levels, detect circular dependencies, evaluate dependency injection, assess architectural boundaries
+4. **Data Flow Analysis** - Trace information flow, evaluate state management, assess data persistence strategies, validate transformation patterns
+5. **Scalability & Performance** - Analyze scaling capabilities, evaluate caching strategies, assess bottlenecks, review resource management
+6. **Security Architecture** - Review trust boundaries, assess authentication patterns, analyze authorization flows, evaluate data protection
+
+**Advanced Analysis**: Component testability, configuration management, error handling patterns, monitoring integration, extensibility assessment.
+
+**Quality Assessment**: Code organization, documentation adequacy, team communication patterns, technical debt evaluation.
+
+**Output**: Detailed architecture assessment with specific improvement recommendations, refactoring strategies, and implementation roadmap.

package/cli-tool/components/commands/team/decision-quality-analyzer.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [analysis-type] | --bias-detection | --scenario-testing | --process-optimization | --outcome-tracking
+description: Analyze team decision quality with bias detection, scenario testing, and process improvement recommendations
+model: sonnet
+---
+
+# Decision Quality Analyzer
+
+Analyze and improve team decision-making quality with comprehensive bias detection: **$ARGUMENTS**
+
+## Current Decision Context
+
+- Team size: !`git log --format='%ae' --since='1 month ago' | sort -u | wc -l` active contributors
+- Recent decisions: Major decisions from recent commits and discussions
+- Decision frequency: Pattern analysis of decision-making cadence
+- Process maturity: Current decision frameworks and methodologies in use
+
+## Task
+
+Execute comprehensive decision quality analysis with bias mitigation and process optimization:
+
+**Analysis Type**: Use $ARGUMENTS for bias detection, scenario testing, process optimization, or outcome tracking analysis
+
+**Decision Quality Framework**:
+1. **Process Quality Assessment** - Evaluate information gathering, stakeholder involvement, alternative generation, analysis rigor
+2. **Bias Detection Analysis** - Identify confirmation bias, anchoring bias, groupthink, authority bias, planning fallacy patterns
+3. **Outcome Evaluation** - Assess goal achievement, unintended consequences, stakeholder satisfaction, sustainability measures
+4. **Scenario Testing** - Historical decision analysis, hypothetical scenario testing, stress test scenarios, learning extraction
+5. **Timing Analysis** - Decision speed evaluation, information timing optimization, implementation coordination, review scheduling
+6. **Learning Integration** - Knowledge capture, institutional learning, process improvement, capability building
+
+**Advanced Features**: Multi-dimensional quality metrics, systematic bias mitigation strategies, decision simulation testing, predictive outcome modeling.
+
+**Process Optimization**: Stakeholder engagement frameworks, analytical tool integration, communication enhancement, cultural development strategies.
+
+**Output**: Comprehensive decision quality assessment with specific bias mitigation strategies, process improvements, and implementation roadmap.

package/cli-tool/components/commands/team/dependency-mapper.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Glob, Grep, Bash
+argument-hint: [scope] | --tasks | --code | --circular | --critical-path
+description: Map project and task dependencies with critical path analysis and circular dependency detection
+model: sonnet
+---
+
+# Dependency Mapper
+
+Map and analyze project dependencies with task ordering optimization: **$ARGUMENTS**
+
+## Current Dependency Context
+
+- Repository: !`gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || echo "No repo context"`
+- Project files: !`find . -name "*.js" -o -name "*.ts" -o -name "*.py" | wc -l` code files analyzed
+- Task tracking: Linear MCP server connectivity and task relationship data
+- Import analysis: Code dependency structure and circular dependency detection
+
+## Task
+
+Execute comprehensive dependency analysis with optimization recommendations:
+
+**Analysis Scope**: Use $ARGUMENTS to focus on task dependencies, code dependencies, circular dependency detection, or critical path analysis
+
+**Dependency Analysis Framework**:
+1. **Code Dependency Mapping** - Extract import statements, analyze module relationships, identify coupling levels, map file interdependencies
+2. **Task Relationship Analysis** - Query Linear task dependencies, extract task mentions, analyze project relationships, map epic structures
+3. **Dependency Graph Construction** - Build comprehensive graph structure, identify dependency chains, calculate critical paths, detect bottlenecks
+4. **Circular Dependency Detection** - Implement cycle detection algorithms, identify problematic loops, assess impact severity, recommend resolution strategies
+5. **Execution Order Optimization** - Calculate topological sort, optimize task sequence, balance team capacity, minimize blocking dependencies
+6. **Risk Assessment** - Identify high-risk chains, assess single points of failure, evaluate dependency complexity, recommend mitigation strategies
+
+**Advanced Features**: Visual dependency graphs, ASCII tree representations, impact analysis, sprint planning optimization, real-time dependency tracking.
+
+**Quality Insights**: Dependency health metrics, coupling analysis, maintainability assessment, team workload distribution.
+
+**Output**: Complete dependency analysis with visual representations, execution order recommendations, risk mitigation strategies, and optimization roadmap.