@monoes/monomindcli 1.6.0

package/.claude/commands/mastermind.md

@@ -0,0 +1,121 @@
+---
+name: mastermind
+description: Swarm & Hive-Mind architecture picker — presents all topologies, consensus protocols, and strategies, then gives one concrete recommendation for the current task
+---
+
+IMPORTANT: Do NOT dump all the reference content at once. Follow the two-phase flow below exactly.
+
+**If $ARGUMENTS is non-empty**, treat it as the user's task description and skip Phase 1 — go straight to Phase 2 with that description.
+
+---
+
+## Phase 1 — Present the picker and STOP
+
+Output this menu and WAIT for the user's reply before doing anything else:
+
+---
+
+**MASTERMIND — Swarm & Hive-Mind Picker**
+
+Describe your task and I'll recommend the right mode, or pick directly from the options below.
+
+### Swarm Topologies
+| # | Topology | Shape | Best for |
+|---|---|---|---|
+| **1** | `hierarchical` | One coordinator → all workers | Feature dev, bug fixes, most coding tasks |
+| **2** | `mesh` | Every agent ↔ every agent | Research, brainstorming, docs |
+| **3** | `hierarchical-mesh` | Queen + peer lanes | Large projects, 10–15 agents |
+| **4** | `ring` | Agent → next → next → loop | Pipelines: research→draft→edit→review |
+| **5** | `star` | Hub aggregates independent workers | Parallel analysis, test coverage |
+| **6** | `adaptive` | Starts hierarchical, self-reconfigures | Long-running or unknown workloads |
+
+### Hive-Mind Modes
+| # | Mode | Consensus | Best for |
+|---|---|---|---|
+| **7** | `hive-mind hierarchical-mesh` | `byzantine` | Security-critical, fault-tolerant (f < n/3) |
+| **8** | `hive-mind hierarchical` | `raft` | Refactors, rewrites — leader keeps authoritative state |
+| **9** | `hive-mind mesh` | `gossip` | Large agent counts, eventual consistency |
+| **10** | `hive-mind hierarchical-mesh` | `crdt` | Concurrent writes, collaborative editing |
+| **11** | `hive-mind adaptive` | `quorum` | Custom fault-tolerance, majority vote |
+
+> Type a number (1–11), or just **describe what you want to build** and I'll pick for you.
+
+---
+
+## Phase 2 — Give a concrete recommendation
+
+Based on the task or user choice, pick ONE mode and output EXACTLY this structure:
+
+---
+
+**Your Plan**
+
+- **Mode:** `<swarm|hive-mind>` · `<topology>` — <one sentence why>
+- **Agents:** <N> · <list agent types>
+- **Consensus:** `<protocol>` — <one sentence why>
+- **Strategy:** `<specialized|balanced|pipeline|parallel>` _(swarm only)_
+
+**Launch command:**
+```bash
+# Swarm:
+npx monomind swarm init --topology <topology> --max-agents <N> --strategy <strategy>
+
+# OR Hive-Mind (no --strategy flag):
+npx monomind hive-mind init --topology <topology> --consensus <protocol> --max-agents <N>
+```
+
+**Agent team:**
+```
+coordinator  → plans and delegates
+<agent>      → <role>
+<agent>      → <role>
+...
+```
+
+**Then spawn in Claude Code (one message):**
+```javascript
+// Bash: init the swarm/hive-mind first (above command)
+// Then Task tool calls — all in the same message:
+Task({ subagent_type: "coordinator", description: "...", run_in_background: true })
+Task({ subagent_type: "<agent>",     description: "...", run_in_background: true })
+// ... one Task call per agent
+```
+
+> Ready? Say **go** and I'll launch it, or adjust any detail first.
+
+---
+
+## Recommendation Logic (internal — do not output)
+
+Use this to pick the right mode when the user describes a task:
+
+| Task type | Mode | Topology | Consensus | Agents | Strategy |
+|---|---|---|---|---|---|
+| Bug fix (1–2 files) | swarm | hierarchical | raft | 4 | specialized |
+| Feature (3+ files) | swarm | hierarchical | raft | 6–8 | specialized |
+| Refactor / migration | swarm | hierarchical | raft | 5–6 | specialized |
+| Performance optimization | swarm | star | raft | 4–5 | parallel |
+| Security audit / fix | hive-mind | hierarchical-mesh | byzantine | 6 | specialized |
+| Research / docs | swarm | mesh | gossip | 4–6 | balanced |
+| Docs pipeline | swarm | ring | raft | 4 | pipeline |
+| Testing / coverage | swarm | star | raft | 5–6 | parallel |
+| Architecture design | swarm | hierarchical-mesh | raft | 8–10 | specialized |
+| Full release (end-to-end) | hive-mind | hierarchical-mesh | byzantine | 12–15 | specialized |
+| Long-running / unknown | swarm | adaptive | raft | 8–10 | specialized |
+| Refactor with rollback safety | hive-mind | hierarchical | raft | 5–6 | specialized |
+| Concurrent collaborative writes | hive-mind | hierarchical-mesh | crdt | 4–6 | balanced |
+| Large-scale eventual consistency (20+ agents) | hive-mind | mesh | gossip | 15–20 | balanced |
+| Custom fault-tolerance / majority vote | hive-mind | adaptive | quorum | 8–12 | specialized |
+
+**Quick decision rule:**
+- 1 file → use Edit tool directly, no swarm needed
+- 2–3 files, clear scope → swarm hierarchical, 4–6 agents, raft
+- Security/fault-critical → hive-mind hierarchical-mesh, byzantine
+- Research/exploration → swarm mesh, gossip
+- Pipeline stages (A→B→C) → swarm ring
+- Parallel independent work → swarm star
+- 10+ agents or long-running → hierarchical-mesh or adaptive
+- Refactor needing authoritative rollback → hive-mind hierarchical, raft
+- Concurrent collaborative writes → hive-mind hierarchical-mesh, crdt
+- Large agent pool (20+), eventual consistency → hive-mind mesh, gossip
+- Custom fault-tolerance threshold → hive-mind adaptive, quorum

