monomind 1.8.0 → 1.9.1

package/.claude/commands/swarm/development.md

@@ -1,96 +1,72 @@
+---
+name: swarm-development
+description: Development swarm strategy — hierarchical team coordination for building features with architect → coder → tester flow
+---
+
 # Development Swarm Strategy
 
-## Purpose
 Coordinated development through specialized agent teams.
 
-## Activation
+## How to Invoke
+
+```
+Skill("swarm:development")
+```
+
+Then describe the feature to build:
+> "Start a development swarm to build OAuth2 authentication."
+> "Coordinate agents to implement the payment processing module."
+
+---
+
+## Swarm Setup
 
-### Using MCP Tools
 ```javascript
 // Initialize development swarm
 mcp__monomind__swarm_init({
-  "topology": "hierarchical",
-  "maxAgents": 8,
-  "strategy": "balanced"
+  topology: "hierarchical",
+  maxAgents: 8,
+  strategy: "specialized"
 })
 
-// Orchestrate development task
-mcp__monomind__task_orchestrate({
-  "task": "build feature X",
-  "strategy": "parallel",
-  "priority": "high"
+// Coordinate development
+mcp__monomind__coordination_orchestrate({
+  task: "build feature X",
+  strategy: "parallel"
 })
 ```
 
-### Using CLI (Fallback)
-`npx monomind swarm "build feature X" --strategy development`
+```bash
+# CLI equivalent
+npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
+npx monomind swarm start "build feature X" --strategy development --parallel
+```
 
 ## Agent Roles
 
-### Agent Spawning with MCP
 ```javascript
-// Spawn development agents
-mcp__monomind__agent_spawn({
-  "type": "architect",
-  "name": "System Designer",
-  "capabilities": ["system-design", "api-design"]
-})
-
-mcp__monomind__agent_spawn({
-  "type": "coder",
-  "name": "Frontend Developer",
-  "capabilities": ["react", "typescript", "ui"]
-})
-
-mcp__monomind__agent_spawn({
-  "type": "coder",
-  "name": "Backend Developer",
-  "capabilities": ["nodejs", "api", "database"]
-})
-
-mcp__monomind__agent_spawn({
-  "type": "specialist",
-  "name": "Database Expert",
-  "capabilities": ["sql", "nosql", "optimization"]
-})
-
-mcp__monomind__agent_spawn({
-  "type": "tester",
-  "name": "Integration Tester",
-  "capabilities": ["integration", "e2e", "api-testing"]
-})
+mcp__monomind__agent_spawn({ type: "architect", capabilities: ["system-design", "api-design"] })
+mcp__monomind__agent_spawn({ type: "coder", capabilities: ["react", "typescript", "ui"] })
+mcp__monomind__agent_spawn({ type: "coder", capabilities: ["nodejs", "api", "database"] })
+mcp__monomind__agent_spawn({ type: "tester", capabilities: ["integration", "e2e", "api-testing"] })
 ```
 
 ## Best Practices
-- Use hierarchical mode for large projects
-- Enable parallel execution
-- Implement continuous testing
-- Monitor swarm health regularly
 
-## Status Monitoring
+- Use hierarchical topology for large features (architect leads, coders implement, tester validates)
+- Enable parallel execution for independent modules
+- Run tester agent concurrently on completed units rather than waiting for all code
+
+## Monitoring
+
 ```javascript
 // Check swarm status
-mcp__monomind__swarm_status({
-  "swarmId": "development-swarm"
-})
-
-// Monitor agent performance
-mcp__monomind__agent_metrics({
-  "agentId": "architect-001"
-})
+mcp__monomind__swarm_status({ swarmId: "current" })
 
-// Real-time monitoring
-mcp__monomind__swarm_monitor({
-  "swarmId": "development-swarm",
-  "interval": 5000
-})
+// System health
+mcp__monomind__system_health({})
 ```
 
