monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/.claude/commands/pair/session.md

@@ -1,124 +0,0 @@
----
-name: pair:session
-description: Pair programming session lifecycle — pre-session setup, context setting, mid-session quality checks, breakpoints, end-of-session recording, and multi-session continuity
----
-
-# Pair Programming Session Lifecycle
-
-How to structure a productive pair programming session from start to finish.
-
-## 1. Before You Start
-
-Get routing and context from the hooks system:
-
-```bash
-# Register the task and get agent/model recommendations
-npx monomind hooks pre-task -d "Pair programming: implement [feature]"
-```
-
-Load relevant context from memory:
-
-```bash
-npx monomind memory search --query "[feature domain]" --type hybrid
-```
-
-## 2. Set Session Context
-
-Tell Claude everything it needs to know upfront:
-
-```
-Context for this session:
-- Goal: [what we're building]
-- Mode: [driver/navigator/TDD/review]
-- Stack: [language, framework, key libraries]
-- Constraints: [any architectural decisions already made]
-- Focus: [what matters most — correctness / speed / learning]
-```
-
-The more context upfront, the less correction mid-session.
-
-## 3. During the Session
-
-**Keeping the session focused:**
-- One concern at a time — don't mix "implement auth" with "also fix the bug in payments"
-- Check in at logical breakpoints: "Before we continue, does this approach make sense?"
-- If you get stuck: "I'm not sure how to handle [edge case]. What are our options?"
-
-**Real-time quality checks:**
-```bash
-# Watch system status during long sessions
-npx monomind status --watch
-
-# Check test state
-# (run your test suite normally)
-```
-
-**Capture decisions as you go:**
-```bash
-# Store important patterns discovered during session
-npx monomind memory store --key "session-[date]-[feature]" \
-  --value "[what we decided and why]" \
-  --namespace "decisions"
-```
-
-## 4. Breakpoints and Handoffs
-
-Use natural stopping points:
-- After implementing a complete unit (function, class, endpoint)
-- Before switching between subsystems
-- When you need to run tests and wait
-
-At each breakpoint:
-> "Summarize what we've done so far and what comes next."
-
-This keeps both you and Claude aligned on state.
-
-## 5. End of Session
-
-Record outcomes for future sessions:
-
-```bash
-# Record task completion
-npx monomind hooks post-task --task-id <id> --success true --quality 0.9
-
-# Store any patterns worth remembering
-npx monomind memory store \
-  --key "pattern-[name]" \
-  --value "[the pattern we found/confirmed]" \
-  --namespace "patterns"
-```
-
-Get a session summary:
-> "Summarize: what did we build, what decisions did we make, and what's left to do?"
-
-## Session Anti-Patterns
-
-| Anti-pattern | Instead |
-|---|---|
-| Asking 5 things at once | One question at a time |
-| No upfront context | Always set context first |
-| Never verifying Claude's code | Test frequently, review before committing |
-| Letting the session drift | Define the goal, return to it |
-| Skipping the summary | Always end with a recap |
-
-## Multi-Session Continuity
-
-Use the hooks session system to restore context across conversations:
-
-```bash
-# At session end — persist state
-npx monomind hooks session-end
-
-# Next session — restore
-npx monomind hooks session-restore
-```
-
-Or just tell Claude at the start of the next session:
-> "We were implementing JWT auth. We finished the token generation but still need the refresh token endpoint. Continue from there."
-
-## See Also
-
-- [modes.md](./modes.md) — pick the right collaboration mode
-- [examples.md](./examples.md) — real workflow examples
-- `hooks pre-task` / `hooks post-task` — task tracking
-- `memory store` / `memory search` — persist session knowledge

package/packages/@monomind/cli/.claude/commands/stream-chain/pipeline.md

