@monoes/monomindcli 1.8.0 → 1.9.0

package/.claude/commands/analysis/bottleneck-detect.md

@@ -1,162 +1,69 @@
-# bottleneck detect
+---
+name: analysis:bottleneck-detect
+---
 
-Analyze performance bottlenecks in swarm operations and suggest optimizations.
+# bottleneck-detect
+
+Detect performance bottlenecks in system components and swarm operations.
 
 ## Usage
 
 ```bash
-npx monomind bottleneck detect [options]
+npx monomind performance bottleneck [options]
 ```
 
 ## Options
 
-- `--swarm-id, -s <id>` - Analyze specific swarm (default: current)
-- `--time-range, -t <range>` - Analysis period: 1h, 24h, 7d, all (default: 1h)
-- `--threshold <percent>` - Bottleneck threshold percentage (default: 20)
-- `--export, -e <file>` - Export analysis to file
-- `--fix` - Apply automatic optimizations
+- `--component, -c <name>` - Analyze a specific component (e.g. `memory`, `neural`, `swarm`)
+- `--depth, -d <level>` - Analysis depth: `quick` (default) or `full`
 
 ## Examples
 
-### Basic bottleneck detection
-
-```bash
-npx monomind bottleneck detect
-```
-
-### Analyze specific swarm
+### Quick bottleneck scan
 
 ```bash
-npx monomind bottleneck detect --swarm-id swarm-123
+npx monomind performance bottleneck
 ```
 
-### Last 24 hours with export
+### Deep analysis of a specific component
 
 ```bash
-npx monomind bottleneck detect -t 24h -e bottlenecks.json
-```
-
-### Auto-fix detected issues
-
-```bash
-npx monomind bottleneck detect --fix --threshold 15
+npx monomind performance bottleneck --component memory --depth full
 ```
 
 ## Metrics Analyzed
 
-### Communication Bottlenecks
+### Processing Bottlenecks
 
-- Message queue delays
-- Agent response times
-- Coordination overhead
-- Memory access patterns
+- CPU load and utilization
+- Memory pressure and heap usage
+- Disk I/O latency
 
-### Processing Bottlenecks
+### Swarm Bottlenecks
 
-- Task completion times
-- Agent utilization rates
+- Agent coordination overhead
+- Task queue depth and wait times
 - Parallel execution efficiency
-- Resource contention
 
 ### Memory Bottlenecks
 
 - Cache hit rates
-- Memory access patterns
+- Neural pattern load time
 - Storage I/O performance
-- Neural pattern loading
-
-### Network Bottlenecks
-
-- API call latency
-- MCP communication delays
-- External service timeouts
-- Concurrent request limits
-
-## Output Format
-
-```
-🔍 Bottleneck Analysis Report
-━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-📊 Summary
-├── Time Range: Last 1 hour
-├── Agents Analyzed: 6
-├── Tasks Processed: 42
-└── Critical Issues: 2
-
-🚨 Critical Bottlenecks
-1. Agent Communication (35% impact)
-   └── coordinator → coder-1 messages delayed by 2.3s avg
-
-2. Memory Access (28% impact)
-   └── Neural pattern loading taking 1.8s per access
-
-⚠️ Warning Bottlenecks
-1. Task Queue (18% impact)
-   └── 5 tasks waiting > 10s for assignment
-
-💡 Recommendations
-1. Switch to hierarchical topology (est. 40% improvement)
-2. Enable memory caching (est. 25% improvement)
-3. Increase agent concurrency to 8 (est. 20% improvement)
-
-✅ Quick Fixes Available
-Run with --fix to apply:
-- Enable smart caching
-- Optimize message routing
-- Adjust agent priorities
-```
-
-## Automatic Fixes
-
-When using `--fix`, the following optimizations may be applied:
-
-1. **Topology Optimization**
-
-   - Switch to more efficient topology
-   - Adjust communication patterns
-   - Reduce coordination overhead
-
-2. **Caching Enhancement**
-
-   - Enable memory caching
-   - Optimize cache strategies
-   - Preload common patterns
-
-3. **Concurrency Tuning**
-
-   - Adjust agent counts
-   - Optimize parallel execution
-   - Balance workload distribution
-
-4. **Priority Adjustment**
-   - Reorder task queues
-   - Prioritize critical paths
-   - Reduce wait times
-
-## Performance Impact
-
-Typical improvements after bottleneck resolution:
-
-- **Communication**: 30-50% faster message delivery
-- **Processing**: 20-40% reduced task completion time
-- **Memory**: 40-60% fewer cache misses
-- **Overall**: 25-45% performance improvement
 
 ## Integration with Claude Code
 
 ```javascript
-// Check for bottlenecks in Claude Code
-mcp__monomind__bottleneck_detect {
-  timeRange: "1h",
-  threshold: 20,
-  autoFix: false
-}
+mcp__monomind__performance_bottleneck({
+  component: "memory",   // optional — omit to scan all
+  threshold: 20,         // alert threshold %
+  deep: false            // set true for full analysis
+})
 ```
 
 ## See Also
 
