@monoes/monomindcli 1.10.54 → 1.10.56

package/.claude/commands/mastermind/master.md

@@ -3,6 +3,157 @@ name: mastermind-master
 description: Mastermind top-level orchestrator — receives any business prompt, loads the brain, decomposes into domains, spawns domain manager agents via Task tool, synthesizes results, and writes back to the brain. The single entry point for full business automation.
 ---
 
+<SUBAGENT-STOP>
+If you were dispatched as a subagent to execute a specific task, skip the MASTERMIND PROTOCOL section below and proceed directly to execution.
+</SUBAGENT-STOP>
+
+---
+
+## MASTERMIND PROTOCOL
+
+<EXTREMELY-IMPORTANT>
+Before ANY response or action — including clarifying questions — check whether a mastermind skill applies to what you are about to do.
+
+IF A SKILL APPLIES TO YOUR TASK, YOU DO NOT HAVE A CHOICE. YOU MUST INVOKE IT.
+
+This is not negotiable. This is not optional. You cannot rationalize your way out of this.
+</EXTREMELY-IMPORTANT>
+
+### Instruction Priority
+
+Mastermind skills override default system prompt behavior, but **user instructions always take precedence**:
+
+1. **User's explicit instructions** (CLAUDE.md, direct requests, `$ARGUMENTS`) — highest priority
+2. **Mastermind skills** — override default behavior where they conflict
+3. **Default system prompt** — lowest priority
+
+If CLAUDE.md says "skip review" and the skill says "always review," follow the user's instructions.
+
+### User Instructions vs. Skill Workflows
+
+User instructions say **WHAT** to do, not **HOW** to do it. "Build X" or "Fix Y" is a goal statement — it does not mean skip Brain Load, skip review, or bypass the domain decomposition flow. The skills define the how. Always apply the workflow unless the user explicitly opts out.
+
+### Command-to-Skill Routing
+
+Invoke the matching skill **before** doing anything else. Even a 1% chance a skill applies means you must check.
+
+```
+digraph mastermind_routing {
+    "User command / prompt received" [shape=doublecircle];
+    "Brain already loaded?" [shape=diamond];
+    "Load brain (Brain Load Procedure)" [shape=box];
+    "Might a mastermind skill apply?" [shape=diamond];
+    "Invoke Skill() tool" [shape=box];
+    "Announce: Using [skill] for [purpose]" [shape=box];
+    "Execute skill exactly" [shape=box];
+    "Respond or act" [shape=doublecircle];
+
+    "User command / prompt received" -> "Brain already loaded?";
+    "Brain already loaded?" -> "Load brain (Brain Load Procedure)" [label="no"];
+    "Brain already loaded?" -> "Might a mastermind skill apply?" [label="yes"];
+    "Load brain (Brain Load Procedure)" -> "Might a mastermind skill apply?";
+    "Might a mastermind skill apply?" -> "Invoke Skill() tool" [label="yes, even 1%"];
+    "Might a mastermind skill apply?" -> "Respond or act" [label="definitely not"];
+    "Invoke Skill() tool" -> "Announce: Using [skill] for [purpose]";
+    "Announce: Using [skill] for [purpose]" -> "Has checklist?" [shape=diamond];
+    "Has checklist?" -> "Create TodoWrite item per checklist step" [label="yes"];
+    "Has checklist?" -> "Execute skill exactly" [label="no"];
+    "Create TodoWrite item per checklist step" -> "Execute skill exactly";
+}
+```
+
+| Situation | Skill to invoke |
+|---|---|
+| Debug a bug, test failure, unexpected behavior | `Skill("mastermind:debug")` |
+| Verify a claim — tests pass, feature works, fix resolved | `Skill("mastermind:verify")` |
+| Write tests first, enforce Red-Green-Refactor | `Skill("mastermind:tdd")` |
+| Write a structured implementation plan (no placeholders) | `Skill("mastermind:plan")` |
+| Execute a written plan step-by-step with stop-on-blocker | `Skill("mastermind:execute")` |
+| Execute a plan via fresh subagents with 2-stage review | `Skill("mastermind:taskdev")` |
+| Design first — spec, approaches, approval gate before code | `Skill("mastermind:design")` |
+| Build a feature, fix a bug, implement anything | `Skill("mastermind:build")` |
+| Code review, content critique, strategy audit | `Skill("mastermind:review")` |
+| Receive a code review and apply it correctly | `Skill("mastermind:receive-review")` |
+| System architecture, DDD, technical design | `Skill("mastermind:architect")` |
+| Market research, competitive analysis, user insights | `Skill("mastermind:research")` |
+| Ideas, feature generation, opportunity framing | `Skill("mastermind:idea")` |
+| Marketing campaign, copy, SEO | `Skill("mastermind:marketing")` |
+| Sales outreach, proposals, pipeline | `Skill("mastermind:sales")` |
+| Blog, docs, newsletters, threads | `Skill("mastermind:content")` |
+| Versioning, changelogs, deployment | `Skill("mastermind:release")` |
+| Finish a branch — tests, options menu, merge/PR/discard | `Skill("mastermind:finish")` |
+| Workflow, process, reporting | `Skill("mastermind:ops")` |
+| Invoicing, forecasting, cost | `Skill("mastermind:finance")` |
+| Inspect or manage brain memory | `Skill("mastermind:brain")` |
+| Technical portfolio, project state assessment | `Skill("mastermind:techport")` |
+| Define/run an agent organization | `Skill("mastermind:createorg")` / `Skill("mastermind:runorg")` |
+| Review and action pending agent approval requests | `Skill("mastermind:approve")` |
+| Autonomous build + review until clean | `Skill("mastermind:autodev")` |
+| Isolate work in a git worktree | `Skill("mastermind:worktree")` |
+| Write or improve a mastermind skill | `Skill("mastermind:skill-builder")` |
+
+### Skill Execution Order
+
+When multiple skills could apply to a **single-skill invocation** (not a full mastermind:master multi-domain run):
+
+1. **Process skills first** — brainstorming (`mastermind:idea`), architecture (`mastermind:architect`), research (`mastermind:research`) determine HOW to approach the work
+2. **Execution skills second** — build, review, release execute the approach
+
+"Let's build X" → `mastermind:architect` first if approach is unclear, then `mastermind:build`.
+"Fix this" → `mastermind:research` to understand root cause if unknown, then `mastermind:build` to fix.
+"Ship it" → `mastermind:review` to verify clean, then `mastermind:release`.
+
+**Multi-domain runs (Steps 4–7 of this command):** Domain manager agents for different domains run concurrently — there is no enforced serial order between `build` and `architect` domain managers when both are active. The order above applies when you (the master) are choosing which single skill to invoke directly.
+
+### Skill Types
+
+**Rigid** (autodev, review with `--tillend`): Follow exactly. Do not skip review cycles. Do not stop early.
+
+**Flexible** (idea, research, content): Adapt principles to context. Use judgment on scope.
+
+The skill itself tells you which it is.
+
+### Anti-Drift Guards
+
+These thoughts mean **STOP** — you are rationalizing. Check for a skill first.
+
+| Thought | Reality |
+|---|---|
+| "This is just a simple task" | Simple tasks define the floor. Check for skills. |
+| "I need more context first" | Skill check comes BEFORE gathering context. |
+| "Let me explore the codebase first" | Skills tell you HOW to explore. Check first. |
+| "I can check git/files quickly before invoking a skill" | Files lack conversation context. Brain Load + skill check come first. |
+| "Let me gather information first, then I'll check" | Skills tell you HOW to gather information. Check first. |
+| "The brain isn't loaded yet — let me just answer" | Brain Load is the first step. Load it. |
+| "This doesn't need a formal skill" | If a skill exists for this domain, use it. |
+| "This doesn't count as a real task" | Action = task. Check for skills. |
+| "I remember how this works" | Skills evolve. Read current version. Always. |
+| "I know what that command does" | Knowing the concept ≠ invoking the skill. Invoke it. |
+| "The skill is overkill for this" | Small tasks become complex. Use it. |
+| "I'll just do this one thing first" | Check BEFORE doing anything. |
+| "This feels productive" | Undisciplined action creates drift. Skills prevent this. |
+| "Auto mode means I should move fast" | Speed without discipline creates drift. Use skills. |
+| "The user said --auto, so I skip confirmation" | --auto skips user confirmation. It does NOT skip skill invocation. |
+| "Spawned agents don't need to check skills" | Subagents that have Skill access MUST use it. Only subagents with the `<SUBAGENT-STOP>` gate may skip. |
+
+### Mandatory Patterns
+
+These sequences are non-negotiable in all modes:
+
+- **Before building**: Load brain → `mastermind:design` if approach is unclear → `mastermind:plan` for complex work → then build
+- **When fixing bugs**: `mastermind:debug` first (root cause) → write failing test via `mastermind:tdd` → fix → `mastermind:verify`
+- **After building**: `mastermind:review` — at minimum one pass before reporting complete
+- **Consuming a review**: `mastermind:receive-review` — verify before implementing, clarify unclear items first
+- **After any run**: Brain Write Procedure — score decisions, append to AgentDB
+- **Before releasing**: `mastermind:review --tillend --auto` → `mastermind:verify` → `mastermind:finish`
+- **Isolated work**: `mastermind:worktree` before making changes to avoid contaminating main
+
+### Platform Note
+
+This command assumes **Claude Code** as the execution environment. The `Skill` tool is the primary mechanism for loading and invoking mastermind skills — never use the Read tool on skill files directly. Skill content is loaded and injected by the harness when you call `Skill("mastermind:name")`.
+
+---
+
 **If $ARGUMENTS is empty:** Output the capability menu below and wait.
 
 ---