@@ -1,116 +0,0 @@
----
-name: stream-chain:pipeline
-description: Execute predefined stream-chain pipelines for common development workflows — analysis, refactor, test, optimize. Each step feeds full context into the next.
----
-
-# Stream-Chain Pipeline Mode
-
-Execute predefined multi-step workflows where each step's output flows into the next as context.
-
-## How to Invoke
-
-In Claude Code, activate pipeline mode:
-```
-Skill("stream-chain:pipeline")
-```
-
-Then tell Claude which pipeline to run and on what target:
-> "Run the analysis pipeline on the `src/auth/` directory."
-> "Run the refactor pipeline on `UserService.ts`."
-
----
-
-## Available Pipelines
-
-### analysis
-
-Comprehensive codebase analysis and improvement identification.
-
-**Steps:**
-1. Map directory structure and identify main components
-2. Identify potential improvements and issues
-3. Generate actionable improvement report with priorities
-
-**When to use:** New codebase onboarding, technical debt assessment, architecture review, code quality audits.
-
----
-
-### refactor
-
-Systematic code refactoring with prioritization.
-
-**Steps:**
-1. Find code that would benefit from refactoring
-2. Create prioritized refactoring plan with specific changes
-3. Provide refactored code for top 3 priorities
-
-**When to use:** Technical debt reduction, code quality improvement, design pattern implementation.
-
----
-
-### test
-
-Comprehensive test generation with coverage analysis.
-
-**Steps:**
-1. Identify areas lacking test coverage
-2. Design test cases for critical functions
-3. Generate unit test implementations with assertions
-
-**When to use:** Increasing test coverage, TDD workflow support, regression test creation.
-
----
-
-### optimize
-
-Performance optimization with profiling and implementation.
-
-**Steps:**
-1. Profile codebase and identify performance bottlenecks
-2. Analyze bottlenecks and suggest optimization strategies
-3. Provide optimized implementations for main issues
-
-**When to use:** Performance improvement, resource optimization, latency reduction.
-
----
-
-## Running Pipelines
-
-After invoking the skill, direct Claude conversationally:
-
-> "Run the test pipeline on all files in `src/services/`."
-> "Run the optimization pipeline, focus on database query patterns."
-> "Run the analysis pipeline, then the refactor pipeline on the findings."
-
-## Chaining Pipelines
-
-Run multiple pipelines sequentially for a full QA cycle:
-```
-analysis → refactor → test → optimize
-```
-
-> "Run a full QA chain: analysis, then refactor, then test on the resulting changes."
-
-## Custom Pipelines
-
-For repeatable custom pipelines, define the steps explicitly:
-
-> "Run a custom pipeline on the payment module:
-> 1. Scan for security vulnerabilities
-> 2. Categorize issues by severity
-> 3. Generate fixes with priority
-> 4. Create security test cases"
-
-Or use the `stream-chain:run` mode for ad-hoc custom chains.
-
-## Pipeline Output
-
-Each pipeline step delivers:
-- Step-by-step progress and results
-- Success/failure status per step
-- Consolidated summary of findings
-- Actionable recommendations
-
-## See Also
-- `stream-chain:run` — custom prompt chains with full control
-- `stream-chain` — full stream-chain skill with advanced patterns

package/packages/@monomind/cli/.claude/commands/stream-chain/run.md

