@monoes/monomindcli 1.7.0 → 1.9.0

package/.claude/commands/hooks/post-edit.md

@@ -1,117 +1,78 @@
-# hook post-edit
+---
+name: hooks:post-edit
+---
 
-Execute post-edit processing including formatting, validation, and memory updates.
+# hooks post-edit
+
+Record editing outcome for neural pattern learning.
 
 ## Usage
 
 ```bash
-npx monomind hook post-edit [options]
+npx monomind hooks post-edit [options]
 ```
 
 ## Options
 
-- `--file, -f <path>` - File path that was edited
-- `--auto-format` - Automatically format code (default: true)
-- `--memory-key, -m <key>` - Store edit context in memory
-- `--train-patterns` - Train neural patterns from edit
-- `--validate-output` - Validate edited file
+| Flag | Short | Type | Default | Description |
+|---|---|---|---|---|
+| `--file` | `-f` | string | `unknown` | File path that was edited |
+| `--success` | `-s` | boolean | `true` | Whether the edit succeeded |
+| `--outcome` | `-o` | string | — | Outcome description |
+| `--metrics` | `-m` | string | — | Performance metrics, e.g. `"time:500ms,quality:0.95"` |
+| `--format` | — | string | — | Output format: `json` |
 
 ## Examples
 
-### Basic post-edit hook
-
 ```bash
-npx monomind hook post-edit --file "src/components/Button.jsx"
-```
-
-### With memory storage
+# Record successful edit
+npx monomind hooks post-edit --file src/utils.ts --success true
 
-```bash
-npx monomind hook post-edit -f "api/auth.js" --memory-key "auth/login-implementation"
-```
+# Record failed edit with reason
+npx monomind hooks post-edit -f src/api.ts --success false -o "Type error in return type"
 
-### Format and validate
+# With performance metrics
+npx monomind hooks post-edit -f src/auth.ts --success true -m "time:200ms,quality:0.9"
 
-```bash
-npx monomind hook post-edit -f "config/webpack.js" --auto-format --validate-output
+# JSON output
+npx monomind hooks post-edit -f src/utils.ts --format json
 ```
 
-### Neural training
-
-```bash
-npx monomind hook post-edit -f "utils/helpers.ts" --train-patterns --memory-key "utils/refactor"
-```
-
-## Features
-
-### Auto Formatting
-
-- Language-specific formatters
-- Prettier for JS/TS/JSON
-- Black for Python
-- gofmt for Go
-- Maintains consistency
-
-### Memory Storage
-
-- Saves edit context
-- Records decisions made
-- Tracks implementation details
-- Enables knowledge sharing
-
-### Pattern Training
-
-- Learns from successful edits
-- Improves future suggestions
-- Adapts to coding style
-- Enhances coordination
-
-### Output Validation
-
-- Checks syntax correctness
-- Runs linting rules
-- Validates formatting
-- Ensures quality
-
-## Integration
-
-This hook is automatically called by Claude Code when:
-
-- After Edit tool completes
-- Following MultiEdit operations
-- During file saves
-- After code generation
-
-Manual usage in agents:
+## Output
 
-```bash
-# After editing files
-npx monomind hook post-edit --file "path/to/edited.js" --memory-key "feature/step1"
-```
+- **Learning updates** — patterns updated, confidence adjustments, new patterns discovered
 
-## Output
+## Claude Code Integration
 
-Returns JSON with:
+Typically fired automatically via `settings.json`:
 
 ```json
 {
-  "file": "src/components/Button.jsx",
-  "formatted": true,
-  "formatterUsed": "prettier",
-  "lintPassed": true,
-  "memorySaved": "component/button-refactor",
-  "patternsTrained": 3,
-  "warnings": [],
-  "stats": {
-    "linesChanged": 45,
-    "charactersAdded": 234
+  "hooks": {
+    "PostToolUse": [{
+      "matcher": "^(Write|Edit|MultiEdit)$",
+      "hooks": [{
+        "type": "command",
+        "command": "npx monomind hooks post-edit --file '${tool.params.file_path}' --success true"
+      }]
+    }]
   }
 }
 ```
 
+## MCP Tool
+
+```javascript
+mcp__monomind__hooks_post_edit({
+  filePath: "src/utils.ts",
+  success: true,
+  outcome: "Added error handling",
+  metrics: { time: 200, quality: 0.9 },
+  timestamp: Date.now()
+})
+```
+
 ## See Also
 
