monomind 1.16.5 → 1.16.7

package/packages/@monomind/cli/.claude/commands/coordination/agent-spawn.md

@@ -0,0 +1,69 @@
+---
+name: coordination:agent-spawn
+---
+
+# agent-spawn
+
+Spawn a new agent in the current swarm.
+
+## Usage
+
+```bash
+npx monomind agent spawn [options]
+```
+
+## Options
+
+- `--type, -t <type>` - Agent type: `coder`, `researcher`, `analyst`, `tester`, `coordinator`, `architect`
+- `--name, -n <name>` - Custom agent name/identifier
+- `--task <description>` - Initial task for the agent
+- `--provider <name>` - Provider: `anthropic`, `openrouter`, `ollama`
+- `--model <id>` - Specific model to use
+- `--timeout <seconds>` - Agent timeout in seconds
+- `--auto-tools` - Enable automatic tool selection
+
+## Examples
+
+```bash
+# Spawn a coder agent
+npx monomind agent spawn --type coder --name bot-1
+
+# Spawn researcher with an initial task
+npx monomind agent spawn --type researcher --task "Research React 19 concurrent features"
+
+# Spawn with specific provider and model
+npx monomind agent spawn --type architect --provider anthropic --model claude-sonnet-4-6
+
+# Spawn with auto tools and timeout
+npx monomind agent spawn --type coder --auto-tools --timeout 300
+```
+
+## Agent Types
+
+| Type | Best For |
+|------|----------|
+| `coder` | Implementation, code generation |
+| `researcher` | Documentation, exploration, analysis |
+| `analyst` | Data-driven decisions, performance review |
+| `tester` | Test creation, quality assurance |
+| `coordinator` | Task management, progress tracking |
+| `architect` | System design, architecture decisions |
+
+## Integration with Claude Code
+
+```javascript
+mcp__monomind__agent_spawn({
+  type: "coder",
+  name: "API Builder",
+  capabilities: ["typescript", "rest-api"]
+})
+```
+
+> Note: This tool provides coordination and metadata — Claude Code performs all actual implementation using its native tools.
+
+## See Also
+
+- `swarm-init` — initialize the swarm before spawning agents
+- `agent list` — list all active agents (`monomind agent list`)
+- `agent status` — check agent status (`monomind agent status --id <id>`)
+- `task-orchestrate` — coordinate tasks across spawned agents

package/packages/@monomind/cli/.claude/commands/coordination/swarm-init.md

@@ -0,0 +1,82 @@
+---
+name: coordination:swarm-init
+---
+
+# swarm-init
+
+Initialize a Monomind swarm with specified topology and configuration.
+
+## Usage
+
+```bash
+npx monomind swarm init [options]
+```
+
+## Options
+
+- `--topology, -t <type>` - Swarm topology (default: `hierarchical`)
+- `--max-agents, -m <n>` - Maximum number of agents (default: `8`)
+- `--strategy, -s <type>` - Coordination strategy: `balanced`, `parallel`, `sequential`, `specialized`
+- `--auto-scale` - Enable automatic agent scaling
+- `--v1-mode` - Enable v1 15-agent hierarchical mesh mode
+
+## Examples
+
+### Default hierarchical swarm
+
+```bash
+npx monomind swarm init
+```
+
+### Mesh topology for research tasks
+
+```bash
+npx monomind swarm init --topology mesh --max-agents 5 --strategy balanced
+```
+
+### Specialized development swarm
+
+```bash
+npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
+```
+
+### Auto-scaling adaptive swarm
+
+```bash
+npx monomind swarm init --topology adaptive --auto-scale
+```
+
+### v1 high-performance mode (15 agents)
+
+```bash
+npx monomind swarm init --v1-mode
+```
+
+## Topologies
+
+| Topology | Best For | Communication |
+|----------|----------|---------------|
+| `hierarchical` | Development, structured tasks, large projects | Efficient, clear chain of command |
+| `hierarchical-mesh` | Complex cross-domain work (recommended default) | Balanced overhead + information sharing |
+| `mesh` | Research, exploration, brainstorming | High information sharing |
+| `ring` | Pipeline processing, sequential workflows | Low overhead, ordered |
+| `star` | Centralized control, simple tasks | Minimal overhead |
+| `adaptive` | Unknown complexity, dynamic workloads | Self-adjusting |
+| `hybrid` | Mixed-mode tasks | Configurable |
+
+## Integration with Claude Code
+
+```javascript
+mcp__monomind__swarm_init({
+  topology: "hierarchical",
+  maxAgents: 8,
+  strategy: "specialized"
+})
+```
+
+## See Also
+
+- `agent-spawn` — create agents within the swarm
+- `swarm status` — check swarm state (`monomind swarm status`)
+- `swarm start` — start execution (`monomind swarm start --objective "..."`)
+- `task-orchestrate` — coordinate tasks across agents

