@monoes/monomindcli 1.7.0 → 1.9.0

package/.claude/commands/swarm/swarm-strategies.md

@@ -1,8 +1,76 @@
-# swarm-strategies
+---
+name: swarm-swarm-strategies
+description: Swarm strategy selection guide — when to use specialized, adaptive, balanced, sequential, and parallel strategies for different tasks
+---
 
-Command documentation for swarm-strategies in category swarm.
+# Swarm Strategy Guide
 
-Usage:
-```bash
-npx monomind swarm swarm-strategies [options]
+Choose the right strategy for your swarm objective.
+
+## How to Invoke
+
+```
+Skill("swarm:swarm-strategies")
+```
+
+---
+
+## Available Strategies
+
+### specialized
+
+```javascript
+mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
 ```
+
+- Each agent has a specific role and skill set — no overlap
+- Best for: complex feature development, audits, structured workflows
+- Agents: architect, coder, tester, reviewer — each owns their domain
+
+### adaptive
+
+```javascript
+mcp__monomind__swarm_init({ topology: "mesh", maxAgents: 6, strategy: "adaptive" })
+```
+
+- Agents dynamically adjust to task demands
+- Best for: research, exploration, unknown problem spaces
+- Agents can shift roles as needs emerge
+
+### balanced
+
+```javascript
+mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "balanced" })
+```
+
+- Mix of specialization and flexibility
+- Best for: medium complexity features where requirements may evolve
+
+### sequential
+
+```javascript
+mcp__monomind__swarm_init({ topology: "star", maxAgents: 5, strategy: "sequential" })
+```
+
+- Tasks execute one after another in a defined order
+- Best for: maintenance workflows, migrations, processes with strict dependencies
+
+### parallel
+
+```javascript
+mcp__monomind__swarm_init({ topology: "star", maxAgents: 7, strategy: "parallel" })
+```
+
+- Tasks execute simultaneously, no dependencies between them
+- Best for: running multiple independent test suites, analyzing multiple modules
+
+## Decision Matrix
+
+| Objective | Strategy | Topology |
+|-----------|----------|----------|
+| Build complex feature | specialized | hierarchical |
+| Research open-ended topic | adaptive | mesh |
+| Run test suites | parallel | star |
+| Update dependencies | sequential | star |
+| Analyze codebase | adaptive | mesh |
+| Security audit | specialized | hierarchical |

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

@@ -1,27 +1,79 @@
-# swarm
+---
+name: swarm-swarm
+description: Main swarm skill — initializes and starts multi-agent swarms for research, development, analysis, testing, optimization, and maintenance tasks
+---
 
-Main swarm orchestration command for Monomind.
+# Swarm Orchestration
 
-## Usage
-```bash
-npx monomind swarm <objective> [options]
+Start and coordinate multi-agent swarms for complex tasks.
+
+## How to Invoke
+
+In Claude Code, load this skill:
 ```
+Skill("swarm:swarm")
+```
+
+Then describe what you want to accomplish:
+> "Start a development swarm to build a REST API with auth endpoints."
+> "Run a research swarm on AI agent coordination patterns."
 
-## Options
-- `--strategy <type>` - Execution strategy (research, development, analysis, testing)
-- `--mode <type>` - Coordination mode (centralized, distributed, hierarchical, mesh)
-- `--max-agents <n>` - Maximum number of agents (default: 5)
-- `--claude` - Open Claude Code CLI with swarm prompt
-- `--parallel` - Enable parallel execution
+---
+
+## CLI Reference
 
