@monoes/monomindcli 1.7.0 → 1.9.0

package/.claude/commands/pair/session.md

@@ -1,407 +1,124 @@
-# Pair Programming Session Management
+---
+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
+---
 
-Complete guide to managing pair programming sessions.
+# Pair Programming Session Lifecycle
 
-## Session Lifecycle
+How to structure a productive pair programming session from start to finish.
 
-### 1. Initialization
-```bash
-monomind pair --start
-```
+## 1. Before You Start
 
-### 2. Active Session
-- Real-time collaboration
-- Continuous verification
-- Quality monitoring
-- Role management
+Get routing and context from the hooks system:
 
-### 3. Completion
 ```bash
-monomind pair --end
-```
-
-## Session Commands
-
-During an active session, use these commands:
-
-### Basic Commands
-```
-/help          - Show all available commands
-/status        - Current session status
-/metrics       - View quality metrics
-/pause         - Pause current session
-/resume        - Resume paused session
-/end           - End current session
+# Register the task and get agent/model recommendations
+npx monomind hooks pre-task -d "Pair programming: implement [feature]"
 ```
 
-### Code Commands
-```
-/explain       - Explain current code
-/suggest       - Get improvement suggestions
-/refactor      - Refactor selected code
-/optimize      - Optimize for performance
-/document      - Add documentation
-/comment       - Add inline comments
-```
-
-### Testing Commands
-```
-/test          - Run test suite
-/test-gen      - Generate tests
-/coverage      - Check test coverage
-/test-watch    - Enable test watching
-/mock          - Generate mocks
-```
-
-### Review Commands
-```
-/review        - Full code review
-/security      - Security analysis
-/perf          - Performance review
-/quality       - Quality metrics
-/lint          - Run linters
-```
-
-### Navigation Commands
-```
-/goto <file>   - Navigate to file
-/find <text>   - Search in project
-/recent        - Recent files
-/bookmark      - Bookmark location
-/history       - Command history
-```
-
-### Role Commands
-```
-/switch        - Switch driver/navigator
-/mode <type>   - Change mode
-/role          - Show current role
-/handoff       - Prepare role handoff
-```
-
-### Git Commands
-```
-/diff          - Show changes
-/commit        - Commit with verification
-/branch        - Branch operations
-/stash         - Stash changes
-/log           - View git log
-```
-
-## Session Status
-
-Check current session status:
+Load relevant context from memory:
 
 ```bash
-monomind pair --status
+npx monomind memory search --query "[feature domain]" --type hybrid
 ```
 
-Output:
-```
-👥 Pair Programming Session
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Session ID: pair_1755021234567
-Duration: 45 minutes
-Status: Active
-
-Partner: senior-dev
-Current Role: DRIVER (you)
-Mode: Switch (10m intervals)
-Next Switch: in 3 minutes
-
-📊 Metrics:
-├── Truth Score: 0.982 ✅
-├── Lines Changed: 234
-├── Files Modified: 5
-├── Tests Added: 12
-├── Coverage: 87% ↑3%
-└── Commits: 3
-
-🎯 Focus: Implementation
-📝 Current File: src/auth/login.js
-```
-
-## Session History
+## 2. Set Session Context
 
-View past sessions:
-
-```bash
-monomind pair --history
-```
-
-Output:
-```
-📚 Session History
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-1. 2024-01-15 14:30 - 16:45 (2h 15m)
-   Partner: expert-coder
-   Focus: Refactoring
-   Truth Score: 0.975
-   Changes: +340 -125 lines
-
-2. 2024-01-14 10:00 - 11:30 (1h 30m)
-   Partner: tdd-specialist
-   Focus: Testing
-   Truth Score: 0.991
-   Tests Added: 24
-
-3. 2024-01-13 15:00 - 17:00 (2h)
-   Partner: debugger-expert
-   Focus: Bug Fixing
-   Truth Score: 0.968
-   Issues Fixed: 5
-```
-
-## Session Metrics
-
-Real-time metrics during session:
-
-### Truth Score
-```
-Current: 0.982 ✅
-Average: 0.975
-Minimum: 0.951
-Threshold: 0.950
-```
+Tell Claude everything it needs to know upfront:
 
-### Productivity
 ```
-Lines Changed: 234
-Files Modified: 5
-Functions Added: 8
-Functions Refactored: 3
+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]
 ```
 
-### Quality
-```
-Test Coverage: 87% ↑3%
-Lint Issues: 0
-Security Issues: 0
-Performance Issues: 1 ⚠️
-```
+The more context upfront, the less correction mid-session.
 
-### Collaboration
-```
-Suggestions Given: 45
-Suggestions Accepted: 38 (84%)
-Reviews Completed: 12
-Rollbacks: 1
-```
+## 3. During the Session
 
-## Session Persistence
+**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?"
 
-### Save Session
+**Real-time quality checks:**
 ```bash
-monomind pair --save [--name <name>]
-```
+# Watch system status during long sessions
+npx monomind status --watch
 
