monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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.

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

@@ -1,64 +0,0 @@
----
-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 |
-| `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

@@ -1,86 +0,0 @@
----
-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