-## Examples
 ```bash
-# Basic swarm
-npx monomind swarm "Build REST API"
+# Initialize a swarm
+npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
+
+# Start a swarm with an objective
+npx monomind swarm start "Build REST API" --strategy development --parallel
+
+# Check swarm status
+npx monomind swarm status
+
+# Stop the swarm
+npx monomind swarm stop
 
-# With strategy
-npx monomind swarm "Research AI patterns" --strategy research
+# Scale agents
+npx monomind swarm scale <swarm-id> --agents 12
+```
+
+## MCP Tools
+
+```javascript
+// Initialize swarm
+mcp__monomind__swarm_init({
+  topology: "hierarchical",
+  maxAgents: 8,
+  strategy: "specialized"
+})
+
+// Check status
+mcp__monomind__swarm_status({ swarmId: "current" })
+
+// Coordinate tasks
+mcp__monomind__coordination_orchestrate({ task: "build feature", strategy: "parallel" })
 
-# Open in Claude Code
-npx monomind swarm "Build API" --claude
+// Spawn an agent
+mcp__monomind__agent_spawn({ type: "coder", capabilities: ["typescript", "api"] })
+
+// Shut down swarm
+mcp__monomind__swarm_shutdown({ swarmId: "current" })
 ```
+
+## Strategy Selection
+
+| Strategy | Topology | Use when |
+|----------|----------|----------|
+| research | mesh | Gathering information from multiple sources in parallel |
+| development | hierarchical | Building features with architect → coder → tester flow |
+| analysis | mesh | Distributed codebase or performance analysis |
+| testing | star | Parallel test suite execution |
+| optimization | mesh | Performance profiling and bottleneck resolution |
+| maintenance | star | Sequential dependency updates with checkpoints |
+
+## See Also
+- `swarm:examples` — Common swarm patterns with full code
+- `swarm:swarm-modes` — Topology reference
+- `swarm:swarm-strategies` — Strategy selection guide

package/.claude/commands/swarm/testing.md

@@ -1,131 +1,80 @@
+---
+name: swarm-testing
+description: Testing swarm strategy — distributed parallel test execution with specialized unit, integration, E2E, and performance testing agents
+---
+
 # Testing Swarm Strategy
 
-## Purpose
 Comprehensive testing through distributed execution.
 
-## Activation
+## How to Invoke
+
+```
+Skill("swarm:testing")
+```
+
+Then describe the testing scope:
+> "Start a testing swarm to run full test coverage on the API."
+> "Run a testing swarm to validate the auth module end-to-end."
+
+---
+
+## Swarm Setup
 
-### Using MCP Tools
 ```javascript
 // Initialize testing swarm
 mcp__monomind__swarm_init({
-  "topology": "star",
-  "maxAgents": 7,
-  "strategy": "parallel"
+  topology: "star",
+  maxAgents: 7,
+  strategy: "parallel"
 })
 
-// Orchestrate testing task
-mcp__monomind__task_orchestrate({
-  "task": "test application",
-  "strategy": "parallel",
-  "priority": "high"
+// Coordinate testing
+mcp__monomind__coordination_orchestrate({
+  task: "test application",
+  strategy: "parallel"
 })
 ```
 
-### Using CLI (Fallback)
-`npx monomind swarm "test application" --strategy testing`
+```bash
+# CLI equivalent
+npx monomind swarm init --topology star --max-agents 7
+npx monomind swarm start "test application" --strategy testing --parallel
+```
 
 ## Agent Roles
 
