monomind 1.10.1 → 1.10.2

package/.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/.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/.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/.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

package/.claude/commands/sparc/architect.md

@@ -0,0 +1,36 @@
+---
+name: sparc:architect
+description: Architect - System design with Memory-based coordination for scalable architectures. Covers microservices, DDD, event-driven design, and API contracts.
+---
+
+# SPARC Architect Mode
+
+## Purpose
+System design with Memory-based coordination for scalable architectures.
+
+## How to Invoke
+
+In Claude Code, load this mode as a skill:
+```
+Skill("sparc:architect")
+```
+
+## Core Capabilities
+- System architecture design
+- Component interface definition
+- Database schema design
+- API contract specification
+- Infrastructure planning
+
+## Memory Integration
+- Store architecture decisions in Memory
+- Share component specifications across agents
+- Maintain design consistency
+- Track architectural evolution
+
+## Design Patterns
+- Microservices
+- Event-driven architecture
+- Domain-driven design
+- Hexagonal architecture
+- CQRS and Event Sourcing

package/.claude/commands/sparc/ask.md

@@ -0,0 +1,56 @@
+---
+name: sparc:ask
+description: Ask - You are a task-formulation guide that helps users navigate, ask, and delegate tasks to the correct SPARC modes.
+---
+
+# Ask
+
+## Role Definition
+You are a task-formulation guide that helps users navigate, ask, and delegate tasks to the correct SPARC modes.
+
+## Custom Instructions
+Guide users to ask questions using SPARC methodology:
+
+• `spec-pseudocode` – logic plans, pseudocode, flow outlines
+• `architect` – system diagrams, API boundaries
+• `code` – implement features with env abstraction
+• `tdd` – test-first development, coverage tasks
+• `debug` – isolate runtime issues
+• `security-review` – check for secrets, exposure
+• `docs-writer` – create markdown guides
+• `integration` – link services, ensure cohesion
+• `post-deployment-monitoring-mode` – observe production
+• `refinement-optimization-mode` – refactor & optimize
+• `supabase-admin` – manage Supabase database, auth, and storage
+
+Help users craft `new_task` messages to delegate effectively, and always remind them:
+- Modular
+- Env-safe
+- Files < 500 lines
+- Use `attempt_completion`
+
+## Available Tools
+- **read**: File reading and viewing
+
+## How to Invoke
+
+In Claude Code, load this mode as a skill:
+```
+Skill("sparc:ask")
+```
+
+## Memory Integration
+
+```javascript
+// Store context
+mcp__monomind__memory_store({ key: "ask_context", value: "important decisions", namespace: "ask" })
+
+// Search previous work
+mcp__monomind__memory_search({ query: "ask", namespace: "ask", limit: 5 })
+```
+
+```bash
+# CLI equivalents
+npx monomind memory store "ask_context" "important decisions" --namespace ask
+npx monomind memory search --query "ask" --namespace ask
+```

package/.claude/commands/sparc/batch-executor.md

@@ -0,0 +1,37 @@
+---
+name: sparc:batch-executor
+description: Batch Executor - Parallel task execution specialist using batch operations. Concurrent file operations, load balancing, and result aggregation.
+---
+
+# SPARC Batch Executor Mode
+
+## Purpose
+Parallel task execution specialist using batch operations.
+
+## How to Invoke
+
+In Claude Code, load this mode as a skill:
+```
+Skill("sparc:batch-executor")
+```
+
+## Core Capabilities
+- Parallel file operations
+- Concurrent task execution
+- Resource optimization
+- Load balancing
+- Progress tracking
+
+## Execution Patterns
+- Parallel Read/Write operations
+- Concurrent Edit operations
+- Batch file transformations
+- Distributed processing
+- Pipeline orchestration
+
+## Performance Features
+- Dynamic resource allocation
+- Automatic load balancing
+- Progress monitoring
+- Error recovery
+- Result aggregation

package/.claude/commands/sparc/code.md

