@monoes/monomindcli 1.10.54 → 1.10.55

package/.claude/commands/analysis/token-efficiency.md

@@ -1,42 +0,0 @@
----
-name: analysis:token-efficiency
----
-
-# Token Usage Optimization
-
-## Purpose
-Reduce token consumption while maintaining quality through intelligent coordination.
-
-## Optimization Strategies
-
-### 1. Smart Caching
-- Search results cached for 5 minutes
-- File content cached during session
-- Pattern recognition reduces redundant searches
-
-### 2. Efficient Coordination
-- Agents share context automatically
-- Avoid duplicate file reads
-- Batch related operations
-
-### 3. Measurement & Tracking
-
-```bash
-# Check token usage for today
-npx monomind tokens today
-
-# Full period breakdown
-npx monomind tokens summary --period 30days --json
-```
-
-## Best Practices
-1. **Use Task tool** for complex searches
-2. **Enable caching** in pre-search hooks
-3. **Batch operations** when possible
-4. **Review session summaries** for insights
-
-## Token Reduction Results
-- 32.3% average token reduction
-- More focused operations
-- Intelligent result reuse
-- Cumulative improvements

package/.claude/commands/optimization/README.md

@@ -1,73 +0,0 @@
----
-name: optimization:README
-description: Optimization skills index — swarm topology selection, parallel execution patterns, and system-level performance tuning
----
-
-# Optimization Commands
-
-Guides and commands for optimizing Monomind performance — swarm topology, parallel execution, and system-level tuning.
-
-## Real CLI Commands
-
-| Command | Description |
-|---|---|
-| `performance optimize` | Analyze and apply system optimizations (memory/CPU/latency) |
-| `performance bottleneck` | Find performance bottlenecks |
-| `performance benchmark` | Run benchmark suites (WASM/neural/memory/search) |
-| `performance metrics` | View performance metrics over time |
-| `neural optimize` | Quantize or compact neural model weights |
-| `swarm init --topology` | Configure swarm topology for performance |
-
-## Quick Reference
-
-```bash
-# Find what's slow
-npx monomind performance bottleneck
-
-# Get optimization recommendations (no changes)
-npx monomind performance optimize --dry-run
-
-# Apply all optimizations
-npx monomind performance optimize --target all --apply
-
-# Benchmark all subsystems
-npx monomind performance benchmark --suite all
-
-# Neural model quantization
-npx monomind neural optimize --method quantize
-```
-
-## Files
-
-- [auto-topology.md](./auto-topology.md) — Automatic topology selection and swarm configuration
-- [parallel-execution.md](./parallel-execution.md) — Parallel agent execution patterns with Task tool
-- [performance-optimize.md](./performance-optimize.md) — `performance optimize` CLI reference
-
-## MCP Tools
-
-| Tool | Purpose |
-|---|---|
-| `mcp__monomind__performance_optimize` | Apply performance optimizations |
-| `mcp__monomind__performance_benchmark` | Run benchmarks |
-| `mcp__monomind__performance_metrics` | Get performance metrics |
-| `mcp__monomind__performance_bottleneck` | Detect bottlenecks |
-| `mcp__monomind__performance_profile` | CPU/memory profiling |
-| `mcp__monomind__coordination_topology` | Optimize swarm topology |
-| `mcp__monomind__neural_optimize` | Neural model optimization |
-
-## Performance Targets
-
-| Metric | Target |
-|---|---|
-| Flash Attention | 2.49x–7.47x speedup |
-| HNSW Search | 150x–12,500x faster |
-| Memory Reduction | 50–75% with quantization |
-| MCP Response | <100ms |
-| CLI Startup | <500ms |
-
-## See Also
-
-- `performance` — full performance command set
-- `neural` — neural training and optimization
-- `memory compress` — memory-level optimization
-- `hooks metrics` — intelligence system metrics

package/.claude/commands/optimization/parallel-execution.md

