monomind 1.10.0 → 1.10.1

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({})
-
-// AgentDB health (memory integrity)
-mcp__monomind__agentdb_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__agentdb_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.

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

@@ -1,106 +0,0 @@
----
-name: verify-check
-description: Verify code quality, security, and correctness using real MCP tools — AI defence scanning, neural pattern analysis, and system health checks
----
-
-# Verify Check
-
-Run verification checks on code, tasks, or agent outputs using real MCP analysis tools.
-
-## How to Invoke
-
-```
-Skill("verify:check")
-```
-
----
-
-## What to Verify
-
-| 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` |
-
-## Security Verification
-
-```javascript
-// Scan content for security issues
-mcp__monomind__aidefence_scan({ content: "file content or task output" })
-
-// Check if content is safe
-mcp__monomind__aidefence_is_safe({ content: "content to check" })
-
-// 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" })
-```
-
-## 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" })
-
-// 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
-```
-
-## Related Skills
-
-- `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,105 +0,0 @@
----
-name: verify-start
-description: Verification skill overview — guides running quality, security, and correctness checks using real MCP tools and git-based workflows
----
-
-# Verify — Quality and Correctness Checks
-
-Run targeted verification checks on code, agent outputs, and system state.
-
-## How to Invoke
-
-```
-Skill("verify:start")
-```
-
-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."
-
----
-
-## Verification Areas
-
-| 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 |
-
-## Quick Checks
-
-### Security Scan
-
-```javascript
-mcp__monomind__aidefence_scan({ content: "output or code to verify" })
-mcp__monomind__aidefence_is_safe({ content: "content" })
-```
-
-### System Integrity
-
-```javascript
-mcp__monomind__agentdb_health({})
-mcp__monomind__system_health({})
-mcp__monomind__system_status({})
-```
-
-### Pattern Confidence
-
-```javascript
-mcp__monomind__neural_status({ verbose: true })
-mcp__monomind__neural_patterns({ action: "analyze" })
-```
-
-### Performance Baseline
-
-```javascript
-mcp__monomind__performance_report({ format: "detailed" })
-mcp__monomind__performance_bottleneck({ component: "all" })
-```
-
-## Code Change Verification
-
-For verifying code changes before committing or merging:
-
-```bash
-# Type safety
-npx tsc --noEmit
-
-# Tests
-npm test
-
-# Lint
-npm run lint
-
-# Diff review
-git diff HEAD~1 --stat
-```
-
-## Post-Task Verification
-
-After a swarm or agent task completes, verify outputs:
-
-```javascript
-// 1. Check agent health post-task
-mcp__monomind__agent_health({})
-
-// 2. Scan output for security issues
-mcp__monomind__aidefence_analyze({ content: "task summary or generated code" })
-
-// 3. Store verified pattern for future use
-mcp__monomind__agentdb_pattern_store({
-  pattern: "verified-approach",
-  context: "task type and context",
-  outcome: "success"
-})
-```
-
-## Related Skills
-
-- `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,65 +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 |
-| `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,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

package/.claude/commands/workflows/research.md

@@ -1,89 +0,0 @@
----
-name: workflows:research
-description: Research workflow coordination pattern — mesh swarm for comprehensive exploration using real MCP tools and npx monomind workflow run -t research
----
-
-# Research Workflow Coordination
-
-Coordinate multi-agent research activities for comprehensive, systematic exploration.
-
-## How to Invoke
-
-```
-Skill("workflows:research")
-```
-
----
-
-## Quick Start
-
-```bash
-# Run the built-in research workflow
-npx monomind workflow run -t research --task "Analyze modern web framework performance"
-
-# Preview stages without executing
-npx monomind workflow run -t research --dry-run
-
-# Show template details
-npx monomind workflow template show research
-```
-
-## Stages
-
-The `research` template runs these stages:
-1. **Discovery** — Identify sources, gather raw information
-2. **Analysis** — Evaluate and compare findings
-3. **Synthesis** — Combine into coherent conclusions
-4. **Documentation** — Write up findings
-
-Agents: `researcher`, `analyst` (mesh topology for broad coverage)
-
-## MCP Coordination
-
-For custom research coordination via MCP:
-
-```javascript
-// Initialize mesh swarm for broad exploration
-mcp__monomind__swarm_init({
-  topology: "mesh",
-  maxAgents: 5,
-  strategy: "balanced"
-})
-
-// Run the research workflow
-mcp__monomind__workflow_run({
-  template: "research",
-  task: "Research modern web frameworks performance",
-  options: { parallel: true, maxAgents: 4 }
-})
-
-// Store research findings in memory
-mcp__monomind__memory_store({
-  key: "research-web-frameworks-2026",
-  value: "React/Next.js leads for SSR; Astro for static; Svelte for performance",
-  namespace: "research"
-})
-
-// Search past research before starting
-mcp__monomind__memory_search({
-  query: "web framework performance analysis",
-  namespace: "research",
-  limit: 5
-})
-```
-
-## What Claude Code Actually Does
-
-1. **WebSearch** tool — finds relevant resources
-2. **Read** tool — analyzes documentation and code
-3. **Task** tool — spawns parallel research agents for different angles
-4. Synthesizes findings in the conversation
-5. Stores insights in memory for future sessions
-
-The workflow template coordinates the research strategy; Claude Code does the actual searching and reading.
-
-## Related Skills
-
-- `workflows:workflow-execute` — Full workflow run reference
-- `swarm:research` — Direct swarm-based research coordination
-- `memory:memory-search` — Search past research findings

package/.claude/commands/workflows/workflow-create.md

@@ -1,84 +0,0 @@
----
-name: workflows:workflow-create
-description: Create and save custom workflow templates using npx monomind workflow template create — save successful workflows for reuse
----
-
-# Workflow Create
-
-Create and save custom workflow templates for reuse.
-
-## How to Invoke
-
-```
-Skill("workflows:workflow-create")
-```
-
----
-
-## CLI Reference
-
-```bash
-# Create a template from a workflow ID
-npx monomind workflow template create --name "my-api-workflow" --workflow wf-abc123
-
-# Create a template from a workflow file
-npx monomind workflow template create --name "deploy-workflow" --file ./workflow.yaml
-
-# List existing templates
-npx monomind workflow template list
-
-# Show a specific template's stages and agents
-npx monomind workflow template show development
-npx monomind workflow template show sparc
-```
-
-## Template Create Flags
-
-| Flag | Short | Description |
-|------|-------|-------------|
-| `--name` | `-n` | Template name (required) |
-| `--workflow` | `-w` | Workflow ID to save as template |
-| `--file` | `-f` | Workflow file to save as template |
-
-## MCP Tools
-
-```javascript
-// Create a workflow definition
-mcp__monomind__workflow_create({
-  name: "my-workflow",
-  template: "development",
-  task: "Build auth system"
-})
-
-// List available templates
-mcp__monomind__workflow_template({})
-
-// Execute workflow from template
-mcp__monomind__workflow_run({
-  template: "my-workflow",
-  task: "Build feature X"
-})
-```
-
-## Workflow
-
-1. Run a workflow that works well:
-   ```bash
-   npx monomind workflow run -t development --task "Build auth"
-   # Note the workflowId in the output
-   ```
-
-2. Save it as a reusable template:
-   ```bash
-   npx monomind workflow template create --name "auth-workflow" --workflow <workflowId>
-   ```
-
-3. Reuse it:
-   ```bash
-   npx monomind workflow run -t auth-workflow --task "New auth task"
-   ```
-
-## Related Skills
-
-- `workflows:workflow-execute` — Run workflows from templates
-- `workflows:workflow-export` — Browse and manage templates