monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/commands/analysis/performance-bottlenecks.md

@@ -0,0 +1,59 @@
+---
+name: analysis:performance-bottlenecks
+---
+
+# Performance Bottleneck Analysis
+
+## Purpose
+Identify and resolve performance bottlenecks in your development workflow.
+
+## Automated Analysis
+
+### 1. Real-time Detection
+The post-task hook automatically analyzes:
+- Execution time vs. complexity
+- Agent utilization rates
+- Resource constraints
+- Operation patterns
+
+### 2. Common Bottlenecks
+
+**Time Bottlenecks:**
+- Tasks taking > 5 minutes
+- Sequential operations that could parallelize
+- Redundant file operations
+
+**Coordination Bottlenecks:**
+- Single agent for complex tasks
+- Unbalanced agent workloads
+- Poor topology selection
+
+**Resource Bottlenecks:**
+- High operation count (> 100)
+- Memory constraints
+- I/O limitations
+
+### 3. Improvement Suggestions
+
+```javascript
+mcp__monomind__performance_bottleneck({
+  component: "swarm",  // optional — omit to scan all
+  threshold: 20,       // alert threshold %
+  deep: true           // full analysis
+})
+
+// Result includes:
+{
+  "bottlenecks": [
+    {
+      "component": "cpu",
+      "severity": "high",
+      "message": "CPU load at 82%",
+      "threshold": 75
+    }
+  ]
+}
+```
+
+## Continuous Optimization
+The system learns from each task to prevent future bottlenecks!

package/packages/@monomind/cli/.claude/commands/analysis/performance-report.md

@@ -0,0 +1,52 @@
+---
+name: analysis:performance-report
+---
+
+# performance-report
+
+Generate performance metrics reports for swarm operations and system components.
+
+## Usage
+
+```bash
+npx monomind performance metrics [options]
+```
+
+## Options
+
+- `--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
+# Default 24h report
+npx monomind performance metrics
+
+# Last 7 days in JSON
+npx monomind performance metrics --timeframe 7d --format json
+
+# Prometheus-compatible output
+npx monomind performance metrics --format prometheus
+
+# 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/packages/@monomind/cli/.claude/commands/analysis/token-usage.md

@@ -0,0 +1,47 @@
+---
+name: analysis:token-usage
+---
+
+# token-usage
+
+Analyze token consumption and cost across sessions.
+
+## Usage
+
+```bash
+npx monomind tokens summary [options]
+```
+
+## 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
+# Today's usage
+npx monomind tokens today
+
+# Full 30-day summary
+npx monomind tokens summary --period 30days
+
+# Machine-readable output
+npx monomind tokens summary --period week --json
+
+# Live interactive dashboard
+npx monomind tokens dashboard
+```
+
+## See Also
+
+- `performance metrics` — CPU/memory/latency metrics
+- `performance bottleneck` — identify performance hotspots

package/packages/@monomind/cli/.claude/commands/automation/README.md