-### Load Session
-```bash
-monomind pair --load <session-id>
+# Check test state
+# (run your test suite normally)
 ```
 
-### Export Session
+**Capture decisions as you go:**
 ```bash
-monomind pair --export <session-id> [--format json|md]
+# Store important patterns discovered during session
+npx monomind memory store --key "session-[date]-[feature]" \
+  --value "[what we decided and why]" \
+  --namespace "decisions"
 ```
 
-## Background Sessions
+## 4. Breakpoints and Handoffs
 
-Run pair programming in background:
+Use natural stopping points:
+- After implementing a complete unit (function, class, endpoint)
+- Before switching between subsystems
+- When you need to run tests and wait
 
-### Start Background Session
-```bash
-monomind pair --start --background
-```
+At each breakpoint:
+> "Summarize what we've done so far and what comes next."
 
-### Monitor Background Session
-```bash
-monomind pair --monitor
-```
+This keeps both you and Claude aligned on state.
 
-### Attach to Background Session
-```bash
-monomind pair --attach <session-id>
-```
+## 5. End of Session
 
-## Session Configuration
-
-### Default Settings
-```json
-{
-  "pair": {
-    "session": {
-      "autoSave": true,
-      "saveInterval": "5m",
-      "maxDuration": "4h",
-      "idleTimeout": "15m",
-      "metricsInterval": "1m"
-    }
-  }
-}
-```
+Record outcomes for future sessions:
 
-### Per-Session Config
 ```bash
-monomind pair --start \
-  --config custom-config.json
-```
-
-## Session Templates
-
-### Refactoring Template
-```bash
-monomind pair --template refactor
-```
-- Focus: Code improvement
-- Verification: High (0.98)
-- Testing: After each change
-- Review: Continuous
-
-### Feature Template
-```bash
-monomind pair --template feature
-```
-- Focus: Implementation
-- Verification: Standard (0.95)
-- Testing: On completion
-- Review: Pre-commit
-
-### Debug Template
-```bash
-monomind pair --template debug
-```
-- Focus: Problem solving
-- Verification: Moderate (0.90)
-- Testing: Regression tests
-- Review: Root cause
-
-### Learning Template
-```bash
-monomind pair --template learn
-```
-- Mode: Mentor
-- Pace: Slow
-- Explanations: Detailed
-- Examples: Many
-
-## Session Reports
-
-Generate session report:
-
-```bash
-monomind pair --report <session-id>
-```
-
-Report includes:
-- Session summary
-- Metrics overview
-- Code changes
-- Test results
-- Quality scores
-- Learning points
-- Recommendations
-
-## Multi-Session Management
-
-### List Active Sessions
-```bash
-monomind pair --list
-```
-
-### Switch Between Sessions
-```bash
-monomind pair --switch <session-id>
-```
-
-### Merge Sessions
-```bash
-monomind pair --merge <session-1> <session-2>
-```
+# Record task completion
+npx monomind hooks post-task --task-id <id> --success true --quality 0.9
 
-## Session Recovery
-
-### Auto-Recovery
-Sessions auto-save every 5 minutes with recovery points.
-
-### Manual Recovery
-```bash
-monomind pair --recover [--point <timestamp>]
+# Store any patterns worth remembering
+npx monomind memory store \
+  --key "pattern-[name]" \
+  --value "[the pattern we found/confirmed]" \
+  --namespace "patterns"
 ```
 
-### Crash Recovery
-```bash
-monomind pair --crash-recovery
-```
-
-## Session Sharing
-
-### Share with Team
-```bash
-monomind pair --share <session-id> \
-  --team <team-id>
-```
+Get a session summary:
+> "Summarize: what did we build, what decisions did we make, and what's left to do?"
 
-### Export for Review
-```bash
-monomind pair --export-review <session-id>
-```
+## Session Anti-Patterns
 
-### Create Learning Material
-```bash
-monomind pair --create-tutorial <session-id>
-```
+| 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 |
 
-## Advanced Features
+## Multi-Session Continuity
 
-### Session Recording
-```bash
-monomind pair --start --record
-```
-Records all interactions for playback.
+Use the hooks session system to restore context across conversations:
 
-### Session Replay
 ```bash
-monomind pair --replay <session-id>
-```
-Replay recorded session for learning.
+# At session end — persist state
+npx monomind hooks session-end
 
-### Session Analytics
-```bash
-monomind pair --analytics <session-id>
+# Next session — restore
+npx monomind hooks session-restore
 ```
-Deep analysis of session patterns.
-
-## Troubleshooting
-
-### Session Won't Start
-- Check agent availability
-- Verify configuration
-- Ensure clean workspace
-
-### Session Disconnected
-- Use `--recover` to restore
-- Check network connection
-- Verify background processes
-
-### Poor Performance
-- Reduce verification threshold
-- Disable continuous testing
-- Check system resources
-
-## Best Practices
 