-## Error Handling
-```javascript
-// Enable fault tolerance
-mcp__monomind__daa_fault_tolerance({
-  "agentId": "all",
-  "strategy": "auto-recovery"
-})
+```bash
+npx monomind swarm status
 ```

package/.claude/commands/swarm/examples.md

@@ -1,168 +1,103 @@
-# Examples Swarm Strategy
+---
+name: swarm-examples
+description: Swarm pattern examples — concrete recipes for research, development, analysis, and testing swarms with real MCP tool invocations
+---
 
-## Common Swarm Patterns
+# Common Swarm Patterns
 
-### Research Swarm
+Ready-to-use recipes for the most common swarm scenarios.
+
+## Research Swarm
 
-#### Using MCP Tools
 ```javascript
-// Initialize research swarm
-mcp__monomind__swarm_init({
-  "topology": "mesh",
-  "maxAgents": 6,
-  "strategy": "adaptive"
-})
-
-// Spawn research agents
-mcp__monomind__agent_spawn({
-  "type": "researcher",
-  "name": "AI Trends Researcher",
-  "capabilities": ["web-search", "analysis", "synthesis"]
-})
-
-// Orchestrate research
-mcp__monomind__task_orchestrate({
-  "task": "research AI trends",
-  "strategy": "parallel",
-  "priority": "medium"
-})
-
-// Monitor progress
-mcp__monomind__swarm_status({
-  "swarmId": "research-swarm"
-})
+// 1. Initialize
+mcp__monomind__swarm_init({ topology: "mesh", maxAgents: 6, strategy: "adaptive" })
+
+// 2. Spawn agents
+mcp__monomind__agent_spawn({ type: "researcher", capabilities: ["web-search", "analysis", "synthesis"] })
+mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["data-processing", "reporting"] })
+
+// 3. Coordinate
+mcp__monomind__coordination_orchestrate({ task: "research AI trends", strategy: "parallel" })
+
+// 4. Monitor
+mcp__monomind__swarm_status({ swarmId: "current" })
 ```
 
-#### Using CLI (Fallback)
 ```bash
-npx monomind swarm "research AI trends" \
-  --strategy research \
-  --mode distributed \
-  --max-agents 6 \
-  --parallel
+npx monomind swarm init --topology mesh --max-agents 6 --strategy research
+npx monomind swarm start "research AI trends" --strategy research --parallel
 ```
 
-### Development Swarm
+---
+
+## Development Swarm
 
-#### Using MCP Tools
 ```javascript
-// Initialize development swarm
-mcp__monomind__swarm_init({
-  "topology": "hierarchical",
-  "maxAgents": 8,
-  "strategy": "balanced"
-})
-
-// Spawn development team
-const devAgents = [
-  { type: "architect", name: "API Designer" },
-  { type: "coder", name: "Backend Developer" },
-  { type: "tester", name: "API Tester" },
-  { type: "documenter", name: "API Documenter" }
-]
-
-devAgents.forEach(agent => {
-  mcp__monomind__agent_spawn({
-    "type": agent.type,
-    "name": agent.name,
-    "swarmId": "dev-swarm"
-  })
-})
-
-// Orchestrate development
-mcp__monomind__task_orchestrate({
-  "task": "build REST API",
-  "strategy": "sequential",
-  "dependencies": ["design", "implement", "test", "document"]
-})
-
-// Enable monitoring
-mcp__monomind__swarm_monitor({
-  "swarmId": "dev-swarm",
-  "interval": 5000
-})
+// 1. Initialize
+mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
+
+// 2. Spawn team
+mcp__monomind__agent_spawn({ type: "architect", capabilities: ["system-design", "api-design"] })
+mcp__monomind__agent_spawn({ type: "coder", capabilities: ["typescript", "api", "backend"] })
+mcp__monomind__agent_spawn({ type: "tester", capabilities: ["integration", "e2e"] })
+mcp__monomind__agent_spawn({ type: "documenter", capabilities: ["api-docs", "readme"] })
+
+// 3. Coordinate
+mcp__monomind__coordination_orchestrate({ task: "build REST API", strategy: "sequential" })
+
+// 4. Monitor
+mcp__monomind__swarm_status({ swarmId: "current" })
 ```
 
-#### Using CLI (Fallback)
 ```bash