package/.claude/commands/memory/README.md

@@ -0,0 +1,9 @@
+# Memory Commands
+
+Commands for memory operations in Monomind.
+
+## Available Commands
+
+- [memory-usage](./memory-usage.md)
+- [memory-persist](./memory-persist.md)
+- [memory-search](./memory-search.md)

package/.claude/commands/memory/memory-persist.md

@@ -0,0 +1,25 @@
+# memory-persist
+
+Persist memory across sessions.
+
+## Usage
+```bash
+npx monomind memory persist [options]
+```
+
+## Options
+- `--export <file>` - Export to file
+- `--import <file>` - Import from file
+- `--compress` - Compress memory data
+
+## Examples
+```bash
+# Export memory
+npx monomind memory persist --export memory-backup.json
+
+# Import memory
+npx monomind memory persist --import memory-backup.json
+
+# Compressed export
+npx monomind memory persist --export memory.gz --compress
+```

package/.claude/commands/memory/memory-search.md

@@ -0,0 +1,25 @@
+# memory-search
+
+Search through stored memory.
+
+## Usage
+```bash
+npx monomind memory search [options]
+```
+
+## Options
+- `--query <text>` - Search query
+- `--pattern <regex>` - Pattern matching
+- `--limit <n>` - Result limit
+
+## Examples
+```bash
+# Search memory
+npx monomind memory search --query "authentication"
+
+# Pattern search
+npx monomind memory search --pattern "api-.*"
+
+# Limited results
+npx monomind memory search --query "config" --limit 10
+```

package/.claude/commands/memory/memory-usage.md

@@ -0,0 +1,25 @@
+# memory-usage
+
+Manage persistent memory storage.
+
+## Usage
+```bash
+npx monomind memory usage [options]
+```
+
+## Options
+- `--action <type>` - Action (store, retrieve, list, clear)
+- `--key <key>` - Memory key
+- `--value <data>` - Data to store (JSON)
+
+## Examples
+```bash
+# Store memory
+npx monomind memory usage --action store --key "project-config" --value '{"api": "v2"}'
+
+# Retrieve memory
+npx monomind memory usage --action retrieve --key "project-config"
+
+# List all keys
+npx monomind memory usage --action list
+```

package/.claude/commands/memory/neural.md