@@ -13,15 +164,30 @@ Describe your goal. Mastermind identifies the relevant domains, spawns specialis
 
 ---
 
+**Debug & quality**
+`/mastermind:debug` — systematic root-cause investigation before any fix attempt
+`/mastermind:verify` — confirm claims with evidence: tests pass, feature works, fix resolved
+`/mastermind:tdd` — enforce Red-Green-Refactor; no production code before failing test
+
+**Plan & execute**
+`/mastermind:design` — brainstorm, propose approaches, write approved spec before building
+`/mastermind:plan` — write a complete implementation plan (no placeholders, exact file paths)
+`/mastermind:execute` — run a written plan step-by-step with stop-on-blocker discipline
+`/mastermind:taskdev` — execute a plan via fresh subagents with two-stage per-task review
+`/mastermind:finish` — complete a branch: verify tests → options menu → merge/PR/keep/discard
+
 **Build & ship**
 `/mastermind:build` — code, features, bug fixes, test suites
 `/mastermind:architect` — system structure, DDD, deduplication, migration (`--scope review|design|deduplicate|migrate|all`)
 `/mastermind:idea` — products, features, pivots, opportunity framing
 `/mastermind:content` — blog, threads, documentation, newsletters
 
+**Review & improve**
+`/mastermind:review` — code quality, content critique, strategy audit
+`/mastermind:receive-review` — consume a code review correctly: verify, clarify, push back with evidence
+
 **Understand & decide**
 `/mastermind:research` — market intelligence, competitors, user insights
