@monoes/monomindcli 1.8.0 → 1.9.0

package/.claude/commands/training/neural-train.md

@@ -1,25 +1,79 @@
-# neural-train
+---
+name: training:neural-train
+description: Train neural patterns with WASM SIMD acceleration — MicroLoRA, Flash Attention (2.49x-7.47x speedup), MoE routing, contrastive learning
+---
 
-Train neural patterns from operations.
+# Neural Train
+
+Train neural patterns with WASM acceleration using the real `npx monomind neural train` command.
+
+## How to Invoke
 
-## Usage
-```bash
-npx monomind training neural-train [options]
 ```
+Skill("training:neural-train")
+```
+
+---
 
-## Options
-- `--data <source>` - Training data source
-- `--model <name>` - Target model
-- `--epochs <n>` - Training epochs
+## CLI Reference
 
-## Examples
 ```bash
-# Train from recent ops
-npx monomind training neural-train --data recent
+# Train coordination patterns (default, 50 epochs)
+npx monomind neural train --pattern coordination --epochs 50
+
+# Train with Flash Attention speedup (2.49x-7.47x)
+npx monomind neural train --pattern optimization --flash --epochs 100
+
+# Train security patterns with contrastive learning (InfoNCE)
+npx monomind neural train --pattern security --wasm --contrastive
+
+# Train with Mixture of Experts routing
+npx monomind neural train --pattern coordination --moe --epochs 200
+
+# Train from a data file
+npx monomind neural train --data ./training-data.json --flash
+
+# Curriculum learning (easy → hard)
+npx monomind neural train --pattern prediction --curriculum --epochs 150
+```
+
+## All Flags
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--pattern` | `coordination` | Pattern type: coordination, optimization, prediction, security, testing |
+| `--epochs` | `50` | Training epochs |
+| `--data` | — | Training data file path or inline JSON |
+| `--model` | — | Specific model ID to train |
+| `--learning-rate` | `0.01` | Learning rate |
+| `--batch-size` | `32` | Batch size |
+| `--dim` | `256` | Embedding dimension (max 256) |
+| `--wasm` | `true` | Use RuVector WASM SIMD acceleration |
+| `--flash` | `true` | Enable Flash Attention (2.49x-7.47x speedup) |
+| `--moe` | `false` | Enable Mixture of Experts routing (8 experts) |
+| `--hyperbolic` | `false` | Hyperbolic attention for hierarchical patterns |
+| `--contrastive` | `true` | Contrastive learning with InfoNCE loss |
+| `--curriculum` | `false` | Curriculum learning (easy → hard progression) |
+
+## MCP Tools
+
+```javascript
+// Train via MCP
+mcp__monomind__neural_train({ patternType: "coordination", epochs: 50 })
 
-# Specific model
-npx monomind training neural-train --model task-predictor
+// Check training progress
+mcp__monomind__neural_status({ verbose: true })
+
+// MicroLoRA adaptation
+mcp__monomind__ruvllm_microlora_adapt({ modelId: "coordination", data: trainingData })
+```
+
+## After Training
+
+```bash
+# Verify training improved the model
+npx monomind neural status --verbose
 
-# Custom epochs
-npx monomind training neural-train --epochs 100
+# Export the trained model
+npx monomind neural export --model coordination
 ```

package/.claude/commands/training/pattern-learn.md

@@ -1,25 +1,69 @@
-# pattern-learn
+---
+name: training:pattern-learn
+description: Analyze and store patterns from successful operations — list, search, and manually store neural patterns for task routing and prediction
+---
 
-Learn patterns from successful operations.
+# Pattern Learn
+
+Analyze successful operations and store patterns to improve future routing and predictions.
+
+## How to Invoke
 
-## Usage
-```bash
-npx monomind training pattern-learn [options]
 ```
+Skill("training:pattern-learn")
+```
+
+---
 
-## Options
-- `--source <type>` - Pattern source
-- `--threshold <score>` - Success threshold
-- `--save <name>` - Save pattern set
+## CLI Reference
 
-## Examples
 ```bash