@@ -1,156 +0,0 @@
----
-name: stream-chain:run
-description: Execute custom stream chains where you define the prompt sequence. Each step receives the full output of the previous step as context.
----
-
-# Stream-Chain Run Mode
-
-Execute custom multi-step workflows with your own prompt sequence. Each step's full output becomes context for the next.
-
-## How to Invoke
-
-In Claude Code, activate run mode:
-```
-Skill("stream-chain:run")
-```
-
-Then provide your chain directly:
-> "Run a stream chain:
-> 1. Write a sorting function
-> 2. Add tests for it
-> 3. Optimize it for performance"
-
----
-
-## How Context Flows
-
-Each step receives the complete output of all previous steps:
-
-```
-Step 1: "Write a sorting function"
-Output: [function code]
-
-Step 2 receives:
-  Previous output: [function code]
-  Task: "Add comprehensive tests"
-
-Step 3 receives:
-  Previous output: [function + tests]
-  Task: "Optimize for performance"
-```
-
----
-
-## Examples
-
-### Basic Development Chain
-
-> "Stream chain:
-> 1. Write a user authentication function
-> 2. Add input validation and error handling
-> 3. Create unit tests with edge cases"
-
-### Security Audit Workflow
-
-> "Stream chain for the `src/auth/` module:
-> 1. Analyze for security vulnerabilities
-> 2. Categorize issues by severity (critical/high/medium/low)
-> 3. Propose fixes with implementation priority
-> 4. Generate security test cases"
-
-### Code Refactoring Chain
-
-> "Stream chain:
-> 1. Identify code smells in `src/` directory
-> 2. Create refactoring plan with specific changes
-> 3. Apply refactoring to top 3 priority items
-> 4. Verify refactored code maintains original behavior"
-
-### Data Processing Pipeline
-
-> "Stream chain:
-> 1. Extract data from API responses in `handlers/`
-> 2. Transform data into normalized format
-> 3. Validate data against schema
-> 4. Generate data quality report"
-
-### Code Migration Workflow
-
-> "Stream chain for migrating Vue 2 to Vue 3:
-> 1. Analyze codebase dependencies and breaking changes
-> 2. Create migration plan with risk assessment
-> 3. Generate modernized code for high-priority components
-> 4. Create migration tests
-> 5. Document migration steps and rollback procedures"
-
----
-
-## Best Practices
-
-### 1. Clear, Specific Prompts
-
-Good:
-> "Analyze `auth.ts` for SQL injection vulnerabilities"
-
-Avoid:
-> "Check security"
-
-### 2. Logical Progression
-
-Build on previous outputs:
-1. Identify the problem
-2. Analyze root causes
-3. Design solution
-4. Implement solution
-5. Verify implementation
-
-### 3. Include Verification Steps
-
-> "Stream chain:
-> 1. Implement feature X
-> 2. Write tests for feature X
-> 3. Verify tests pass and cover edge cases"
-
-### 4. Iterative Refinement
-
-> "Stream chain:
-> 1. Generate initial implementation
-> 2. Review and identify issues
-> 3. Refine based on issues found
-> 4. Final quality check"
-
----
-
-## Multi-Agent Integration
-
-For complex chains, combine with swarm coordination:
-
-```javascript
-// Initialize swarm first
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 4, strategy: "specialized" })
-```
-
-Then direct the stream chain:
-> "With our 4-agent swarm, run a stream chain:
-> 1. Research: best practices for API design
-> 2. Design: REST API with discovered patterns
-> 3. Implement: API endpoints with validation
-> 4. Review: final quality check and documentation"
-
-## Memory Integration
-
-Use memory tools to persist chain results for future sessions:
-
-```javascript
-mcp__monomind__memory_store({
-  key: "stream-chain-result",
-  value: "summary of findings",
-  namespace: "stream-chain"
-})
-```
-
----
-
-## See Also
-- `stream-chain:pipeline` — predefined pipelines for common workflows
-- `stream-chain` — full stream-chain skill with advanced patterns

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

@@ -1,40 +0,0 @@
----
-name: swarm-README
-description: Swarm skill index — lists all available swarm coordination skills and strategies for multi-agent task execution
----
-
-# Swarm Skills
-
-Multi-agent swarm coordination for Monomind.
-
-## Core Skills
-
-- [swarm](./swarm.md) — Main swarm skill: how to start and coordinate swarms
-
-## Strategy Skills
-
-- [analysis](./analysis.md) — Distributed analysis via coordinated agents
-- [development](./development.md) — Coordinated development teams
-- [research](./research.md) — Parallel information gathering
-- [testing](./testing.md) — Distributed test execution
-- [maintenance](./maintenance.md) — System maintenance coordination
-- [optimization](./optimization.md) — Performance optimization swarms
-- [examples](./examples.md) — Common swarm patterns and recipes
-
-## Reference Skills
-
-- [swarm-status](./swarm-status.md) — Check swarm health and agent progress
-- [swarm-monitor](./swarm-monitor.md) — Monitor running swarms
-- [swarm-modes](./swarm-modes.md) — Topology modes: hierarchical, mesh, star
-- [swarm-strategies](./swarm-strategies.md) — Strategy selection guide
-- [swarm-background](./swarm-background.md) — Running swarms in the background
-- [swarm-analysis](./swarm-analysis.md) — Swarm performance analysis
-
-## Quick Start
-
-```bash
-# Initialize and start a swarm via CLI
-npx monomind swarm init --topology hierarchical --max-agents 8
-npx monomind swarm start "Build REST API" --strategy development
-npx monomind swarm status
-```

