@monoes/monomindcli 1.10.54 → 1.10.55

package/.claude/commands/training/pattern-learn.md

@@ -1,69 +0,0 @@
----
-name: training:pattern-learn
-description: Analyze and store patterns from successful operations — list, search, and manually store neural patterns for task routing and prediction
----
-
-# Pattern Learn
-
-Analyze successful operations and store patterns to improve future routing and predictions.
-
-## How to Invoke
-
-```
-Skill("training:pattern-learn")
-```
-
----
-
-## CLI Reference
-
-```bash
-# List stored patterns
-npx monomind neural patterns --action list --limit 20
-
-# Analyze recent patterns for quality
-npx monomind neural patterns --action analyze
-
-# Search for specific patterns
-npx monomind neural patterns --action analyze --query "coordination"
-
-# Predict routing for a task description
-npx monomind neural predict --input "build a REST API" --k 5
-```
-
-## MCP Tools
-
-```javascript
-// List all stored patterns
-mcp__monomind__neural_patterns({ action: "list", limit: 20 })
-
-// Analyze pattern quality
-mcp__monomind__neural_patterns({ action: "analyze" })
-
-// Search for specific patterns
-mcp__monomind__neural_patterns({ action: "analyze", query: "coordination" })
-
-// Predict best routing for a task
-mcp__monomind__neural_predict({ input: "build REST API with auth" })
-
-// Store a new pattern manually via agentdb
-mcp__monomind__agentdb_pattern_store({
-  pattern: "successful-approach",
-  context: "typescript API with validation",
-  outcome: "passed all tests"
-})
-
-// Search existing patterns
-mcp__monomind__agentdb_pattern_search({ query: "API testing", limit: 10 })
-```
-
-## When to Use Pattern Learning
-
-- After completing a complex task successfully — store the approach for reuse
-- When a routing decision was wrong — correct the pattern to improve future predictions
-- Before starting a new task type — search existing patterns to benefit from past experience
-
-## See Also
-
-- `training:neural-train` — Train models on stored patterns
-- `training:neural-patterns` — Overview of automatic vs manual training

package/.claude/commands/training/specialization.md

@@ -1,92 +0,0 @@
----
-name: training:specialization
-description: Agent specialization training — spawn capability-specific agents for TypeScript, React, security, and other domains; track specialization progress
----
-
-# Agent Specialization Training
-
-Train and spawn agents that specialize in specific domains for better task performance.
-
-## How to Invoke
-
-```
-Skill("training:specialization")
-```
-
----
-
-## Spawning Specialized Agents
-
-```javascript
-// Spawn a React/TypeScript specialist
-mcp__monomind__agent_spawn({
-  type: "coder",
-  capabilities: ["react", "typescript", "testing"],
-  name: "React Specialist"
-})
-
-// Spawn a security-focused agent
-mcp__monomind__agent_spawn({
-  type: "security-architect",
-  capabilities: ["security-audit", "vulnerability-detection", "cve-remediation"]
-})
-
-// Spawn a database specialist
-mcp__monomind__agent_spawn({
-  type: "analyst",
-  capabilities: ["sql", "nosql", "query-optimization", "schema-design"]
-})
-```
-
-```bash
-npx monomind agent spawn --type coder --capabilities "react,typescript,testing"
-npx monomind agent list
-```
-
-## How Specialization Builds
-
-Agents accumulate expertise through:
-- Successful edits to files of a given type (`.ts`, `.py`, `.go`)
-- Pattern matching from stored neural patterns
-- Hooks feedback from `post-edit` and `post-task` results
-
-The hooks intelligence system records what worked and feeds it back into agent routing.
-
-## Specialization by File Type
-
-| Extension | Auto-specialization |
-|-----------|-------------------|
-| `.ts` / `.tsx` | TypeScript, React patterns |
-| `.py` | Python idioms, type hints |
-| `.go` | Go concurrency, interfaces |
-| `.rs` | Rust borrowing, ownership |
-| `.sql` | Query optimization, schema |
-
-## Checking Agent Specializations
-
-```javascript
-// List agents with their capabilities
-mcp__monomind__agent_list({})
-
-// Agent status detail
-mcp__monomind__agent_status({ agentId: "coder-001" })
-```
-
-```bash
-npx monomind agent list
-npx monomind agent status --id coder-001
-```
-
-## Training New Specializations
-
-```javascript
-// Train neural patterns for a specific domain
-mcp__monomind__neural_train({ patternType: "optimization", epochs: 100 })
-
-// Store a domain-specific pattern for future reuse
-mcp__monomind__agentdb_pattern_store({
-  pattern: "react-component-pattern",
-  context: "TypeScript functional components with hooks",
-  outcome: "clean, testable components"
-})
-```

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/helpers/README.md