-# Learn from all ops
-npx monomind training pattern-learn
+# List stored patterns
+npx monomind neural patterns --action list --limit 20
+
+# Analyze recent patterns for quality
+npx monomind neural patterns --action analyze
+
+# Search for specific patterns
+npx monomind neural patterns --action analyze --query "coordination"
+
+# Predict routing for a task description
+npx monomind neural predict --input "build a REST API" --k 5
+```
 
-# High success only
-npx monomind training pattern-learn --threshold 0.9
+## MCP Tools
 
-# Save patterns
-npx monomind training pattern-learn --save optimal-patterns
+```javascript
+// List all stored patterns
+mcp__monomind__neural_patterns({ action: "list", limit: 20 })
+
+// Analyze pattern quality
+mcp__monomind__neural_patterns({ action: "analyze" })
+
+// Search for specific patterns
+mcp__monomind__neural_patterns({ action: "analyze", query: "coordination" })
+
+// Predict best routing for a task
+mcp__monomind__neural_predict({ input: "build REST API with auth" })
+
+// Store a new pattern manually via agentdb
+mcp__monomind__agentdb_pattern_store({
+  pattern: "successful-approach",
+  context: "typescript API with validation",
+  outcome: "passed all tests"
+})
+
+// Search existing patterns
+mcp__monomind__agentdb_pattern_search({ query: "API testing", limit: 10 })
 ```
+
+## When to Use Pattern Learning
+
+- After completing a complex task successfully — store the approach for reuse
+- When a routing decision was wrong — correct the pattern to improve future predictions
+- Before starting a new task type — search existing patterns to benefit from past experience
+
+## See Also
+
+- `training:neural-train` — Train models on stored patterns
+- `training:neural-patterns` — Overview of automatic vs manual training

package/.claude/commands/training/specialization.md

@@ -1,63 +1,92 @@
-# Agent Specialization Training
+---
+name: training:specialization
+description: Agent specialization training — spawn capability-specific agents for TypeScript, React, security, and other domains; track specialization progress
+---
 
-## Purpose
-Train agents to become experts in specific domains for better performance.
+# Agent Specialization Training
 
-## Specialization Areas
+Train and spawn agents that specialize in specific domains for better task performance.
 
-### 1. By File Type
-Agents automatically specialize based on file extensions:
-- **.js/.ts**: Modern JavaScript patterns
-- **.py**: Pythonic idioms
-- **.go**: Go best practices
-- **.rs**: Rust safety patterns
+## How to Invoke
 
-### 2. By Task Type
 ```
-Tool: mcp__monomind__agent_spawn
-Parameters: {
-  "type": "coder",
-  "capabilities": ["react", "typescript", "testing"],
-  "name": "React Specialist"
-}
+Skill("training:specialization")
 ```
 
-### 3. Training Process
-The system trains through:
-- Successful edit operations
-- Code review patterns
-- Error fix approaches
-- Performance optimizations
+---
+
+## Spawning Specialized Agents
+
+```javascript
+// Spawn a React/TypeScript specialist
+mcp__monomind__agent_spawn({
+  type: "coder",
+  capabilities: ["react", "typescript", "testing"],
+  name: "React Specialist"
+})
+
+// Spawn a security-focused agent
+mcp__monomind__agent_spawn({
+  type: "security-architect",
+  capabilities: ["security-audit", "vulnerability-detection", "cve-remediation"]
+})
 
-### 4. Specialization Benefits
+// Spawn a database specialist
+mcp__monomind__agent_spawn({
+  type: "analyst",
+  capabilities: ["sql", "nosql", "query-optimization", "schema-design"]
+})
 ```
-# Check agent specializations
-Tool: mcp__monomind__agent_list
-Parameters: {"swarmId": "current"}
-
-Result shows expertise levels:
-{
-  "agents": [
-    {
-      "id": "coder-123",
-      "specializations": {
-        "javascript": 0.95,
-        "react": 0.88,
-        "testing": 0.82
-      }
-    }
-  ]
-}
+
+```bash
+npx monomind agent spawn --type coder --capabilities "react,typescript,testing"
+npx monomind agent list
 ```
 
-## Continuous Improvement
-Agents share learnings across sessions for cumulative expertise!
+## How Specialization Builds
+
+Agents accumulate expertise through:
+- Successful edits to files of a given type (`.ts`, `.py`, `.go`)
+- Pattern matching from stored neural patterns
+- Hooks feedback from `post-edit` and `post-task` results
+
+The hooks intelligence system records what worked and feeds it back into agent routing.
+
+## Specialization by File Type
+
+| Extension | Auto-specialization |
+|-----------|-------------------|
+| `.ts` / `.tsx` | TypeScript, React patterns |
+| `.py` | Python idioms, type hints |
+| `.go` | Go concurrency, interfaces |
+| `.rs` | Rust borrowing, ownership |
+| `.sql` | Query optimization, schema |
+
+## Checking Agent Specializations
+
+```javascript
+// List agents with their capabilities
+mcp__monomind__agent_list({})
+
+// Agent status detail
+mcp__monomind__agent_status({ agentId: "coder-001" })
+```
 
-## CLI Usage
 ```bash