package/packages/@monomind/cli/.claude/commands/coordination/task-orchestrate.md

@@ -0,0 +1,79 @@
+---
+name: coordination:task-orchestrate
+---
+
+# task-orchestrate
+
+Coordinate tasks across a swarm of agents.
+
+## Usage
+
+```bash
+npx monomind swarm coordinate [options]
+```
+
+## Options
+
+- `--task <description>` - Task to distribute across agents
+- `--agents <list>` - Comma-separated agent IDs or types
+- `--strategy <type>` - Coordination strategy: `parallel`, `sequential`, `pipeline`, `broadcast`
+- `--timeout <seconds>` - Max time to wait for completion
+
+## Examples
+
+### Coordinate in parallel (default)
+
+```bash
+npx monomind swarm coordinate --task "Run all tests" --strategy parallel
+```
+
+### Sequential pipeline
+
+```bash
+npx monomind swarm coordinate --task "Build, test, and deploy" --strategy pipeline
+```
+
+### Broadcast to all agents
+
+```bash
+npx monomind swarm coordinate --task "Update shared context" --strategy broadcast
+```
+
+## Task Lifecycle (separate from orchestration)
+
+Use `monomind task` subcommands for individual task management:
+
+```bash
+npx monomind task create --title "Fix auth bug" --priority high
+npx monomind task list --status pending
+npx monomind task status --id <task-id>
+npx monomind task assign --id <task-id> --agent <agent-id>
+npx monomind task cancel --id <task-id>
+npx monomind task retry --id <task-id>
+```
+
+## Strategies
+
+| Strategy | Description |
+|----------|-------------|
+| `parallel` | All agents work simultaneously (default) |
+| `sequential` | Agents execute one after another |
+| `pipeline` | Output of one agent feeds the next |
+| `broadcast` | Same task sent to all agents |
+
+## Integration with Claude Code
+
+```javascript
+mcp__monomind__coordination_orchestrate({
+  task: "Implement user authentication",
+  agents: ["architect", "coder", "tester"],
+  strategy: "sequential",
+  timeout: 300
+})
+```
+
+## See Also
+
+- `swarm-init` — initialize the swarm before orchestrating
+- `agent-spawn` — create agents to orchestrate tasks across
+- `swarm status` — check current swarm state (`monomind swarm status`)

package/packages/@monomind/cli/.claude/commands/github/README.md

@@ -0,0 +1,24 @@
+---
+name: github:README
+---
+
+# GitHub Commands
+
+Commands and guidance for GitHub workflow automation in Monomind. All GitHub operations use the `gh` CLI and real monomind MCP tools — there is no `monomind github` CLI command group.
+
+## Commands (invoke as slash commands)
+
+- [github-modes](./github-modes.md) — overview of all GitHub workflow modes and swarm integration patterns
+- [issue-tracker](./issue-tracker.md) — issue management and project coordination with swarm agents
+- [pr-manager](./pr-manager.md) — pull request lifecycle management with multi-agent review coordination
+- [release-manager](./release-manager.md) — release preparation, versioning, and deployment pipeline coordination
+- [repo-architect](./repo-architect.md) — repository structure optimization and template management
+- [sync-coordinator](./sync-coordinator.md) — multi-package version alignment and cross-repo synchronization
+
+## Real Tools Used
+
+- `gh` CLI — all GitHub operations (issues, PRs, releases, repos, branches)
+- `mcp__monomind__swarm_init` / `agent_spawn` — swarm coordination
+- `mcp__monomind__coordination_orchestrate` — task coordination across agents (`strategy: parallel|sequential|pipeline|broadcast`)
+- `mcp__monomind__memory_store` / `memory_retrieve` — cross-agent state persistence
+- `gh` CLI — preferred for all direct GitHub API operations not covered by the above