-- `performance report` - Detailed performance analysis
-- `token usage` - Token optimization analysis
-- `swarm monitor` - Real-time monitoring
-- `cache manage` - Cache optimization
+- `performance metrics` — detailed time-series metrics
+- `performance optimize` — apply recommended fixes
+- `performance benchmark` — run benchmark suites
+- `token-usage` — token consumption analysis

package/.claude/commands/analysis/performance-bottlenecks.md

@@ -1,3 +1,7 @@
+---
+name: analysis:performance-bottlenecks
+---
+
 # Performance Bottleneck Analysis
 
 ## Purpose
@@ -31,25 +35,21 @@ The post-task hook automatically analyzes:
 
 ### 3. Improvement Suggestions
 
-```
-Tool: mcp__monomind__task_results
-Parameters: {"taskId": "task-123", "format": "detailed"}
+```javascript
+mcp__monomind__performance_bottleneck({
+  component: "swarm",  // optional — omit to scan all
+  threshold: 20,       // alert threshold %
+  deep: true           // full analysis
+})
 
-Result includes:
+// Result includes:
 {
   "bottlenecks": [
     {
-      "type": "coordination",
+      "component": "cpu",
       "severity": "high",
-      "description": "Single agent used for complex task",
-      "recommendation": "Spawn specialized agents for parallel work"
-    }
-  ],
-  "improvements": [
-    {
-      "area": "execution_time",
-      "suggestion": "Use parallel task execution",
-      "expectedImprovement": "30-50% time reduction"
+      "message": "CPU load at 82%",
+      "threshold": 75
     }
   ]
 }

package/.claude/commands/analysis/performance-report.md

@@ -1,25 +1,52 @@
+---
+name: analysis:performance-report
+---
+
 # performance-report
 
-Generate comprehensive performance reports for swarm operations.
+Generate performance metrics reports for swarm operations and system components.
 
 ## Usage
+
 ```bash
-npx monomind analysis performance-report [options]
+npx monomind performance metrics [options]
 ```
 
 ## Options
-- `--format <type>` - Report format (json, html, markdown)
-- `--include-metrics` - Include detailed metrics
-- `--compare <id>` - Compare with previous swarm
+
+- `--timeframe, -t <range>` - Time range: `1h`, `24h` (default), `7d`, `30d`
+- `--format, -f <type>` - Output format: `text` (default), `json`, `prometheus`
+- `--component, -c <name>` - Filter to a specific component
 
 ## Examples
+
 ```bash
-# Generate HTML report
-npx monomind analysis performance-report --format html
+# Default 24h report
+npx monomind performance metrics
+
+# Last 7 days in JSON
+npx monomind performance metrics --timeframe 7d --format json
 
-# Compare swarms
-npx monomind analysis performance-report --compare swarm-123
+# Prometheus-compatible output
+npx monomind performance metrics --format prometheus
 
-# Full metrics report
-npx monomind analysis performance-report --include-metrics --format markdown
+# Filter to memory component
+npx monomind performance metrics --component memory
 ```