@@ -1,105 +0,0 @@
-# MonoMind v1 Helpers
-
-This directory contains helper scripts and utilities for v1 development.
-
-## 🚀 Quick Start
-
-```bash
-# Initialize v1 development environment
-.claude/helpers/v1.sh init
-
-# Quick status check
-.claude/helpers/v1.sh status
-
-# Update progress metrics
-.claude/helpers/v1.sh update domain 3
-.claude/helpers/v1.sh update agent 8
-.claude/helpers/v1.sh update security 2
-```
-
-## Available Helpers
-
-### 🎛️ v1 Master Tool
-
-- **`v1.sh`** - Main command-line interface for all v1 operations
-  ```bash
-  .claude/helpers/v1.sh help           # Show all commands
-  .claude/helpers/v1.sh status         # Quick development status
-  .claude/helpers/v1.sh update domain 3 # Update specific metrics
-  .claude/helpers/v1.sh validate       # Validate configuration
-  .claude/helpers/v1.sh full-status    # Complete status overview
-  ```
-
-### 📊 v1 Progress Management
-
-- **`update-v1-progress.sh`** - Update v1 development metrics
-  ```bash
-  # Usage examples:
-  .claude/helpers/update-v1-progress.sh domain 3      # Mark 3 domains complete
-  .claude/helpers/update-v1-progress.sh agent 8       # 8 agents active
-  .claude/helpers/update-v1-progress.sh security 2    # 2 CVEs fixed
-  .claude/helpers/update-v1-progress.sh performance 2.5x # Performance boost
-  .claude/helpers/update-v1-progress.sh status        # Show current status
-  ```
-
-### 🔍 Configuration Validation
-
-- **`validate-v1-config.sh`** - Comprehensive environment validation
-  - Checks all required directories and files
-  - Validates JSON configuration files
-  - Verifies Node.js and development tools
-  - Confirms Git repository status
-  - Validates file permissions
-
-### ⚡ Quick Status
-
-- **`v1-quick-status.sh`** - Compact development progress overview
-  - Shows domain, agent, and DDD progress
-  - Displays security and performance metrics
-  - Color-coded status indicators
-  - Current Git branch information
-
-## Helper Script Standards
-
-### File Naming
-
-- Use kebab-case: `update-v1-progress.sh`
-- Include version prefix: `v1-*` for v1-specific helpers
-- Use descriptive names that indicate purpose
-
-### Script Requirements
-
-- Must be executable (`chmod +x`)
-- Include proper error handling (`set -e`)
-- Provide usage help when called without arguments
-- Use consistent exit codes (0 = success, non-zero = error)
-
-### Configuration Integration
-
-Helpers are configured in `.claude/settings.json`:
-
-```json
-{
-  "helpers": {
-    "directory": ".claude/helpers",
-    "enabled": true,
-    "v1ProgressUpdater": ".claude/helpers/update-v1-progress.sh"
-  }
-}
-```
-
-## Development Guidelines
-
-1. **Security First**: All helpers must validate inputs
-2. **Idempotent**: Scripts should be safe to run multiple times
-3. **Fast Execution**: Keep helper execution under 1 second when possible
-4. **Clear Output**: Provide clear success/error messages
-5. **JSON Safe**: When updating JSON files, use `jq` for safety
-
-## Adding New Helpers
-
-1. Create script in `.claude/helpers/`
-2. Make executable: `chmod +x script-name.sh`
-3. Add to settings.json helpers section
-4. Test thoroughly before committing
-5. Update this README with usage documentation