package/packages/@monomind/cli/.claude/commands/github/github-modes.md

@@ -0,0 +1,151 @@
+---
+name: github:github-modes
+---
+
+# GitHub Integration Modes
+
+## Overview
+This document describes all GitHub integration modes available in Monomind. Each mode is optimized for specific GitHub workflows and includes batch tool integration for maximum efficiency.
+
+## GitHub Workflow Modes
+
+### gh-coordinator
+**GitHub workflow orchestration and coordination**
+- **Coordination Mode**: Hierarchical
+- **Max Parallel Operations**: 10
+- **Batch Optimized**: Yes
+- **Tools**: gh CLI commands, TodoWrite, TodoRead, Task, Memory, Bash
+- **Usage**: `/github gh-coordinator <GitHub workflow description>`
+- **Best For**: Complex GitHub workflows, multi-repo coordination
+
+### pr-manager
+**Pull request management and review coordination**
+- **Review Mode**: Automated
+- **Multi-reviewer**: Yes
+- **Conflict Resolution**: Intelligent
+- **Tools**: gh pr create, gh pr view, gh pr review, gh pr merge, TodoWrite, Task
+- **Usage**: `/github pr-manager <PR management task>`
+- **Best For**: PR reviews, merge coordination, conflict resolution
+
+### issue-tracker
+**Issue management and project coordination**
+- **Issue Workflow**: Automated
+- **Label Management**: Smart
+- **Progress Tracking**: Real-time
+- **Tools**: gh issue create, gh issue edit, gh issue comment, gh issue list, TodoWrite
+- **Usage**: `/github issue-tracker <issue management task>`
+- **Best For**: Project management, issue coordination, progress tracking
+
+### release-manager
+**Release coordination and deployment**
+- **Release Pipeline**: Automated
+- **Versioning**: Semantic
+- **Deployment**: Multi-stage
+- **Tools**: gh pr create, gh pr merge, gh release create, Bash, TodoWrite
+- **Usage**: `/github release-manager <release task>`
+- **Best For**: Release management, version coordination, deployment pipelines
+
+## Repository Management Modes
+
+### repo-architect
+**Repository structure and organization**
+- **Structure Optimization**: Yes
+- **Multi-repo**: Support
+- **Template Management**: Advanced
+- **Tools**: gh repo create, gh repo clone, git commands, Write, Read, Bash
+- **Usage**: `/github repo-architect <repository management task>`
+- **Best For**: Repository setup, structure optimization, multi-repo management
+
+### code-reviewer
+**Automated code review and quality assurance**
+- **Review Quality**: Deep
+- **Security Analysis**: Yes
+- **Performance Check**: Automated
+- **Tools**: gh pr view --json files, gh pr review, gh pr comment, Read, Write
+- **Usage**: `/github code-reviewer <review task>`
+- **Best For**: Code quality, security reviews, performance analysis
+
+### branch-manager
+**Branch management and workflow coordination**
+- **Branch Strategy**: GitFlow
+- **Merge Strategy**: Intelligent
+- **Conflict Prevention**: Proactive
+- **Tools**: gh api (for branch operations), git commands, Bash
+- **Usage**: `/github branch-manager <branch management task>`
+- **Best For**: Branch coordination, merge strategies, workflow management
+
+## Integration Commands
+
+### sync-coordinator
+**Multi-package synchronization**
+- **Package Sync**: Intelligent
+- **Version Alignment**: Automatic
+- **Dependency Resolution**: Advanced
+- **Tools**: git commands, gh pr create, Read, Write, Bash
+- **Usage**: `/github sync-coordinator <sync task>`
+- **Best For**: Package synchronization, version management, dependency updates
+
+### ci-orchestrator
+**CI/CD pipeline coordination**
+- **Pipeline Management**: Advanced
+- **Test Coordination**: Parallel
+- **Deployment**: Automated
+- **Tools**: gh pr checks, gh workflow list, gh run list, Bash, TodoWrite, Task
+- **Usage**: `/github ci-orchestrator <CI/CD task>`
+- **Best For**: CI/CD coordination, test management, deployment automation
+
+### security-guardian
+**Security and compliance management**
+- **Security Scan**: Automated
+- **Compliance Check**: Continuous
+- **Vulnerability Management**: Proactive
+- **Tools**: gh search code, gh issue create, gh secret list, Read, Write
+- **Usage**: `/github security-guardian <security task>`
+- **Best For**: Security audits, compliance checks, vulnerability management
+
+## Usage Examples
+
+### Creating a coordinated pull request workflow:
+```bash
+/github pr-manager "Review and merge feature/new-integration branch with automated testing and multi-reviewer coordination"
+```
+
+### Managing repository synchronization:
+```bash
+/github sync-coordinator "Synchronize packages, align versions, and update cross-dependencies"
+```
+
+### Setting up automated issue tracking:
+```bash
+/github issue-tracker "Create and manage integration issues with automated progress tracking and swarm coordination"
+```
+
+## Batch Operations
+
+All GitHub modes support batch operations for maximum efficiency:
+
+### Parallel GitHub Operations Example:
+```javascript
+[Single Message with BatchTool]:
+  Bash("gh issue create --title 'Feature A' --body '...'")
+  Bash("gh issue create --title 'Feature B' --body '...'")
+  Bash("gh pr create --title 'PR 1' --head 'feature-a' --base 'main'")
+  Bash("gh pr create --title 'PR 2' --head 'feature-b' --base 'main'")
+  TodoWrite { todos: [todo1, todo2, todo3] }
+  Bash("git checkout main && git pull")
+```
+
+## Integration with Monomind Swarm
+
+All GitHub modes can be enhanced with swarm coordination:
+
+```javascript
+// Initialize swarm for GitHub workflow
+mcp__monomind__swarm_init { topology: "hierarchical", maxAgents: 5 }
+mcp__monomind__agent_spawn { type: "coordinator", name: "GitHub Coordinator" }
+mcp__monomind__agent_spawn { type: "reviewer", name: "Code Reviewer" }
+mcp__monomind__agent_spawn { type: "tester", name: "QA Agent" }
+
+// Execute GitHub workflow with coordination
+mcp__monomind__coordination_orchestrate { task: "GitHub workflow", agents: ["coordinator", "reviewer", "tester"], strategy: "parallel" }
+```