package/packages/@monomind/cli/.claude/commands/swarm/analysis.md

@@ -1,73 +0,0 @@
----
-name: swarm-analysis
-description: Analysis swarm strategy — distributed codebase, performance, and security analysis through coordinated mesh agents
----
-
-# Analysis Swarm Strategy
-
-Comprehensive analysis through distributed agent coordination.
-
-## How to Invoke
-
-```
-Skill("swarm:analysis")
-```
-
-Then describe what to analyze:
-> "Run an analysis swarm on the src/ directory."
-> "Analyze API performance bottlenecks across all services."
-
----
-
-## Swarm Setup
-
-```javascript
-// Initialize analysis swarm
-mcp__monomind__swarm_init({
-  topology: "mesh",
-  maxAgents: 6,
-  strategy: "adaptive"
-})
-
-// Coordinate analysis
-mcp__monomind__coordination_orchestrate({
-  task: "analyze system performance",
-  strategy: "parallel"
-})
-```
-
-```bash
-# CLI equivalent
-npx monomind swarm init --topology mesh --max-agents 6
-npx monomind swarm start "analyze system performance" --strategy analysis --parallel
-```
-
-## Agent Roles
-
-```javascript
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["metrics", "logging", "monitoring"] })
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["pattern-recognition", "anomaly-detection"] })
-mcp__monomind__agent_spawn({ type: "documenter", capabilities: ["reporting", "visualization"] })
-mcp__monomind__agent_spawn({ type: "coordinator", capabilities: ["synthesis", "correlation"] })
-```
-
-## Coordination Modes
-
-| Mode | When to use |
-|------|-------------|
-| Mesh | Exploratory analysis — agents search in parallel |
-| Hierarchical | Complex systems — coordinator aggregates sub-agent findings |
-| Star | Sequential pipeline — each step depends on previous |
-
-## Monitoring
-
-```javascript
-// Check analysis progress
-mcp__monomind__swarm_status({ swarmId: "current" })
-
-// Performance metrics
-mcp__monomind__performance_report({ format: "detailed" })
-
-// System health
-mcp__monomind__system_health({})
-```

package/packages/@monomind/cli/.claude/commands/swarm/development.md

@@ -1,72 +0,0 @@
----
-name: swarm-development
-description: Development swarm strategy — hierarchical team coordination for building features with architect → coder → tester flow
----
-
-# Development Swarm Strategy
-
-Coordinated development through specialized agent teams.
-
-## How to Invoke
-
-```
-Skill("swarm:development")
-```
-
-Then describe the feature to build:
-> "Start a development swarm to build OAuth2 authentication."
-> "Coordinate agents to implement the payment processing module."
-
----
-
-## Swarm Setup
-
-```javascript
-// Initialize development swarm
-mcp__monomind__swarm_init({
-  topology: "hierarchical",
-  maxAgents: 8,
-  strategy: "specialized"
-})
-
-// Coordinate development
-mcp__monomind__coordination_orchestrate({
-  task: "build feature X",
-  strategy: "parallel"
-})
-```
-
-```bash
-# CLI equivalent
-npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
-npx monomind swarm start "build feature X" --strategy development --parallel
-```
-
-## Agent Roles
-
-```javascript
-mcp__monomind__agent_spawn({ type: "architect", capabilities: ["system-design", "api-design"] })
-mcp__monomind__agent_spawn({ type: "coder", capabilities: ["react", "typescript", "ui"] })
-mcp__monomind__agent_spawn({ type: "coder", capabilities: ["nodejs", "api", "database"] })
-mcp__monomind__agent_spawn({ type: "tester", capabilities: ["integration", "e2e", "api-testing"] })
-```
-
-## Best Practices
-
-- Use hierarchical topology for large features (architect leads, coders implement, tester validates)
-- Enable parallel execution for independent modules
-- Run tester agent concurrently on completed units rather than waiting for all code
-
-## Monitoring
-
-```javascript
-// Check swarm status
-mcp__monomind__swarm_status({ swarmId: "current" })
-
-// System health
-mcp__monomind__system_health({})
-```
-
-```bash
-npx monomind swarm status
-```