+
+## Integration with Claude Code
+
+```javascript
+mcp__monomind__performance_report({
+  timeRange: "24h",   // "1h" | "24h" | "7d"
+  format: "summary",  // "json" | "summary" | "detailed"
+  components: ["memory", "neural", "swarm"]  // optional filter
+})
+```
+
+## See Also
+
+- `performance benchmark` — run benchmark suites
+- `performance bottleneck` — detect bottlenecks
+- `performance optimize` — apply optimizations
+- `token-usage` — token consumption by period

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

@@ -1,3 +1,7 @@
+---
+name: analysis:token-efficiency
+---
+
 # Token Usage Optimization
 
 ## Purpose
@@ -18,18 +22,11 @@ Reduce token consumption while maintaining quality through intelligent coordinat
 ### 3. Measurement & Tracking
 
 ```bash
-# Check token savings after session
-Tool: mcp__monomind__token_usage
-Parameters: {"operation": "session", "timeframe": "24h"}
-
-# Result shows:
-{
-  "metrics": {
-    "tokensSaved": 15420,
-    "operations": 45,
-    "efficiency": "343 tokens/operation"
-  }
-}
+# Check token usage for today
+npx monomind tokens today
+
+# Full period breakdown
+npx monomind tokens summary --period 30days --json
 ```
 
 ## Best Practices
@@ -39,7 +36,7 @@ Parameters: {"operation": "session", "timeframe": "24h"}
 4. **Review session summaries** for insights
 
 ## Token Reduction Results
-- 📉 32.3% average token reduction
-- 🎯 More focused operations
-- 🔄 Intelligent result reuse
-- 📊 Cumulative improvements
+- 32.3% average token reduction
+- More focused operations
+- Intelligent result reuse
+- Cumulative improvements

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

@@ -1,25 +1,47 @@
+---
+name: analysis:token-usage
+---
+
 # token-usage
 
-Analyze token usage patterns and optimize for efficiency.
+Analyze token consumption and cost across sessions.
 
 ## Usage
+
 ```bash
-npx monomind analysis token-usage [options]
+npx monomind tokens summary [options]
 ```
 
-## Options
-- `--period <time>` - Analysis period (1h, 24h, 7d, 30d)
-- `--by-agent` - Break down by agent
-- `--by-operation` - Break down by operation type
+## Subcommands
+
+| Command | Description |
+|---------|-------------|
+| `tokens summary` | Summary for a period |
+| `tokens today` | Quick today + month totals |
+| `tokens dashboard` | Interactive live dashboard |
+
+## Options for `tokens summary`
+
+- `--period, -p <range>` - Time period: `today` (default), `week`, `30days`, `month`
+- `--json` - Output raw JSON
 
 ## Examples
+
 ```bash
-# Last 24 hours token usage
-npx monomind analysis token-usage --period 24h
+# Today's usage
+npx monomind tokens today
+
+# Full 30-day summary
+npx monomind tokens summary --period 30days
 
-# By agent breakdown
-npx monomind analysis token-usage --by-agent
+# Machine-readable output
+npx monomind tokens summary --period week --json
 
-# Export detailed report
-npx monomind analysis token-usage --period 7d --export tokens.csv
+# Live interactive dashboard
+npx monomind tokens dashboard
 ```
+
+## See Also
+
+- `performance metrics` — CPU/memory/latency metrics
+- `performance bottleneck` — identify performance hotspots

package/.claude/commands/automation/README.md

@@ -1,9 +1,19 @@
+---
+name: automation:readme
+---
+
 # Automation Commands
 
-Commands for automation operations in Monomind.
+Commands and guidance for agent automation, self-healing, and session management in Monomind.
+
+## Commands (invoke as slash commands)
+
+- [auto-agent](./auto-agent.md) — spawn agents by type and task (`monomind agent spawn`)
+- [smart-spawn](./smart-spawn.md) — auto-spawn agents via hooks pre-task (`monomind hooks pre-task --auto-spawn`)
+- [workflow-select](./workflow-select.md) — run predefined workflow templates (`monomind workflow run`)
 