-### Agent Spawning with MCP
 ```javascript
-// Spawn testing agents
-mcp__monomind__agent_spawn({
-  "type": "tester",
-  "name": "Unit Tester",
-  "capabilities": ["unit-testing", "mocking", "coverage"]
-})
-
-mcp__monomind__agent_spawn({
-  "type": "tester",
-  "name": "Integration Tester",
-  "capabilities": ["integration", "api-testing", "contract-testing"]
-})
-
-mcp__monomind__agent_spawn({
-  "type": "tester",
-  "name": "E2E Tester",
-  "capabilities": ["e2e", "ui-testing", "user-flows"]
-})
-
-mcp__monomind__agent_spawn({
-  "type": "tester",
-  "name": "Performance Tester",
-  "capabilities": ["load-testing", "stress-testing", "benchmarking"]
-})
-
-mcp__monomind__agent_spawn({
-  "type": "monitor",
-  "name": "Security Tester",
-  "capabilities": ["security-testing", "penetration-testing", "vulnerability-scanning"]
-})
+mcp__monomind__agent_spawn({ type: "tester", capabilities: ["unit-testing", "mocking", "coverage"] })
+mcp__monomind__agent_spawn({ type: "tester", capabilities: ["integration", "api-testing", "contract-testing"] })
+mcp__monomind__agent_spawn({ type: "tester", capabilities: ["e2e", "ui-testing", "user-flows"] })
+mcp__monomind__agent_spawn({ type: "tester", capabilities: ["load-testing", "stress-testing", "benchmarking"] })
+mcp__monomind__agent_spawn({ type: "tester", capabilities: ["security-testing", "vulnerability-scanning"] })
 ```
 
-## Test Coverage
+## Test Execution
 
-### Coverage Analysis
-```javascript
-// Quality assessment
-mcp__monomind__quality_assess({
-  "target": "test-coverage",
-  "criteria": ["line-coverage", "branch-coverage", "function-coverage"]
-})
+Run tests in parallel via Bash agents:
 
-// Edge case detection
-mcp__monomind__pattern_recognize({
-  "data": testScenarios,
-  "patterns": ["edge-case", "boundary-condition", "error-path"]
-})
+```bash
+# Agents each run one of these in parallel
+npm run test:unit
+npm run test:integration
+npm run test:e2e
 ```
 
-### Test Execution
-```javascript
-// Parallel test execution
-mcp__monomind__parallel_execute({
-  "tasks": [
-    { "id": "unit-tests", "command": "npm run test:unit" },
-    { "id": "integration-tests", "command": "npm run test:integration" },
-    { "id": "e2e-tests", "command": "npm run test:e2e" }
-  ]
-})
-
-// Batch processing for test suites
-mcp__monomind__batch_process({
-  "items": testSuites,
-  "operation": "execute-test-suite"
-})
-```
+## Monitoring and Reporting
 
-### Performance Testing
 ```javascript
-// Run performance benchmarks
-mcp__monomind__benchmark_run({
-  "suite": "performance-tests"
-})
+// Check swarm status
+mcp__monomind__swarm_status({ swarmId: "current" })
 
-// Security scanning
-mcp__monomind__security_scan({
-  "target": "application",
-  "depth": "comprehensive"
-})
+// Performance metrics
+mcp__monomind__performance_report({ format: "detailed" })
 ```
 
-### Monitoring and Reporting
-```javascript
-// Monitor test execution
-mcp__monomind__swarm_monitor({
-  "swarmId": "testing-swarm",
-  "interval": 2000
-})
-
-// Generate test report
-mcp__monomind__performance_report({
-  "format": "detailed",
-  "timeframe": "current-run"
-})
+## Best Practices
 
-// Get test results
-mcp__monomind__task_results({
-  "taskId": "test-execution-001"
-})
-```
+- Use star topology (coordinator at center, test agents at spokes) for isolated parallel runs
+- Run unit and integration tests in parallel; run E2E only after integration passes
+- Security testing agent runs last, after code is stable

package/.claude/commands/tokens.md

@@ -1,9 +1,14 @@
+---
+name: tokens
+description: Show the Monomind token usage dashboard — reports spend and call counts for today, week, 30days, or month
+---
+
 Show the Monomind token usage dashboard for the requested period.
 
 Run this shell command immediately without asking for confirmation:
 
 ```bash
