monomind 1.10.0 → 1.10.1

package/.claude/commands/swarm/swarm-strategies.md

@@ -1,76 +0,0 @@
----
-name: swarm-swarm-strategies
-description: Swarm strategy selection guide — when to use specialized, adaptive, balanced, sequential, and parallel strategies for different tasks
----
-
-# Swarm Strategy Guide
-
-Choose the right strategy for your swarm objective.
-
-## How to Invoke
-
-```
-Skill("swarm:swarm-strategies")
-```
-
----
-
-## Available Strategies
-
-### specialized
-
-```javascript
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
-```
-
-- Each agent has a specific role and skill set — no overlap
-- Best for: complex feature development, audits, structured workflows
-- Agents: architect, coder, tester, reviewer — each owns their domain
-
-### adaptive
-
-```javascript
-mcp__monomind__swarm_init({ topology: "mesh", maxAgents: 6, strategy: "adaptive" })
-```
-
-- Agents dynamically adjust to task demands
-- Best for: research, exploration, unknown problem spaces
-- Agents can shift roles as needs emerge
-
-### balanced
-
-```javascript
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "balanced" })
-```
-
-- Mix of specialization and flexibility
-- Best for: medium complexity features where requirements may evolve
-
-### sequential
-
-```javascript
-mcp__monomind__swarm_init({ topology: "star", maxAgents: 5, strategy: "sequential" })
-```
-
-- Tasks execute one after another in a defined order
-- Best for: maintenance workflows, migrations, processes with strict dependencies
-
-### parallel
-
-```javascript
-mcp__monomind__swarm_init({ topology: "star", maxAgents: 7, strategy: "parallel" })
-```
-
-- Tasks execute simultaneously, no dependencies between them
-- Best for: running multiple independent test suites, analyzing multiple modules
-
-## Decision Matrix
-
-| Objective | Strategy | Topology |
-|-----------|----------|----------|
-| Build complex feature | specialized | hierarchical |
-| Research open-ended topic | adaptive | mesh |
-| Run test suites | parallel | star |
-| Update dependencies | sequential | star |
-| Analyze codebase | adaptive | mesh |
-| Security audit | specialized | hierarchical |

package/.claude/commands/swarm/swarm.md

@@ -1,79 +0,0 @@
----
-name: swarm-swarm
-description: Main swarm skill — initializes and starts multi-agent swarms for research, development, analysis, testing, optimization, and maintenance tasks
----
-
-# Swarm Orchestration
-
-Start and coordinate multi-agent swarms for complex tasks.
-
-## How to Invoke
-
-In Claude Code, load this skill:
-```
-Skill("swarm:swarm")
-```
-
-Then describe what you want to accomplish:
-> "Start a development swarm to build a REST API with auth endpoints."
-> "Run a research swarm on AI agent coordination patterns."
-
----
-
-## CLI Reference
-
-```bash
-# Initialize a swarm
-npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
-
-# Start a swarm with an objective
-npx monomind swarm start "Build REST API" --strategy development --parallel
-
-# Check swarm status
-npx monomind swarm status
-
-# Stop the swarm
-npx monomind swarm stop
-
-# Scale agents
-npx monomind swarm scale <swarm-id> --agents 12
-```
-
-## MCP Tools
-
-```javascript
-// Initialize swarm
-mcp__monomind__swarm_init({
-  topology: "hierarchical",
-  maxAgents: 8,
-  strategy: "specialized"
-})
-
-// Check status
-mcp__monomind__swarm_status({ swarmId: "current" })
-
-// Coordinate tasks
-mcp__monomind__coordination_orchestrate({ task: "build feature", strategy: "parallel" })
-
-// Spawn an agent
-mcp__monomind__agent_spawn({ type: "coder", capabilities: ["typescript", "api"] })
-
-// Shut down swarm
-mcp__monomind__swarm_shutdown({ swarmId: "current" })
-```
-
-## Strategy Selection
-
-| Strategy | Topology | Use when |
-|----------|----------|----------|
-| research | mesh | Gathering information from multiple sources in parallel |
-| development | hierarchical | Building features with architect → coder → tester flow |
-| analysis | mesh | Distributed codebase or performance analysis |
-| testing | star | Parallel test suite execution |
-| optimization | mesh | Performance profiling and bottleneck resolution |
-| maintenance | star | Sequential dependency updates with checkpoints |
-
-## See Also
-- `swarm:examples` — Common swarm patterns with full code
-- `swarm:swarm-modes` — Topology reference
-- `swarm:swarm-strategies` — Strategy selection guide

package/.claude/commands/swarm/testing.md