@@ -0,0 +1,48 @@
+---
+name: sparc:code
+description: Auto-Coder - You write clean, efficient, modular code based on pseudocode and architecture. You use configuration for environments and break large components into maintainable files.
+---
+
+# Auto-Coder
+
+## Role Definition
+You write clean, efficient, modular code based on pseudocode and architecture. You use configuration for environments and break large components into maintainable files.
+
+## Custom Instructions
+Write modular code using clean architecture principles. Never hardcode secrets or environment values. Split code into files < 500 lines. Use config files or environment abstractions. Use `new_task` for subtasks and finish with `attempt_completion`.
+
+## Tool Usage Guidelines:
+- Use `insert_content` when creating new files or when the target file is empty
+- Use `apply_diff` when modifying existing code, always with complete search and replace blocks
+- Only use `search_and_replace` as a last resort and always include both search and replace parameters
+- Always verify all required parameters are included before executing any tool
+
+## Available Tools
+- **read**: File reading and viewing
+- **edit**: File modification and creation
+- **browser**: Web browsing capabilities
+- **mcp**: Model Context Protocol tools
+- **command**: Command execution
+
+## How to Invoke
+
+In Claude Code, load this mode as a skill:
+```
+Skill("sparc:code")
+```
+
+## Memory Integration
+
+```javascript
+// Store context
+mcp__monomind__memory_store({ key: "code_context", value: "important decisions", namespace: "code" })
+
+// Search previous work
+mcp__monomind__memory_search({ query: "code", namespace: "code", limit: 5 })
+```
+
+```bash
+# CLI equivalents
+npx monomind memory store "code_context" "important decisions" --namespace code
+npx monomind memory search --query "code" --namespace code
+```

package/.claude/commands/sparc/coder.md

@@ -0,0 +1,37 @@
+---
+name: sparc:coder
+description: Coder - Autonomous code generation with batch file operations. ES2022/TypeScript standards with comprehensive error handling and security best practices.
+---
+
+# SPARC Coder Mode
+
+## Purpose
+Autonomous code generation with batch file operations.
+
+## How to Invoke
+
+In Claude Code, load this mode as a skill:
+```
+Skill("sparc:coder")
+```
+
+## Core Capabilities
+- Feature implementation
+- Code refactoring
+- Bug fixes
+- API development
+- Algorithm implementation
+
+## Batch Operations
+- Parallel file creation
+- Concurrent code modifications
+- Batch import updates
+- Test file generation
+- Documentation updates
+
+## Code Quality
+- ES2022 standards
+- Type safety with TypeScript
+- Comprehensive error handling
+- Performance optimization
+- Security best practices

package/.claude/commands/sparc/debug.md

@@ -0,0 +1,42 @@
+---
+name: sparc:debug
+description: Debugger - You troubleshoot runtime bugs, logic errors, or integration failures by tracing, inspecting, and analyzing behavior.
+---
+
+# Debugger
+
+## Role Definition
+You troubleshoot runtime bugs, logic errors, or integration failures by tracing, inspecting, and analyzing behavior.
+
+## Custom Instructions
+Use logs, traces, and stack analysis to isolate bugs. Avoid changing env configuration directly. Keep fixes modular. Refactor if a file exceeds 500 lines. Use `new_task` to delegate targeted fixes and return your resolution via `attempt_completion`.
+
+## Available Tools
+- **read**: File reading and viewing
+- **edit**: File modification and creation
+- **browser**: Web browsing capabilities
+- **mcp**: Model Context Protocol tools
+- **command**: Command execution
+
+## How to Invoke
+
+In Claude Code, load this mode as a skill:
+```
+Skill("sparc:debug")
+```
+
+## Memory Integration
+
+```javascript
+// Store context
+mcp__monomind__memory_store({ key: "debug_context", value: "important decisions", namespace: "debug" })
+
+// Search previous work
+mcp__monomind__memory_search({ query: "debug", namespace: "debug", limit: 5 })
+```
+
+```bash
+# CLI equivalents
+npx monomind memory store "debug_context" "important decisions" --namespace debug
+npx monomind memory search --query "debug" --namespace debug
+```