-- `hook pre-edit` - Pre-edit preparation
-- `Edit` - File editing tool
-- `memory usage` - Memory management
-- `neural train` - Pattern training
+- `hooks pre-edit` — get context before editing
+- `hooks metrics` — view learning metrics

package/.claude/commands/hooks/post-task.md

@@ -1,112 +1,62 @@
-# hook post-task
+---
+name: hooks:post-task
+---
 
-Execute post-task cleanup, performance analysis, and memory storage.
+# hooks post-task
+
+Record task completion for neural pattern learning.
 
 ## Usage
 
 ```bash
-npx monomind hook post-task [options]
+npx monomind hooks post-task [options]
 ```
 
 ## Options
 
-- `--task-id, -t <id>` - Task identifier for tracking
-- `--analyze-performance` - Generate performance metrics (default: true)
-- `--store-decisions` - Save task decisions to memory
-- `--export-learnings` - Export neural pattern learnings
-- `--generate-report` - Create task completion report
+| Flag | Short | Type | Required | Description |
+|---|---|---|---|---|
+| `--task-id` | `-i` | string | no | Task identifier (auto-generated if omitted) |
+| `--success` | `-s` | boolean | no | Whether task succeeded (default: true) |
+| `--quality` | `-q` | number | no | Quality score 0–1 |
+| `--agent` | `-a` | string | no | Agent that executed the task |
+| `--format` | — | string | no | Output format: `json` |
 
 ## Examples
 
-### Basic post-task hook
-
 ```bash
-npx monomind hook post-task --task-id "auth-implementation"
-```
-
-### With full analysis
-
-```bash
-npx monomind hook post-task -t "api-refactor" --analyze-performance --generate-report
-```
+# Record successful completion
+npx monomind hooks post-task -i task-123 --success true
 
-### Memory storage
+# Record failed task with quality score
+npx monomind hooks post-task -i task-456 --success false -q 0.3
 
-```bash
-npx monomind hook post-task -t "bug-fix-123" --store-decisions --export-learnings
-```
+# Record with agent attribution
+npx monomind hooks post-task -i task-789 --success true -a coder -q 0.95
 
-### Quick cleanup
-
-```bash
-npx monomind hook post-task -t "minor-update" --analyze-performance false
+# JSON output
+npx monomind hooks post-task -i task-123 --success true --format json
 ```
 
-## Features
-
-### Performance Analysis
-
-- Measures execution time
-- Tracks token usage
-- Identifies bottlenecks
-- Suggests optimizations
-
-### Decision Storage
-
-- Saves key decisions made
-- Records implementation choices
-- Stores error resolutions
-- Maintains knowledge base
-
-### Neural Learning
-
-- Exports successful patterns
-- Updates coordination models
-- Improves future performance
-- Trains on task outcomes
-
-### Report Generation
-
-- Creates completion summary
-- Documents changes made
-- Lists files modified
-- Tracks metrics achieved
-
-## Integration
-
-This hook is automatically called by Claude Code when:
-
-- Completing a task
-- Switching to a new task
-- Ending a work session
-- After major milestones
-
-Manual usage in agents:
+## Output
 
-```bash
-# In agent coordination
-npx monomind hook post-task --task-id "your-task-id" --analyze-performance true
-```
+- Patterns updated / new patterns discovered
+- Task duration
+- Trajectory ID (for intelligence system tracking)
 
-## Output
+## MCP Tool
 
-Returns JSON with:
-
-```json
-{
-  "taskId": "auth-implementation",
-  "duration": 1800000,
-  "tokensUsed": 45000,
-  "filesModified": 12,
-  "performanceScore": 0.92,
-  "learningsExported": true,
-  "reportPath": "/reports/task-auth-implementation.md"
-}
+```javascript
+mcp__monomind__hooks_post_task({
+  taskId: "task-123",
+  success: true,
+  quality: 0.95,
+  agent: "coder",
+  timestamp: Date.now()
+})
 ```
 
 ## See Also
 
-- `hook pre-task` - Pre-task setup
-- `performance report` - Detailed metrics
-- `memory usage` - Memory management
-- `neural patterns` - Pattern analysis
+- `hooks pre-task` — register task start
+- `hooks metrics` — view learning metrics

package/.claude/commands/hooks/pre-edit.md

@@ -1,113 +1,81 @@
-# hook pre-edit
+---
+name: hooks:pre-edit
+---
 
-Execute pre-edit validations and agent assignment before file modifications.
+# hooks pre-edit
+
+Get context and agent suggestions before editing a file.
 
 ## Usage
 
 ```bash
