monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/commands/swarm/optimization.md

@@ -0,0 +1,84 @@
+---
+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/packages/@monomind/cli/.claude/commands/swarm/research.md

@@ -0,0 +1,76 @@
+---
+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/packages/@monomind/cli/.claude/commands/swarm/swarm.md

@@ -0,0 +1,79 @@
+---
+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/packages/@monomind/cli/.claude/commands/swarm/testing.md

@@ -0,0 +1,80 @@
+---
+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/packages/@monomind/cli/.claude/commands/tokens.md

@@ -0,0 +1,18 @@
+---
+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/packages/@monomind/cli/.claude/commands/truth/start.md

@@ -0,0 +1,121 @@
+---
+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/packages/@monomind/cli/.claude/commands/ts.md

@@ -0,0 +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:-$(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.

package/packages/@monomind/cli/.claude/commands/workflows/README.md

@@ -0,0 +1,65 @@
+---
+name: workflows:README
+description: Workflow skills index — run, validate, and manage multi-agent workflows using real CLI subcommands and MCP tools
+---
+
+# Workflows Skills
+
+Skills for running and managing multi-agent workflows in Monomind.
+
+## Available Skills
+
+- [workflow-execute](./workflow-execute.md) — Run workflows using built-in templates
+- [workflow-create](./workflow-create.md) — Create and save custom workflow templates
+- [workflow-export](./workflow-export.md) — Manage and list workflow templates
+- [development](./development.md) — Development workflow coordination pattern
+- [research](./research.md) — Research workflow coordination pattern
+
+## Real CLI Subcommands
+
+```bash
+# Run a workflow from a template
+npx monomind workflow run -t development --task "Build auth system"
+npx monomind workflow run -t research --task "Analyze performance"
+npx monomind workflow run -f ./workflow.yaml
+
+# Validate a workflow file
+npx monomind workflow validate -f ./workflow.yaml --strict
+
+# List running/completed workflows
+npx monomind workflow list --status all --limit 10
+
+# Check workflow status
+npx monomind workflow status <workflowId>
+
+# Stop a running workflow
+npx monomind workflow stop <workflowId>
+
+# Manage templates
+npx monomind workflow template list
+npx monomind workflow template show development
+npx monomind workflow template create --name "my-workflow"
+```
+
+## Built-in Templates
+
+| Template | Stages | Agents |
+|----------|--------|--------|
+| `development` | Planning → Implementation → Testing → Review → Integration | coder, tester, reviewer |
+| `research` | Discovery → Analysis → Synthesis → Documentation | researcher, analyst |
+| `testing` | Unit → Integration → E2E → Performance | tester, coder |
+| `security-audit` | Threat Model → Static → Dynamic → Report | security-architect, auditor |
+| `code-review` | Initial → Security → Quality → Feedback | reviewer, auditor, analyst |
+| `refactoring` | Analysis → Planning → Refactor → Validation | architect, coder, reviewer |
+| `sparc` | Spec → Pseudocode → Architecture → Refinement → Completion | architect, coder, tester, reviewer |
+| `custom` | Define your own stages | configurable |
+
+## MCP Tools
+
+```javascript
+mcp__monomind__workflow_run({ template: "development", task: "Build feature", options: { parallel: true } })
+mcp__monomind__workflow_list({ status: "all", limit: 10 })
+mcp__monomind__workflow_status({ workflowId: "wf-123" })
+mcp__monomind__workflow_create({})
+mcp__monomind__workflow_template({})
+```

package/packages/@monomind/cli/.claude/commands/workflows/development.md

@@ -0,0 +1,86 @@
+---
+name: workflows:development
+description: Development workflow coordination pattern — hierarchical swarm for structured implementation tasks using real MCP tools and npx monomind workflow run -t development
+---
+
+# Development Workflow Coordination
+
+Structure multi-agent development tasks using the built-in development template for maximum efficiency.
+
+## How to Invoke
+
+```
+Skill("workflows:development")
+```
+
+---
+
+## Quick Start
+
+```bash
+# Run the built-in development workflow
+npx monomind workflow run -t development --task "Build REST API with auth"
+
+# Preview stages without executing
+npx monomind workflow run -t development --dry-run
+
+# Show template details (stages, agents, duration)
+npx monomind workflow template show development
+```
+
+## Stages
+
+The `development` template runs these stages:
+1. **Planning** — Requirements, architecture decisions
+2. **Implementation** — Code writing
+3. **Testing** — Unit and integration tests
+4. **Review** — Code quality and security check
+5. **Integration** — Connect all pieces
+
+Agents: `coder`, `tester`, `reviewer` (in parallel where possible)
+
+## MCP Coordination
+
+For custom development coordination via MCP:
+
+```javascript
+// Initialize hierarchical swarm for development
+mcp__monomind__swarm_init({
+  topology: "hierarchical",
+  maxAgents: 8,
+  strategy: "specialized"
+})
+
+// Run the development workflow
+mcp__monomind__workflow_run({
+  template: "development",
+  task: "Build REST API with authentication",
+  options: { parallel: true, maxAgents: 6 }
+})
+
+// Check progress
+mcp__monomind__workflow_status({ workflowId: "wf-123" })
+
+// Store findings for future sessions
+mcp__monomind__memory_store({
+  key: "dev-pattern-rest-api",
+  value: "JWT auth + Express + Zod validation worked well",
+  namespace: "patterns"
+})
+```
+
+## What Claude Code Actually Does
+
+Claude Code handles all execution via native tools:
+1. **Read/Write/Edit** tools — create and modify files
+2. **Bash** tool — run tests, builds, type checks
+3. **TodoWrite** tool — track implementation steps
+4. **Task** tool — spawn parallel agent workers
+
+The workflow template defines the coordination strategy; Claude Code does the actual work.
+
+## Related Skills
+
+- `workflows:workflow-execute` — Full workflow run reference
+- `swarm:development` — Direct swarm-based development coordination
+- `swarm:swarm-strategies` — Strategy selection guide