-`/mastermind:review` — code quality, content critique, strategy audit
 `/mastermind:brain` — inspect and manage business memory
 
 **Go to market & operate**
@@ -34,6 +200,13 @@ Describe your goal. Mastermind identifies the relevant domains, spawns specialis
 **Persistent agent orgs** — named teams that coordinate across sessions
 `/mastermind:createorg` — define an org: roles, hierarchy, goal
 `/mastermind:runorg` — start a saved org; boss agent assigns work to all roles
+`/mastermind:approve` — review and action pending approval requests from running org agents
+
+**Autonomous & advanced**
+`/mastermind:autodev` — research → build → review loop until clean (`--tillend` supported)
+`/mastermind:techport` — technical portfolio assessment; port capabilities from other projects
+`/mastermind:worktree` — isolate work in a git worktree safely
+`/mastermind:skill-builder` — write or improve a mastermind skill with TDD discipline
 
 ---
 Flags: `--auto` · `--confirm` · `--project <name>` · `--iterate <N>`
@@ -722,10 +895,10 @@ Log this as a decision in the cycle's output schema with `confidence` set accord
 
 #### 12c — Execute
 
-Execute the chosen activity by invoking the appropriate domain skill via the `Skill` tool (Steps 4–10 of the main flow, condensed). Use `Skill("mastermind:<domain>")` — do NOT use slash command syntax (`/<name>`), which only works in the Claude Code CLI prompt and not inside a running skill:
+Execute the chosen activity by invoking the appropriate domain skill via the `Skill` tool (Steps 4–10 of the main flow, condensed). Use `Skill("mastermind:<domain>")` — do NOT use slash command syntax (`/<name>`), which only works when typed interactively in the Claude Code CLI, not within an executing command or skill:
 