@@ -1,76 +0,0 @@
----
-name: optimization:parallel-execution
-description: Execute independent subtasks in parallel using Claude Code's Task tool — spawn all agents in one message, use swarm coordination, and monitor with swarm_status
----
-
-# Parallel Task Execution
-
-Execute independent subtasks in parallel for maximum throughput. Parallel execution is handled by Claude Code's Task tool — not a CLI command.
-
-## The Pattern: Spawn All Agents in One Message
-
-```javascript
-// Initialize swarm coordination
-// npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
-
-// Then spawn ALL agents in ONE message with run_in_background: true
-Task({ prompt: "Design API structure and document decisions", subagent_type: "system-architect", run_in_background: true });
-Task({ prompt: "Implement auth endpoints following the architecture", subagent_type: "coder", run_in_background: true });
-Task({ prompt: "Implement CRUD endpoints in parallel with auth", subagent_type: "coder", run_in_background: true });
-Task({ prompt: "Write tests as features complete", subagent_type: "tester", run_in_background: true });
-Task({ prompt: "Review code quality and security", subagent_type: "reviewer", run_in_background: true });
-```
-
-After spawning, **stop and wait** — do not poll or check status. Agents report back when done.
-
-## Coordination via MCP
-
-```javascript
-// Orchestrate a parallel task plan
-mcp__monomind__coordination_orchestrate({
-  task: "Build REST API with auth, CRUD, and tests",
-  strategy: "parallel",
-  maxAgents: 8
-})
-```
-
-## Task Decomposition Principles
-
-1. **Identify independent components** — what has no dependency on others?
-2. **Assign by specialization** — coder for implementation, tester for tests, architect for design
-3. **Synchronize at dependency points** — one agent waits for another's output before proceeding
-4. **Keep tasks focused** — one clear objective per agent, not a list of things
-
-## Example Breakdown for a Feature
-
-| Agent | Task | Depends On |
-|---|---|---|
-| Architect | Design data model + API contract | — |
-| Coder A | Implement auth module | Architect |
-| Coder B | Implement CRUD module | Architect |
-| Tester | Write integration tests | Coder A + B |
-| Reviewer | Code review + security check | Coder A + B |
-
-## Performance Impact
-
-With 5 parallel agents on a typical feature:
-- Sequential: ~30 minutes
-- Parallel: ~10–12 minutes (2.5–3x faster)
-
-The bottleneck shifts to synchronization points, not raw execution time.
-
-## Monitor Active Execution
-
-```bash
-# Check current swarm and agent status
-npx monomind status --watch
-
-# Or via MCP
-mcp__monomind__swarm_status({ includeMetrics: true })
-```
-
-## See Also
-
-- `swarm init` — configure topology before spawning
-- `status` — monitor parallel execution progress
-- `hooks pre-task` — get agent recommendations before spawning

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

@@ -1,62 +0,0 @@
----
-name: swarm-swarm-analysis
-description: Analyze swarm performance — review coordination efficiency, bottlenecks, and agent utilization for a completed swarm run
----
-
-# Swarm Performance Analysis
-
-Analyze how a swarm performed: coordination efficiency, agent utilization, and bottlenecks.
-
-## How to Invoke
-
-```
-Skill("swarm:swarm-analysis")
-```
-
----
-
-## Performance Review
-
-```javascript
-// Full performance report
-mcp__monomind__performance_report({ format: "detailed" })
-
-// Identify bottlenecks
-mcp__monomind__performance_bottleneck({ component: "swarm" })
-
-// System metrics snapshot
-mcp__monomind__system_metrics({})
-
-// Coordination topology review
-mcp__monomind__coordination_metrics({})
-```
-
-## What to Analyze
-
-After a swarm completes, review:
-
-1. **Agent utilization** — were all agents busy or were some idle?
-2. **Task completion time** — which tasks took longest?
-3. **Coordination overhead** — how much time was spent coordinating vs executing?
-4. **Memory usage** — did agents share knowledge effectively?
-
-## Optimization Loop
-
-```javascript
-// Check what patterns worked
-mcp__monomind__neural_patterns({ action: "stats" })
-
-// Store lessons learned
-mcp__monomind__memory_store({
-  key: "swarm-analysis",
-  value: "what worked: hierarchical was efficient, what to improve: too many agents for small task",
-  namespace: "swarm"
-})
-```
-
-## CLI
-
-```bash
-npx monomind performance report --format detailed
-npx monomind performance bottleneck --component swarm
-```

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

@@ -1,65 +0,0 @@
----
-name: swarm-swarm-background
-description: Run swarms in background mode — start a swarm, let it work autonomously, and retrieve results later without blocking
----
-
-# Background Swarm Operations
-
-Start swarms that work autonomously without blocking the main conversation.
-
-## How to Invoke
-
-```
-Skill("swarm:swarm-background")
-```
-
----
-
-## Pattern
-
-Background swarms work best with the Claude Code Task tool — spawn agents with `run_in_background: true`, then continue other work while they run.
-
-```javascript
-// 1. Initialize the swarm
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 6, strategy: "specialized" })
-
-// 2. Spawn agents with background execution via Task tool
-// (spawn multiple agents in a single message for true parallelism)
-
-// 3. Check status later (do NOT poll — wait for notifications)
-mcp__monomind__swarm_status({ swarmId: "current" })
-```
-
-## Anti-Patterns to Avoid
-
-- **Do NOT** poll `swarm_status` in a loop — wait for agents to report back
-- **Do NOT** spawn agents one-at-a-time sequentially — spawn all in one message
-- **Do NOT** check status immediately after spawning — give agents time to work
-
-## Memory Persistence
-
-Store results from a background swarm for retrieval in future sessions:
-
-```javascript
-mcp__monomind__memory_store({
-  key: "background-swarm-results",
-  value: "summary of what was found",
-  namespace: "swarm"
-})
-```
-
-Retrieve later:
-
-```javascript
-mcp__monomind__memory_search({ query: "background swarm results", namespace: "swarm", limit: 5 })
-```
-
-## CLI
-
-```bash
-# Start in background (returns immediately)
-npx monomind swarm start "analyze codebase" --strategy analysis &
-
-# Check later
-npx monomind swarm status
-```

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