@@ -0,0 +1,47 @@
+# Neural Pattern Training
+
+## 🎯 Key Principle
+**This tool coordinates Claude Code's actions. It does NOT write code or create content.**
+
+## MCP Tool Usage in Claude Code
+
+**Tool:** `mcp__monomind__neural_train`
+
+## Parameters
+```json
+{
+  "pattern_type": "coordination",
+  "training_data": "task decomposition patterns",
+  "epochs": 50
+}
+```
+
+## Description
+Improve coordination patterns through neural network training
+
+## Details
+Training improves:
+- Task breakdown effectiveness
+- Coordination pattern selection
+- Resource allocation strategies
+- Overall coordination efficiency
+
+## Example Usage
+
+**In Claude Code:**
+1. Train coordination patterns: Use tool `mcp__monomind__neural_train` with parameters `{"pattern_type": "coordination", "training_data": "successful task patterns", "epochs": 50}`
+2. Train optimization patterns: Use tool `mcp__monomind__neural_train` with parameters `{"pattern_type": "optimization", "training_data": "performance metrics", "epochs": 30}`
+3. Check training status: Use tool `mcp__monomind__neural_status`
+4. Analyze patterns: Use tool `mcp__monomind__neural_patterns` with parameters `{"action": "analyze"}`
+
+## Important Reminders
+- ✅ This tool provides coordination and structure
+- ✅ Claude Code performs all actual implementation
+- ❌ The tool does NOT write code
+- ❌ The tool does NOT access files directly
+- ❌ The tool does NOT execute commands
+
+## See Also
+- Main documentation: /CLAUDE.md
+- Other commands in this category
+- Workflow examples in /workflows/

package/.claude/commands/metrics.md

@@ -0,0 +1,11 @@
+Show the full Monomind system metrics dashboard: statusline panel + today's token usage breakdown.
+
+Run these two shell commands immediately without asking for confirmation:
+
+```bash
+node "${CLAUDE_PROJECT_DIR:-/Users/morteza/Desktop/tools/monomind}/.claude/helpers/statusline.cjs"
+echo ""
+node "${CLAUDE_PROJECT_DIR:-/Users/morteza/Desktop/tools/monomind}/.claude/helpers/token-tracker.cjs" report today
+```
+
+Show the full output verbatim. No other commentary needed.

package/.claude/commands/monitoring/README.md

@@ -0,0 +1,9 @@
+# Monitoring Commands
+
+Commands for monitoring operations in Monomind.
+
+## Available Commands
+
+- [swarm-monitor](./swarm-monitor.md)
+- [agent-metrics](./agent-metrics.md)
+- [real-time-view](./real-time-view.md)

package/.claude/commands/monitoring/agent-metrics.md

@@ -0,0 +1,25 @@
+# agent-metrics
+
+View agent performance metrics.
+
+## Usage
+```bash
+npx monomind agent metrics [options]
+```
+
+## Options
+- `--agent-id <id>` - Specific agent
+- `--period <time>` - Time period
+- `--format <type>` - Output format
+
+## Examples
+```bash
+# All agents metrics
+npx monomind agent metrics
+
+# Specific agent
+npx monomind agent metrics --agent-id agent-001
+
+# Last hour
+npx monomind agent metrics --period 1h
+```

package/.claude/commands/monitoring/agents.md

@@ -0,0 +1,44 @@
+# List Active Patterns
+
+## 🎯 Key Principle
+**This tool coordinates Claude Code's actions. It does NOT write code or create content.**
+
+## MCP Tool Usage in Claude Code
+
+**Tool:** `mcp__monomind__agent_list`
+
+## Parameters
+```json
+{
+  "swarmId": "current"
+}
+```
+
+## Description
+View all active cognitive patterns and their current focus areas
+
+## Details
+Filters:
+- **all**: Show all defined patterns
+- **active**: Currently engaged patterns
+- **idle**: Available but unused patterns
+- **busy**: Patterns actively coordinating tasks
+
+## Example Usage
+
+**In Claude Code:**
+1. List all agents: Use tool `mcp__monomind__agent_list`
+2. Get specific agent metrics: Use tool `mcp__monomind__agent_metrics` with parameters `{"agentId": "coder-123"}`
+3. Monitor agent performance: Use tool `mcp__monomind__swarm_monitor` with parameters `{"interval": 2000}`
+
+## Important Reminders
+- ✅ This tool provides coordination and structure
+- ✅ Claude Code performs all actual implementation
+- ❌ The tool does NOT write code
+- ❌ The tool does NOT access files directly
+- ❌ The tool does NOT execute commands
+
+## See Also
+- Main documentation: /CLAUDE.md
+- Other commands in this category
+- Workflow examples in /workflows/

package/.claude/commands/monitoring/real-time-view.md

@@ -0,0 +1,25 @@
+# real-time-view
+
+Real-time view of swarm activity.
+
+## Usage
+```bash
+npx monomind monitoring real-time-view [options]
+```
+
+## Options
+- `--filter <type>` - Filter view
+- `--highlight <pattern>` - Highlight pattern
+- `--tail <n>` - Show last N events
+
+## Examples
+```bash
+# Start real-time view
+npx monomind monitoring real-time-view
+
+# Filter errors
+npx monomind monitoring real-time-view --filter errors
+
+# Highlight pattern
+npx monomind monitoring real-time-view --highlight "API"
+```