@@ -1,80 +0,0 @@
----
-name: swarm-testing
-description: Testing swarm strategy — distributed parallel test execution with specialized unit, integration, E2E, and performance testing agents
----
-
-# Testing Swarm Strategy
-
-Comprehensive testing through distributed execution.
-
-## How to Invoke
-
-```
-Skill("swarm:testing")
-```
-
-Then describe the testing scope:
-> "Start a testing swarm to run full test coverage on the API."
-> "Run a testing swarm to validate the auth module end-to-end."
-
----
-
-## Swarm Setup
-
-```javascript
-// Initialize testing swarm
-mcp__monomind__swarm_init({
-  topology: "star",
-  maxAgents: 7,
-  strategy: "parallel"
-})
-
-// Coordinate testing
-mcp__monomind__coordination_orchestrate({
-  task: "test application",
-  strategy: "parallel"
-})
-```
-
-```bash
-# CLI equivalent
-npx monomind swarm init --topology star --max-agents 7
-npx monomind swarm start "test application" --strategy testing --parallel
-```
-
-## Agent Roles
-
-```javascript
-mcp__monomind__agent_spawn({ type: "tester", capabilities: ["unit-testing", "mocking", "coverage"] })
-mcp__monomind__agent_spawn({ type: "tester", capabilities: ["integration", "api-testing", "contract-testing"] })
-mcp__monomind__agent_spawn({ type: "tester", capabilities: ["e2e", "ui-testing", "user-flows"] })
-mcp__monomind__agent_spawn({ type: "tester", capabilities: ["load-testing", "stress-testing", "benchmarking"] })
-mcp__monomind__agent_spawn({ type: "tester", capabilities: ["security-testing", "vulnerability-scanning"] })
-```
-
-## Test Execution
-
-Run tests in parallel via Bash agents:
-
-```bash
-# Agents each run one of these in parallel
-npm run test:unit
-npm run test:integration
-npm run test:e2e
-```
-
-## Monitoring and Reporting
-
-```javascript
-// Check swarm status
-mcp__monomind__swarm_status({ swarmId: "current" })
-
-// Performance metrics
-mcp__monomind__performance_report({ format: "detailed" })
-```
-
-## Best Practices
-
-- Use star topology (coordinator at center, test agents at spokes) for isolated parallel runs
-- Run unit and integration tests in parallel; run E2E only after integration passes
-- Security testing agent runs last, after code is stable

package/.claude/commands/tokens.md

@@ -1,18 +0,0 @@
----
-name: tokens
-description: Show the Monomind token usage dashboard — reports spend and call counts for today, week, 30days, or month
----
-
-Show the Monomind token usage dashboard for the requested period.
-
-Run this shell command immediately without asking for confirmation:
-
-```bash
-node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/token-tracker.cjs" report "${1:-today}"
-```
-
-Valid periods: `today` (default), `week`, `30days`, `month`.
-
-Examples: `/tokens`, `/tokens week`, `/tokens month`
-
-After running, show the full output verbatim. No other commentary needed.

package/.claude/commands/training/README.md

@@ -1,39 +0,0 @@
----
-name: training:README
-description: Training skill index — neural pattern training, model optimization, agent specialization, and pattern learning reference
----
-
-# Training Skills
-
-Neural network training, pattern learning, and agent specialization for Monomind.
-
-## Available Skills
-
-- [neural-patterns](./neural-patterns.md) — Overview of how automatic and manual neural training works
-- [neural-train](./neural-train.md) — Train neural patterns with WASM acceleration (MicroLoRA + Flash Attention)
-- [pattern-learn](./pattern-learn.md) — Analyze and store patterns from successful operations
-- [model-update](./model-update.md) — Update and optimize trained neural models
-- [specialization](./specialization.md) — Train agents to specialize in specific domains or file types
-
-## Quick Start
-
-```bash
-# Train coordination patterns (50 epochs, WASM + Flash Attention)
-npx monomind neural train --pattern coordination --epochs 50
-
-# Check neural status
-npx monomind neural status
-
-# Analyze stored patterns
-npx monomind neural patterns --action analyze
-```
-
-## MCP Tools
-
-```javascript
-mcp__monomind__neural_train({ patternType: "coordination", epochs: 50 })
-mcp__monomind__neural_status({})
-mcp__monomind__neural_patterns({ action: "list", limit: 10 })
-mcp__monomind__neural_predict({ input: "task description" })
-mcp__monomind__neural_optimize({ method: "quantize" })
-```

package/.claude/commands/training/model-update.md