@@ -0,0 +1,19 @@
+---
+name: automation:readme
+---
+
+# Automation Commands
+
+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`)
+
+## Guidance Docs (contextual reference)
+
+- [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/packages/@monomind/cli/.claude/commands/automation/auto-agent.md

@@ -0,0 +1,86 @@
+---
+name: automation:auto-agent
+---
+
+# auto-agent
+
+Automatically spawn agents based on task requirements.
+
+## Usage
+
+```bash
+npx monomind agent spawn [options]
+```
+
+## Options
+
+- `--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
+
+### Spawn a coder agent for a task
+
+```bash
+npx monomind agent spawn --type coder --task "Build a REST API with authentication"
+```
+
+### Spawn coordinator with auto tools
+
+```bash
+npx monomind agent spawn --type coordinator --auto-tools --task "Refactor codebase"
+```
+
+### Check spawned agent status
+
+```bash
+npx monomind agent list
+npx monomind agent status --id <agent-id>
+```
+
+## How It Works
+
+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
+
+## Agent Types
+
+| 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
+// Spawn a single specialized agent
+mcp__monomind__agent_spawn({
+  type: "coder",
+  name: "API Builder",
+  task: "Build authentication system",
+  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 list` — list all active agents
+- `agent status` — check agent status
+- `swarm init` — initialize a multi-agent swarm
+- `workflow-select` — choose predefined workflows

package/packages/@monomind/cli/.claude/commands/automation/self-healing.md

@@ -0,0 +1,108 @@
+---
+name: automation:self-healing
+---
+
+# Self-Healing Workflows
+
+## Purpose
+Automatically detect and recover from errors without interrupting your flow.
+
+## Self-Healing Features
+
+### 1. Error Detection
+Monitors for:
+- Failed commands
+- Syntax errors
+- Missing dependencies
+- Broken tests
+
+### 2. Automatic Recovery
+
+**Missing Dependencies:**
+```
+Error: Cannot find module 'express'
+→ Automatically runs: npm install express
+→ Retries original command
+```
+
+**Syntax Errors:**
+```
+Error: Unexpected token
+→ Analyzes error location
+→ Suggests fix through analyzer agent
+→ Applies fix with confirmation
+```
+
+**Test Failures:**
+```
+Test failed: "user authentication"
+→ Spawns debugger agent
+→ Analyzes failure cause
+→ Implements fix
+→ Re-runs tests
+```
+
+### 3. Learning from Failures
+Each recovery improves future prevention:
+- Patterns saved to knowledge base
+- Similar errors prevented proactively
+- Recovery strategies optimized
+
+**Pattern Storage:**
+```javascript
+// Store error patterns
+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({
+  operation: "error-recovery",
+  outcome: "success"
+})
+```
+
+## Self-Healing Integration
+
+### MCP Tool Coordination
+```javascript
+// Initialize self-healing swarm
+mcp__monomind__swarm_init({
+  "topology": "star",
+  "maxAgents": 4,
+  "strategy": "adaptive"
+})
+
+// Spawn recovery agents
+mcp__monomind__agent_spawn({
+  "type": "monitor",
+  "name": "Error Monitor",
+  "capabilities": ["error-detection", "recovery"]
+})
+
+// Orchestrate recovery
+mcp__monomind__coordination_orchestrate({
+  task: "recover from error",
+  strategy: "sequential",
+  priority: "critical"
+})
+```
+
+### Fallback Hook Configuration
+```json
+{
+  "PostToolUse": [{
+    "matcher": "^Bash$",
+    "command": "npx monomind hooks post-command --command \"$TOOL_INPUT_command\" --success \"$TOOL_SUCCESS\""
+  }]
+}
+```
+
+## Benefits
+- Resilient workflows
+- Automatic recovery
+- Learns from errors
+- Saves debugging time

package/packages/@monomind/cli/.claude/commands/automation/session-memory.md

@@ -0,0 +1,89 @@
+---
+name: automation:session-memory
+---
+
+# Cross-Session Memory
+
+## Purpose
+Maintain context and learnings across Claude Code sessions for continuous improvement.
+
+## Memory Features
+
+### 1. Automatic State Persistence
+At session end, automatically saves:
+- Active agents and specializations
+- Task history and patterns
+- Performance metrics
+- Neural network weights
+- Knowledge base updates
+
+### 2. Session Restoration
+```javascript
+// Retrieve saved session state
+mcp__monomind__memory_retrieve({
+  key: "session-state",
+  namespace: "sessions"
+})
+
+// Restore a named session
+mcp__monomind__session_restore({
+  sessionId: "sess-123"
+})
+```
+
+**Fallback with npx:**
+```bash
+npx monomind hooks session-restore --id "sess-123"
+```
+
+### 3. Memory Types
+
+**Project Memory:**
+- File relationships
+- Common edit patterns
+- Testing approaches
+- Build configurations
+
+**Agent Memory:**
+- Specialization levels
+- Task success rates
+- Optimization strategies
+- Error patterns
+
+**Performance Memory:**
+- Bottleneck history
+- Optimization results
+- Token usage patterns
+- Efficiency trends
+
+### 4. Privacy & Control
+```javascript
+// List memory entries by namespace
+mcp__monomind__memory_list({
+  namespace: "sessions"
+})
+
+// Delete specific memory entry
+mcp__monomind__memory_delete({
+  key: "session-123",
+  namespace: "sessions"
+})
+
+// Check memory stats
+mcp__monomind__memory_stats({})
+```
+
+**Manual control:**
+```bash
+# List saved sessions
+npx monomind session list
+
+# Disable memory persistence
+export MONOMIND_MEMORY_PERSIST=false
+```
+
+## Benefits
+- Contextual awareness
+- Cumulative learning
+- Faster task completion
+- Personalized optimization

package/packages/@monomind/cli/.claude/commands/automation/smart-agents.md

@@ -0,0 +1,81 @@
+---
+name: automation:smart-agents
+---
+
+# Smart Agent Auto-Spawning
+
+## Purpose
+Automatically spawn the right agents at the right time without manual intervention.
+
+## Auto-Spawning Triggers
+
+### 1. File Type Detection
+When editing files, agents auto-spawn:
+- **JavaScript/TypeScript**: Coder agent
+- **Markdown**: Researcher agent
+- **JSON/YAML**: Analyst agent
+- **Multiple files**: Coordinator agent
+
+### 2. Task Complexity
+```
+Simple task: "Fix typo"
+→ Single coordinator agent
+
+Complex task: "Implement OAuth with Google"
+→ Architect + Coder + Tester + Researcher
+```
+
+### 3. Dynamic Scaling
+The system monitors workload and spawns additional agents when:
+- Task queue grows
+- Complexity increases
+- Parallel opportunities exist
+
+**Status Monitoring:**
+```javascript
+// Check swarm health
+mcp__monomind__swarm_status({
+  swarmId: "current"
+})
+
+// Monitor agent status and health
+mcp__monomind__agent_status({
+  id: "agent-123"
+})
+mcp__monomind__agent_health({
+  id: "agent-123",
+  detailed: true
+})
+```
+
+## Configuration
+
+### MCP Tool Integration
+Uses Monomind MCP tools for agent coordination:
+```javascript
+// Initialize swarm with appropriate topology
+mcp__monomind__swarm_init({
+  "topology": "mesh",
+  "maxAgents": 8,
+  "strategy": "auto"
+})
+
+// Spawn agents based on file type
+mcp__monomind__agent_spawn({
+  "type": "coder",
+  "name": "JavaScript Handler",
+  "capabilities": ["javascript", "typescript"]
+})
+```
+
+### Fallback Configuration
+If MCP tools are unavailable:
+```bash
+npx monomind hooks pre-task --description "<task>" --auto-spawn
+```
+
+## Benefits
+- Zero manual agent management
+- Perfect agent selection
+- Dynamic scaling
+- Resource efficiency

package/packages/@monomind/cli/.claude/commands/automation/smart-spawn.md

@@ -0,0 +1,66 @@
+---
+name: automation:smart-spawn
+---
+
+# smart-spawn
+
+Automatically spawn agents at the start of a task using the hooks pre-task system.
+
+## Usage
+
+```bash
+npx monomind hooks pre-task --description "<task>" --auto-spawn
+```
+
+## Options
+
+- `--description, -d <text>` - Task description (used for agent selection)
+- `--auto-spawn` - Enable automatic agent spawning based on task analysis
+- `--id, -i <id>` - Task ID
+
+## Examples
+
+### Auto-spawn agents for a task
+
+```bash
+npx monomind hooks pre-task --description "Implement OAuth with Google" --auto-spawn
+```
+
+### Route + spawn in one step
+
+```bash
+npx monomind hooks route --task "Build REST API" --include-explanation
+npx monomind hooks pre-task --description "Build REST API" --auto-spawn
+```
+
+## How It Works
+
+The `pre-task` hook analyzes the task description and automatically selects and spawns the right agents:
+
+- **Simple tasks** (`Fix typo`) → single coordinator agent
+- **Complex tasks** (`Implement OAuth`) → Architect + Coder + Tester + Researcher
+- **Parallel tasks** → mesh topology with load-balanced workers
+
+## Integration with Claude Code
+
+```javascript
+// Initialize swarm with auto strategy
+mcp__monomind__swarm_init({
+  topology: "hierarchical",
+  maxAgents: 8,
+  strategy: "specialized"
+})
+
+// Then spawn the appropriate agent type
+mcp__monomind__agent_spawn({
+  type: "coder",
+  name: "Task Handler",
+  capabilities: ["typescript", "api"]
+})
+```
+
+## See Also
+
+- `auto-agent` — spawn agents manually with explicit type/task
+- `workflow-select` — run a predefined workflow template
+- `hooks pre-task` — full pre-task hook reference

package/packages/@monomind/cli/.claude/commands/automation/workflow-select.md

@@ -0,0 +1,60 @@
+---
+name: automation:workflow-select
+---
+
+# workflow-select
+
+Run a predefined workflow template for common tasks.
+
+## Usage
+
+```bash
+npx monomind workflow run [options]
+```
+
+## Options
+
+- `--template, -t <name>` - Workflow template name
+- `--task <description>` - Task description (for template selection)
+- `--parallel` - Enable parallel agent execution
+- `--max-agents <n>` - Max agents to spawn (default: 4)
+- `--dry-run` - Preview workflow without executing
+
+## Examples
+
+### List available templates
+
+```bash
+npx monomind workflow template list
+```
+
+### Run a template
+
+```bash
+npx monomind workflow run --template feature-development --task "Add OAuth login"
+```
+
+### Preview without executing
+
+```bash
+npx monomind workflow run --template deploy --dry-run
+```
+
+### Run in parallel
+
+```bash
+npx monomind workflow run --template code-review --parallel --max-agents 6
+```
+
+## Workflow Status
+
+```bash
+npx monomind workflow list
+npx monomind workflow status --watch
+```
+
+## See Also
+
+- `auto-agent` — spawn agents without a template
+- `smart-spawn` — auto-select agents from task description
+- `swarm init` — manual swarm initialization

package/packages/@monomind/cli/.claude/commands/coordination/README.md

@@ -0,0 +1,13 @@
+---
+name: coordination:readme
+---
+
+# Coordination Commands
+
+Commands and guidance for swarm coordination and task orchestration in Monomind.
+
+## Commands (invoke as slash commands)
+
+- [swarm-init](./swarm-init.md) — initialize a swarm with topology and strategy (`monomind swarm init`)
+- [agent-spawn](./agent-spawn.md) — spawn a new agent in the swarm (`monomind agent spawn`)
+- [task-orchestrate](./task-orchestrate.md) — coordinate tasks across swarm agents (`monomind swarm coordinate`)