monomind 1.18.15 → 2.0.0

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

@@ -1,103 +0,0 @@
----
-name: swarm-examples
-description: Swarm pattern examples — concrete recipes for research, development, analysis, and testing swarms with real MCP tool invocations
----
-
-# Common Swarm Patterns
-
-Ready-to-use recipes for the most common swarm scenarios.
-
-## Research Swarm
-
-```javascript
-// 1. Initialize
-mcp__monomind__swarm_init({ topology: "mesh", maxAgents: 6, strategy: "adaptive" })
-
-// 2. Spawn agents
-mcp__monomind__agent_spawn({ type: "researcher", capabilities: ["web-search", "analysis", "synthesis"] })
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["data-processing", "reporting"] })
-
-// 3. Coordinate
-mcp__monomind__coordination_orchestrate({ task: "research AI trends", strategy: "parallel" })
-
-// 4. Monitor
-mcp__monomind__swarm_status({ swarmId: "current" })
-```
-
-```bash
-npx monomind swarm init --topology mesh --max-agents 6 --strategy research
-npx monomind swarm start "research AI trends" --strategy research --parallel
-```
-
----
-
-## Development Swarm
-
-```javascript
-// 1. Initialize
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
-
-// 2. Spawn team
-mcp__monomind__agent_spawn({ type: "architect", capabilities: ["system-design", "api-design"] })
-mcp__monomind__agent_spawn({ type: "coder", capabilities: ["typescript", "api", "backend"] })
-mcp__monomind__agent_spawn({ type: "tester", capabilities: ["integration", "e2e"] })
-mcp__monomind__agent_spawn({ type: "documenter", capabilities: ["api-docs", "readme"] })
-
-// 3. Coordinate
-mcp__monomind__coordination_orchestrate({ task: "build REST API", strategy: "sequential" })
-
-// 4. Monitor
-mcp__monomind__swarm_status({ swarmId: "current" })
-```
-
-```bash
-npx monomind swarm start "build REST API" --strategy development --mode hierarchical
-```
-
----
-
-## Analysis Swarm
-
-```javascript
-// 1. Initialize
-mcp__monomind__swarm_init({ topology: "mesh", maxAgents: 5, strategy: "adaptive" })
-
-// 2. Spawn agents
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["static-analysis", "complexity-analysis"] })
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["security-scan", "vulnerability-detection"] })
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["performance-analysis", "bottleneck-detection"] })
-
-// 3. Coordinate
-mcp__monomind__coordination_orchestrate({ task: "analyze codebase", strategy: "parallel" })
-
-// 4. Report
-mcp__monomind__performance_report({ format: "detailed" })
-```
-
-```bash
-npx monomind swarm start "analyze codebase" --strategy analysis --mode mesh --parallel
-```
-
----
-
-## Error Recovery
-
-When a swarm gets into a bad state:
-
-```javascript
-// Check status first
-mcp__monomind__swarm_status({ swarmId: "current" })
-
-// System health check
-mcp__monomind__system_health({})
-
-// Shut down and restart
-mcp__monomind__swarm_shutdown({ swarmId: "current" })
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 6, strategy: "specialized" })
-```
-
-## See Also
-
-- `swarm:swarm` — Main skill with strategy selection guide
-- `swarm:swarm-modes` — Topology reference
-- `swarm:swarm-strategies` — When to use each strategy

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

