monomind 1.10.47 → 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/config/v1-dependency-optimization.json

@@ -1,266 +0,0 @@
-{
-  "v1DependencyOptimization": {
-    "version": "1.0.0",
-    "strategy": "enhanced_parallelism",
-    "description": "Optimized dependency chain for maximum parallel execution efficiency",
-
-    "originalDependencies": {
-      "description": "Current dependency chain with blocking issues",
-      "issues": [
-        "Some agents wait unnecessarily for unrelated dependencies",
-        "Phase boundaries too rigid, reducing parallelism",
-        "Agent #11 and #12 have excessive blocking dependencies"
-      ]
-    },
-
-    "optimizedDependencies": {
-      "description": "Enhanced parallel execution with reduced blocking",
-
-      "phases": {
-        "phase1_enhanced": {
-          "name": "Enhanced Foundation (Weeks 1-3)",
-          "description": "Increased parallelism in foundation phase",
-          "parallel_groups": [
-            {
-              "group": "security_foundation",
-              "agents": [2, 3, 4],
-              "dependencies": [],
-              "description": "Security agents run in full parallel",
-              "estimated_duration": "2 weeks"
-            },
-            {
-              "group": "core_architecture",
-              "agents": [5],
-              "dependencies": [],
-              "description": "Core architect starts immediately with security",
-              "estimated_duration": "1 week"
-            },
-            {
-              "group": "testing_foundation",
-              "agents": [13],
-              "dependencies": [],
-              "description": "TDD engineer starts early for framework setup",
-              "estimated_duration": "1 week"
-            },
-            {
-              "group": "performance_setup",
-              "agents": [14],
-              "dependencies": [],
-              "description": "Performance engineer starts benchmark setup",
-              "estimated_duration": "1 week"
-            }
-          ]
-        },
-
-        "phase2_enhanced": {
-          "name": "Enhanced Core Systems (Weeks 2-6)",
-          "description": "Overlapped execution with phase 1",
-          "parallel_groups": [
-            {
-              "group": "core_implementation",
-              "agents": [6, 7, 8],
-              "dependencies": [5],
-              "description": "Core implementation agents start after architect",
-              "estimated_duration": "3 weeks"
-            },
-            {
-              "group": "mcp_optimization",
-              "agents": [9],
-              "dependencies": [5],
-              "description": "MCP specialist works in parallel with core",
-              "estimated_duration": "2 weeks"
-            },
-            {
-              "group": "queen_coordination",
-              "agents": [1],
-              "dependencies": [2, 5],
-              "description": "Queen starts once security baseline + architecture ready",
-              "estimated_duration": "4 weeks"
-            }
-          ]
-        },
-
-        "phase3_enhanced": {
-          "name": "Enhanced Integration (Weeks 5-9)",
-          "description": "Reduced blocking dependencies for integration agents",
-          "parallel_groups": [
-            {
-              "group": "integration_core",
-              "agents": [10],
-              "dependencies": [5, 7],
-              "description": "Integration architect needs only core arch + memory",
-              "estimated_duration": "3 weeks"
-            },
-            {
-              "group": "cli_modernization",
-              "agents": [11],
-              "dependencies": [5],
-              "description": "CLI developer needs only core architecture (reduced from [5,10])",
-              "estimated_duration": "2 weeks"
-            },
-            {
-              "group": "neural_learning",
-              "agents": [12],
-              "dependencies": [5],
-              "description": "Neural developer needs only core architecture (reduced from [7,10])",
-              "estimated_duration": "2 weeks"
-            }
-          ]
-        },
-
-        "phase4_enhanced": {
-          "name": "Enhanced Polish & Release (Weeks 9-16)",
-          "description": "Final optimization with all agents active",
-          "parallel_groups": [
-            {
-              "group": "release_preparation",
-              "agents": [15],
-              "dependencies": [13, 14],
-              "description": "Release engineer waits for testing + performance validation",
-              "estimated_duration": "2 weeks"
-            },
-            {
-              "group": "final_optimization",
-              "agents": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
-              "dependencies": [],
-              "description": "All agents perform final optimization in parallel",
-              "estimated_duration": "1 week"
-            }
-          ]
-        }
-      }
-    },
-
-    "reducedBlockingDependencies": {
-      "description": "Specific dependency reductions to enable better parallelism",
-      "changes": [
-        {
-          "agent": "cli-hooks-developer (11)",
-          "original_dependencies": [5, 10],
-          "optimized_dependencies": [5],
-          "rationale": "CLI can be modernized with just core architecture, integration can happen later",
-          "parallel_gain": "Can start 2 weeks earlier"
-        },
-        {
-          "agent": "neural-learning-developer (12)",
-          "original_dependencies": [7, 10],
-          "optimized_dependencies": [5],
-          "rationale": "Neural learning can start with core architecture, memory/integration can be added incrementally",
-          "parallel_gain": "Can start 3 weeks earlier"
-        },
-        {
-          "agent": "queen-coordinator (1)",
-          "original_dependencies": [],
-          "optimized_dependencies": [2, 5],
-          "rationale": "Queen should wait for security baseline and core architecture before orchestrating",
-          "coordination_benefit": "More intelligent coordination with foundation in place"
-        }
-      ]
-    },
-
-    "phaseBoundaryOptimization": {
-      "description": "Flexible phase boundaries to maximize parallel efficiency",
-      "strategy": "overlapping_phases",
-      "rules": {
-        "phase_overlap": "50%",
-        "description": "Phases can overlap by 50% once foundation requirements are met",
-        "example": "Phase 2 core systems can start in week 2 while Phase 1 security continues"
-      },
-
-      "flexibility_rules": [
-        {
-          "condition": "Agent dependencies satisfied",
-          "action": "Allow early phase advancement",
-          "benefit": "Maximize parallel agent utilization"
-        },
-        {
-          "condition": "Critical path agents complete",
-          "action": "Start next phase critical agents early",
-          "benefit": "Reduce overall timeline"
-        },
-        {
-          "condition": "Blocking issues detected",
-          "action": "Reassign free agents to unblocked work",
-          "benefit": "Maintain productivity during blocks"
-        }
-      ]
-    },
-
-    "parallelEfficiencyTargets": {
-      "phase1": {
-        "agent_utilization": "85%",
-        "parallel_agents": "4-6 concurrent",
-        "timeline_efficiency": "20% improvement"
-      },
-      "phase2": {
-        "agent_utilization": "90%",
-        "parallel_agents": "6-8 concurrent",
-        "timeline_efficiency": "25% improvement"
-      },
-      "phase3": {
-        "agent_utilization": "95%",
-        "parallel_agents": "8-12 concurrent",
-        "timeline_efficiency": "30% improvement"
-      },
-      "phase4": {
-        "agent_utilization": "100%",
-        "parallel_agents": "15 concurrent",
-        "timeline_efficiency": "Maximum parallel execution"
-      }
-    },
-
-    "riskMitigation": {
-      "description": "Risk management for optimized dependency chain",
-      "strategies": [
-        {
-          "risk": "Early agent starts without sufficient foundation",
-          "mitigation": "Minimum viable dependencies enforced",
-          "monitoring": "Regular dependency satisfaction checks"
-        },
-        {
-          "risk": "Coordination overhead with more parallel agents",
-          "mitigation": "Queen coordinator with enhanced GitHub integration",
-          "monitoring": "Agent coordination latency tracking"
-        },
-        {
-          "risk": "Integration complexity with reduced dependencies",
-          "mitigation": "Incremental integration approach",
-          "monitoring": "Integration test coverage requirements"
-        }
-      ]
-    },
-
-    "implementation": {
-      "tooling": {
-        "dependency_tracker": "GitHub project boards with agent assignments",
-        "parallel_monitor": "Real-time agent utilization dashboard",
-        "coordination": "Queen coordinator with MCP orchestration tools"
-      },
-
-      "coordination_patterns": {
-        "daily_standups": "Agent status and dependency updates",
-        "blocker_resolution": "Immediate reassignment protocols",
-        "phase_transitions": "Gradual transition with readiness checks"
-      }
-    },
-
-    "success_metrics": {
-      "efficiency": {
-        "target": "90% average agent utilization",
-        "measurement": "Time agents spend on productive work vs waiting"
-      },
-      "timeline": {
-        "target": "16 weeks total (vs 20 weeks with original dependencies)",
-        "measurement": "Overall project completion time"
-      },
-      "coordination": {
-        "target": "<4 hours average blocker resolution time",
-        "measurement": "Time from blocker identification to resolution"
-      },
-      "quality": {
-        "target": "No degradation in output quality due to rushed dependencies",
-        "measurement": "Test coverage and review completion rates"
-      }
-    }
-  }
-}