-1. **Regular Saves** - Auto-save enabled
-2. **Clear Goals** - Define objectives
-3. **Appropriate Duration** - 1-2 hour sessions
-4. **Breaks** - Take regular breaks
-5. **Review** - End with summary
+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."
 
-## Related Commands
+## See Also
 
-- `pair --start` - Start new session
-- `pair --config` - Configure settings
-- `pair --templates` - Manage templates
-- `pair --analytics` - View analytics
+- [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

@@ -1,35 +1,18 @@
+---
+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.
 
-## Activation
+## How to Invoke
 
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "analyzer",
-  task_description: "analyze codebase performance",
-  options: {
-    parallel: true,
-    detailed: true
-  }
-}
+In Claude Code, load this mode as a skill:
 ```
-
-### Option 2: Using NPX CLI (Fallback when MCP not available)
-```bash
-# Use when running from terminal or MCP tools unavailable
-npx monomind sparc run analyzer "analyze codebase performance"
-
-# For alpha features
-npx monomind@alpha sparc run analyzer "analyze codebase performance"
-```
-
-### Option 3: Local Installation
-```bash
-# If monomind is installed locally
-./monomind sparc run analyzer "analyze codebase performance"
+Skill("sparc:analyzer")
 ```
 
 ## Core Capabilities
@@ -49,4 +32,4 @@ npx monomind@alpha sparc run analyzer "analyze codebase performance"
 - Detailed analysis reports
 - Performance metrics
 - Improvement recommendations
-- Visualizations when applicable
+- Visualizations when applicable

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

@@ -1,35 +1,18 @@
+---
+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.
 
-## Activation
+## How to Invoke
 
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "architect",
-  task_description: "design microservices architecture",
-  options: {
-    detailed: true,
-    memory_enabled: true
-  }
-}
+In Claude Code, load this mode as a skill:
 ```
-
-### Option 2: Using NPX CLI (Fallback when MCP not available)
-```bash
-# Use when running from terminal or MCP tools unavailable
-npx monomind sparc run architect "design microservices architecture"
-
-# For alpha features
-npx monomind@alpha sparc run architect "design microservices architecture"
-```
-
-### Option 3: Local Installation
-```bash
-# If monomind is installed locally
-./monomind sparc run architect "design microservices architecture"
+Skill("sparc:architect")
 ```
 
 ## Core Capabilities

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

@@ -1,9 +1,9 @@
 ---
-name: sparc-ask
-description: ❓Ask - You are a task-formulation guide that helps users navigate, ask, and delegate tasks to the correc...
+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
+# Ask
 
 ## Role Definition
 You are a task-formulation guide that helps users navigate, ask, and delegate tasks to the correct SPARC modes.
@@ -11,87 +11,46 @@ You are a task-formulation guide that helps users navigate, ask, and delegate ta
 ## 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
+• `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`
+- Modular
+- Env-safe
+- Files < 500 lines
+- Use `attempt_completion`
 
 ## Available Tools
 - **read**: File reading and viewing
 
-## Usage
+## How to Invoke
 
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "ask",
-  task_description: "help me choose the right mode",
-  options: {
-    namespace: "ask",
-    non_interactive: false
-  }
-}
-```
-
-### Option 2: Using NPX CLI (Fallback when MCP not available)
-```bash
-# Use when running from terminal or MCP tools unavailable
-npx monomind sparc run ask "help me choose the right mode"
-
-# For alpha features
-npx monomind@alpha sparc run ask "help me choose the right mode"
-
-# With namespace
-npx monomind sparc run ask "your task" --namespace ask
-
-# Non-interactive mode
-npx monomind sparc run ask "your task" --non-interactive
+In Claude Code, load this mode as a skill:
 ```
-
-### Option 3: Local Installation
-```bash
-# If monomind is installed locally
-./monomind sparc run ask "help me choose the right mode"
+Skill("sparc:ask")
 ```
 
 ## Memory Integration
 
-### Using MCP Tools (Preferred)
 ```javascript
-// Store mode-specific context
-mcp__monomind__memory_usage {
-  action: "store",
-  key: "ask_context",
-  value: "important decisions",
-  namespace: "ask"
-}
+// Store context
+mcp__monomind__memory_store({ key: "ask_context", value: "important decisions", namespace: "ask" })
 
-// Query previous work
-mcp__monomind__memory_search {
-  pattern: "ask",
-  namespace: "ask",
-  limit: 5
-}
+// Search previous work
+mcp__monomind__memory_search({ query: "ask", namespace: "ask", limit: 5 })
 ```
 
-### Using NPX CLI (Fallback)
 ```bash
-# Store mode-specific context
+# CLI equivalents
 npx monomind memory store "ask_context" "important decisions" --namespace ask
-
-# Query previous work
-npx monomind memory query "ask" --limit 5
+npx monomind memory search --query "ask" --namespace ask
 ```