@monoes/monomindcli 1.7.0 → 1.9.0

package/.claude/commands/verify/check.md

@@ -1,50 +1,106 @@
-# verify check
+---
+name: verify-check
+description: Verify code quality, security, and correctness using real MCP tools — AI defence scanning, neural pattern analysis, and system health checks
+---
 
-Run verification checks on code, tasks, or agent outputs.
+# Verify Check
 
-## Usage
+Run verification checks on code, tasks, or agent outputs using real MCP analysis tools.
+
+## How to Invoke
 
-```bash
-monomind verify check [options]
+```
+Skill("verify:check")
 ```
 
-## Options
+---
 
-- `--file <path>` - Verify specific file
-- `--task <id>` - Verify task output
-- `--directory <path>` - Verify entire directory
-- `--threshold <0-1>` - Override default threshold (0.95)
-- `--auto-fix` - Attempt automatic fixes
-- `--json` - Output results as JSON
-- `--verbose` - Show detailed verification steps
+## What to Verify
 
-## Examples
+| Area | MCP Tools |
+|------|-----------|
+| Security vulnerabilities | `aidefence_scan`, `aidefence_is_safe`, `aidefence_analyze` |
+| Pattern correctness | `neural_patterns`, `agentdb_pattern_search` |
+| System integrity | `agentdb_health`, `system_health` |
+| Memory consistency | `memory_search`, `memory_stats` |
+| Performance regressions | `performance_report`, `performance_bottleneck` |
 
-```bash
-# Basic file verification
-monomind verify check --file src/app.js
+## Security Verification
 
-# Verify with higher threshold
-monomind verify check --file src/critical.js --threshold 0.99
+```javascript
+// Scan content for security issues
+mcp__monomind__aidefence_scan({ content: "file content or task output" })
 
-# Verify and auto-fix issues
-monomind verify check --directory src/ --auto-fix
+// Check if content is safe
+mcp__monomind__aidefence_is_safe({ content: "content to check" })
 
-# Get JSON output for CI/CD
-monomind verify check --json > verification.json
+// Deep analysis with context
+mcp__monomind__aidefence_analyze({ content: "task output or code change" })
+
+// Check for PII exposure
+mcp__monomind__transfer_detect_pii({ content: "content to check" })
 ```
 
-## Truth Scoring
+## Pattern Verification
+
+```javascript
+// Check stored patterns for this type of task
+mcp__monomind__agentdb_pattern_search({ query: "task or code description", limit: 5 })
+
+// Compare with known good patterns
+mcp__monomind__neural_patterns({ action: "analyze", query: "task type" })
 
-The check command evaluates:
-- Code correctness
-- Best practices adherence
-- Security vulnerabilities
-- Performance implications
-- Documentation completeness
+// Predict expected routing for the task
+mcp__monomind__neural_predict({ input: "task description" })
+```
+
+## System Health Verification
+
+```javascript
+// AgentDB memory integrity
+mcp__monomind__agentdb_health({})
+
+// Full system health
+mcp__monomind__system_health({})
+
+// Performance snapshot
+mcp__monomind__performance_report({ format: "detailed" })
+```
+
+## Code Verification Workflow
+
+Run checks in parallel for speed:
+
+```javascript
+// Batch all checks at once
+mcp__monomind__aidefence_scan({ content: "code or output" })
+mcp__monomind__agentdb_health({})
+mcp__monomind__system_health({})
+mcp__monomind__performance_bottleneck({ component: "all" })
+```
+
+Then synthesize:
+- **Pass** — no security issues, healthy system, no performance regressions
+- **Review** — low-confidence patterns, minor warnings
+- **Fail** — security vulnerabilities found, system degraded
+
+## Git-Based Code Review
+
+For verifying code changes, use git and standard tools:
+
+```bash
+# Check what changed
+git diff HEAD~1
+
+# Run tests against changed files
+npm test -- --testPathPattern "changed-file"
+
+# TypeScript type check
+npx tsc --noEmit
+```
 
-## Exit Codes
+## Related Skills
 
-- `0` - Verification passed
-- `1` - Verification failed
-- `2` - Error during verification
+- `truth:start` — Full system reliability assessment
+- `swarm:swarm-analysis` — Post-swarm run analysis
+- `security-hardening` — Comprehensive security hardening workflow

package/.claude/commands/verify/start.md

@@ -1,128 +1,105 @@
-# 🔍 Verification Commands
+---
+name: verify-start
+description: Verification skill overview — guides running quality, security, and correctness checks using real MCP tools and git-based workflows
+---
 