-# Train agent specialization via CLI
-npx monomind train agent --type coder --capabilities "react,typescript"
+npx monomind agent list
+npx monomind agent status --id coder-001
+```
+
+## Training New Specializations
 
-# Check specializations
-npx monomind agent list --specializations
-```
+```javascript
+// Train neural patterns for a specific domain
+mcp__monomind__neural_train({ patternType: "optimization", epochs: 100 })
+
+// Store a domain-specific pattern for future reuse
+mcp__monomind__agentdb_pattern_store({
+  pattern: "react-component-pattern",
+  context: "TypeScript functional components with hooks",
+  outcome: "clean, testable components"
+})
+```

package/.claude/commands/truth/start.md

@@ -1,143 +1,121 @@
-# 📊 Truth Command
+---
+name: truth:start
+description: Truth skill — assess system health, agent reliability, and task quality using real MCP metrics tools. Use when you want a holistic picture of how well the system is performing.
+---
 
-View truth scores and reliability metrics for your codebase and agent tasks.
+# Truth — System Reliability Assessment
 
-## Overview
+Assess the current health, agent performance, and task quality of the Monomind system.
 
-The `truth` command provides comprehensive insights into code quality, agent performance, and verification metrics.
+## How to Invoke
 
-## Usage
-
-```bash
-monomind truth [options]
 ```
+Skill("truth:start")
+```
+
+Then describe what you want to assess:
+> "Run a truth check on the current session."
+> "Show me system health and agent performance."
+> "Check for any reliability issues across active agents."
 
-## Options
+---
 
-- `--format <type>` - Output format: table (default), json, csv, html
-- `--period <time>` - Time period: 1h, 24h, 7d, 30d
-- `--agent <name>` - Filter by specific agent
-- `--threshold <0-1>` - Show only scores below threshold
-- `--export <file>` - Export metrics to file
-- `--watch` - Real-time monitoring mode
+## What Truth Covers
 
-## Metrics Displayed
+| Area | What to check |
+|------|--------------|
+| System health | MCP server status, memory DB, daemon |
+| Agent performance | Active agents, task completion rates |
+| Neural quality | Pattern confidence scores |
+| Security posture | Recent AI defence scan results |
+| Performance | Bottlenecks, latency, resource usage |
 
-### Truth Scores
-- **Overall Score**: Aggregate truth score (0.0-1.0)
-- **File Scores**: Individual file truth ratings
-- **Agent Scores**: Per-agent reliability metrics
-- **Task Scores**: Task completion quality
+## MCP Tools for Truth Assessment
 
-### Trends
-- **Improvement Rate**: Quality trend over time
-- **Regression Detection**: Identifies declining scores
-- **Agent Learning**: Shows agent improvement curves
+### System Health
 
-### Statistics
-- **Mean Score**: Average truth score
-- **Median Score**: Middle value of scores
-- **Standard Deviation**: Score consistency
-- **Confidence Interval**: Statistical reliability
+```javascript
+// Full system status
+mcp__monomind__system_health({})
+mcp__monomind__system_status({})
+mcp__monomind__system_metrics({})
 
-## Examples
+// MCP server connectivity
+mcp__monomind__mcp_status({})
+```
 
-### Basic Usage
-```bash
-# View current truth scores
-monomind truth
+### Agent Reliability
 
-# View scores for last 7 days
-monomind truth --period 7d
+```javascript
+// List active agents and their states
+mcp__monomind__agent_list({})
+mcp__monomind__agent_health({})
 
-# Export to HTML report
-monomind truth --export report.html --format html
+// Swarm health (if a swarm is running)
+mcp__monomind__swarm_health({})
+mcp__monomind__swarm_status({ swarmId: "current" })
 ```
 
-### Advanced Analysis
-```bash
-# Monitor real-time scores
-monomind truth --watch
-
-# Find problematic files
-monomind truth --threshold 0.8
+### Neural Pattern Quality
 
-# Agent-specific metrics
-monomind truth --agent coder --period 24h
+```javascript
+// Pattern confidence scores
+mcp__monomind__neural_status({ verbose: true })
+mcp__monomind__neural_patterns({ action: "list", limit: 10 })
 