-## Available Commands
+## Guidance Docs (contextual reference)
 
-- [auto-agent](./auto-agent.md)
-- [smart-spawn](./smart-spawn.md)
-- [workflow-select](./workflow-select.md)
+- [smart-agents](./smart-agents.md) — auto-spawning triggers by file type, complexity, and workload
+- [self-healing](./self-healing.md) — automatic error detection and recovery patterns
+- [session-memory](./session-memory.md) — cross-session context persistence and restoration

package/.claude/commands/automation/auto-agent.md

@@ -1,122 +1,86 @@
-# auto agent
+---
+name: automation:auto-agent
+---
 
-Automatically spawn and manage agents based on task requirements.
+# auto-agent
+
+Automatically spawn agents based on task requirements.
 
 ## Usage
 
 ```bash
-npx monomind auto agent [options]
+npx monomind agent spawn [options]
 ```
 
 ## Options
 
-- `--task, -t <description>` - Task description for agent analysis
-- `--max-agents, -m <number>` - Maximum agents to spawn (default: auto)
-- `--min-agents <number>` - Minimum agents required (default: 1)
-- `--strategy, -s <type>` - Selection strategy: optimal, minimal, balanced
-- `--no-spawn` - Analyze only, don't spawn agents
+- `--type, -t <type>` - Agent type: `coder`, `tester`, `researcher`, `coordinator`, `architect`, `analyst`
+- `--name, -n <name>` - Agent name
+- `--task <description>` - Task description
+- `--timeout <ms>` - Timeout in milliseconds
+- `--auto-tools` - Enable automatic tool selection
 
 ## Examples
 
-### Basic auto-spawning
-
-```bash
-npx monomind auto agent --task "Build a REST API with authentication"
-```
-
-### Constrained spawning
+### Spawn a coder agent for a task
 
 ```bash
-npx monomind auto agent -t "Debug performance issue" --max-agents 3
+npx monomind agent spawn --type coder --task "Build a REST API with authentication"
 ```
 
-### Analysis only
+### Spawn coordinator with auto tools
 
 ```bash
-npx monomind auto agent -t "Refactor codebase" --no-spawn
+npx monomind agent spawn --type coordinator --auto-tools --task "Refactor codebase"
 ```
 
-### Minimal strategy
+### Check spawned agent status
 
 ```bash
-npx monomind auto agent -t "Fix bug in login" -s minimal
+npx monomind agent list
+npx monomind agent status --id <agent-id>
 ```
 
 ## How It Works
 
-1. **Task Analysis**
-
-   - Parses task description
-   - Identifies required skills
-   - Estimates complexity
-   - Determines parallelization opportunities
-
-2. **Agent Selection**
-
-   - Matches skills to agent types
-   - Considers task dependencies
-   - Optimizes for efficiency
-   - Respects constraints
-
-3. **Topology Selection**
-
-   - Chooses optimal swarm structure
-   - Configures communication patterns
-   - Sets up coordination rules
-   - Enables monitoring
-
-4. **Automatic Spawning**
-   - Creates selected agents
-   - Assigns specific roles
-   - Distributes subtasks
-   - Initiates coordination
-
-## Agent Types Selected
-
-- **Architect**: System design, architecture decisions
-- **Coder**: Implementation, code generation
-- **Tester**: Test creation, quality assurance
-- **Analyst**: Performance, optimization
-- **Researcher**: Documentation, best practices
-- **Coordinator**: Task management, progress tracking
-
-## Strategies
-
-### Optimal
-
-- Maximum efficiency
-- May spawn more agents
-- Best for complex tasks
-- Highest resource usage
-
-### Minimal
-
-- Minimum viable agents
-- Conservative approach
-- Good for simple tasks
-- Lowest resource usage
+1. **Task Analysis** — Parses task description and identifies required skills
+2. **Agent Selection** — Matches skills to agent type (`coder`, `architect`, `tester`, etc.)
+3. **Topology Selection** — Chooses swarm structure for multi-agent tasks
+4. **Spawning** — Creates agent with role, assigns subtasks, enables coordination
 