-Truth verification system for ensuring code quality and correctness with a 0.95 accuracy threshold.
+# Verify — Quality and Correctness Checks
 
-## Overview
+Run targeted verification checks on code, agent outputs, and system state.
 
-The verification system provides real-time truth checking and validation for all agent tasks, ensuring high-quality outputs and automatic rollback on failures.
+## How to Invoke
 
-## Subcommands
-
-### `verify check`
-Run verification checks on current code or agent outputs.
-
-```bash
-monomind verify check --file src/app.js
-monomind verify check --task "task-123"
-monomind verify check --threshold 0.98
+```
+Skill("verify:start")
 ```
 
-### `verify rollback`
-Automatically rollback changes that fail verification.
+Then describe what to verify:
+> "Verify the last agent output for security issues."
+> "Check system health before deploying."
+> "Verify the code changes in this PR are safe."
 
-```bash
-monomind verify rollback --to-commit abc123
-monomind verify rollback --last-good
-monomind verify rollback --interactive
-```
+---
 
-### `verify report`
-Generate verification reports and metrics.
+## Verification Areas
 
-```bash
-monomind verify report --format json
-monomind verify report --export metrics.html
-monomind verify report --period 7d
-```
+| Area | Skill | What it checks |
+|------|-------|---------------|
+| Code security | `verify:check` | AI defence scan, PII detection |
+| Pattern quality | `verify:check` | Neural pattern confidence, routing accuracy |
+| System health | `truth:start` | MCP status, AgentDB health, performance |
+| Agent outputs | `verify:check` | Task correctness against stored patterns |
 
-### `verify dashboard`
-Launch interactive verification dashboard.
+## Quick Checks
 
-```bash
-monomind verify dashboard
-monomind verify dashboard --port 3000
-monomind verify dashboard --export
-```
+### Security Scan
 
-## Configuration
-
-Default threshold: **0.95** (95% accuracy required)
-
-Configure in `.monomind/config.json`:
-```json
-{
-  "verification": {
-    "threshold": 0.95,
-    "autoRollback": true,
-    "gitIntegration": true,
-    "hooks": {
-      "preCommit": true,
-      "preTask": true,
-      "postEdit": true
-    }
-  }
-}
+```javascript
+mcp__monomind__aidefence_scan({ content: "output or code to verify" })
+mcp__monomind__aidefence_is_safe({ content: "content" })
 ```
 
-## Integration
+### System Integrity
 
-### With Swarm Commands
-```bash
-monomind swarm --verify --threshold 0.98
-monomind hive-mind --verify
+```javascript
+mcp__monomind__agentdb_health({})
+mcp__monomind__system_health({})
+mcp__monomind__system_status({})
 ```
 
-### With Training Pipeline
-```bash
-monomind train --verify --rollback-on-fail
-```
+### Pattern Confidence
 
-### With Pair Programming
-```bash
-monomind pair --verify --real-time
+```javascript
+mcp__monomind__neural_status({ verbose: true })
+mcp__monomind__neural_patterns({ action: "analyze" })
 ```
 
-## Metrics
+### Performance Baseline
+
+```javascript
+mcp__monomind__performance_report({ format: "detailed" })
+mcp__monomind__performance_bottleneck({ component: "all" })
+```
 
-- **Truth Score**: 0.0 to 1.0 (higher is better)
-- **Confidence Level**: Statistical confidence in verification
-- **Rollback Rate**: Percentage of changes rolled back
-- **Quality Improvement**: Trend over time
+## Code Change Verification
 
-## Examples
+For verifying code changes before committing or merging:
 
-### Basic Verification
 ```bash
-# Verify current directory
-monomind verify check
+# Type safety
+npx tsc --noEmit
+
+# Tests
+npm test
 
-# Verify with custom threshold
-monomind verify check --threshold 0.99
+# Lint
+npm run lint
 
-# Verify and auto-fix
-monomind verify check --auto-fix
+# Diff review
+git diff HEAD~1 --stat
 ```
 