-npx monomind swarm "build REST API" \
-  --strategy development \
-  --mode hierarchical \
-  --monitor \
-  --output sqlite
+npx monomind swarm start "build REST API" --strategy development --mode hierarchical
 ```
 
-### Analysis Swarm
+---
+
+## Analysis Swarm
 
-#### Using MCP Tools
 ```javascript
-// Initialize analysis swarm
-mcp__monomind__swarm_init({
-  "topology": "mesh",
-  "maxAgents": 5,
-  "strategy": "adaptive"
-})
-
-// Spawn analysis agents
-mcp__monomind__agent_spawn({
-  "type": "analyst",
-  "name": "Code Analyzer",
-  "capabilities": ["static-analysis", "complexity-analysis"]
-})
-
-mcp__monomind__agent_spawn({
-  "type": "analyst",
-  "name": "Security Analyzer",
-  "capabilities": ["security-scan", "vulnerability-detection"]
-})
-
-// Parallel analysis execution
-mcp__monomind__parallel_execute({
-  "tasks": [
-    { "id": "analyze-code", "command": "analyze codebase structure" },
-    { "id": "analyze-security", "command": "scan for vulnerabilities" },
-    { "id": "analyze-performance", "command": "identify bottlenecks" }
-  ]
-})
-
-// Generate comprehensive report
-mcp__monomind__performance_report({
-  "format": "detailed",
-  "timeframe": "current"
-})
+// 1. Initialize
+mcp__monomind__swarm_init({ topology: "mesh", maxAgents: 5, strategy: "adaptive" })
+
+// 2. Spawn agents
+mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["static-analysis", "complexity-analysis"] })
+mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["security-scan", "vulnerability-detection"] })
+mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["performance-analysis", "bottleneck-detection"] })
+
+// 3. Coordinate
+mcp__monomind__coordination_orchestrate({ task: "analyze codebase", strategy: "parallel" })
+
+// 4. Report
+mcp__monomind__performance_report({ format: "detailed" })
 ```
 
-#### Using CLI (Fallback)
 ```bash
-npx monomind swarm "analyze codebase" \
-  --strategy analysis \
-  --mode mesh \
-  --parallel \
-  --timeout 300
+npx monomind swarm start "analyze codebase" --strategy analysis --mode mesh --parallel
 ```
 
-## Error Handling Examples
+---
+
+## Error Recovery
+
+When a swarm gets into a bad state:
 
 ```javascript
-// Setup fault tolerance
-mcp__monomind__daa_fault_tolerance({
-  "agentId": "all",
-  "strategy": "auto-recovery"
-})
-
-// Handle errors gracefully
-try {
-  await mcp__monomind__task_orchestrate({
-    "task": "complex operation",
-    "strategy": "parallel"
-  })
-} catch (error) {
-  // Check swarm health
-  const status = await mcp__monomind__swarm_status({})
-  
-  // Log error patterns
-  await mcp__monomind__error_analysis({
-    "logs": [error.message]
-  })
-}
+// Check status first
+mcp__monomind__swarm_status({ swarmId: "current" })
+
+// System health check
+mcp__monomind__system_health({})
+
+// Shut down and restart
+mcp__monomind__swarm_shutdown({ swarmId: "current" })
+mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 6, strategy: "specialized" })
 ```
+
+## See Also
+
+- `swarm:swarm` — Main skill with strategy selection guide
+- `swarm:swarm-modes` — Topology reference
+- `swarm:swarm-strategies` — When to use each strategy

package/.claude/commands/swarm/maintenance.md

@@ -1,102 +1,75 @@
+---
+name: swarm-maintenance
+description: Maintenance swarm strategy — sequential coordinated system maintenance for dependency updates, security audits, and documentation
+---
+
 # Maintenance Swarm Strategy
 
-## Purpose
 System maintenance and updates through coordinated agents.
 
-## Activation
+## How to Invoke
+
+```
+Skill("swarm:maintenance")
+```
+
+Then describe the maintenance task:
+> "Run a maintenance swarm to update all dependencies safely."
+> "Start a maintenance swarm for the monthly security audit."
+
+---
+
+## Swarm Setup
 
-### Using MCP Tools
 ```javascript
 // Initialize maintenance swarm
 mcp__monomind__swarm_init({
-  "topology": "star",
-  "maxAgents": 5,
-  "strategy": "sequential"
+  topology: "star",
+  maxAgents: 5,
+  strategy: "sequential"
 })
 