@@ -1,67 +0,0 @@
----
-name: swarm-swarm-modes
-description: Swarm topology modes reference — hierarchical, mesh, star topologies with when-to-use guidance for each coordination pattern
----
-
-# Swarm Topology Modes
-
-Reference for choosing the right topology when initializing a swarm.
-
-## How to Invoke
-
-```
-Skill("swarm:swarm-modes")
-```
-
----
-
-## Topologies
-
-### Hierarchical
-
-```javascript
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
-```
-
-- Coordinator agent manages worker agents
-- Best for: feature development, sequential workflows with dependencies
-- Example flow: architect → coders → tester → documenter
-
-### Mesh
-
-```javascript
-mcp__monomind__swarm_init({ topology: "mesh", maxAgents: 6, strategy: "adaptive" })
-```
-
-- All agents communicate with all others — fully connected
-- Best for: research, analysis, exploration where findings are shared across agents
-- Example flow: multiple researcher agents sharing discovered facts in real time
-
-### Star
-
-```javascript
-mcp__monomind__swarm_init({ topology: "star", maxAgents: 7, strategy: "parallel" })
-```
-
-- Central coordinator, isolated worker spokes
-- Best for: parallel independent tasks (running multiple test suites, analyzing separate modules)
-- Example flow: coordinator dispatches to 6 isolated test runner agents
-
-## Quick Selection Guide
-
-| Task | Topology | Why |
-|------|----------|-----|
-| Build a feature | hierarchical | Sequential: design → code → test |
-| Research a topic | mesh | Knowledge shared across all researchers |
-| Run test suites | star | Independent parallel execution |
-| Security audit | mesh | Cross-agent findings correlation |
-| Maintenance tasks | star | Sequential isolated steps |
-| Performance optimization | mesh | Profilers share bottleneck data |
-
-## CLI
-
-```bash
-npx monomind swarm init --topology hierarchical --max-agents 8
-npx monomind swarm init --topology mesh --max-agents 6
-npx monomind swarm init --topology star --max-agents 5
-```

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

@@ -1,54 +0,0 @@
----
-name: swarm-swarm-monitor
-description: Monitor a running swarm in real-time — track agent activity, task completion, and swarm health during execution
----
-
-# Swarm Monitor
-
-Monitor a running swarm's progress and agent activity.
-
-## How to Invoke
-
-```
-Skill("swarm:swarm-monitor")
-```
-
----
-
-## MCP Tools
-
-```javascript
-// Poll swarm status (call repeatedly to monitor)
-mcp__monomind__swarm_status({ swarmId: "current" })
-
-// System-level metrics
-mcp__monomind__system_metrics({})
-
-// Agent health
-mcp__monomind__agent_health({})
-
-// Agent list with status
-mcp__monomind__agent_list({})
-```
-
-## CLI
-
-```bash
-# Check status
-npx monomind swarm status
-
-# List active agents
-npx monomind agent list
-
-# Agent metrics
-npx monomind agent metrics
-```
-
-## Monitoring Pattern
-
-Do NOT poll in a tight loop — check status every 30-60 seconds for long-running swarms. The swarm will report when it finishes.
-
-```javascript
-// One-time health snapshot
-mcp__monomind__swarm_health({})
-```

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

@@ -1,44 +0,0 @@
----
-name: swarm-swarm-status
-description: Check swarm health, agent status, and progress for a running multi-agent swarm
----
-
-# Swarm Status
-
-Check the health and progress of a running swarm.
-
-## How to Invoke
-
-```
-Skill("swarm:swarm-status")
-```
-
----
-
-## MCP Tools
-
-```javascript
-// Check current swarm
-mcp__monomind__swarm_status({ swarmId: "current" })
-
-// System-level health
-mcp__monomind__system_health({})
-
-// System metrics
-mcp__monomind__system_metrics({})
-```
-
-## CLI
-
-```bash
-npx monomind swarm status
-```
-
-## What to Look For
-
-- **Active agents**: count of agents currently running
-- **Task completion**: percentage of tasks finished
-- **Agent health**: any failed or stalled agents
-- **Memory usage**: memory consumption across agents
-
-If any agent is stalled, run `swarm stop` then `swarm start` to restart.

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

@@ -1,76 +0,0 @@
----
-name: swarm-swarm-strategies
-description: Swarm strategy selection guide — when to use specialized, adaptive, balanced, sequential, and parallel strategies for different tasks
----
-
-# Swarm Strategy Guide
-
-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/training/model-update.md

@@ -1,78 +0,0 @@
----
-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
----
-
-# Model Update
-
-Update, optimize, and export trained neural models.
-
-## How to Invoke
-
-```
-Skill("training:model-update")
-```
-
----
-
-## CLI Reference
-
-```bash
-# 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
-```
-
-## 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
-
-```bash
-# 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
-
-# 4. Verify improvement
-npx monomind neural status --verbose
-
-# 5. Export for deployment
-npx monomind neural export --model coordination
-```