@@ -1,78 +0,0 @@
----
-name: training:model-update
-description: Update and optimize trained neural models — quantize, compact, and export models using the real neural optimize and export CLI commands
----
-
-# Model Update
-
-Update, optimize, and export trained neural models.
-
-## How to Invoke
-
-```
-Skill("training:model-update")
-```
-
----
-
-## CLI Reference
-
-```bash
-# Optimize a model (quantize for size/speed)
-npx monomind neural optimize --method quantize
-
-# Analyze model quality before/after optimization
-npx monomind neural optimize --method analyze --verbose
-
-# Compact model for faster inference
-npx monomind neural optimize --method compact
-
-# Check model status after update
-npx monomind neural status --verbose
-
-# Export a trained model
-npx monomind neural export --model coordination
-```
-
-## MCP Tools
-
-```javascript
-// Optimize model (quantize/compact)
-mcp__monomind__neural_optimize({ method: "quantize" })
-
-// Compress for deployment
-mcp__monomind__neural_compress({})
-
-// Check model health and scores
-mcp__monomind__neural_status({ verbose: true })
-
-// SONA self-adapting model update
-mcp__monomind__ruvllm_sona_adapt({ modelId: "coordination" })
-```
-
-## Optimization Methods
-
-| Method | What it does |
-|--------|-------------|
-| `quantize` | Reduce model precision for smaller size and faster inference |
-| `analyze` | Report model quality metrics without changing the model |
-| `compact` | Prune low-value weights, reduce model footprint |
-
-## Workflow
-
-```bash
-# 1. Analyze current state
-npx monomind neural optimize --method analyze --verbose
-
-# 2. Train with new data if needed
-npx monomind neural train --pattern coordination --epochs 100
-
-# 3. Optimize the updated model
-npx monomind neural optimize --method quantize
-
-# 4. Verify improvement
-npx monomind neural status --verbose
-
-# 5. Export for deployment
-npx monomind neural export --model coordination
-```

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

@@ -1,73 +0,0 @@
----
-name: training:neural-patterns
-description: Neural pattern training overview — automatic learning from operations, manual training, pattern types, and improvement tracking
----
-
-# Neural Pattern Training
-
-How Monomind continuously learns and improves through neural pattern training.
-
-## How to Invoke
-
-```
-Skill("training:neural-patterns")
-```
-
----
-
-## Automatic Learning
-
-Every successful operation trains the neural networks automatically:
-- Edit patterns for different file types
-- Search strategies that find results faster
-- Task decomposition approaches
-- Agent coordination patterns
-
-The hooks system (`post-edit`, `post-task`) feeds successful operations into training automatically.
-
-## Manual Training
-
-```javascript
-// Train coordination patterns
-mcp__monomind__neural_train({ patternType: "coordination", epochs: 50 })
-
-// Train security patterns with contrastive learning
-mcp__monomind__neural_train({ patternType: "security", epochs: 100 })
-
-// Check training status and pattern scores
-mcp__monomind__neural_status({})
-
-// Analyze recent patterns
-mcp__monomind__neural_patterns({ action: "analyze", limit: 20 })
-```
-
-```bash
-npx monomind neural train --pattern coordination --epochs 50
-npx monomind neural status
-npx monomind neural patterns --action analyze
-```
-
-## Pattern Types
-
-| Pattern | Purpose |
-|---------|---------|
-| `coordination` | Multi-agent task coordination (default) |
-| `optimization` | Performance and resource optimization |
-| `prediction` | Task routing and agent selection |
-| `security` | Security scanning and vulnerability detection |
-| `testing` | Test strategy selection and coverage |
-
-## Improvement Tracking
-
-```javascript
-// View current pattern scores and improvement
-mcp__monomind__neural_status({ verbose: true })
-```
-
-Output includes pattern confidence scores and improvement percentage since last session.
-
-## See Also
-
-- `training:neural-train` — Full training options with WASM acceleration
-- `training:pattern-learn` — Manual pattern storage
-- `training:model-update` — Model optimization

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

@@ -1,79 +0,0 @@
----
-name: training:neural-train
-description: Train neural patterns with WASM SIMD acceleration — MicroLoRA, Flash Attention (2.49x-7.47x speedup), MoE routing, contrastive learning
----
-
-# Neural Train
-
-Train neural patterns with WASM acceleration using the real `npx monomind neural train` command.
-
-## How to Invoke
-
-```
-Skill("training:neural-train")
-```
-
----
-
-## CLI Reference
-
-```bash
-# 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 })
-
-// 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
-
-# Export the trained model
-npx monomind neural export --model coordination
-```

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

@@ -1,69 +0,0 @@
----
-name: training:pattern-learn
-description: Analyze and store patterns from successful operations — list, search, and manually store neural patterns for task routing and prediction
----
-
-# Pattern Learn
-
-Analyze successful operations and store patterns to improve future routing and predictions.
-
-## How to Invoke
-
-```
-Skill("training:pattern-learn")
-```
-
----
-
-## CLI Reference
-
-```bash
-# 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
-```
-
-## MCP Tools
-
-```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,92 +0,0 @@
----
-name: training:specialization
-description: Agent specialization training — spawn capability-specific agents for TypeScript, React, security, and other domains; track specialization progress
----
-
-# Agent Specialization Training
-
-Train and spawn agents that specialize in specific domains for better task performance.
-
-## How to Invoke
-
-```
-Skill("training:specialization")
-```
-
----
-
-## 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"]
-})
-
-// Spawn a database specialist
-mcp__monomind__agent_spawn({
-  type: "analyst",
-  capabilities: ["sql", "nosql", "query-optimization", "schema-design"]
-})
-```
-
-```bash
-npx monomind agent spawn --type coder --capabilities "react,typescript,testing"
-npx monomind agent list
-```
-
-## 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" })
-```
-
-```bash
-npx monomind agent list
-npx monomind agent status --id coder-001
-```
-
-## Training New 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"
-})
-```