-// Orchestrate maintenance task
-mcp__monomind__task_orchestrate({
-  "task": "update dependencies",
-  "strategy": "sequential",
-  "priority": "medium",
-  "dependencies": ["backup", "test", "update", "verify"]
+// Coordinate maintenance
+mcp__monomind__coordination_orchestrate({
+  task: "update dependencies",
+  strategy: "sequential"
 })
 ```
 
-### Using CLI (Fallback)
-`npx monomind swarm "update dependencies" --strategy maintenance`
+```bash
+# CLI equivalent
+npx monomind swarm init --topology star --max-agents 5
+npx monomind swarm start "update dependencies" --strategy maintenance
+```
 
 ## Agent Roles
 
-### Agent Spawning with MCP
 ```javascript
-// Spawn maintenance agents
-mcp__monomind__agent_spawn({
-  "type": "analyst",
-  "name": "Dependency Analyzer",
-  "capabilities": ["dependency-analysis", "version-management"]
-})
-
-mcp__monomind__agent_spawn({
-  "type": "monitor",
-  "name": "Security Scanner",
-  "capabilities": ["security", "vulnerability-scan"]
-})
-
-mcp__monomind__agent_spawn({
-  "type": "tester",
-  "name": "Test Runner",
-  "capabilities": ["testing", "validation"]
-})
-
-mcp__monomind__agent_spawn({
-  "type": "documenter",
-  "name": "Documentation Updater",
-  "capabilities": ["documentation", "changelog"]
-})
+mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["dependency-analysis", "version-management"] })
+mcp__monomind__agent_spawn({ type: "tester", capabilities: ["testing", "validation"] })
+mcp__monomind__agent_spawn({ type: "documenter", capabilities: ["documentation", "changelog"] })
 ```
 
-## Safety Features
+## Maintenance Sequence
 
-### Backup and Recovery
-```javascript
-// Create system backup
-mcp__monomind__backup_create({
-  "components": ["code", "config", "dependencies"],
-  "destination": "./backups/maintenance-" + Date.now()
-})
+Star topology runs sequentially — each agent completes before the next starts:
 
-// Create state snapshot
-mcp__monomind__state_snapshot({
-  "name": "pre-maintenance-" + Date.now()
-})
+1. **Analyzer agent** — audit outdated dependencies, find vulnerabilities
+2. **Tester agent** — verify tests pass on current state (baseline)
+3. **Analyst agent** — apply updates, verify no regressions
+4. **Tester agent** — rerun tests to confirm updates are safe
+5. **Documenter agent** — update CHANGELOG, document what changed
 
-// Enable fault tolerance
-mcp__monomind__daa_fault_tolerance({
-  "agentId": "all",
-  "strategy": "checkpoint-recovery"
-})
-```
+## Security Scanning
 
-### Security Scanning
 ```javascript
-// Run security scan
-mcp__monomind__security_scan({
-  "target": "./",
-  "depth": "comprehensive"
-})
+// Run security scan via AI defence
+mcp__monomind__aidefence_scan({ target: "./" })
 ```
 
-### Monitoring
-```javascript
-// Health check before/after
-mcp__monomind__health_check({
-  "components": ["dependencies", "tests", "build"]
-})
+## Monitoring
 
-// Monitor maintenance progress
-mcp__monomind__swarm_monitor({
-  "swarmId": "maintenance-swarm",
-  "interval": 3000
-})
+```javascript
+mcp__monomind__swarm_status({ swarmId: "current" })
+mcp__monomind__system_health({})
 ```