@monoes/monomindcli 1.10.54 → 1.10.55

package/.claude/skills/github-project-management/SKILL.md

@@ -1,1245 +0,0 @@
----
-name: github-project-management
-description: |
-  Comprehensive GitHub project management with swarm-coordinated issue tracking, project board automation, and sprint planning
-allowed-tools: "mcp__github__*, mcp__monomind__*, Bash, Read, Write, TodoWrite"
----
-
-# GitHub Project Management
-
-## Overview
-
-A comprehensive skill for managing GitHub projects using AI swarm coordination. This skill combines intelligent issue management, automated project board synchronization, and swarm-based coordination for efficient project delivery.
-
-## Quick Start
-
-### Basic Issue Creation with Swarm Coordination
-
-```bash
-# Create a coordinated issue
-gh issue create \
-  --title "Feature: Advanced Authentication" \
-  --body "Implement OAuth2 with social login..." \
-  --label "enhancement,swarm-ready"
-
-# Initialize swarm for issue
-npx monomind@alpha hooks pre-task --description "Feature implementation"
-```
-
-### Project Board Quick Setup
-
-```bash
-# Get project ID
-PROJECT_ID=$(gh project list --owner @me --format json | \
-  jq -r '.projects[0].id')
-
-# Initialize board sync
-npx monomind github board-init \
-  --project-id "$PROJECT_ID" \
-  --sync-mode "bidirectional"
-
-# Note: Use the gh CLI for GitHub project management and monomind swarm commands for agent coordination
-```
-
----
-
-## Core Capabilities
-
-### 1. Issue Management & Triage
-
-<details>
-<summary><strong>Automated Issue Creation</strong></summary>
-
-#### Single Issue with Swarm Coordination
-
-```javascript
-// Initialize issue management swarm
-mcp__monomind__swarm_init { topology: "star", maxAgents: 3 }
-mcp__monomind__agent_spawn { type: "coordinator", name: "Issue Coordinator" }
-mcp__monomind__agent_spawn { type: "researcher", name: "Requirements Analyst" }
-mcp__monomind__agent_spawn { type: "coder", name: "Implementation Planner" }
-
-// Create comprehensive issue
-mcp__github__create_issue {
-  owner: "org",
-  repo: "repository",
-  title: "Integration Review: Complete system integration",
-  body: `## Integration Review
-
-  ### Overview
-  Comprehensive review and integration between components.
-
-  ### Objectives
-  - [ ] Verify dependencies and imports
-  - [ ] Ensure API integration
-  - [ ] Check hook system integration
-  - [ ] Validate data systems alignment
-
-  ### Swarm Coordination
-  This issue will be managed by coordinated swarm agents for optimal progress tracking.`,
-  labels: ["integration", "review", "enhancement"],
-  assignees: ["username"]
-}
-
-// Set up automated tracking via Task tool
-Task("Progress Monitor", "Monitor and coordinate issue progress with automated updates", "coordinator")
-```
-
-#### Batch Issue Creation
-
-```bash
-# Create multiple related issues using gh CLI
-gh issue create \
-  --title "Feature: Advanced GitHub Integration" \
-  --body "Implement comprehensive GitHub workflow automation..." \
-  --label "feature,github,high-priority"
-
-gh issue create \
-  --title "Bug: Merge conflicts in integration branch" \
-  --body "Resolve merge conflicts..." \
-  --label "bug,integration,urgent"
-
-gh issue create \
-  --title "Documentation: Update integration guides" \
-  --body "Update all documentation..." \
-  --label "documentation,integration"
-```
-
-</details>
-
-<details>
-<summary><strong>Issue-to-Swarm Conversion</strong></summary>
-
-#### Transform Issues into Swarm Tasks
-
-```bash
-# Get issue details
-ISSUE_DATA=$(gh issue view 456 --json title,body,labels,assignees,comments)
-
-# Create swarm from issue
-npx monomind github issue-to-swarm 456 \
-  --issue-data "$ISSUE_DATA" \
-  --auto-decompose \
-  --assign-agents
-
-# Batch process multiple issues
-ISSUES=$(gh issue list --label "swarm-ready" --json number,title,body,labels)
-npx monomind github issues-batch \
-  --issues "$ISSUES" \
-  --parallel
-
-# Update issues with swarm status
-echo "$ISSUES" | jq -r '.[].number' | while read -r num; do
-  gh issue edit $num --add-label "swarm-processing"
-done
-```
-
-#### Issue Comment Commands
-
-Execute swarm operations via issue comments:
-
-```markdown
-<!-- In issue comment -->
-/swarm analyze
-/swarm decompose 5
-/swarm assign @agent-coder
-/swarm estimate
-/swarm start
-```
-
-</details>
-
-<details>
-<summary><strong>Automated Issue Triage</strong></summary>
-
-#### Auto-Label Based on Content
-
-```javascript
-// .github/swarm-labels.json
-{
-  "rules": [
-    {
-      "keywords": ["bug", "error", "broken"],
-      "labels": ["bug", "swarm-debugger"],
-      "agents": ["debugger", "tester"]
-    },
-    {
-      "keywords": ["feature", "implement", "add"],
-      "labels": ["enhancement", "swarm-feature"],
-      "agents": ["architect", "coder", "tester"]
-    },
-    {
-      "keywords": ["slow", "performance", "optimize"],
-      "labels": ["performance", "swarm-optimizer"],
-      "agents": ["analyst", "optimizer"]
-    }
-  ]
-}
-```
-
-#### Automated Triage System
-
-```bash
-# Analyze and triage unlabeled issues
-npx monomind github triage \
-  --unlabeled \
-  --analyze-content \
-  --suggest-labels \
-  --assign-priority
-
-# Find and link duplicate issues
-npx monomind github find-duplicates \
-  --threshold 0.8 \
-  --link-related \
-  --close-duplicates
-```
-
-</details>
-
-<details>
-<summary><strong>Task Decomposition & Progress Tracking</strong></summary>
-
-#### Break Down Issues into Subtasks
-
-```bash
-# Get issue body
-ISSUE_BODY=$(gh issue view 456 --json body --jq '.body')
-
-# Decompose into subtasks
-SUBTASKS=$(npx monomind github issue-decompose 456 \
-  --body "$ISSUE_BODY" \
-  --max-subtasks 10 \
-  --assign-priorities)
-
-# Update issue with checklist
-CHECKLIST=$(echo "$SUBTASKS" | jq -r '.tasks[] | "- [ ] " + .description')
-UPDATED_BODY="$ISSUE_BODY
-
-## Subtasks
-$CHECKLIST"
-
-gh issue edit 456 --body "$UPDATED_BODY"
-
-# Create linked issues for major subtasks
-echo "$SUBTASKS" | jq -r '.tasks[] | select(.priority == "high")' | while read -r task; do
-  TITLE=$(echo "$task" | jq -r '.title')
-  BODY=$(echo "$task" | jq -r '.description')
-
-  gh issue create \
-    --title "$TITLE" \
-    --body "$BODY
-
-Parent issue: #456" \
-    --label "subtask"
-done
-```
-
-#### Automated Progress Updates
-
-```bash
-# Get current issue state
-CURRENT=$(gh issue view 456 --json body,labels)
-
-# Get swarm progress
-PROGRESS=$(npx monomind github issue-progress 456)
-
-# Update checklist in issue body
-UPDATED_BODY=$(echo "$CURRENT" | jq -r '.body' | \
-  npx monomind github update-checklist --progress "$PROGRESS")
-
-# Edit issue with updated body
-gh issue edit 456 --body "$UPDATED_BODY"
-
-# Post progress summary as comment
-SUMMARY=$(echo "$PROGRESS" | jq -r '
-"## Progress Update
-
-**Completion**: \(.completion)%
-**ETA**: \(.eta)
-
-### Completed Tasks
-\(.completed | map("- [done] " + .) | join("\n"))
-
-### In Progress
-\(.in_progress | map("- [active] " + .) | join("\n"))
-
-### Remaining
-\(.remaining | map("- [pending] " + .) | join("\n"))
-
----
-Automated update by swarm agent"')
-
-gh issue comment 456 --body "$SUMMARY"
-
-# Update labels based on progress
-if [[ $(echo "$PROGRESS" | jq -r '.completion') -eq 100 ]]; then
-  gh issue edit 456 --add-label "ready-for-review" --remove-label "in-progress"
-fi
-```
-
-</details>
-
-<details>
-<summary><strong>Stale Issue Management</strong></summary>
-
-#### Auto-Close Stale Issues with Swarm Analysis
-
-```bash
-# Find stale issues
-STALE_DATE=$(date -d '30 days ago' --iso-8601)
-STALE_ISSUES=$(gh issue list --state open --json number,title,updatedAt,labels \
-  --jq ".[] | select(.updatedAt < \"$STALE_DATE\")")
-
-# Analyze each stale issue
-echo "$STALE_ISSUES" | jq -r '.number' | while read -r num; do
-  # Get full issue context
-  ISSUE=$(gh issue view $num --json title,body,comments,labels)
-
-  # Analyze with swarm
-  ACTION=$(npx monomind github analyze-stale \
-    --issue "$ISSUE" \
-    --suggest-action)
-
-  case "$ACTION" in
-    "close")
-      gh issue comment $num --body "This issue has been inactive for 30 days and will be closed in 7 days if there's no further activity."
-      gh issue edit $num --add-label "stale"
-      ;;
-    "keep")
-      gh issue edit $num --remove-label "stale" 2>/dev/null || true
-      ;;
-    "needs-info")
-      gh issue comment $num --body "This issue needs more information. Please provide additional context or it may be closed as stale."
-      gh issue edit $num --add-label "needs-info"
-      ;;
-  esac
-done
-
-# Close issues that have been stale for 37+ days
-gh issue list --label stale --state open --json number,updatedAt \
-  --jq ".[] | select(.updatedAt < \"$(date -d '37 days ago' --iso-8601)\") | .number" | \
-  while read -r num; do
-    gh issue close $num --comment "Closing due to inactivity. Feel free to reopen if this is still relevant."
-  done
-```
-
-</details>
-
-### 2. Project Board Automation
-
-<details>
-<summary><strong>Board Initialization & Configuration</strong></summary>
-
-#### Connect Swarm to GitHub Project
-
-```bash
-# Get project details
-PROJECT_ID=$(gh project list --owner @me --format json | \
-  jq -r '.projects[] | select(.title == "Development Board") | .id')
-
-# Initialize swarm with project
-npx monomind github board-init \
-  --project-id "$PROJECT_ID" \
-  --sync-mode "bidirectional" \
-  --create-views "swarm-status,agent-workload,priority"
-
-# Create project fields for swarm tracking
-gh project field-create $PROJECT_ID --owner @me \
-  --name "Swarm Status" \
-  --data-type "SINGLE_SELECT" \
-  --single-select-options "pending,in_progress,completed"
-```
-
-#### Board Mapping Configuration
-
-```yaml
-# .github/board-sync.yml
-version: 1
-project:
-  name: "AI Development Board"
-  number: 1
-
-mapping:
-  # Map swarm task status to board columns
-  status:
-    pending: "Backlog"
-    assigned: "Ready"
-    in_progress: "In Progress"
-    review: "Review"
-    completed: "Done"
-    blocked: "Blocked"
-
-  # Map agent types to labels
-  agents:
-    coder: "Development"
-    tester: "Testing"
-    analyst: "Analysis"
-    designer: "Design"
-    architect: "Architecture"
-
-  # Map priority to project fields
-  priority:
-    critical: "Critical"
-    high: "High"
-    medium: "Medium"
-    low: "Low"
-
-  # Custom fields
-  fields:
-    - name: "Agent Count"
-      type: number
-      source: task.agents.length
-    - name: "Complexity"
-      type: select
-      source: task.complexity
-    - name: "ETA"
-      type: date
-      source: task.estimatedCompletion
-```
-
-</details>
-
-<details>
-<summary><strong>Task Synchronization</strong></summary>
-
-#### Real-time Board Sync
-
-```bash
-# Sync swarm tasks with project cards
-npx monomind github board-sync \
-  --map-status '{
-    "todo": "To Do",
-    "in_progress": "In Progress",
-    "review": "Review",
-    "done": "Done"
-  }' \
-  --auto-move-cards \
-  --update-metadata
-
-# Enable real-time board updates
-npx monomind github board-realtime \
-  --webhook-endpoint "https://api.example.com/github-sync" \
-  --update-frequency "immediate" \
-  --batch-updates false
-```
-
-#### Convert Issues to Project Cards
-
-```bash
-# List issues with label
-ISSUES=$(gh issue list --label "enhancement" --json number,title,body)
-
-# Add issues to project
-echo "$ISSUES" | jq -r '.[].number' | while read -r issue; do
-  gh project item-add $PROJECT_ID --owner @me --url "https://github.com/$GITHUB_REPOSITORY/issues/$issue"
-done
-
-# Process with swarm
-npx monomind github board-import-issues \
-  --issues "$ISSUES" \
-  --add-to-column "Backlog" \
-  --parse-checklist \
-  --assign-agents
-```
-
-</details>
-
-<details>
-<summary><strong>Smart Card Management</strong></summary>
-
-#### Auto-Assignment
-
-```bash
-# Automatically assign cards to agents
-npx monomind github board-auto-assign \
-  --strategy "load-balanced" \
-  --consider "expertise,workload,availability" \
-  --update-cards
-```
-
-#### Intelligent Card State Transitions
-
-```bash
-# Smart card movement based on rules
-npx monomind github board-smart-move \
-  --rules '{
-    "auto-progress": "when:all-subtasks-done",
-    "auto-review": "when:tests-pass",
-    "auto-done": "when:pr-merged"
-  }'
-```
-
-#### Bulk Operations
-
-```bash
-# Bulk card operations
-npx monomind github board-bulk \
-  --filter "status:blocked" \
-  --action "add-label:needs-attention" \
-  --notify-assignees
-```
-
-</details>
-
-<details>
-<summary><strong>Custom Views & Dashboards</strong></summary>
-
-#### View Configuration
-
-```javascript
-// Custom board views
-{
-  "views": [
-    {
-      "name": "Swarm Overview",
-      "type": "board",
-      "groupBy": "status",
-      "filters": ["is:open"],
-      "sort": "priority:desc"
-    },
-    {
-      "name": "Agent Workload",
-      "type": "table",
-      "groupBy": "assignedAgent",
-      "columns": ["title", "status", "priority", "eta"],
-      "sort": "eta:asc"
-    },
-    {
-      "name": "Sprint Progress",
-      "type": "roadmap",
-      "dateField": "eta",
-      "groupBy": "milestone"
-    }
-  ]
-}
-```
-
-#### Dashboard Configuration
-
-```javascript
-// Dashboard with performance widgets
-{
-  "dashboard": {
-    "widgets": [
-      {
-        "type": "chart",
-        "title": "Task Completion Rate",
-        "data": "completed-per-day",
-        "visualization": "line"
-      },
-      {
-        "type": "gauge",
-        "title": "Sprint Progress",
-        "data": "sprint-completion",
-        "target": 100
-      },
-      {
-        "type": "heatmap",
-        "title": "Agent Activity",
-        "data": "agent-tasks-per-day"
-      }
-    ]
-  }
-}
-```
-
-</details>
-
-### 3. Sprint Planning & Tracking
-
-<details>
-<summary><strong>Sprint Management</strong></summary>
-
-#### Initialize Sprint with Swarm Coordination
-
-```bash
-# Manage sprints with swarms
-npx monomind github sprint-manage \
-  --sprint "Sprint 23" \
-  --auto-populate \
-  --capacity-planning \
-  --track-velocity
-
-# Track milestone progress
-npx monomind github milestone-track \
-  --milestone "v2.0 Release" \
-  --update-board \
-  --show-dependencies \
-  --predict-completion
-```
-
-#### Agile Development Board Setup
-
-```bash
-# Setup agile board
-npx monomind github agile-board \
-  --methodology "scrum" \
-  --sprint-length "2w" \
-  --ceremonies "planning,review,retro" \
-  --metrics "velocity,burndown"
-```
-
-#### Kanban Flow Board Setup
-
-```bash
-# Setup kanban board
-npx monomind github kanban-board \
-  --wip-limits '{
-    "In Progress": 5,
-    "Review": 3
-  }' \
-  --cycle-time-tracking \
-  --continuous-flow
-```
-
-</details>
-
-<details>
-<summary><strong>Progress Tracking & Analytics</strong></summary>
-
-#### Board Analytics
-
-```bash
-# Fetch project data
-PROJECT_DATA=$(gh project item-list $PROJECT_ID --owner @me --format json)
-
-# Get issue metrics
-ISSUE_METRICS=$(echo "$PROJECT_DATA" | jq -r '.items[] | select(.content.type == "Issue")' | \
-  while read -r item; do
-    ISSUE_NUM=$(echo "$item" | jq -r '.content.number')
-    gh issue view $ISSUE_NUM --json createdAt,closedAt,labels,assignees
-  done)
-
-# Generate analytics with swarm
-npx monomind github board-analytics \
-  --project-data "$PROJECT_DATA" \
-  --issue-metrics "$ISSUE_METRICS" \
-  --metrics "throughput,cycle-time,wip" \
-  --group-by "agent,priority,type" \
-  --time-range "30d" \
-  --export "dashboard"
-```
-
-#### Performance Reports
-
-```bash
-# Track and visualize progress
-npx monomind github board-progress \
-  --show "burndown,velocity,cycle-time" \
-  --time-period "sprint" \
-  --export-metrics
-
-# Generate reports
-npx monomind github board-report \
-  --type "sprint-summary" \
-  --format "markdown" \
-  --include "velocity,burndown,blockers" \
-  --distribute "slack,email"
-```
-
-#### KPI Tracking
-
-```bash
-# Track board performance
-npx monomind github board-kpis \
-  --metrics '[
-    "average-cycle-time",
-    "throughput-per-sprint",
-    "blocked-time-percentage",
-    "first-time-pass-rate"
-  ]' \
-  --dashboard-url
-
-# Track team performance
-npx monomind github team-metrics \
-  --board "Development" \
-  --per-member \
-  --include "velocity,quality,collaboration" \
-  --anonymous-option
-```
-
-</details>
-
-<details>
-<summary><strong>Release Planning</strong></summary>
-
-#### Release Coordination
-
-```bash
-# Plan releases using board data
-npx monomind github release-plan-board \
-  --analyze-velocity \
-  --estimate-completion \
-  --identify-risks \
-  --optimize-scope
-```
-
-</details>
-
-### 4. Advanced Coordination
-
-<details>
-<summary><strong>Multi-Board Synchronization</strong></summary>
-
-#### Cross-Board Sync
-
-```bash
-# Sync across multiple boards
-npx monomind github multi-board-sync \
-  --boards "Development,QA,Release" \
-  --sync-rules '{
-    "Development->QA": "when:ready-for-test",
-    "QA->Release": "when:tests-pass"
-  }'
-
-# Cross-organization sync
-npx monomind github cross-org-sync \
-  --source "org1/Project-A" \
-  --target "org2/Project-B" \
-  --field-mapping "custom" \
-  --conflict-resolution "source-wins"
-```
-
-</details>
-
-<details>
-<summary><strong>Issue Dependencies & Epic Management</strong></summary>
-
-#### Dependency Resolution
-
-```bash
-# Handle issue dependencies
-npx monomind github issue-deps 456 \
-  --resolve-order \
-  --parallel-safe \
-  --update-blocking
-```
-
-#### Epic Coordination
-
-```bash
-# Coordinate epic-level swarms
-npx monomind github epic-swarm \
-  --epic 123 \
-  --child-issues "456,457,458" \
-  --orchestrate
-```
-
-</details>
-
-<details>
-<summary><strong>Cross-Repository Coordination</strong></summary>
-
-#### Multi-Repo Issue Management
-
-```bash
-# Handle issues across repositories
-npx monomind github cross-repo \
-  --issue "org/repo#456" \
-  --related "org/other-repo#123" \
-  --coordinate
-```
-
-</details>
-
-<details>
-<summary><strong>Team Collaboration</strong></summary>
-
-#### Work Distribution
-
-```bash
-# Distribute work among team
-npx monomind github board-distribute \
-  --strategy "skills-based" \
-  --balance-workload \
-  --respect-preferences \
-  --notify-assignments
-```
-
-#### Standup Automation
-
-```bash
-# Generate standup reports
-npx monomind github standup-report \
-  --team "frontend" \
-  --include "yesterday,today,blockers" \
-  --format "slack" \
-  --schedule "daily-9am"
-```
-
-#### Review Coordination
-
-```bash
-# Coordinate reviews via board
-npx monomind github review-coordinate \
-  --board "Code Review" \
-  --assign-reviewers \
-  --track-feedback \
-  --ensure-coverage
-```
-
-</details>
-
----
-
-## Issue Templates
-
-### Integration Issue Template
-
-```markdown
-## Integration Task
-
-### Overview
-[Brief description of integration requirements]
-
-### Objectives
-- [ ] Component A integration
-- [ ] Component B validation
-- [ ] Testing and verification
-- [ ] Documentation updates
-
-### Integration Areas
-#### Dependencies
-- [ ] Package.json updates
-- [ ] Version compatibility
-- [ ] Import statements
-
-#### Functionality
-- [ ] Core feature integration
-- [ ] API compatibility
-- [ ] Performance validation
-
-#### Testing
-- [ ] Unit tests
-- [ ] Integration tests
-- [ ] End-to-end validation
-
-### Swarm Coordination
-- **Coordinator**: Overall progress tracking
-- **Analyst**: Technical validation
-- **Tester**: Quality assurance
-- **Documenter**: Documentation updates
-
-### Progress Tracking
-Updates will be posted automatically by swarm agents during implementation.
-
----
-Generated with Claude Code
-```
-
-### Bug Report Template
-
-```markdown
-## Bug Report
-
-### Problem Description
-[Clear description of the issue]
-
-### Expected Behavior
-[What should happen]
-
-### Actual Behavior
-[What actually happens]
-
-### Reproduction Steps
-1. [Step 1]
-2. [Step 2]
-3. [Step 3]
-
-### Environment
-- Package: [package name and version]
-- Node.js: [version]
-- OS: [operating system]
-
-### Investigation Plan
-- [ ] Root cause analysis
-- [ ] Fix implementation
-- [ ] Testing and validation
-- [ ] Regression testing
-
-### Swarm Assignment
-- **Debugger**: Issue investigation
-- **Coder**: Fix implementation
-- **Tester**: Validation and testing
-
----
-Generated with Claude Code
-```
-
-### Feature Request Template
-
-```markdown
-## Feature Request
-
-### Feature Description
-[Clear description of the proposed feature]
-
-### Use Cases
-1. [Use case 1]
-2. [Use case 2]
-3. [Use case 3]
-
-### Acceptance Criteria
-- [ ] Criterion 1
-- [ ] Criterion 2
-- [ ] Criterion 3
-
-### Implementation Approach
-#### Design
-- [ ] Architecture design
-- [ ] API design
-- [ ] UI/UX mockups
-
-#### Development
-- [ ] Core implementation
-- [ ] Integration with existing features
-- [ ] Performance optimization
-
-#### Testing
-- [ ] Unit tests
-- [ ] Integration tests
-- [ ] User acceptance testing
-
-### Swarm Coordination
-- **Architect**: Design and planning
-- **Coder**: Implementation
-- **Tester**: Quality assurance
-- **Documenter**: Documentation
-
----
-Generated with Claude Code
-```
-
-### Swarm Task Template
-
-```markdown
-<!-- .github/ISSUE_TEMPLATE/swarm-task.yml -->
-name: Swarm Task
-description: Create a task for AI swarm processing
-body:
-  - type: dropdown
-    id: topology
-    attributes:
-      label: Swarm Topology
-      options:
-        - mesh
-        - hierarchical
-        - ring
-        - star
-  - type: input
-    id: agents
-    attributes:
-      label: Required Agents
-      placeholder: "coder, tester, analyst"
-  - type: textarea
-    id: tasks
-    attributes:
-      label: Task Breakdown
-      placeholder: |
-        1. Task one description
-        2. Task two description
-```
-
----
-
-## Workflow Integration
-
-### GitHub Actions for Issue Management
-
-```yaml
-# .github/workflows/issue-swarm.yml
-name: Issue Swarm Handler
-on:
-  issues:
-    types: [opened, labeled, commented]
-
-jobs:
-  swarm-process:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Process Issue
-        run: |
-            if [[ "${{ github.event.label.name }}" == "swarm-ready" ]]; then
-              npx monomind github issue-init ${{ github.event.issue.number }}
-            fi
-```
-
-### Board Integration Workflow
-
-```bash
-# Sync with project board
-npx monomind github issue-board-sync \
-  --project "Development" \
-  --column-mapping '{
-    "To Do": "pending",
-    "In Progress": "active",
-    "Done": "completed"
-  }'
-```
-
----
-
-## Specialized Issue Strategies
-
-### Bug Investigation Swarm
-
-```bash
-# Specialized bug handling
-npx monomind github bug-swarm 456 \
-  --reproduce \
-  --isolate \
-  --fix \
-  --test
-```
-
-### Feature Implementation Swarm
-
-```bash
-# Feature implementation swarm
-npx monomind github feature-swarm 456 \
-  --design \
-  --implement \
-  --document \
-  --demo
-```
-
-### Technical Debt Refactoring
-
-```bash
-# Refactoring swarm
-npx monomind github debt-swarm 456 \
-  --analyze-impact \
-  --plan-migration \
-  --execute \
-  --validate
-```
-
----
-
-## Best Practices
-
-### 1. Swarm-Coordinated Issue Management
-- Always initialize swarm for complex issues
-- Assign specialized agents based on issue type
-- Use memory for progress coordination
-- Regular automated progress updates
-
-### 2. Board Organization
-- Clear column definitions with consistent naming
-- Systematic labeling strategy across repositories
-- Regular board grooming and maintenance
-- Well-defined automation rules
-
-### 3. Data Integrity
-- Bidirectional sync validation
-- Conflict resolution strategies
-- Comprehensive audit trails
-- Regular backups of project data
-
-### 4. Team Adoption
-- Comprehensive training materials
-- Clear, documented workflows
-- Regular team reviews and retrospectives
-- Active feedback loops for improvement
-
-### 5. Smart Labeling and Organization
-- Consistent labeling strategy across repositories
-- Priority-based issue sorting and assignment
-- Milestone integration for project coordination
-- Agent-type to label mapping
-
-### 6. Automated Progress Tracking
-- Regular automated updates with swarm coordination
-- Progress metrics and completion tracking
-- Cross-issue dependency management
-- Real-time status synchronization
-
----
-
-## Troubleshooting
-
-### Sync Issues
-
-```bash
-# Diagnose sync problems
-npx monomind github board-diagnose \
-  --check "permissions,webhooks,rate-limits" \
-  --test-sync \
-  --show-conflicts
-```
-
-### Performance Optimization
-
-```bash
-# Optimize board performance
-npx monomind github board-optimize \
-  --analyze-size \
-  --archive-completed \
-  --index-fields \
-  --cache-views
-```
-
-### Data Recovery
-
-```bash
-# Recover board data
-npx monomind github board-recover \
-  --backup-id "2024-01-15" \
-  --restore-cards \
-  --preserve-current \
-  --merge-conflicts
-```
-
----
-
-## Metrics & Analytics
-
-### Performance Metrics
-
-Automatic tracking of:
-- Issue creation and resolution times
-- Agent productivity metrics
-- Project milestone progress
-- Cross-repository coordination efficiency
-- Sprint velocity and burndown
-- Cycle time and throughput
-- Work-in-progress limits
-
-### Reporting Features
-
-- Weekly progress summaries
-- Agent performance analytics
-- Project health metrics
-- Integration success rates
-- Team collaboration metrics
-- Quality and defect tracking
-
-### Issue Resolution Time
-
-```bash
-# Analyze swarm performance
-npx monomind github issue-metrics \
-  --issue 456 \
-  --metrics "time-to-close,agent-efficiency,subtask-completion"
-```
-
-### Swarm Effectiveness
-
-```bash
-# Generate effectiveness report
-npx monomind github effectiveness \
-  --issues "closed:>2024-01-01" \
-  --compare "with-swarm,without-swarm"
-```
-
----
-
-## Security & Permissions
-
-1. **Command Authorization**: Validate user permissions before executing commands
-2. **Rate Limiting**: Prevent spam and abuse of issue commands
-3. **Audit Logging**: Track all swarm operations on issues and boards
-4. **Data Privacy**: Respect private repository settings
-5. **Access Control**: Proper GitHub permissions for board operations
-6. **Webhook Security**: Secure webhook endpoints for real-time updates
-
----
-
-## Integration with Other Skills
-
-### Seamless Integration With:
-- `github-pr-workflow` - Link issues to pull requests automatically
-- `github-release-management` - Coordinate release issues and milestones
-- `sparc-orchestrator` - Complex project coordination workflows
-- `sparc-tester` - Automated testing workflows for issues
-
----
-
-## Complete Workflow Example
-
-### Full-Stack Feature Development
-
-```bash
-# 1. Create feature issue with swarm coordination
-gh issue create \
-  --title "Feature: Real-time Collaboration" \
-  --body "$(cat <<EOF
-## Feature: Real-time Collaboration
-
-### Overview
-Implement real-time collaboration features using WebSockets.
-
-### Objectives
-- [ ] WebSocket server setup
-- [ ] Client-side integration
-- [ ] Presence tracking
-- [ ] Conflict resolution
-- [ ] Testing and documentation
-
-### Swarm Coordination
-This feature will use mesh topology for parallel development.
-EOF
-)" \
-  --label "enhancement,swarm-ready,high-priority"
-
-# 2. Initialize swarm and decompose tasks
-ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
-npx monomind github issue-init $ISSUE_NUM \
-  --topology mesh \
-  --auto-decompose \
-  --assign-agents "architect,coder,tester"
-
-# 3. Add to project board
-PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
-gh project item-add $PROJECT_ID --owner @me \
-  --url "https://github.com/$GITHUB_REPOSITORY/issues/$ISSUE_NUM"
-
-# 4. Set up automated tracking
-npx monomind github board-sync \
-  --auto-move-cards \
-  --update-metadata
-
-# 5. Monitor progress
-npx monomind github issue-progress $ISSUE_NUM \
-  --auto-update-comments \
-  --notify-on-completion
-```
-
----
-
-## Quick Reference Commands
-
-```bash
-# Issue Management
-gh issue create --title "..." --body "..." --label "..."
-npx monomind github issue-init <number>
-npx monomind github issue-decompose <number>
-npx monomind github triage --unlabeled
-
-# Project Boards
-npx monomind github board-init --project-id <id>
-npx monomind github board-sync
-npx monomind github board-analytics
-
-# Sprint Management
-npx monomind github sprint-manage --sprint "Sprint X"
-npx monomind github milestone-track --milestone "vX.X"
-
-# Analytics
-npx monomind github issue-metrics --issue <number>
-npx monomind github board-kpis
-```
-
----
-
-## Additional Resources
-
-- [GitHub CLI Documentation](https://cli.github.com/manual/)
-- [GitHub Projects Documentation](https://docs.github.com/en/issues/planning-and-tracking-with-projects)
-- [Monomind Documentation](https://github.com/nokhodian/monomind)
-
----
-
-**Last Updated**: 2025-10-19
-**Version**: 2.0.0
-**Maintainer**: Claude Code