@@ -1,75 +0,0 @@
----
-name: swarm-maintenance
-description: Maintenance swarm strategy — sequential coordinated system maintenance for dependency updates, security audits, and documentation
----
-
-# Maintenance Swarm Strategy
-
-System maintenance and updates through coordinated agents.
-
-## How to Invoke
-
-```
-Skill("swarm:maintenance")
-```
-
-Then describe the maintenance task:
-> "Run a maintenance swarm to update all dependencies safely."
-> "Start a maintenance swarm for the monthly security audit."
-
----
-
-## Swarm Setup
-
-```javascript
-// Initialize maintenance swarm
-mcp__monomind__swarm_init({
-  topology: "star",
-  maxAgents: 5,
-  strategy: "sequential"
-})
-
-// Coordinate maintenance
-mcp__monomind__coordination_orchestrate({
-  task: "update dependencies",
-  strategy: "sequential"
-})
-```
-
-```bash
-# CLI equivalent
-npx monomind swarm init --topology star --max-agents 5
-npx monomind swarm start "update dependencies" --strategy maintenance
-```
-
-## Agent Roles
-
-```javascript
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["dependency-analysis", "version-management"] })
-mcp__monomind__agent_spawn({ type: "tester", capabilities: ["testing", "validation"] })
-mcp__monomind__agent_spawn({ type: "documenter", capabilities: ["documentation", "changelog"] })
-```
-
-## Maintenance Sequence
-
-Star topology runs sequentially — each agent completes before the next starts:
-
-1. **Analyzer agent** — audit outdated dependencies, find vulnerabilities
-2. **Tester agent** — verify tests pass on current state (baseline)
-3. **Analyst agent** — apply updates, verify no regressions
-4. **Tester agent** — rerun tests to confirm updates are safe
-5. **Documenter agent** — update CHANGELOG, document what changed
-
-## Security Scanning
-
-```javascript
-// Run security scan via AI defence
-mcp__monomind__aidefence_scan({ target: "./" })
-```
-
-## Monitoring
-
-```javascript
-mcp__monomind__swarm_status({ swarmId: "current" })
-mcp__monomind__system_health({})
-```

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

@@ -1,84 +0,0 @@
----
-name: swarm-optimization
-description: Optimization swarm strategy — performance profiling, bottleneck detection, and coordinated optimization through specialized mesh agents
----
-
-# Optimization Swarm Strategy
-
-Performance optimization through specialized analysis agents.
-
-## How to Invoke
-
-```
-Skill("swarm:optimization")
-```
-
-Then describe the optimization target:
-> "Start an optimization swarm to improve API response times."
-> "Run an optimization swarm on the memory usage in the agent system."
-
----
-
-## Swarm Setup
-
-```javascript
-// Initialize optimization swarm
-mcp__monomind__swarm_init({
-  topology: "mesh",
-  maxAgents: 6,
-  strategy: "adaptive"
-})
-
-// Coordinate optimization
-mcp__monomind__coordination_orchestrate({
-  task: "optimize performance",
-  strategy: "parallel"
-})
-```
-
-```bash
-# CLI equivalent
-npx monomind swarm init --topology mesh --max-agents 6
-npx monomind swarm start "optimize performance" --strategy optimization --parallel
-```
-
-## Agent Roles
-
-```javascript
-mcp__monomind__agent_spawn({ type: "optimizer", capabilities: ["profiling", "bottleneck-detection"] })
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["memory-analysis", "leak-detection"] })
-mcp__monomind__agent_spawn({ type: "optimizer", capabilities: ["code-optimization", "refactoring"] })
-mcp__monomind__agent_spawn({ type: "tester", capabilities: ["benchmarking", "performance-testing"] })
-```
-
-## Performance Analysis
-
-```javascript
-// Profile performance
-mcp__monomind__performance_profile({ target: "api", metrics: ["cpu", "memory", "latency"] })
-
-// Find bottlenecks
-mcp__monomind__performance_bottleneck({ component: "all" })
-
-// Performance report
-mcp__monomind__performance_report({ format: "detailed", timeframe: "7d" })
-
-// Benchmark results
-mcp__monomind__performance_benchmark({ suite: "performance" })
-```
-
-## Load Balancing
-
-```javascript
-// Balance work across optimization agents
-mcp__monomind__coordination_load_balance({
-  tasks: ["profile", "analyze", "optimize", "benchmark"]
-})
-```
-
-## Monitoring
-
-```javascript
-mcp__monomind__swarm_status({ swarmId: "current" })
-mcp__monomind__system_metrics({})
-```

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

