monomind 1.18.15 → 2.0.0

package/.claude/commands/coordination/agent-spawn.md

@@ -1,69 +0,0 @@
----
-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/.claude/commands/coordination/swarm-init.md

@@ -1,82 +0,0 @@
----
-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/.claude/commands/coordination/task-orchestrate.md

@@ -1,79 +0,0 @@
----
-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/.claude/commands/github/README.md

@@ -1,24 +0,0 @@
----
-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/.claude/commands/github/github-modes.md

@@ -1,151 +0,0 @@
----
-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/.claude/commands/github/issue-tracker.md

@@ -1,293 +0,0 @@
----
-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