-node "${CLAUDE_PROJECT_DIR:-/Users/morteza/Desktop/tools/monomind}/.claude/helpers/token-tracker.cjs" report "${1:-today}"
+node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/token-tracker.cjs" report "${1:-today}"
 ```
 
 Valid periods: `today` (default), `week`, `30days`, `month`.

package/.claude/commands/training/README.md

@@ -1,9 +1,39 @@
-# Training Commands
+---
+name: training:README
+description: Training skill index — neural pattern training, model optimization, agent specialization, and pattern learning reference
+---
 
-Commands for training operations in Monomind.
+# Training Skills
 
-## Available Commands
+Neural network training, pattern learning, and agent specialization for Monomind.
 
-- [neural-train](./neural-train.md)
-- [pattern-learn](./pattern-learn.md)
-- [model-update](./model-update.md)
+## Available Skills
+
+- [neural-patterns](./neural-patterns.md) — Overview of how automatic and manual neural training works
+- [neural-train](./neural-train.md) — Train neural patterns with WASM acceleration (MicroLoRA + Flash Attention)
+- [pattern-learn](./pattern-learn.md) — Analyze and store patterns from successful operations
+- [model-update](./model-update.md) — Update and optimize trained neural models
+- [specialization](./specialization.md) — Train agents to specialize in specific domains or file types
+
+## Quick Start
+
+```bash
+# Train coordination patterns (50 epochs, WASM + Flash Attention)
+npx monomind neural train --pattern coordination --epochs 50
+
+# Check neural status
+npx monomind neural status
+
+# Analyze stored patterns
+npx monomind neural patterns --action analyze
+```
+
+## MCP Tools
+
+```javascript
+mcp__monomind__neural_train({ patternType: "coordination", epochs: 50 })
+mcp__monomind__neural_status({})
+mcp__monomind__neural_patterns({ action: "list", limit: 10 })
+mcp__monomind__neural_predict({ input: "task description" })
+mcp__monomind__neural_optimize({ method: "quantize" })
+```

package/.claude/commands/training/model-update.md

@@ -1,25 +1,78 @@
-# model-update
+---
+name: training:model-update
+description: Update and optimize trained neural models — quantize, compact, and export models using the real neural optimize and export CLI commands
+---
 
-Update neural models with new data.
+# Model Update
+
+Update, optimize, and export trained neural models.
+
+## How to Invoke
+
+```
+Skill("training:model-update")
+```
+
+---
+
+## CLI Reference
 
-## Usage
 ```bash
-npx monomind training model-update [options]
+# Optimize a model (quantize for size/speed)
+npx monomind neural optimize --method quantize
+
+# Analyze model quality before/after optimization
+npx monomind neural optimize --method analyze --verbose
+
+# Compact model for faster inference
+npx monomind neural optimize --method compact
+
+# Check model status after update
+npx monomind neural status --verbose
+
+# Export a trained model
+npx monomind neural export --model coordination
 ```
 
-## Options
-- `--model <name>` - Model to update
-- `--incremental` - Incremental update
-- `--validate` - Validate after update
+## MCP Tools
+
+```javascript
+// Optimize model (quantize/compact)
+mcp__monomind__neural_optimize({ method: "quantize" })
+
+// Compress for deployment
+mcp__monomind__neural_compress({})
+
+// Check model health and scores
+mcp__monomind__neural_status({ verbose: true })
+
+// SONA self-adapting model update
+mcp__monomind__ruvllm_sona_adapt({ modelId: "coordination" })
+```
+
+## Optimization Methods
+
+| Method | What it does |
+|--------|-------------|
+| `quantize` | Reduce model precision for smaller size and faster inference |
+| `analyze` | Report model quality metrics without changing the model |
+| `compact` | Prune low-value weights, reduce model footprint |
+
+## Workflow
 
-## Examples
 ```bash
-# Update all models
-npx monomind training model-update
+# 1. Analyze current state
+npx monomind neural optimize --method analyze --verbose
+
+# 2. Train with new data if needed
+npx monomind neural train --pattern coordination --epochs 100
+
+# 3. Optimize the updated model
+npx monomind neural optimize --method quantize
 