@@ -1,76 +0,0 @@
----
-name: swarm-research
-description: Research swarm strategy — parallel information gathering with mesh topology for deep research, literature review, and knowledge synthesis
----
-
-# Research Swarm Strategy
-
-Deep research through parallel information gathering.
-
-## How to Invoke
-
-```
-Skill("swarm:research")
-```
-
-Then describe the research topic:
-> "Start a research swarm on AI agent coordination patterns."
-> "Research best practices for distributed consensus algorithms."
-
----
-
-## Swarm Setup
-
-```javascript
-// Initialize research swarm
-mcp__monomind__swarm_init({
-  topology: "mesh",
-  maxAgents: 6,
-  strategy: "adaptive"
-})
-
-// Coordinate research
-mcp__monomind__coordination_orchestrate({
-  task: "research topic X",
-  strategy: "parallel"
-})
-```
-
-```bash
-# CLI equivalent
-npx monomind swarm init --topology mesh --max-agents 6
-npx monomind swarm start "research topic X" --strategy research --parallel
-```
-
-## Agent Roles
-
-```javascript
-mcp__monomind__agent_spawn({ type: "researcher", capabilities: ["web-search", "content-extraction", "source-validation"] })
-mcp__monomind__agent_spawn({ type: "researcher", capabilities: ["paper-analysis", "citation-tracking", "literature-review"] })
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["data-processing", "statistical-analysis"] })
-mcp__monomind__agent_spawn({ type: "documenter", capabilities: ["synthesis", "technical-writing", "formatting"] })
-```
-
-## Knowledge Management
-
-```javascript
-// Store research findings for future sessions
-mcp__monomind__memory_store({
-  key: "research-findings",
-  value: "summary of findings",
-  namespace: "research"
-})
-
-// Search existing research
-mcp__monomind__memory_search({
-  query: "topic X",
-  namespace: "research",
-  limit: 20
-})
-```
-
-## Monitoring
-
-```javascript
-mcp__monomind__swarm_status({ swarmId: "current" })
-```

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/truth/start.md

@@ -1,121 +0,0 @@
----
-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.
----
-
-# Truth — System Reliability Assessment
-
-Assess the current health, agent performance, and task quality of the Monomind system.
-
-## How to Invoke
-
-```
-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."
-
----
-
-## What Truth Covers
-
-| 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 |
-
-## MCP Tools for Truth Assessment
-
-### System Health
-
-```javascript
-// Full system status
-mcp__monomind__system_health({})
-mcp__monomind__system_status({})
-mcp__monomind__system_metrics({})
-
-// MCP server connectivity
-mcp__monomind__mcp_status({})
-```
-
-### Agent Reliability
-
-```javascript
-// List active agents and their states
-mcp__monomind__agent_list({})
-mcp__monomind__agent_health({})
-
-// Swarm health (if a swarm is running)
-mcp__monomind__swarm_health({})
-mcp__monomind__swarm_status({ swarmId: "current" })
-```
-
-### Neural Pattern Quality
-
-```javascript
-// Pattern confidence scores
-mcp__monomind__neural_status({ verbose: true })
-mcp__monomind__neural_patterns({ action: "list", limit: 10 })
-
-// Hooks intelligence stats (routing accuracy)
-mcp__monomind__hooks_intelligence_stats({})
-```
-
-### Task Quality
-
-```javascript
-// Recent task outcomes
-mcp__monomind__task_summary({})
-mcp__monomind__progress_summary({})
-
-// LanceDB health (memory integrity)
-mcp__monomind__lancedb_health({})
-```
-
-### Performance
-
-```javascript
-// Performance bottlenecks
-mcp__monomind__performance_bottleneck({ component: "all" })
-mcp__monomind__performance_report({ format: "detailed" })
-```
-
-### Security
-
-```javascript
-// AI defence stats
-mcp__monomind__aidefence_stats({})
-mcp__monomind__aidefence_analyze({ content: "recent session summary" })
-```
-
----
-
-## Assessment Workflow
-
-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__lancedb_health({})
-mcp__monomind__performance_report({ format: "detailed" })
-```
-
-Then synthesize findings into:
-1. **Green** — operating normally
-2. **Yellow** — degraded, worth investigating
-3. **Red** — action required
-
-## Related Skills
-
-- `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,14 +0,0 @@
----
-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:-$(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.