monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/commands/optimization/auto-topology.md

@@ -0,0 +1,85 @@
+---
+name: optimization:auto-topology
+description: Automatically select the optimal swarm topology based on task complexity — use pre-task hook recommendations, swarm init flags, and performance optimize CLI
+---
+
+# Auto Topology Selection
+
+Automatically select the optimal swarm topology based on task complexity so you don't have to configure it manually.
+
+## How It Works
+
+### 1. Get a Routing Recommendation
+
+Before spawning agents, run the `pre-task` hook. It analyzes task complexity and recommends a topology:
+
+```bash
+npx monomind hooks pre-task -d "Refactor authentication system with JWT, add tests, update docs"
+```
+
+Output includes `[TASK_MODEL_RECOMMENDATION] Use model="sonnet"` and agent/topology suggestions.
+
+### 2. Initialize the Swarm With the Recommended Topology
+
+```bash
+# Simple/medium tasks — hierarchical (anti-drift, tight control)
+npx monomind swarm init --topology hierarchical --max-agents 6 --strategy specialized
+
+# Complex multi-domain tasks — hierarchical-mesh (peer communication + queen)
+npx monomind swarm init --topology hierarchical-mesh --max-agents 12 --strategy specialized
+```
+
+### Topology Selection Guide
+
+| Complexity | Agents Needed | Recommended Topology |
+|---|---|---|
+| Simple (single file) | 1–2 | `star` — skip swarm, use Edit tool directly |
+| Medium | 3–5 | `hierarchical` |
+| Complex (multi-module) | 6–8 | `hierarchical` |
+| Large (10+ agents) | 10–15 | `hierarchical-mesh` |
+| Sequential pipeline | any | `ring` |
+
+## Optimize Existing Swarm Topology
+
+If a swarm is already running, optimize its topology via the coordination MCP tool:
+
+```javascript
+mcp__monomind__coordination_topology({
+  swarmId: "current",
+  optimize: true
+})
+```
+
+Or via the performance CLI:
+
+```bash
+# Analyze and recommend optimizations (dry run)
+npx monomind performance optimize --target all --dry-run
+
+# Apply recommended optimizations
+npx monomind performance optimize --target all --apply
+```
+
+## Hook Integration
+
+`pre-task` fires automatically if wired in `settings.json`:
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [{
+      "matcher": "^Task$",
+      "hooks": [{
+        "type": "command",
+        "command": "npx monomind hooks pre-task -d '${tool.params.description}'"
+      }]
+    }]
+  }
+}
+```
+
+## See Also
+
+- `swarm init` — initialize swarm with explicit topology
+- `performance optimize` — system-level performance tuning
+- `hooks pre-task` — get routing and topology recommendations

package/packages/@monomind/cli/.claude/commands/optimization/performance-optimize.md

@@ -0,0 +1,79 @@
+---
+name: optimization:performance-optimize
+description: Analyze and apply system-level performance optimizations — memory, CPU, and latency using npx monomind performance optimize
+---
+
+# performance optimize
+
+Analyze and apply system-level performance optimizations — memory, CPU, and latency.
+
+## Usage
+
+```bash
+npx monomind performance optimize [options]
+```
+
+## Options
+
+| Flag | Short | Type | Default | Description |
+|---|---|---|---|---|
+| `--target` | `-t` | string | `all` | Optimization target: `memory`, `cpu`, `latency`, `all` |
+| `--apply` | `-a` | boolean | `false` | Apply recommended optimizations |
+| `--dry-run` | `-d` | boolean | `false` | Show recommended changes without applying |
+
+## Examples
+
+```bash
+# Analyze and show recommendations (no changes)
+npx monomind performance optimize --dry-run
+
+# Optimize everything and apply
+npx monomind performance optimize --target all --apply
+
+# Memory-specific optimization
+npx monomind performance optimize --target memory --apply
+
+# CPU optimization only
+npx monomind performance optimize --target cpu --apply
+
+# Latency optimization (MCP response time)
+npx monomind performance optimize --target latency --apply
+```
+
+## Optimization Targets
+
+| Target | What It Optimizes |
+|---|---|
+| `memory` | Memory backend compression, HNSW rebuild, cache eviction |
+| `cpu` | Agent pool sizing, task batching, concurrency limits |
+| `latency` | MCP response caching, neural model quantization |
+| `all` | All of the above |
+
+## Related Commands
+
+```bash
+# Find bottlenecks before optimizing
+npx monomind performance bottleneck
+
+# Run benchmarks to measure before/after
+npx monomind performance benchmark --suite all
+
+# View current performance metrics
+npx monomind performance metrics
+```
+
+## MCP Tool
+
+```javascript
+mcp__monomind__performance_optimize({
+  target: "all",
+  apply: false
+})
+```
+
+## See Also
+
+- `performance bottleneck` — diagnose what to optimize first
+- `performance benchmark` — measure optimization impact
+- `performance metrics` — track performance over time
+- `neural optimize` — optimize neural model weights

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

@@ -0,0 +1,79 @@
+---
+name: pair:README
+description: Pair programming with Claude Code — driver/navigator modes, TDD sessions, review sessions, Task tool agent spawning, and hooks integration
+---
+
+# Pair Programming with Claude Code
+
+Collaborative development using Claude Code as your AI pair partner. No special CLI needed — Claude Code IS the pair partner.
+
+## How It Works
+
+Pair programming with Claude Code means structuring your conversation to get the most out of the collaboration. Depending on your goal, you drive or Claude drives.
+
+## Quick Start
+
+**You drive, Claude reviews (driver mode):**
+> "I'm going to implement JWT auth. Review my approach and flag issues as we go."
+
+**Claude drives, you guide (navigator mode):**
+> "Implement a JWT auth middleware for Express with refresh token support. I'll review each piece."
+
+**TDD session:**
+> "Let's do TDD for this shopping cart feature. Write the failing tests first, then we'll implement."
+
+**Review session:**
+> "Review all the changes I've made today to `src/auth/`. Focus on security issues."
+
+## Using the Pair Programming Skill
+
+Invoke the `pair-programming` skill for structured collaboration:
+
+```
+/pair-programming
+```
+
+This loads the workflow guide and sets up the session context.
+
+## Spawning a Specialized Agent
+
+For long-running or complex sessions, spawn a dedicated coding agent via the Task tool:
+
+```javascript
+Task({
+  prompt: "Act as a senior developer pair programming partner. The user is implementing JWT auth. Review their code as they write it, suggest improvements, catch issues, and explain patterns. Start by asking what they want to build.",
+  subagent_type: "Senior Developer",
+  run_in_background: false
+})
+```
+
+Or use a specific specialist:
+- `superpowers:test-driven-development` — TDD-focused pairing
+- `superpowers:systematic-debugging` — debugging sessions
+- `superpowers:receiving-code-review` — code review sessions
+
+## Hooks Integration
+
+Use hooks to track pair session quality:
+
+```bash
+# Register session start
+npx monomind hooks pre-task -d "Pair programming: implement JWT auth"
+
+# After session, record outcome
+npx monomind hooks post-task --task-id <id> --success true --quality 0.95
+```
+
+## Files
+
+- [modes.md](./modes.md) — Driver, navigator, TDD, review, debug modes
+- [session.md](./session.md) — Session lifecycle and real monitoring commands
+- [examples.md](./examples.md) — Real-world pair programming scenarios
+
+## See Also
+
+- `superpowers:pair-programming` — structured pair programming skill
+- `superpowers:test-driven-development` — TDD workflow
+- `superpowers:systematic-debugging` — debugging workflow
+- `superpowers:requesting-code-review` — code review workflow
+- `hooks pre-task` — register task start and get recommendations

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

@@ -0,0 +1,156 @@
+---
+name: pair:examples
+description: Real-world pair programming scenarios — JWT auth, memory leak debugging, TDD, code review, and refactoring with effective prompt patterns
+---
+
+# Pair Programming Examples
+
+Real-world scenarios with actual Claude Code patterns — no fictional CLI.
+
+---
+
+## Example 1: Feature Implementation (Navigator Mode)
+
+**Goal:** Implement JWT authentication with refresh tokens.
+
+**Setup:**
+```bash
+npx monomind hooks pre-task -d "Implement JWT auth with refresh tokens"
+```
+
+**Session:**
+
+> "Implement JWT auth middleware for Express. Include: access token (15min expiry), refresh token (7 days), token rotation on refresh, and blacklisting revoked tokens. Start with the token generation utilities, then we'll do the middleware."
+
+Claude implements. Review each piece:
+
+> "Good. One issue: store refresh tokens in Redis, not in-memory. Update that before continuing."
+
+After middleware is done:
+
+> "Now write unit tests for the token generation utilities. Use Jest. Cover: valid tokens, expired tokens, tampered tokens, and token rotation."
+
+End:
+> "Summarize what we built and what's still needed before this is production-ready."
+
+```bash
+npx monomind hooks post-task --task-id <id> --success true --quality 0.9
+```
+
+---
+
+## Example 2: Debugging (Debug Mode)
+
+**Goal:** Memory leak in a Node.js service.
+
+**Setup:**
+```
+Skill("superpowers:systematic-debugging")
+```
+
+Or directly:
+
+> "Debug session: our Node.js service leaks memory — grows from 150MB to 450MB over 10 minutes, then crashes. I'll share code as needed. Start by asking me questions to narrow down the cause."
+
+Claude asks targeted questions. You share relevant code sections.
+
+> "Here's the event emitter setup: [paste code]"
+
+> "Found it: EventEmitter listeners aren't removed on cleanup. Show me the fix and explain why this pattern causes the leak."
+
+Apply the fix, verify:
+
+> "Fixed. Write a test that would have caught this — one that monitors memory over time or checks listener counts."
+
+---
+
+## Example 3: TDD (TDD Mode)
+
+**Goal:** Shopping cart feature, test-first.
+
+**Setup:**
+```
+Skill("superpowers:test-driven-development")
+```
+
+Or:
+
+> "TDD session: shopping cart. Write failing tests first for: add item, remove item, update quantity, calculate total, apply discount. Then I'll implement each. Don't write implementation code — just tests."
+
+**Red phase:** Claude writes failing tests. You read and understand each.
+
+**Green phase:** You implement just enough to pass.
+
+> "Tests passing. Now refactor the total calculation — it's too long."
+
+Claude refactors. You verify tests still pass.
+
+> "Next cycle: write failing tests for the discount system."
+
+---
+
+## Example 4: Code Review (Review Mode)
+
+**Goal:** Review a PR diff before merging.
+
+**Setup:**
+```bash
+git diff main...feat/auth > /tmp/auth-diff.txt
+```
+
+> "Review this PR. File: `src/auth/middleware.ts`. Rate: (1) correctness, (2) security vulnerabilities, (3) error handling, (4) test coverage. List issues as: [CRITICAL] / [MAJOR] / [MINOR] with file+line."
+
+Review output guides your fixes. For each CRITICAL issue:
+
+> "Fix #2 (JWT secret in code). Show me the corrected version."
+
+After applying fixes:
+
+> "Any remaining issues worth fixing before merge?"
+
+---
+
+## Example 5: Refactoring (Driver Mode)
+
+**Goal:** Modernize callback-heavy code to async/await.
+
+> "Driver mode: I'm refactoring `UserService.js` from callbacks to async/await. Watch what I change and flag if I miss anything or introduce bugs. I'll share the original first."
+
+Paste the original code.
+
+> "Here's the original getUserById. I'm changing it to async/await now."
+
+Paste your refactored version.
+
+Claude reviews: "Looks good, but you're missing error handling on the database call. Add a try/catch."
+
+Continue through each function.
+
+At end:
+
+> "Final check: any patterns in the refactored code that should be extracted into utilities?"
+
+---
+
+## Effective Prompts Reference
+
+| Situation | Prompt |
+|---|---|
+| Start navigator mode | "Implement [X]. I'll review each section before you continue." |
+| Start driver mode | "I'm implementing [X]. Review as I share code and flag issues." |
+| Start TDD | "Write failing tests for [X] first. I'll implement after." |
+| Start review | "Review [file/diff]. Focus on [concern]. Rate and list issues." |
+| Start debug | "Debug [symptom]. Ask me questions to narrow down the cause." |
+| Switch mode | "Now you drive — implement [next piece] based on what we've discussed." |
+| Mid-session check | "Before we continue: summarize state and confirm the next step." |
+| End session | "Summarize: what we built, decisions made, what's left." |
+| Get unstuck | "I'm not sure how to handle [edge case]. What are the options?" |
+| Pattern question | "Is this the right pattern here, or is there a better approach?" |
+
+## See Also
+
+- [modes.md](./modes.md) — choosing the right mode
+- [session.md](./session.md) — session lifecycle and tracking
+- `superpowers:pair-programming` — structured pair programming skill
+- `superpowers:test-driven-development` — full TDD workflow
+- `superpowers:systematic-debugging` — debugging methodology

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

@@ -0,0 +1,122 @@
+---
+name: pair:modes
+description: Pair programming collaboration modes — driver, navigator, TDD, review, and debug modes with effective prompts for each
+---
+
+# Pair Programming Modes
+
+Different collaboration patterns for different goals. Choose based on what you're trying to accomplish.
+
+## Driver Mode — You Write, Claude Reviews
+
+You do the coding. Claude watches, suggests, and catches issues in real time.
+
+**Start it:**
+> "I'm implementing [feature]. Watch what I'm building and review each piece as I share it. Point out issues, security problems, and improvements."
+
+**Best for:**
+- Learning new patterns (you get hands-on + feedback)
+- Implementing features you understand but want reviewed
+- Debugging when you have a hypothesis to test
+
+**Effective prompts during driver mode:**
+- "Here's what I wrote — what do you think?"
+- "I'm about to add validation here. Any pitfalls?"
+- "Is this the right pattern for this situation?"
+- "Review this function before I move on."
+
+---
+
+## Navigator Mode — Claude Writes, You Guide
+
+Claude does the coding. You provide direction, review output, and control architecture decisions.
+
+**Start it:**
+> "Implement [feature]. I'll guide the direction and review each section before you move on. Start with [specific first piece]."
+
+**Best for:**
+- Rapid prototyping
+- Boilerplate and scaffolding
+- Exploring approaches you haven't used before
+- Getting unstuck quickly
+
+**Effective prompts during navigator mode:**
+- "Implement X. Use [pattern/library]."
+- "That's good but change [specific thing]."
+- "Before writing the next piece, explain your approach."
+- "Show me an alternative approach to this."
+
+---
+
+## TDD Mode — Tests First
+
+Write failing tests, then implement just enough to pass, then refactor.
+
+**Start it:**
+> "We're doing TDD for [feature]. Write the failing tests first, explain what each test covers, then I'll implement. We refactor together after tests pass."
+
+**The cycle:**
+1. Claude writes a failing test — you understand it
+2. You implement minimal passing code
+3. Claude reviews the implementation
+4. Together you refactor
+5. Repeat
+
+**Invoke the TDD skill for full workflow:**
+```
+Skill("superpowers:test-driven-development")
+```
+
+---
+
+## Review Mode — Quality Focus
+
+Work through existing code with Claude as reviewer.
+
+**Start it:**
+> "Review the changes in `src/auth/`. Focus on [security / correctness / performance]. Be specific about issues — give file, line, and explanation."
+
+**Structured review request:**
+> "Review this PR diff. Rate it on: (1) correctness, (2) security, (3) readability, (4) test coverage. List issues by severity."
+
+**Invoke the review skill:**
+```
+Skill("superpowers:requesting-code-review")
+```
+
+---
+
+## Debug Mode — Problem Solving
+
+Systematic debugging as a pair.
+
+**Start it:**
+> "We have a bug: [describe symptom]. Let's debug together. Start by asking me questions to narrow down the cause."
+
+**Invoke the debugging skill:**
+```
+Skill("superpowers:systematic-debugging")
+```
+
+---
+
+## Switching Modes
+
+You can switch modes at any point just by redirecting:
+
+> "Let's switch — now you drive. Implement the auth middleware based on what we've discussed."
+
+> "Actually let me write this part. Review as I go."
+
+> "Stop implementing — let's do TDD for the rest of this."
+
+## Mode Selection Guide
+
+| Goal | Mode |
+|---|---|
+| Learning + control | Driver |
+| Speed + generation | Navigator |
+| Quality from the start | TDD |
+| Fix existing code | Review |
+| Fix a bug | Debug |
+| Long complex feature | Switch (start navigator, finish driver) |

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

@@ -0,0 +1,124 @@
+---
+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/sparc/analyzer.md

@@ -0,0 +1,35 @@
+---
+name: sparc:analyzer
+description: Analyzer - Deep code and data analysis with batch processing capabilities. Performs parallel file analysis, pattern recognition, and performance profiling.
+---
+
+# SPARC Analyzer Mode
+
+## Purpose
+Deep code and data analysis with batch processing capabilities.
+
+## How to Invoke
+
+In Claude Code, load this mode as a skill:
+```
+Skill("sparc:analyzer")
+```
+
+## Core Capabilities
+- Code analysis with parallel file processing
+- Data pattern recognition
+- Performance profiling
+- Memory usage analysis
+- Dependency mapping
+
+## Batch Operations
+- Parallel file analysis using concurrent Read operations
+- Batch pattern matching with Grep tool
+- Simultaneous metric collection
+- Aggregated reporting
+
+## Output Format
+- Detailed analysis reports
+- Performance metrics
+- Improvement recommendations
+- Visualizations when applicable