-npx monomind hook pre-edit [options]
+npx monomind hooks pre-edit [options]
 ```
 
 ## Options
 
-- `--file, -f <path>` - File path to be edited
-- `--auto-assign-agent` - Automatically assign best agent (default: true)
-- `--validate-syntax` - Pre-validate syntax before edit
-- `--check-conflicts` - Check for merge conflicts
-- `--backup-file` - Create backup before editing
+| Flag | Short | Type | Default | Description |
+|---|---|---|---|---|
+| `--file` | `-f` | string | `unknown` | File path to edit |
+| `--operation` | `-o` | string | `update` | Edit operation: `create`, `update`, `delete`, `refactor` |
+| `--context` | `-c` | string | — | Additional context about the edit |
+| `--format` | — | string | — | Output format: `json` |
 
 ## Examples
 
-### Basic pre-edit hook
-
 ```bash
-npx monomind hook pre-edit --file "src/auth/login.js"
-```
-
-### With validation
+# Get context before editing a file
+npx monomind hooks pre-edit --file src/auth/login.ts
 
-```bash
-npx monomind hook pre-edit -f "config/database.js" --validate-syntax
-```
+# With operation type
+npx monomind hooks pre-edit -f src/api.ts -o refactor
 
-### Manual agent assignment
+# With additional context
+npx monomind hooks pre-edit -f src/auth.ts -o update -c "Adding JWT refresh logic"
 
-```bash
-npx monomind hook pre-edit -f "api/users.ts" --auto-assign-agent false
+# JSON output for scripting
+npx monomind hooks pre-edit -f src/utils.ts --format json
 ```
 
-### Safe editing with backup
-
-```bash
-npx monomind hook pre-edit -f "production.env" --backup-file --check-conflicts
-```
-
-## Features
-
-### Auto Agent Assignment
-
-- Analyzes file type and content
-- Assigns specialist agents
-- TypeScript → TypeScript expert
-- Database → Data specialist
-- Tests → QA engineer
-
-### Syntax Validation
-
-- Pre-checks syntax validity
-- Identifies potential errors
-- Suggests corrections
-- Prevents broken code
-
-### Conflict Detection
-
-- Checks for git conflicts
-- Identifies concurrent edits
-- Warns about stale files
-- Suggests merge strategies
-
-### File Backup
-
-- Creates safety backups
-- Enables quick rollback
-- Tracks edit history
-- Preserves originals
-
-## Integration
-
-This hook is automatically called by Claude Code when:
-
-- Using Edit or MultiEdit tools
-- Before file modifications
-- During refactoring operations
-- When updating critical files
-
-Manual usage in agents:
+## Output
 
-```bash
-# Before editing files
-npx monomind hook pre-edit --file "path/to/file.js" --validate-syntax
-```
+- **File context** — file type, exists/not-exists, operation
+- **Suggested agents** — which agent types are best for this file
+- **Related files** — files likely affected by the edit
+- **Learned patterns** — matching patterns from past edits with confidence scores
+- **Potential risks** — warnings about the edit
 
-## Output
+## Claude Code Integration
 
-Returns JSON with:
+Typically fired automatically via `settings.json`:
 
 ```json
 {
-  "continue": true,
-  "file": "src/auth/login.js",
-  "assignedAgent": "auth-specialist",
-  "syntaxValid": true,
-  "conflicts": false,
-  "backupPath": ".backups/login.js.bak",
-  "warnings": []
+  "hooks": {
+    "PreToolUse": [{
+      "matcher": "^(Write|Edit|MultiEdit)$",
+      "hooks": [{
+        "type": "command",
+        "command": "npx monomind hooks pre-edit --file '${tool.params.file_path}'"
+      }]
+    }]
+  }
 }
 ```
 
+## MCP Tool
+
+```javascript
+mcp__monomind__hooks_pre_edit({
+  filePath: "src/auth/login.ts",
+  operation: "update",
+  context: "Adding JWT refresh logic",
+  includePatterns: true,
+  includeRisks: true
+})
+```
+
 ## See Also
 
-- `hook post-edit` - Post-edit processing
-- `Edit` - File editing tool
-- `MultiEdit` - Multiple edits tool
-- `agent spawn` - Manual agent creation
+- `hooks post-edit` — record edit outcome
+- `hooks route` — manual agent routing

package/.claude/commands/hooks/pre-task.md

@@ -1,111 +1,76 @@
-# hook pre-task
+---
+name: hooks:pre-task
+---
 
-Execute pre-task preparations and context loading.
+# hooks pre-task
+
+Register task start, get agent suggestions, and receive model routing recommendations.
 
 ## Usage
 
 ```bash