-- Test → `Skill("mastermind:build")` with a testing-focused prompt
-- Debug/Fix → `Skill("mastermind:build")` with the specific failing test or error as prompt
+- Test → `Skill("mastermind:tdd")` with the untested artifacts as prompt (enforce Red-Green-Refactor)
+- Debug/Fix → `Skill("mastermind:debug")` with the failing test or error as prompt (root-cause first, then fix)
 - Review → `Skill("mastermind:review")` with scope = artifacts from last run
 - Improve/Refactor → `Skill("mastermind:build")` with refactor prompt
 - Add feature → `Skill("mastermind:build")` with the next feature from the `next_actions` array printed by the Step 12a output above
@@ -733,9 +906,16 @@ Execute the chosen activity by invoking the appropriate domain skill via the `Sk
 - Content/Docs → `Skill("mastermind:content")` with scope = new artifacts
 - Release → `Skill("mastermind:release")` with project scope
 
-Always pass: the current brain_context, project_name (from the `project_name` field above), the relevant board_id (look up `.board_ids[<chosen_domain>]` from the `board_ids` map printed above), and mode = auto (iteration cycles never pause for confirmation).
+Always pass: the current brain_context, project_name (from the `project_name` field above), the relevant board_id, and mode = auto (iteration cycles never pause for confirmation).
+
+**Board ID lookup per activity:**
+- `tdd`, `debug`, `Improve/Refactor`, `Add feature` → use `board_ids['build']` (these are build-domain activities)
+- `review` → use `board_ids['review']`; fallback to `board_ids['build']` if not present
+- `research` → use `board_ids['research']`; fallback to `board_ids['build']`
+- `content` → use `board_ids['content']`; fallback to `board_ids['build']`
+- `release` → use `board_ids['release']`; fallback to `board_ids['build']`
 
-**Constraint:** Only invoke domains whose board_id already exists in the `board_ids` map. If the chosen activity maps to a domain not in `board_ids` (e.g. `release` was not activated in Step 6), choose the next highest-priority activity whose domain IS in `board_ids`, or invoke `build` as the safe fallback — its board is almost always present.
+**Constraint:** Only invoke a skill whose domain board_id exists in the `board_ids` map. If `board_ids['build']` is missing (rare), skip to the next activity whose board IS present. `build` is almost always present.
 
 #### 12d — Brain Write
 

package/.claude/commands/mastermind/memory.md

@@ -0,0 +1,230 @@
+---
+name: mastermind-memory
+description: AgentDB memory system — store, search, retrieve, list, delete, and manage cross-session persistent memory with vector embeddings
+---
+
+# Monomind Memory System
+
+Persistent memory backed by AgentDB with HNSW vector indexing for semantic search (150x-12,500x faster than brute-force). Supports cross-session and cross-agent collaboration.
+
+## Subcommands
+
+| Subcommand | Alias | Description |
+|---|---|---|
+| `init` | — | Initialize memory database (sql.js + AgentDB) |
+| `store` | — | Store a key/value entry |
+| `edit` | — | Edit an existing entry |
+| `retrieve` | `get` | Retrieve entry by key |
+| `search` | — | Semantic/vector search |
+| `list` | `ls` | List memory entries |
+| `delete` | `rm` | Delete an entry |
+| `templates` | — | Show best-practice entry templates |
+| `stats` | — | Show memory statistics |
+| `configure` | `config` | Configure memory backend |
+| `cleanup` | — | Clean expired/stale entries |
+| `compress` | — | Compress and optimize storage |
+| `export` | — | Export memory to file |
+| `import` | — | Import memory from file |
+
+## init — Initialize Database
+
+```bash
+npx monomind memory init
+npx monomind memory init --backend agentdb --verbose --verify
+npx monomind memory init --force  # Overwrite existing
+```
+
+**Flags:** `--backend hybrid|sqlite|agentdb` (default: `hybrid`), `--path`, `--force`, `--verbose`, `--verify` (default: true), `--load-embeddings`
+
+## store — Store Data
+
+```bash
+# Store with specific namespace
+npx monomind memory store --key "arch/api-design" --value "RESTful microservices" --namespace arch
+
+# With tags and TTL
+npx monomind memory store --key "pattern/auth" --value "JWT + refresh tokens" --namespace patterns --tags "auth,security" --ttl 86400
+
+# Upsert (update if exists)
+npx monomind memory store --key "bug/null-check" --value "Fixed null check in parser" --upsert
+```
+
+**Flags:**
+
+| Flag | Short | Default | Description |
+|---|---|---|---|
+| `--key` | `-k` | — | Storage key (required) |
+| `--value` | — | — | Value to store (required) |
+| `--namespace` | `-n` | `default` | Memory namespace |
+| `--ttl` | — | — | Time to live in seconds |
+| `--tags` | — | — | Comma-separated tags |
+| `--vector` | — | `false` | Store as vector embedding |
+| `--upsert` | `-u` | `false` | Update if key exists |
+
+## search — Semantic Search
+
+```bash
+# Semantic search (default)
+npx monomind memory search --query "authentication patterns"
+
+# Keyword search
+npx monomind memory search --query "JWT" --type keyword
+
+# Hybrid search with namespace filter
+npx monomind memory search --query "error handling" --namespace patterns --limit 5
+
+# Build HNSW index first for max speed
+npx monomind memory search --query "API design" --build-hnsw
+```
+
+**Flags:**
+
+| Flag | Short | Default | Description |
+|---|---|---|---|
+| `--query` | `-q` | — | Search query (required) |
+| `--namespace` | `-n` | all | Filter by namespace |
+| `--limit` | `-l` | `10` | Maximum results |
+| `--threshold` | — | `0.7` | Similarity threshold (0-1) |
+| `--type` | `-t` | `semantic` | `semantic`, `keyword`, `hybrid` |
+| `--build-hnsw` | — | `false` | Rebuild HNSW index before search |
+
+## retrieve — Get by Key
+
+```bash
+npx monomind memory retrieve --key "arch/api-design"
+npx monomind memory retrieve --key "pattern/auth" --namespace patterns
+```
+
+**Flags:** `--key/-k` (required), `--namespace/-n` (default: `default`)
+
+## list — Browse Entries
+
+```bash
+npx monomind memory list
+npx monomind memory list --namespace patterns --limit 20
+```
+
+**Flags:** `--namespace/-n`, `--limit/-l` (default: `20`)
+
+## delete — Remove Entry
+
+```bash
+npx monomind memory delete --key "old-pattern"
+npx monomind memory delete --key "temp-key" --namespace temp --force
+```
+
+**Flags:** `--key/-k` (required), `--namespace/-n` (default: `default`), `--force/-f` (skip confirmation)
+
+## templates — Entry Templates
+
+```bash
+npx monomind memory templates
+npx monomind memory templates --type feedback
+```
+
+Types: `user`, `feedback`, `project`, `reference` — scaffolds for the auto-memory format.
+
+## stats — Storage Overview
+
+```bash
+npx monomind memory stats
+```
+
+Shows backend, total entries, storage size, oldest/newest entry.
+
+## configure — Backend Settings
+
+```bash
+npx monomind memory configure --backend agentdb
+npx monomind memory configure --backend hybrid --cache-size 512 --hnsw-m 16 --hnsw-ef 200
+```
+
+**Flags:** `--backend/-b`, `--path`, `--cache-size`, `--hnsw-m`, `--hnsw-ef`
+
+## cleanup — Remove Stale Entries
+
+```bash
+# Preview without deleting
+npx monomind memory cleanup --dry-run
+
+# Delete entries older than 30 days
+npx monomind memory cleanup --older-than 30d
+
+# Remove expired TTL entries only
+npx monomind memory cleanup --expired-only
+
+# Clean specific namespace
+npx monomind memory cleanup --namespace temp --older-than 7d --force
+```
+
+**Flags:** `--dry-run/-d`, `--older-than/-o` (e.g., `7d`, `30d`), `--expired-only/-e`, `--namespace/-n`, `--force/-f`
+
+## compress — Optimize Storage
+
+```bash
+npx monomind memory compress
+npx monomind memory compress --quantize --bits 4  # 32x size reduction
+npx monomind memory compress --level max --target vectors
+```
+
+**Flags:** `--level fast|balanced|max` (default: `balanced`), `--target vectors|text|patterns|all`, `--quantize/-z`, `--bits 4|8|16`, `--rebuild-index/-r` (default: true)
+
+## export / import
+
+```bash
+# Export all to JSON
+npx monomind memory export --output ./backup.json
+
+# Export specific namespace to CSV
+npx monomind memory export --output ./patterns.csv --format csv --namespace patterns
+
+# Import
+npx monomind memory import --input ./backup.json
+npx monomind memory import --input ./backup.json --namespace archive
+```
+
+## Namespaces
+
+`default`, `agents`, `tasks`, `sessions`, `swarm`, `project`, `spec`, `arch`, `impl`, `test`, `debug`, `patterns`, `solutions`
+
+## MCP Tools
+
+```javascript
+// Store
+mcp__monomind__memory_store({ key: "pattern/auth", value: "JWT + refresh", namespace: "patterns" })
+
+// Search
+mcp__monomind__memory_search({ query: "authentication", namespace: "patterns" })
+
+// Retrieve
+mcp__monomind__memory_retrieve({ key: "pattern/auth", namespace: "patterns" })
+
+// List
+mcp__monomind__memory_list({ namespace: "patterns" })
+
+// Delete
+mcp__monomind__memory_delete({ key: "pattern/auth", namespace: "patterns" })
+
+// Stats
+mcp__monomind__memory_stats({})
+```
+
+## Common Workflows
+
+### Store successful pattern after completing a task
+
+```bash
+npx monomind memory store --key "pattern/oauth-integration" --value "Use PKCE flow, store tokens in httpOnly cookies" --namespace patterns --tags "auth,oauth"
+```
+
+### Search before starting a task
+
+```bash
+npx monomind memory search --query "OAuth integration patterns" --namespace patterns --limit 5
+```
+
+### Backup before major refactor
+
+```bash
+npx monomind memory export --output "./backups/memory-$(date +%Y%m%d).json"
+```

package/.claude/commands/mastermind/plan.md

@@ -0,0 +1,26 @@
+---
+name: mastermind-plan
+description: Write a comprehensive implementation plan from a spec or requirements. Saves to docs/mastermind/plans/. Default mode: confirm.
+---
+
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-prompt check and intake below.
+
+Parse `$ARGUMENTS` for:
+- `--auto` flag → mode = auto
+- `--confirm` flag → mode = confirm
+- `--project <name>` → project_name = <name>
+- Remaining text = spec description or path to spec file
+
+If spec is empty: ask "What would you like a plan for? (provide a spec, requirements, or feature description)"
+
+Load brain context (follow `_protocol.md` Brain Load Procedure).
+
+Default mode: **confirm** (unless `--auto` flag is present).
+
+---
+
+Invoke `Skill("mastermind:plan")` passing: brain_context, params, project_name, mode.
+
+After skill returns: follow `_protocol.md` Brain Write Procedure.
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/.claude/commands/mastermind/receive-review.md

@@ -0,0 +1,20 @@
+---
+name: mastermind-receive-review
+description: Use when receiving code review feedback to evaluate and implement it with technical rigor — verifies before implementing, clarifies unclear items first, applies reasoned pushback when warranted
+---
+
+**First — extract repeat flags:** Follow REPEAT PREAMBLE from `_repeat.md`.
+
+Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text.
+
+Load brain context (follow `_protocol.md` Brain Load Procedure).
+
+Default mode: **confirm**.
+
+---
+
+Invoke `Skill("mastermind:receive-review")` passing: brain_context, params, mode.
+
+After skill returns: follow `_protocol.md` Brain Write Procedure.
+
+Invoke `Skill("mastermind:_repeat")` now. Required — do not skip.