package/.claude/commands/monitoring/status.md

@@ -0,0 +1,46 @@
+# Check Coordination Status
+
+## 🎯 Key Principle
+**This tool coordinates Claude Code's actions. It does NOT write code or create content.**
+
+## MCP Tool Usage in Claude Code
+
+**Tool:** `mcp__monomind__swarm_status`
+
+## Parameters
+```json
+{
+  "swarmId": "current"
+}
+```
+
+## Description
+Monitor the effectiveness of current coordination patterns
+
+## Details
+Shows:
+- Active coordination topologies
+- Current cognitive patterns in use
+- Task breakdown and progress
+- Resource utilization for coordination
+- Overall system health
+
+## Example Usage
+
+**In Claude Code:**
+1. Check swarm status: Use tool `mcp__monomind__swarm_status`
+2. Monitor in real-time: Use tool `mcp__monomind__swarm_monitor` with parameters `{"interval": 1000}`
+3. Get agent metrics: Use tool `mcp__monomind__agent_metrics` with parameters `{"agentId": "agent-123"}`
+4. Health check: Use tool `mcp__monomind__health_check` with parameters `{"components": ["swarm", "memory", "neural"]}`
+
+## Important Reminders
+- ✅ This tool provides coordination and structure
+- ✅ Claude Code performs all actual implementation
+- ❌ The tool does NOT write code
+- ❌ The tool does NOT access files directly
+- ❌ The tool does NOT execute commands
+
+## See Also
+- Main documentation: /CLAUDE.md
+- Other commands in this category
+- Workflow examples in /workflows/

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

@@ -0,0 +1,25 @@
+# swarm-monitor
+
+Real-time swarm monitoring.
+
+## Usage
+```bash
+npx monomind swarm monitor [options]
+```
+
+## Options
+- `--interval <ms>` - Update interval
+- `--metrics` - Show detailed metrics
+- `--export` - Export monitoring data
+
+## Examples
+```bash
+# Start monitoring
+npx monomind swarm monitor
+
+# Custom interval
+npx monomind swarm monitor --interval 5000
+
+# With metrics
+npx monomind swarm monitor --metrics
+```

package/.claude/commands/monobrain-help.md

@@ -0,0 +1,103 @@
+---
+name: monomind-help
+description: Show Monomind commands and usage
+---
+
+# Monomind Commands
+
+## 🌊 Monomind: Agent Orchestration Platform
+
+Monomind is the ultimate multi-terminal orchestration platform that revolutionizes how you work with Claude Code.
+
+## Core Commands
+
+### 🚀 System Management
+- `./monomind start` - Start orchestration system
+- `./monomind start --ui` - Start with interactive process management UI
+- `./monomind status` - Check system status
+- `./monomind monitor` - Real-time monitoring
+- `./monomind stop` - Stop orchestration
+
+### 🤖 Agent Management
+- `./monomind agent spawn <type>` - Create new agent
+- `./monomind agent list` - List active agents
+- `./monomind agent info <id>` - Agent details
+- `./monomind agent terminate <id>` - Stop agent
+
+### 📋 Task Management
+- `./monomind task create <type> "description"` - Create task
+- `./monomind task list` - List all tasks
+- `./monomind task status <id>` - Task status
+- `./monomind task cancel <id>` - Cancel task
+- `./monomind task workflow <file>` - Execute workflow
+
+### 🧠 Memory Operations
+- `./monomind memory store "key" "value"` - Store data
+- `./monomind memory query "search"` - Search memory
+- `./monomind memory stats` - Memory statistics
+- `./monomind memory export <file>` - Export memory
+- `./monomind memory import <file>` - Import memory
+
+### ⚡ SPARC Development
+- `./monomind sparc "task"` - Run SPARC orchestrator
+- `./monomind sparc modes` - List all 17+ SPARC modes
+- `./monomind sparc run <mode> "task"` - Run specific mode
+- `./monomind sparc tdd "feature"` - TDD workflow
+- `./monomind sparc info <mode>` - Mode details
+
+### 🐝 Swarm Coordination
+- `./monomind swarm "task" --strategy <type>` - Start swarm
+- `./monomind swarm "task" --background` - Long-running swarm
+- `./monomind swarm "task" --monitor` - With monitoring
+- `./monomind swarm "task" --ui` - Interactive UI
+- `./monomind swarm "task" --distributed` - Distributed coordination
+
+### 🌍 MCP Integration
+- `./monomind mcp status` - MCP server status
+- `./monomind mcp tools` - List available tools
+- `./monomind mcp config` - Show configuration
+- `./monomind mcp logs` - View MCP logs
+
+### 🤖 Claude Integration
+- `./monomind claude spawn "task"` - Spawn Claude with enhanced guidance
+- `./monomind claude batch <file>` - Execute workflow configuration
+
+## 🌟 Quick Examples
+
+### Initialize with SPARC:
+```bash
+npx -y monomind@latest init --sparc
+```
+
+### Start a development swarm:
+```bash
+./monomind swarm "Build REST API" --strategy development --monitor --review
+```
+
+### Run TDD workflow:
+```bash
+./monomind sparc tdd "user authentication"
+```
+
+### Store project context:
+```bash
+./monomind memory store "project_requirements" "e-commerce platform specs" --namespace project
+```
+
+### Spawn specialized agents:
+```bash
+./monomind agent spawn researcher --name "Senior Researcher" --priority 8
+./monomind agent spawn developer --name "Lead Developer" --priority 9
+```
+
+## 🎯 Best Practices
+- Use `./monomind` instead of `npx monomind` after initialization
+- Store important context in memory for cross-session persistence
+- Use swarm mode for complex tasks requiring multiple agents
+- Enable monitoring for real-time progress tracking
+- Use background mode for tasks > 30 minutes
+
+## 📚 Resources
+- Documentation: https://github.com/nokhodian/claude-code-flow/docs
+- Examples: https://github.com/nokhodian/claude-code-flow/examples
+- Issues: https://github.com/nokhodian/claude-code-flow/issues