package/packages/@monomind/cli/.claude/commands/github/issue-tracker.md

@@ -0,0 +1,293 @@
+---
+name: github:issue-tracker
+---
+
+# GitHub Issue Tracker
+
+## Purpose
+Intelligent issue management and project coordination with monomind swarm integration for automated tracking, progress monitoring, and team coordination.
+
+## Capabilities
+- **Automated issue creation** with smart templates and labeling
+- **Progress tracking** with swarm-coordinated updates
+- **Multi-agent collaboration** on complex issues
+- **Project milestone coordination** with integrated workflows
+- **Cross-repository issue synchronization** for monorepo management
+
+## Tools Available
+- `mcp__github__create_issue`
+- `mcp__github__list_issues`
+- `mcp__github__get_issue`
+- `mcp__github__update_issue`
+- `mcp__github__add_issue_comment`
+- `mcp__github__search_issues`
+- `mcp__monomind__*` (all swarm coordination tools)
+- `TodoWrite`, `TodoRead`, `Task`, `Bash`, `Read`, `Write`
+
+## Usage Patterns
+
+### 1. Create Coordinated Issue with Swarm Tracking
+```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: ":owner",
+  repo: ":repo",
+  title: "Integration Review: comprehensive package integration",
+  body: `## Integration Review
+  
+  ### Overview
+  Comprehensive review and integration between packages.
+  
+  ### Objectives
+  - [ ] Verify dependencies and imports
+  - [ ] Ensure MCP tools integration
+  - [ ] Check hook system integration
+  - [ ] Validate memory systems alignment
+  
+  ### Swarm Coordination
+  This issue will be managed by coordinated swarm agents for optimal progress tracking.`,
+  labels: ["integration", "review", "enhancement"],
+  assignees: [":assignee"]
+}
+
+// Set up automated tracking
+mcp__monomind__coordination_orchestrate {
+  task: "Monitor and coordinate issue progress with automated updates",
+  agents: ["coordinator", "researcher", "coder"],
+  strategy: "parallel"
+}
+```
+
+### 2. Automated Progress Updates
+```javascript
+// Update issue with progress from swarm memory
+mcp__monomind__memory_retrieve {
+  key: "issue/54/progress"
+}
+
+// Add coordinated progress comment
+mcp__github__add_issue_comment {
+  owner: ":owner",
+  repo: ":repo",
+  issue_number: 54,
+  body: `## Progress Update
+
+  ### Completed Tasks
+  - Architecture review completed (agent-1751574161764)
+  - Dependency analysis finished (agent-1751574162044)
+  - Integration testing verified (agent-1751574162300)
+  
+  ### Current Status
+  - Documentation review in progress
+  - Integration score: 89% (Excellent)
+  
+  ### Next Steps
+  - Final validation and merge preparation
+  
+  ---
+  Generated with Claude Code using Monomind swarm coordination`
+}
+
+// Store progress in swarm memory
+mcp__monomind__memory_store {
+  key: "issue/54/latest_update",
+  value: { timestamp: Date.now(), progress: "89%", status: "near_completion" }
+}
+```
+
+### 3. Multi-Issue Project Coordination
+```javascript
+// Search and coordinate related issues
+mcp__github__search_issues {
+  q: "repo::owner/:repo label:integration state:open",
+  sort: "created",
+  order: "desc"
+}
+
+// Create coordinated issue updates
+mcp__github__update_issue {
+  owner: ":owner",
+  repo: ":repo",
+  issue_number: 54,
+  state: "open",
+  labels: ["integration", "review", "enhancement", "in-progress"],
+  milestone: 1
+}
+```
+
+## Batch Operations Example
+
+### Complete Issue Management Workflow:
+```javascript
+[Single Message - Issue Lifecycle Management]:
+  // Initialize issue coordination swarm
+  mcp__monomind__swarm_init { topology: "mesh", maxAgents: 4 }
+  mcp__monomind__agent_spawn { type: "coordinator", name: "Issue Manager" }
+  mcp__monomind__agent_spawn { type: "analyst", name: "Progress Tracker" }
+  mcp__monomind__agent_spawn { type: "researcher", name: "Context Gatherer" }
+  
+  // Create multiple related issues using gh CLI
+  Bash(`gh issue create \
+    --repo :owner/:repo \
+    --title "Feature: Advanced GitHub Integration" \
+    --body "Implement comprehensive GitHub workflow automation..." \
+    --label "feature,github,high-priority"`)
+    
+  Bash(`gh issue create \
+    --repo :owner/:repo \
+    --title "Bug: PR merge conflicts in integration branch" \
+    --body "Resolve merge conflicts in integration branch..." \
+    --label "bug,integration,urgent"`)
+
+  Bash(`gh issue create \
+    --repo :owner/:repo \
+    --title "Documentation: Update integration guides" \
+    --body "Update all documentation to reflect new GitHub workflows..." \
+    --label "documentation,integration"`)
+  
+  
+  // Set up coordinated tracking
+  TodoWrite { todos: [
+    { id: "github-feature", content: "Implement GitHub integration", status: "pending", priority: "high" },
+    { id: "merge-conflicts", content: "Resolve PR conflicts", status: "pending", priority: "critical" },
+    { id: "docs-update", content: "Update documentation", status: "pending", priority: "medium" }
+  ]}
+  
+  // Store initial coordination state
+  mcp__monomind__memory_store {
+    key: "project/github_integration/issues",
+    value: { created: Date.now(), total_issues: 3, status: "initialized" }
+  }
+```
+
+## Smart 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
+```
+
+## 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
+
+### 2. **Automated Progress Tracking**
+- Regular automated updates with swarm coordination
+- Progress metrics and completion tracking
+- Cross-issue dependency management
+
+### 3. **Smart Labeling and Organization**
+- Consistent labeling strategy across repositories
+- Priority-based issue sorting and assignment
+- Milestone integration for project coordination
+
+### 4. **Batch Issue Operations**
+- Create multiple related issues simultaneously
+- Bulk updates for project-wide changes
+- Coordinated cross-repository issue management
+
+## Integration with Other Modes
+
+### Seamless integration with:
+- `/github pr-manager` - Link issues to pull requests
+- `/github release-manager` - Coordinate release issues
+- `/sparc orchestrator` - Complex project coordination
+- `/sparc tester` - Automated testing workflows
+
+## Metrics and Analytics
+
+### Automatic tracking of:
+- Issue creation and resolution times
+- Agent productivity metrics
+- Project milestone progress
+- Cross-repository coordination efficiency
+
+### Reporting features:
+- Weekly progress summaries
+- Agent performance analytics
+- Project health metrics
+- Integration success rates