-# JSON for processing
-monomind truth --format json | jq '.overall_score'
+// Hooks intelligence stats (routing accuracy)
+mcp__monomind__hooks_intelligence_stats({})
 ```
 
-## Dashboard View
+### Task Quality
+
+```javascript
+// Recent task outcomes
+mcp__monomind__task_summary({})
+mcp__monomind__progress_summary({})
 
+// AgentDB health (memory integrity)
+mcp__monomind__agentdb_health({})
 ```
-📊 Truth Metrics Dashboard
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-Overall Truth Score: 0.947 ✅
-Trend: ↗️ +2.3% (7d)
+### Performance
 
-Top Performers:
-  verification-agent   0.982 ⭐
-  code-analyzer       0.971 ⭐
-  test-generator      0.958 ✅
+```javascript
+// Performance bottlenecks
+mcp__monomind__performance_bottleneck({ component: "all" })
+mcp__monomind__performance_report({ format: "detailed" })
+```
 
-Needs Attention:
-  refactor-agent      0.821 ⚠️
-  docs-generator      0.794 ⚠️
+### Security
 
-Recent Tasks:
-  task-456  0.991 ✅  "Implement auth"
-  task-455  0.967 ✅  "Add tests"
-  task-454  0.743 ❌  "Refactor API"
+```javascript
+// AI defence stats
+mcp__monomind__aidefence_stats({})
+mcp__monomind__aidefence_analyze({ content: "recent session summary" })
 ```
 
-## Integration
-
-### With CI/CD
-```yaml
-# GitHub Actions example
-- name: Check Truth Scores
-  run: |
-    monomind truth --format json > truth.json
-    score=$(jq '.overall_score' truth.json)
-    if (( $(echo "$score < 0.95" | bc -l) )); then
-      echo "Truth score too low: $score"
-      exit 1
-    fi
-```
+---
 
-### With Monitoring
-```bash
-# Send to monitoring system
-monomind truth --format json | \
-  curl -X POST https://metrics.example.com/api/truth \
-  -H "Content-Type: application/json" \
-  -d @-
-```
+## Assessment Workflow
 
-## Configuration
-
-Set truth display preferences in `.monomind/config.json`:
-
-```json
-{
-  "truth": {
-    "defaultFormat": "table",
-    "defaultPeriod": "24h",
-    "warningThreshold": 0.85,
-    "criticalThreshold": 0.75,
-    "autoExport": {
-      "enabled": true,
-      "path": ".monomind/metrics/truth-daily.json"
-    }
-  }
-}
+When invoked, run these checks in parallel:
+
+```javascript
+// Batch all checks in one message for speed
+mcp__monomind__system_health({})
+mcp__monomind__agent_health({})
+mcp__monomind__neural_status({ verbose: true })
+mcp__monomind__agentdb_health({})
+mcp__monomind__performance_report({ format: "detailed" })
 ```
 
-## Related Commands
+Then synthesize findings into:
+1. **Green** — operating normally
+2. **Yellow** — degraded, worth investigating
+3. **Red** — action required
+
+## Related Skills
 
-- `verify` - Run verification checks
-- `pair` - Collaborative development with truth tracking
-- `report` - Generate detailed reports
+- `verify:start` — Run targeted verification checks on specific code or tasks
+- `monitoring:status` — Real-time agent monitoring
+- `swarm:swarm-status` — Check running swarm health

package/.claude/commands/ts.md

@@ -1,9 +1,14 @@
+---
+name: ts
+description: Toggle the Monomind statusline panel between full (multi-line dashboard) and compact (single-line) mode
+---
+
 Toggle the Monomind statusline panel between full (multi-line dashboard) and compact (single-line) mode.
 
 Run this shell command immediately without asking for confirmation:
 
 ```bash
-node "${CLAUDE_PROJECT_DIR:-/Users/morteza/Desktop/tools/monomind}/.claude/helpers/toggle-statusline.cjs"
+node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/toggle-statusline.cjs"
 ```
 
-After running, tell me the new mode in one line (e.g. "Panel → compact" or "Panel → full"). No other output needed.
+After running, tell me the new mode in one line (e.g. "Panel -> compact" or "Panel -> full"). No other output needed.