package/.claude/commands/monobrain-memory.md

@@ -0,0 +1,107 @@
+---
+name: monomind-memory
+description: Interact with Monomind memory system
+---
+
+# 🧠 Monomind Memory System
+
+The memory system provides persistent storage for cross-session and cross-agent collaboration with CRDT-based conflict resolution.
+
+## Store Information
+```bash
+# Store with default namespace
+./monomind memory store "key" "value"
+
+# Store with specific namespace
+./monomind memory store "architecture_decisions" "microservices with API gateway" --namespace arch
+```
+
+## Query Memory
+```bash
+# Search across all namespaces
+./monomind memory query "authentication"
+
+# Search with filters
+./monomind memory query "API design" --namespace arch --limit 10
+```
+
+## Memory Statistics
+```bash
+# Show overall statistics
+./monomind memory stats
+
+# Show namespace-specific stats
+./monomind memory stats --namespace project
+```
+
+## Export/Import
+```bash
+# Export all memory
+./monomind memory export full-backup.json
+
+# Export specific namespace
+./monomind memory export project-backup.json --namespace project
+
+# Import memory
+./monomind memory import backup.json
+```
+
+## Cleanup Operations
+```bash
+# Clean entries older than 30 days
+./monomind memory cleanup --days 30
+
+# Clean specific namespace
+./monomind memory cleanup --namespace temp --days 7
+```
+
+## 🗂️ Namespaces
+- **default** - General storage
+- **agents** - Agent-specific data and state
+- **tasks** - Task information and results
+- **sessions** - Session history and context
+- **swarm** - Swarm coordination and objectives
+- **project** - Project-specific context
+- **spec** - Requirements and specifications
+- **arch** - Architecture decisions
+- **impl** - Implementation notes
+- **test** - Test results and coverage
+- **debug** - Debug logs and fixes
+
+## 🎯 Best Practices
+
+### Naming Conventions
+- Use descriptive, searchable keys
+- Include timestamp for time-sensitive data
+- Prefix with component name for clarity
+
+### Organization
+- Use namespaces to categorize data
+- Store related data together
+- Keep values concise but complete
+
+### Maintenance
+- Regular backups with export
+- Clean old data periodically
+- Monitor storage statistics
+- Compress large values
+
+## Examples
+
+### Store SPARC context:
+```bash
+./monomind memory store "spec_auth_requirements" "OAuth2 + JWT with refresh tokens" --namespace spec
+./monomind memory store "arch_api_design" "RESTful microservices with GraphQL gateway" --namespace arch
+./monomind memory store "test_coverage_auth" "95% coverage, all tests passing" --namespace test
+```
+
+### Query project decisions:
+```bash
+./monomind memory query "authentication" --namespace arch --limit 5
+./monomind memory query "test results" --namespace test
+```
+
+### Backup project memory:
+```bash
+./monomind memory export project-$(date +%Y%m%d).json --namespace project
+```