monomind 1.19.0 → 2.0.1

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

@@ -1,59 +0,0 @@
----
-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/.claude/commands/analysis/performance-report.md

@@ -1,52 +0,0 @@
----
-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/.claude/commands/analysis/token-usage.md

@@ -1,47 +0,0 @@
----
-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/.claude/commands/automation/README.md

@@ -1,19 +0,0 @@
----
-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/.claude/commands/automation/auto-agent.md

@@ -1,86 +0,0 @@
----
-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/.claude/commands/automation/self-healing.md

@@ -1,108 +0,0 @@
----
-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/.claude/commands/automation/session-memory.md

@@ -1,89 +0,0 @@
----
-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/.claude/commands/automation/smart-agents.md

@@ -1,81 +0,0 @@
----
-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/.claude/commands/automation/smart-spawn.md

@@ -1,66 +0,0 @@
----
-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/.claude/commands/automation/workflow-select.md

@@ -1,60 +0,0 @@
----
-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/.claude/commands/coordination/README.md

@@ -1,13 +0,0 @@
----
-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`)