-### Balanced
+## Agent Types
 
-- Middle ground
-- Adaptive to complexity
-- Default strategy
-- Good performance/resource ratio
+| Type | Best For |
+|------|----------|
+| `architect` | System design, architecture decisions |
+| `coder` | Implementation, code generation |
+| `tester` | Test creation, quality assurance |
+| `analyst` | Performance, optimization |
+| `researcher` | Documentation, best practices |
+| `coordinator` | Task management, progress tracking |
 
 ## Integration with Claude Code
 
 ```javascript
-// In Claude Code after auto-spawning
-mcp__monomind__auto_agent {
+// Spawn a single specialized agent
+mcp__monomind__agent_spawn({
+  type: "coder",
+  name: "API Builder",
   task: "Build authentication system",
-  strategy: "balanced",
-  maxAgents: 6
-}
+  capabilities: ["typescript", "rest-api"]
+})
+
+// For multi-agent coordination, initialize a swarm first
+mcp__monomind__swarm_init({
+  topology: "hierarchical",
+  maxAgents: 6,
+  strategy: "specialized"
+})
 ```
 
 ## See Also
 
-- `agent spawn` - Manual agent creation
-- `swarm init` - Initialize swarm manually
-- `smart spawn` - Intelligent agent spawning
-- `workflow select` - Choose predefined workflows
+- `agent list` — list all active agents
+- `agent status` — check agent status
+- `swarm init` — initialize a multi-agent swarm
+- `workflow-select` — choose predefined workflows

package/.claude/commands/automation/self-healing.md

@@ -1,3 +1,7 @@
+---
+name: automation:self-healing
+---
+
 # Self-Healing Workflows
 
 ## Purpose
@@ -47,19 +51,17 @@ Each recovery improves future prevention:
 **Pattern Storage:**
 ```javascript
 // Store error patterns
-mcp__monomind__memory_usage({
-  "action": "store",
-  "key": "error-pattern-" + Date.now(),
-  "value": JSON.stringify(errorData),
-  "namespace": "error-patterns",
-  "ttl": 2592000 // 30 days
+mcp__monomind__memory_store({
+  key: "error-pattern-" + Date.now(),
+  value: JSON.stringify(errorData),
+  namespace: "error-patterns",
+  ttl: 2592000 // 30 days
 })
 
 // Analyze patterns
 mcp__monomind__neural_patterns({
-  "action": "analyze",
-  "operation": "error-recovery",
-  "outcome": "success"
+  operation: "error-recovery",
+  outcome: "success"
 })
 ```
 
@@ -82,10 +84,10 @@ mcp__monomind__agent_spawn({
 })
 
 // Orchestrate recovery
-mcp__monomind__task_orchestrate({
-  "task": "recover from error",
-  "strategy": "sequential",
-  "priority": "critical"
+mcp__monomind__coordination_orchestrate({
+  task: "recover from error",
+  strategy: "sequential",
+  priority: "critical"
 })
 ```
 
@@ -94,13 +96,13 @@ mcp__monomind__task_orchestrate({
 {
   "PostToolUse": [{
     "matcher": "^Bash$",
-    "command": "npx monomind hook post-bash --exit-code '${tool.result.exitCode}' --auto-recover"
+    "command": "npx monomind hooks post-command --command \"$TOOL_INPUT_command\" --success \"$TOOL_SUCCESS\""
   }]
 }
 ```
 
 ## Benefits
-- 🛡️ Resilient workflows
-- 🔄 Automatic recovery
-- 📚 Learns from errors
-- ⏱️ Saves debugging time
+- Resilient workflows
+- Automatic recovery
+- Learns from errors
+- Saves debugging time