-### Advanced Workflows
-```bash
-# Continuous verification during development
-monomind verify watch --directory src/
+## Post-Task Verification
 
-# Batch verification
-monomind verify batch --files "*.js" --parallel
+After a swarm or agent task completes, verify outputs:
 
-# Integration testing
-monomind verify integration --test-suite full
-```
+```javascript
+// 1. Check agent health post-task
+mcp__monomind__agent_health({})
 
-## Performance
+// 2. Scan output for security issues
+mcp__monomind__aidefence_analyze({ content: "task summary or generated code" })
 
-- Verification latency: <100ms for most checks
-- Rollback time: <1s for git-based rollback
-- Dashboard refresh: Real-time via WebSocket
+// 3. Store verified pattern for future use
+mcp__monomind__agentdb_pattern_store({
+  pattern: "verified-approach",
+  context: "task type and context",
+  outcome: "success"
+})
+```
 
-## Related Commands
+## Related Skills
 
-- `truth` - View truth scores and metrics
-- `pair` - Collaborative development with verification
-- `train` - Training with verification feedback
+- `verify:check` — Targeted verification checks with MCP tools
+- `truth:start` — Full system reliability assessment
+- `hooks:post-task` — Automatic post-task verification via hooks
+- `security-hardening` — Comprehensive security workflows

package/.claude/commands/workflows/README.md

@@ -1,9 +1,65 @@
-# Workflows Commands
+---
+name: workflows:README
+description: Workflow skills index — run, validate, and manage multi-agent workflows using real CLI subcommands and MCP tools
+---
 
-Commands for workflows operations in Monomind.
+# Workflows Skills
 
-## Available Commands
+Skills for running and managing multi-agent workflows in Monomind.
 
-- [workflow-create](./workflow-create.md)
-- [workflow-execute](./workflow-execute.md)
-- [workflow-export](./workflow-export.md)
+## 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/.claude/commands/workflows/development.md

@@ -1,78 +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
 
-## Purpose
-Structure Claude Code's approach to complex development tasks for maximum efficiency.
+Structure multi-agent development tasks using the built-in development template for maximum efficiency.
 
-## Step-by-Step Coordination
+## How to Invoke
 
-### 1. Initialize Development Framework
 ```
-Tool: mcp__monomind__swarm_init
-Parameters: {"topology": "hierarchical", "maxAgents": 8, "strategy": "specialized"}
+Skill("workflows:development")
 ```
-Creates hierarchical structure for organized, top-down development.
 
-### 2. Define Development Perspectives
-```
-Tool: mcp__monomind__agent_spawn
-Parameters: {
-  "type": "architect",
-  "name": "System Design",
-  "capabilities": ["api-design", "database-schema"]
-}
-```
-```
-Tool: mcp__monomind__agent_spawn
-Parameters: {
-  "type": "coder",
-  "name": "Implementation Focus",
-  "capabilities": ["nodejs", "typescript", "express"]
-}
-```
-```
-Tool: mcp__monomind__agent_spawn
-Parameters: {
-  "type": "tester",
-  "name": "Quality Assurance",
-  "capabilities": ["unit-testing", "integration-testing"]
-}
-```
-Sets up architectural and implementation thinking patterns.
+---
 
-### 3. Coordinate Implementation
-```
-Tool: mcp__monomind__task_orchestrate
-Parameters: {
-  "task": "Build REST API with authentication",
-  "strategy": "parallel",
-  "priority": "high",
-  "dependencies": ["database setup", "auth system"]
-}
-```
+## Quick Start
+
+```bash
+# Run the built-in development workflow
+npx monomind workflow run -t development --task "Build REST API with auth"
 
-### 4. Monitor Progress
+# Preview stages without executing
+npx monomind workflow run -t development --dry-run
+
+# Show template details (stages, agents, duration)
+npx monomind workflow template show development
 ```
-Tool: mcp__monomind__task_status
-Parameters: {"taskId": "api-build-task-123"}
+
+## 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
-1. Uses **Write** tool to create new files
-2. Uses **Edit/MultiEdit** tools for code modifications
-3. Uses **Bash** tool for testing and building
-4. Uses **TodoWrite** tool for task tracking
-5. Follows coordination patterns for systematic implementation
 
-Remember: All code is written by Claude Code using its native tools!
+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
 
-## CLI Usage
-```bash
-# Start development workflow via CLI
-npx monomind workflow dev "REST API with auth"
+The workflow template defines the coordination strategy; Claude Code does the actual work.
 
-# Create custom workflow
-npx monomind workflow create --name "api-dev" --steps "design,implement,test,deploy"
+## Related Skills
 
-# Execute saved workflow
-npx monomind workflow execute api-dev
-```
+- `workflows:workflow-execute` — Full workflow run reference
+- `swarm:development` — Direct swarm-based development coordination
+- `swarm:swarm-strategies` — Strategy selection guide