package/packages/@monomind/cli/.claude/commands/swarm/examples.md

@@ -1,103 +0,0 @@
----
-name: swarm-examples
-description: Swarm pattern examples — concrete recipes for research, development, analysis, and testing swarms with real MCP tool invocations
----
-
-# Common Swarm Patterns
-
-Ready-to-use recipes for the most common swarm scenarios.
-
-## Research Swarm
-
-```javascript
-// 1. Initialize
-mcp__monomind__swarm_init({ topology: "mesh", maxAgents: 6, strategy: "adaptive" })
-
-// 2. Spawn agents
-mcp__monomind__agent_spawn({ type: "researcher", capabilities: ["web-search", "analysis", "synthesis"] })
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["data-processing", "reporting"] })
-
-// 3. Coordinate
-mcp__monomind__coordination_orchestrate({ task: "research AI trends", strategy: "parallel" })
-
-// 4. Monitor
-mcp__monomind__swarm_status({ swarmId: "current" })
-```
-
-```bash
-npx monomind swarm init --topology mesh --max-agents 6 --strategy research
-npx monomind swarm start "research AI trends" --strategy research --parallel
-```
-
----
-
-## Development Swarm
-
-```javascript
-// 1. Initialize
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
-
-// 2. Spawn team
-mcp__monomind__agent_spawn({ type: "architect", capabilities: ["system-design", "api-design"] })
-mcp__monomind__agent_spawn({ type: "coder", capabilities: ["typescript", "api", "backend"] })
-mcp__monomind__agent_spawn({ type: "tester", capabilities: ["integration", "e2e"] })
-mcp__monomind__agent_spawn({ type: "documenter", capabilities: ["api-docs", "readme"] })
-
-// 3. Coordinate
-mcp__monomind__coordination_orchestrate({ task: "build REST API", strategy: "sequential" })
-
-// 4. Monitor
-mcp__monomind__swarm_status({ swarmId: "current" })
-```
-
-```bash
-npx monomind swarm start "build REST API" --strategy development --mode hierarchical
-```
-
----
-
-## Analysis Swarm
-
-```javascript
-// 1. Initialize
-mcp__monomind__swarm_init({ topology: "mesh", maxAgents: 5, strategy: "adaptive" })
-
-// 2. Spawn agents
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["static-analysis", "complexity-analysis"] })
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["security-scan", "vulnerability-detection"] })
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["performance-analysis", "bottleneck-detection"] })
-
-// 3. Coordinate
-mcp__monomind__coordination_orchestrate({ task: "analyze codebase", strategy: "parallel" })
-
-// 4. Report
-mcp__monomind__performance_report({ format: "detailed" })
-```
-
-```bash
-npx monomind swarm start "analyze codebase" --strategy analysis --mode mesh --parallel
-```
-
----
-
-## Error Recovery
-
-When a swarm gets into a bad state:
-
-```javascript
-// Check status first
-mcp__monomind__swarm_status({ swarmId: "current" })
-
-// System health check
-mcp__monomind__system_health({})
-
-// Shut down and restart
-mcp__monomind__swarm_shutdown({ swarmId: "current" })
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 6, strategy: "specialized" })
-```
-
-## See Also
-
-- `swarm:swarm` — Main skill with strategy selection guide
-- `swarm:swarm-modes` — Topology reference
-- `swarm:swarm-strategies` — When to use each strategy