-# Specific model
-npx monomind training model-update --model agent-selector
+# 4. Verify improvement
+npx monomind neural status --verbose
 
-# Incremental with validation
-npx monomind training model-update --incremental --validate
+# 5. Export for deployment
+npx monomind neural export --model coordination
 ```

package/.claude/commands/training/neural-patterns.md

@@ -1,74 +1,73 @@
+---
+name: training:neural-patterns
+description: Neural pattern training overview — automatic learning from operations, manual training, pattern types, and improvement tracking
+---
+
 # Neural Pattern Training
 
-## Purpose
-Continuously improve coordination through neural network learning.
+How Monomind continuously learns and improves through neural pattern training.
+
+## How to Invoke
+
+```
+Skill("training:neural-patterns")
+```
+
+---
 
-## How Training Works
+## Automatic Learning
 
-### 1. Automatic Learning
-Every successful operation trains the neural networks:
+Every successful operation trains the neural networks automatically:
 - Edit patterns for different file types
 - Search strategies that find results faster
 - Task decomposition approaches
 - Agent coordination patterns
 
-### 2. Manual Training
-```
-Tool: mcp__monomind__neural_train
-Parameters: {
-  "pattern_type": "coordination",
-  "training_data": "successful task patterns",
-  "epochs": 50
-}
-```
+The hooks system (`post-edit`, `post-task`) feeds successful operations into training automatically.
 
-### 3. Pattern Types
+## Manual Training
 
-**Cognitive Patterns:**
-- Convergent: Focused problem-solving
-- Divergent: Creative exploration
-- Lateral: Alternative approaches
-- Systems: Holistic thinking
-- Critical: Analytical evaluation
-- Abstract: High-level design
+```javascript
+// Train coordination patterns
+mcp__monomind__neural_train({ patternType: "coordination", epochs: 50 })
 
-### 4. Improvement Tracking
-```
-Tool: mcp__monomind__neural_status
-Result: {
-  "patterns": {
-    "convergent": 0.92,
-    "divergent": 0.87,
-    "lateral": 0.85
-  },
-  "improvement": "5.3% since last session",
-  "confidence": 0.89
-}
-```
+// Train security patterns with contrastive learning
+mcp__monomind__neural_train({ patternType: "security", epochs: 100 })
 
-## Pattern Analysis
+// Check training status and pattern scores
+mcp__monomind__neural_status({})
+
+// Analyze recent patterns
+mcp__monomind__neural_patterns({ action: "analyze", limit: 20 })
 ```
-Tool: mcp__monomind__neural_patterns
-Parameters: {
-  "action": "analyze",
-  "operation": "recent_edits"
-}
+
+```bash
+npx monomind neural train --pattern coordination --epochs 50
+npx monomind neural status
+npx monomind neural patterns --action analyze
 ```
 
-## Benefits
-- 🧠 Learns your coding style
-- 📈 Improves with each use
-- 🎯 Better task predictions
-- ⚡ Faster coordination
+## Pattern Types
 
-## CLI Usage
-```bash
-# Train neural patterns via CLI
-npx monomind neural train --type coordination --epochs 50
+| Pattern | Purpose |
+|---------|---------|
+| `coordination` | Multi-agent task coordination (default) |
+| `optimization` | Performance and resource optimization |
+| `prediction` | Task routing and agent selection |
+| `security` | Security scanning and vulnerability detection |
+| `testing` | Test strategy selection and coverage |
 
-# Check neural status
-npx monomind neural status
+## Improvement Tracking
+
+```javascript
+// View current pattern scores and improvement
+mcp__monomind__neural_status({ verbose: true })
+```
+
+Output includes pattern confidence scores and improvement percentage since last session.
+
+## See Also
 
-# Analyze patterns
-npx monomind neural patterns --analyze
-```
+- `training:neural-train` — Full training options with WASM acceleration
+- `training:pattern-learn` — Manual pattern storage
+- `training:model-update` — Model optimization