-npx monomind hook pre-task [options]
+npx monomind hooks pre-task [options]
 ```
 
 ## Options
 
-- `--description, -d <text>` - Task description for context
-- `--auto-spawn-agents` - Automatically spawn required agents (default: true)
-- `--load-memory` - Load relevant memory from previous sessions
-- `--optimize-topology` - Select optimal swarm topology
-- `--estimate-complexity` - Analyze task complexity
+| Flag | Short | Type | Required | Description |
+|---|---|---|---|---|
+| `--description` | `-d` | string | yes | Task description |
+| `--task-id` | `-i` | string | no | Unique task ID (auto-generated if omitted) |
+| `--auto-spawn` | `-a` | boolean | no | Auto-spawn suggested agents (default: false) |
+| `--format` | — | string | no | Output format: `json` |
 
 ## Examples
 
-### Basic pre-task hook
-
-```bash
-npx monomind hook pre-task --description "Implement user authentication"
-```
-
-### With memory loading
-
 ```bash
-npx monomind hook pre-task -d "Continue API development" --load-memory
-```
-
-### Manual agent control
+# Register task start and get suggestions
+npx monomind hooks pre-task -d "Implement user authentication"
 
-```bash
-npx monomind hook pre-task -d "Debug issue #123" --auto-spawn-agents false
-```
+# With explicit task ID
+npx monomind hooks pre-task -i task-123 -d "Fix auth bug"
 
-### Full optimization
+# With auto-spawn of suggested agents
+npx monomind hooks pre-task -d "Implement feature" --auto-spawn
 
-```bash
-npx monomind hook pre-task -d "Refactor codebase" --optimize-topology --estimate-complexity
+# JSON output for scripting
+npx monomind hooks pre-task -d "Refactor database layer" --format json
 ```
 
-## Features
-
-### Auto Agent Assignment
-
-- Analyzes task requirements
-- Determines needed agent types
-- Spawns agents automatically
-- Configures agent parameters
-
-### Memory Loading
-
-- Retrieves relevant past decisions
-- Loads previous task contexts
-- Restores agent configurations
-- Maintains continuity
-
-### Topology Optimization
-
-- Analyzes task structure
-- Selects best swarm topology
-- Configures communication patterns
-- Optimizes for performance
-
-### Complexity Estimation
-
-- Evaluates task difficulty
-- Estimates time requirements
-- Suggests agent count
-- Identifies dependencies
-
-## Integration
+## Output
 
-This hook is automatically called by Claude Code when:
+The command outputs:
+- **Task registration** — task ID, complexity estimate, estimated duration
+- **Suggested agents** — agent type, confidence, reason
+- **Potential risks** — issues to watch for
+- **Recommendations** — approach suggestions
+- **Model routing** — one of:
+  - `[AGENT_BOOSTER_AVAILABLE]` — skip LLM, use Agent Booster (< 1ms, $0)
+  - `[TASK_MODEL_RECOMMENDATION] Use model="haiku|sonnet|opus"` — use that model
 
-- Starting a new task
-- Resuming work after a break
-- Switching between projects
-- Beginning complex operations
+## Integration in Claude Code
 
-Manual usage in agents:
+Run before starting any significant task:
 
 ```bash
-# In agent coordination
-npx monomind hook pre-task --description "Your task here"
+npx monomind hooks pre-task -d "Your task description here"
 ```
 
-## Output
+Then use the model routing output to set the Task tool's `model` parameter.
+
+## MCP Tool
 
-Returns JSON with:
-
-```json
-{
-  "continue": true,
-  "topology": "hierarchical",
-  "agentsSpawned": 5,
-  "complexity": "medium",
-  "estimatedMinutes": 30,
-  "memoryLoaded": true
-}
+```javascript
+mcp__monomind__hooks_pre_task({
+  taskId: "task-123",
+  description: "Implement authentication",
+  autoSpawn: false,
+  timestamp: Date.now()
+})
 ```
 
 ## See Also
 
-- `hook post-task` - Post-task cleanup
-- `agent spawn` - Manual agent creation
-- `memory usage` - Memory management
-- `swarm init` - Swarm initialization
+- `hooks post-task` — record task completion
+- `hooks route` — manual agent routing
+- `hooks explain` — explain routing decision