@monoes/monomindcli 2.10.10 → 2.10.14

package/.claude/commands/mastermind/brain.md

@@ -1,4 +1,4 @@
-<!-- Mastermind brain management — inspect, compact, refresh, and control the three-tier business memory (LanceDB + Monograph) -->
+<!-- Mastermind brain management — inspect, compact, refresh, and control the three-tier business memory (memory store + Monograph) -->
 
 **First — extract repeat flags:** Follow the REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing.
 
@@ -11,9 +11,9 @@ Parse `$ARGUMENTS` to determine the sub-command and flags.
 Show the current state of all brain tiers across all domains.
 
 For each domain that has data, call:
-- `mcp__monomind__lancedb_health` on namespace `mastermind:<domain>:raw` → Tier 1 entry count, last write date, archived count
-- `mcp__monomind__lancedb_health` on namespace `mastermind:<domain>:weekly` → Tier 2 summary count, last compaction date
-- `mcp__monomind__lancedb_health` on namespace `mastermind:principles` → Tier 3 principle count
+- `mcp__monomind__memory_health` on namespace `mastermind:<domain>:raw` → Tier 1 entry count, last write date, archived count
+- `mcp__monomind__memory_health` on namespace `mastermind:<domain>:weekly` → Tier 2 summary count, last compaction date
+- `mcp__monomind__memory_health` on namespace `mastermind:principles` → Tier 3 principle count
 
 Display as a table:
 
@@ -39,9 +39,9 @@ Avg memory score: 0.64 | Entries below archive threshold: 3
 Force immediate weekly distillation across all domains (or `--domain <name>` for one domain).
 
 For each domain (or the specified domain):
-1. Retrieve all Tier 1 raw entries since last compaction via `mcp__monomind__lancedb_hierarchical-recall` (namespace `mastermind:<domain>:raw`)
+1. Retrieve all Tier 1 raw entries since last compaction via `mcp__monomind__memory_hierarchical-recall` (namespace `mastermind:<domain>:raw`)
 2. Produce per-domain weekly summary: synthesize decisions, patterns, and lessons into ≤300 words
-3. Store to Tier 2 via `mcp__monomind__lancedb_hierarchical-store` (namespace `mastermind:<domain>:weekly`)
+3. Store to Tier 2 via `mcp__monomind__memory_hierarchical-store` (namespace `mastermind:<domain>:weekly`)
 4. Archive Tier 1 entries with score < 0.1 (update metadata: `{ archived: true }`)
 5. Report: "Compacted <domain>: <N> entries → <M> summary, <K> archived"
 
@@ -53,8 +53,8 @@ Re-cluster the knowledge graph for a specific domain and rebuild Tier 3 principl
 
 1. Call `mcp__monomind__monograph_community` for nodes matching `mastermind:<domain>`
 2. For any cluster of 3+ similar nodes: merge into a single principle (LLM synthesis)
-3. Store merged principle: `mcp__monomind__lancedb_hierarchical-store` namespace `mastermind:principles`
-4. For conflicting nodes: add `EXCEPTION` edge via `mcp__monomind__monograph_add_fact`
+3. Store merged principle: `mcp__monomind__memory_hierarchical-store` namespace `mastermind:principles`
+4. For conflicting nodes: add the exception relation via `mcp__monomind__memory_kg_ingest`
 5. Report: "Refreshed <domain>: <N> clusters found, <M> principles updated, <K> exceptions noted"
 
 ---
@@ -63,9 +63,9 @@ Re-cluster the knowledge graph for a specific domain and rebuild Tier 3 principl
 
 Show raw contents of a specific brain tier.
 
-- Tier 1: Call `mcp__monomind__lancedb_hierarchical-recall` on `mastermind:<domain>:raw`, display each entry with its score and date.
-- Tier 2: Call `mcp__monomind__lancedb_hierarchical-recall` on `mastermind:<domain>:weekly`, display summaries with dates.
-- Tier 3: Call `mcp__monomind__lancedb_hierarchical-recall` on `mastermind:principles`, display all principles.
+- Tier 1: Call `mcp__monomind__memory_hierarchical-recall` on `mastermind:<domain>:raw`, display each entry with its score and date.
+- Tier 2: Call `mcp__monomind__memory_hierarchical-recall` on `mastermind:<domain>:weekly`, display summaries with dates.
+- Tier 3: Call `mcp__monomind__memory_hierarchical-recall` on `mastermind:principles`, display all principles.
 
 Default limit: 10. Use `--limit N` to override.
 
@@ -75,7 +75,7 @@ Default limit: 10. Use `--limit N` to override.
 
 Find and archive all brain entries semantically matching the query.
 
-1. Call `mcp__monomind__lancedb_pattern-search` with query text across all mastermind namespaces
+1. Call `mcp__monomind__memory_pattern-search` with query text across all mastermind namespaces
 2. Display matching entries with their scores and domains
 3. Ask: "Archive these N entries? (yes/no)"
 4. If yes: update each entry's metadata to `{ archived: true }`
@@ -88,8 +88,8 @@ Find and archive all brain entries semantically matching the query.
 **Destructive.** Wipes all brain data for a specific domain. Requires `--confirm` flag explicitly — refuse if missing.
 
 If `--confirm` is present:
-1. Delete all Tier 1 entries: `mcp__monomind__memory_delete` on namespace `mastermind:<domain>:raw`
-2. Delete all Tier 2 entries: `mcp__monomind__memory_delete` on namespace `mastermind:<domain>:weekly`
+1. Delete all Tier 1 entries: `npx monomind@latest memory delete --namespace mastermind:<domain>:raw`
+2. Delete all Tier 2 entries: `npx monomind@latest memory delete --namespace mastermind:<domain>:weekly`
 3. Remove domain nodes from Monograph graph
 4. Report: "Reset complete for domain <name>. All memory wiped."
 

package/.claude/commands/mastermind/help.md

@@ -119,8 +119,8 @@ mcp__monomind__monograph_suggest({ task: "..." })
 mcp__monomind__monograph_query({ query: "..." })
 
 // Swarm
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
-mcp__monomind__swarm_status({})
+mcp__monomind__monoswarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
+mcp__monomind__monoswarm_status({})
 
 // System
 mcp__monomind__system_health({})

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

@@ -91,19 +91,19 @@ digraph mastermind_routing {
 | 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")` |
+| Verify a claim — tests pass, feature works, fix resolved | `Skill("mastermind-review")` |
+| Write tests first, enforce Red-Green-Refactor | `Skill("mastermind-debug")` (Phase 4 covers the failing-test-first loop) |
 | 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")` |
-| Fix or investigate 2+ independent problems concurrently (different files, subsystems, or bugs) | dispatch parallel subagents in one message — one per independent domain; use `Skill("mastermind-taskdev")` for plan-driven parallel work |
+| Execute a plan via fresh subagents with 2-stage review | `Skill("mastermind-execute")` |
+| Fix or investigate 2+ independent problems concurrently (different files, subsystems, or bugs) | dispatch parallel subagents in one message — one per independent domain; use `Skill("mastermind-execute")` for plan-driven parallel work |
 | Ingest a prompt/spec/folder and generate agent-optimized tasks | `Skill("mastermind-createtask")` |
 | Execute tasks from a task file or monotask board (parallel/sequential/minimal modes, review cycles, loop) | `Skill("mastermind-do")` |
 | Design first — spec, approaches, approval gate before code | `Skill("mastermind-design")` |
-| Build a feature, fix a bug, implement anything | `Skill("mastermind-build")` |
+| Build a feature, fix a bug, implement anything | `Skill("mastermind-plan")` then `Skill("mastermind-execute")` |
 | 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")` |
+| System architecture, DDD, technical design | `Skill("mastermind-design")` |
 | Market research, competitive analysis, user insights | `Skill("mastermind-research")` |
 | Ideas, feature generation, opportunity framing | `Skill("mastermind-idea")` |
 | Research ideas, evaluate with PM lens, decompose into subtasks | `Skill("mastermind-ideate")` |
@@ -112,14 +112,13 @@ digraph mastermind_routing {
 | 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")` |
+| Finish a branch — tests, options menu, merge/PR/discard | `Skill("mastermind-review")` |
 | 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-approvev1")` (v1 orgs only — v2 approvals arrive in the dashboard Human Input tab) |
-| Autonomous build + review until clean | `Skill("mastermind-autodev")` |
+| Autonomous build + review until clean | `Skill("mastermind-execute")` |
 | Isolate work in a git worktree | `Skill("mastermind-worktree")` |
 | Write or improve a mastermind skill | `Skill("mastermind-skill-builder")` |
 
@@ -182,7 +181,7 @@ These sequences are non-negotiable in all modes:
 - **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 LanceDB
+- **After any run**: Brain Write Procedure — score decisions, append to the memory store
 - **Before releasing**: `mastermind:review --tillend --auto` → `mastermind:verify` → `mastermind:finish`
 - **Isolated work**: `mastermind:worktree` before making changes to avoid contaminating main
 - **Before claiming complete**: Run `mastermind:verify` — never claim completion based on agent reports, linter passes, or partial checks
@@ -292,8 +291,8 @@ project_name="${project_name:-$(basename "$PWD")}"
 
 Follow the Brain Load Procedure from `mastermind-protocol/SKILL.md`:
 
-1. Call `mcp__monomind__lancedb_hierarchical-recall` namespace `mastermind:principles` (limit 20)
-2. For each domain that appears relevant to the prompt, call `mcp__monomind__lancedb_context-synthesize` namespace `mastermind:<domain>:weekly`
+1. Call `mcp__monomind__memory_hierarchical-recall` namespace `mastermind:principles` (limit 20)
+2. For each domain that appears relevant to the prompt, call `mcp__monomind__memory_context-synthesize` namespace `mastermind:<domain>:weekly`
 3. Call `mcp__monomind__monograph_query` with 3-5 keywords from the prompt
 
 Assemble the BRAIN CONTEXT block from results.
@@ -658,9 +657,15 @@ pick_domain_manager() {
        | {name: .name,
           score: (
             (.name | ascii_downcase) as $n |
-            # Score on ANY keyword match, not just the first
+            (.description // "" | ascii_downcase) as $desc |
+            # Score keyword matches against both name (weight 2) and description (weight 1) —
+            # name match is a stronger signal. Bind each word to $w before contains(): piping
+            # into contains(.) rebinds "." to the piped value, which would silently match everything.
             (if ($kw | length) > 0
-             then ([$kw | split(" ")[] | select(length > 0) | if ($n | contains(.)) then 1 else 0 end] | add // 0)
+             then ([$kw | split(" ")[] | select(length > 0) | . as $w |
+                    (if ($n | contains($w)) then 2 else 0 end) +
+                    (if ($desc | contains($w)) then 1 else 0 end)
+                   ] | add // 0)
              else 0 end) +
             (if $n | test("manager|director|coordinator") then 1 else 0 end)
           )}
@@ -761,7 +766,7 @@ Each Task call must include a complete briefing following the Monotask Task Brie
 - Instruction to create monotask cards directly using `monotask card create $BOARD_ID $COL_TODO_ID "<title>" --json` for all sub-tasks
 - Instruction to use `Skill("mastermind-do")` to execute tasks (Task agents have Skill tool access — do NOT use slash command syntax)
 - Instruction to spawn specialized agents using the domain-appropriate swarm topology
-- **For the `build` domain only:** include `build_exec_mode` (value: `"taskdev"` or `"execute"`) and instruct the manager: "Use `Skill("mastermind-taskdev")` if build_exec_mode is `taskdev`, or `Skill("mastermind-execute")` if `execute`. This was resolved in the Step 3.6 Plan Gate (or Step 5)." If `build_plan` is set in `current.json`, include the plan path and instruct the manager to execute THAT plan task-by-task rather than re-deriving tasks from the goal.
+- **For the `build` domain only:** instruct the manager: "Use `Skill("mastermind-execute")`. This was resolved in the Step 3.6 Plan Gate (or Step 5)." If `build_plan` is set in `current.json`, include the plan path and instruct the manager to execute THAT plan task-by-task rather than re-deriving tasks from the goal.
 - Instruction to return the unified output schema when done
 
 Example Task call for Development Manager. Substitute all **pre-known** `<…>` placeholders (project_name, SESSION_ID, board/col IDs, goals, manager name) before calling Task. Placeholders like `<status>`, `<path1>`, `<action1>` are filled at runtime by the spawned agent — do not attempt to substitute them. `subagent_type` is the **string value** of `$domain_manager_build` (e.g. `"Backend Architect"`), not a variable reference.
@@ -931,7 +936,7 @@ Monotask boards:
 
 Follow the Brain Write Procedure from `mastermind-protocol/SKILL.md` for each domain that ran:
 1. Score all decisions from this run
-2. Append to Tier 1 raw log (LanceDB)
+2. Append to Tier 1 raw log (the memory store)
 3. Check and trigger weekly compaction if threshold met
 4. Check and trigger graph consolidation if cluster detected
 
@@ -1085,11 +1090,11 @@ Log this as a decision in the cycle's output schema with `confidence` set accord
 
 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-tdd")` with the untested artifacts as prompt (enforce Red-Green-Refactor)
+- Test → `Skill("mastermind-debug")` Phase 4 with the untested artifacts as prompt (write the failing test first, 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
+- Improve/Refactor → `Skill("mastermind-plan")` then `Skill("mastermind-execute")` with refactor prompt
+- Add feature → `Skill("mastermind-plan")` then `Skill("mastermind-execute")` with the next feature from the `next_actions` array printed by the Step 12a output above
 - Research → `Skill("mastermind-research")` with the open question as prompt
 - Content/Docs → `Skill("mastermind-content")` with scope = new artifacts
 - Release → `Skill("mastermind-release")` with project scope

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

@@ -193,17 +193,17 @@ mcp__monomind__memory_pattern-store({ key: "pattern/auth", value: "JWT + refresh
 // Search
 mcp__monomind__memory_pattern-search({ query: "authentication", namespace: "patterns" })
 
-// Retrieve
-mcp__monomind__memory_retrieve({ key: "pattern/auth", namespace: "patterns" })
+// Retrieve (CLI only — no MCP tool)
+// npx monomind@latest memory retrieve --key "pattern/auth" --namespace patterns
 
-// List
-mcp__monomind__memory_list({ namespace: "patterns" })
+// List (CLI only — no MCP tool)
+// npx monomind@latest memory list --namespace patterns
 
-// Delete
-mcp__monomind__memory_delete({ key: "pattern/auth", namespace: "patterns" })
+// Delete (CLI only — no MCP tool)
+// npx monomind@latest memory delete --key "pattern/auth" --namespace patterns
 
-// Stats
-mcp__monomind__memory_stats({})
+// Stats (CLI only — no MCP tool)
+// npx monomind@latest memory stats
 ```
 
 ## Common Workflows

package/.claude/commands/mastermind/monoswarm.md

@@ -113,16 +113,16 @@ npx monomind monoswarm scale swarm-abc123 --agents 8 --type coder
 
 ```javascript
 // Initialize swarm
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
+mcp__monomind__monoswarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
 
 // Check status
-mcp__monomind__swarm_status({})
+mcp__monomind__monoswarm_status({})
 
 // Health check
-mcp__monomind__swarm_health({})
+mcp__monomind__monoswarm_health({})
 
 // Shutdown swarm
-mcp__monomind__swarm_shutdown({})
+mcp__monomind__monoswarm_shutdown({})
 ```
 
 ## Agent Team Routing

package/.claude/commands/mastermind.md

@@ -47,14 +47,14 @@ Match the intent against this catalog. Pick ONE primary route, plus supporting s
 | Intent | Primary route |
 |---|---|
 | Fix a bug, test failure, unexpected behavior | `Skill("mastermind-debug")` → root cause first, then fix |
-| Build a feature / implement anything | `Skill("mastermind-design")` → spec, then `Skill("mastermind-build")` |
-| Plan before coding | `Skill("mastermind-plan")` (write) / `Skill("mastermind-execute")` or `Skill("mastermind-taskdev")` (run) |
-| TDD workflow | `Skill("mastermind-tdd")` |
-| Refactor / architecture / DDD / dedup | `Skill("mastermind-architect")` |
+| Build a feature / implement anything | `Skill("mastermind-design")` → spec, then `Skill("mastermind-plan")` → `Skill("mastermind-execute")` |
+| Plan before coding | `Skill("mastermind-plan")` (write) / `Skill("mastermind-execute")` (run) |
+| TDD workflow | `Skill("mastermind-debug")` (Phase 4 covers the failing-test-first loop) |
+| Refactor / architecture / DDD / dedup | `Skill("mastermind-design")` |
 | Code review, audit quality | `Skill("mastermind-review")`; apply one received: `Skill("mastermind-receive-review")` |
-| Verify a claim ("it works", "tests pass") | `Skill("mastermind-verify")` |
-| Autonomous improve-loop | `Skill("mastermind-autodev")` (`--tillend` for until-clean) |
-| Finish/merge/PR a branch | `Skill("mastermind-finish")`; release/versioning: `Skill("mastermind-release")` |
+| Verify a claim ("it works", "tests pass") | `Skill("mastermind-review")` |
+| Autonomous improve-loop | `Skill("mastermind-execute")`, re-invoking `Skill("mastermind-review")` between passes until clean |
+| Finish/merge/PR a branch | `Skill("mastermind-review")`; release/versioning: `Skill("mastermind-release")` |
 | Isolate risky work | `Skill("mastermind-worktree")` |
 | Spec → agent task file/board | `Skill("mastermind-createtask")`, execute with `Skill("mastermind-do")` |
 

package/.claude/commands/truth/start.md

@@ -74,8 +74,8 @@ mcp__monomind__hooks_intelligence_stats({})
 mcp__monomind__task_summary({})
 mcp__monomind__progress_summary({})
 
-// LanceDB health (memory integrity)
-mcp__monomind__lancedb_health({})
+// Memory store health (memory integrity)
+mcp__monomind__memory_health({})
 ```
 
 ### Performance
@@ -105,7 +105,7 @@ When invoked, run these checks in parallel:
 mcp__monomind__system_health({})
 mcp__monomind__agent_health({})
 mcp__monomind__neural_status({ verbose: true })
-mcp__monomind__lancedb_health({})
+mcp__monomind__memory_health({})
 mcp__monomind__performance_report({ format: "detailed" })
 ```
 

package/.claude/helpers/handlers/gates-handler.cjs

@@ -18,7 +18,19 @@
 
 const fs = require('fs');
 const path = require('path');
-const { appendAuditEvent } = require('../audit-log-writer.cjs');
+// Audit logging must never be able to take the gates down with it. This
+// handler runs inside hook-handler.cjs's fail-closed PreToolUse path, so a
+// throw at module load — MODULE_NOT_FOUND when audit-log-writer.cjs is absent
+// (issue #225) — blocked every Bash and Write call for the rest of the
+// session, including the write that would have restored the file. The gate
+// decisions themselves do not depend on the audit log, so degrade to a no-op
+// writer and keep enforcing them.
+let appendAuditEvent;
+try {
+  ({ appendAuditEvent } = require('../audit-log-writer.cjs'));
+} catch {
+  appendAuditEvent = () => {};
+}
 
 // ─── monofence-ai integration (additional layer on top of regex gates) ───────
 //

package/.claude/skills/mastermind/SKILL.md

@@ -7,30 +7,21 @@ description: Use when a request may need a Mastermind workflow such as planning,
 
 Load only the workflow that matches the request:
 
+- `mastermind-idea` to shape a raw prompt into a stated problem and options.
+- `mastermind-design` before building a feature — this is a gate, not a suggestion.
 - `mastermind-plan` before multi-file implementation.
+- `mastermind-execute` for a written plan.
 - `mastermind-review` for audits and critiques.
 - `mastermind-debug` for failures or unexpected behavior.
 - `mastermind-research` for open questions.
-- `mastermind-execute` for a written plan.
 - `mastermind-org` for organization lifecycle work.
 - `mastermind-memory` for persistent knowledge.
 
+**For build/feature work, the gates are mandatory and ordered:** idea → design → plan →
+execute → review. The full routing table for the other 20+ Mastermind workflows lives in
+`.claude/commands/mastermind-master.md`; consult it before concluding that no workflow applies.
+
 Use Monograph before broad repository search when the platform exposes the
 Monomind MCP server. Without native skills, run
 `monomind mastermind run <skill> --print` and follow the printed procedure.
 Platform tool mappings are in [references/](references/).
-# monomind:start skills:claude:mastermind
-# Mastermind
-
-Load only the workflow that matches the current task:
-- `mastermind` — Route a request to the relevant Mastermind workflow.
-- `mastermind-plan` — Write a detailed implementation plan before changing code.
-- `mastermind-review` — Review code, content, strategy, or security work.
-- `mastermind-debug` — Investigate a failure or unexpected behavior before fixing it.
-- `mastermind-research` — Research an open question before making a decision.
-- `mastermind-execute` — Execute a written implementation plan step by step.
-- `mastermind-org` — Create, run, inspect, and manage a Mastermind organization.
-- `mastermind-memory` — Store, retrieve, and maintain persistent organization knowledge.
-
-If skills cannot be loaded natively, run `monomind mastermind run <skill> --print`.
-# monomind:end skills:claude:mastermind

package/.claude/skills/mastermind-debug/SKILL.md

@@ -157,7 +157,7 @@ Once you understand WHERE the break is, find existing working examples:
 
 1. **Write a failing test first** (before touching production code)
    - Automated test where possible; a one-off test script if no framework
-   - Use `Skill("mastermind-tdd")` for writing proper failing tests
+   - Write the test so it fails for the stated root cause, not for a setup error
    - The test MUST fail before the fix proves it
 
 2. **Implement a single fix**
@@ -266,8 +266,8 @@ If systematic investigation reveals the issue is truly environmental, timing-dep
 - **Condition-based waiting:** replace arbitrary sleeps/timeouts in flaky tests and scripts with polling for the actual condition ("wait until the file exists / the port answers"), with a hard cap. Timing guesses are bugs waiting for a slower machine.
 
 **Related skills:**
-- `Skill("mastermind-tdd")` — for creating the failing test case (Phase 4, Step 1)
-- `Skill("mastermind-verify")` — verify the fix worked before claiming success
+- `Skill("mastermind-review")` — verify the fix worked before claiming success
+- `Skill("mastermind-plan")` — when the root cause turns out to need a multi-file change
 
 ## Impact
 

package/.claude/skills/mastermind-design/SKILL.md

@@ -79,6 +79,7 @@ Invoke Skill("mastermind-plan")  ← TERMINAL STATE
 ### Understanding the idea
 
 - Check current project state first (files, docs, recent commits)
+- Check `brain_context` for relevant prior decisions, lessons, or patterns for this domain/project before drafting questions — if it surfaces something relevant (a past constraint, a lesson from a similar feature, a decision already made), say so to the user and let it steer which questions actually need asking. Do not silently re-ask what's already answered in `brain_context`.
 - Before asking detailed questions, assess scope: if the request describes multiple independent subsystems, flag this immediately. Don't spend questions refining details of a project that needs to be decomposed first.
 - If too large for a single spec, help the user decompose into sub-projects: what are the independent pieces, how do they relate, what order to build? Then design the first sub-project through the normal flow. Each sub-project gets its own spec → plan → implementation cycle.
 - For appropriately-scoped projects, ask questions one at a time
@@ -88,6 +89,7 @@ Invoke Skill("mastermind-plan")  ← TERMINAL STATE
 
 ### Exploring approaches
 
+- Check `brain_context` for approaches tried (and their outcomes) on similar past work before proposing new ones — prefer what worked, flag what didn't, and say when a proposed approach is informed by recalled history
 - Propose 2-3 different approaches with trade-offs
 - Present options conversationally with your recommendation and reasoning
 - Lead with the recommended option and explain why

package/.claude/skills/mastermind-execute/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: mastermind-execute
-description: Load a written implementation plan, review it critically, execute all tasks step by step, and hand off to mastermind:finish when complete.
+description: Load a written implementation plan, review it critically, execute all tasks step by step, and hand off to mastermind:review when complete.
 type: domain-skill
 default_mode: confirm
 ---
@@ -11,7 +11,7 @@ Load plan, review critically, execute all tasks, report when complete.
 
 **Announce at start:** "I'm using the mastermind:execute skill to implement this plan."
 
-**Note:** This skill works best with subagent support (Claude Code). When subagents are available, prefer `Skill("mastermind-taskdev")` for parallel task execution.
+**Note:** This skill works best with subagent support (Claude Code). When subagents are available, dispatch one subagent per independent task in a single message.
 
 ---
 
@@ -47,18 +47,43 @@ For each task in the plan:
 3. Run verifications as specified in the plan
 4. Mark as `completed`
 
+**Dispatching subagents (when available):** when independent tasks can run in parallel, dispatch one subagent per task in a single message via the Task tool. Each subagent starts with no memory of this session — embed the plan step and the `brain_context` received in Inputs directly in its prompt so it has the same grounding this skill was given.
+
+**CRITICAL — variable substitution required:** before constructing the Task prompt, replace `${brain_context}` and `${project_name}` below with their actual literal values (the BRAIN CONTEXT block from Inputs, and the project name) — an unsubstituted `${brain_context}` placeholder means the subagent executes blind to prior decisions and constraints. This is the same substitution discipline `mastermind-idea/SKILL.md` uses for its Task prompts.
+
+```javascript
+Task({
+  subagent_type: "coder", // pick per task, per the plan's agent recommendation
+  description: "<task title from plan>",
+  run_in_background: false, // true only when running independently alongside other parallel tasks
+  prompt: `You are executing one task from an implementation plan for project "${project_name}".
+
+BRAIN CONTEXT:
+${brain_context}
+
+TASK: <task title>
+STEPS:
+<verbatim bite-sized steps for this task from the plan>
+
+VERIFICATION:
+<verification command(s) from the plan>
+
+Follow the steps exactly — do not skip, reorder, or invent steps not listed. Run the verification before reporting done.`
+})
+```
+
 When the plan references skills:
-- `mastermind:taskdev` → invoke `Skill("mastermind-taskdev")`
-- `mastermind:verify` → invoke `Skill("mastermind-verify")`
+- `mastermind:taskdev` → this skill; continue inline (no separate taskdev skill exists)
+- `mastermind:verify` → invoke `Skill("mastermind-review")`
 - Any other `mastermind:*` skill → invoke `Skill("mastermind-<name>")`
 
 ### Step 3: Complete Development
 
 After all tasks complete and are verified:
 
-- Announce: "All tasks complete. Handing off to mastermind:finish."
-- **REQUIRED SUB-SKILL:** invoke `Skill("mastermind-finish")`
-- Follow that skill to verify tests, present options, and execute the chosen finish action
+- Announce: "All tasks complete. Handing off to mastermind:review."
+- **REQUIRED SUB-SKILL:** invoke `Skill("mastermind-review")`
+- Follow that skill to verify the work before any merge, PR, or release step
 
 ---
 
@@ -72,6 +97,37 @@ After all tasks complete and are verified:
 
 **Ask for clarification rather than guessing.** Never invent steps not in the plan.
 
+**Required stop-report format.** When any condition above fires, report using this exact structure — never just "I'm stuck" or a bare "please advise":
+
+```
+STOP — <one-line description of what blocked>
+
+Task:      <the specific plan task/step that stopped, e.g. "Task 3: Add rate limiter">
+Tried:     <what was actually attempted — commands run, files checked, approaches tried — not just "it failed">
+Result:    <the actual error, output, or contradiction observed>
+Need:      <the exact decision or input required to unblock — a choice between named options,
+           a missing value, or explicit permission for a specific next step>
+```
+
+Example:
+
+```
+STOP — verification fails repeatedly on Task 3
+
+Task:      Task 3: Add rate limiter to /api/upload
+Tried:     Ran `npm test -- rate-limiter.test.ts` 3x after adding express-rate-limit
+           middleware per plan step 3.2. Confirmed middleware order matches the plan.
+           Checked for port conflicts (none). Re-read plan steps 3.1-3.4 — no gap found.
+Result:    Test "blocks after 100 requests/min" fails every run: expected 429, got 200.
+           express-rate-limit v7's `max` option appears to be silently ignored — same
+           failure with max:1.
+Need:      Decide between (a) pin express-rate-limit to v6 (last version where `max`
+           worked as documented) or (b) switch to a different limiter library — the plan
+           doesn't specify a version. Confirm which, or provide the correct v7 config.
+```
+
+The report must let the user act without re-deriving the investigation themselves — never a vague "please advise" with no Task/Tried/Result/Need detail.
+
 ---
 
 ## When to Revisit Earlier Steps
@@ -90,7 +146,7 @@ After all tasks complete and are verified:
 - Follow plan steps exactly — do not improvise
 - Do not skip verifications
 - Reference skills when the plan says to invoke them
-- Stop when blocked; never guess
+- Stop when blocked; never guess — use the required stop-report format above
 - Never start implementation on `main` or `master` without explicit user consent
 
 ---
@@ -99,6 +155,5 @@ After all tasks complete and are verified:
 
 **Skills used by this skill:**
 - `Skill("mastermind-plan")` — creates the plan this skill executes
-- `Skill("mastermind-taskdev")` — subagent-driven parallel task execution (preferred for complex plans)
-- `Skill("mastermind-finish")` — complete the development branch after all tasks
-- `Skill("mastermind-verify")` — verification gate before finishing
+- `Skill("mastermind-review")` — verification gate after all tasks complete
+- `Skill("mastermind-debug")` — when a task fails for a reason the plan did not anticipate

package/.claude/skills/mastermind-idea/SKILL.md

@@ -172,9 +172,16 @@ user_market_agents=$(jq \
      | {name: .name, slug: .slug, category: .category,
         score: (
           (.name | ascii_downcase) as $n |
-          # Score on ANY keyword match (mirrors master.md pick_domain_manager scoring)
+          (.description // "" | ascii_downcase) as $desc |
+          # Score keyword matches against both name (weight 2) and description (weight 1) —
+          # name match is a stronger signal (mirrors master.md pick_domain_manager scoring).
+          # Bind each word to $w before contains(): piping into contains(.) rebinds "." to the
+          # piped value, which would silently match everything.
           (if ($kw | length) > 0
-           then ([$kw | split(" ")[] | select(length > 0) | if ($n | contains(.)) then 1 else 0 end] | add // 0)
+           then ([$kw | split(" ")[] | select(length > 0) | . as $w |
+                  (if ($n | contains($w)) then 2 else 0 end) +
+                  (if ($desc | contains($w)) then 1 else 0 end)
+                 ] | add // 0)
            else 0 end)
         )}
    ] | sort_by(-.score) | unique_by(.slug) | .[0:$n] | [.[].name]' \

package/.claude/skills/mastermind-intake/SKILL.md

@@ -14,12 +14,16 @@ This file is referenced by `master.md` and domain commands. Never invoke directl
 
 Count the words in `$ARGUMENTS` and scan for domain signals.
 
-**Rich prompt** (skip all intake questions → proceed to execution):
-- Word count ≥ 20 AND
-- Contains at least one domain signal (build, ship, feature, bug, fix, campaign, marketing, SEO, content, review, audit, research, launch, release, sales, outreach, ops, finance, report) AND
-- Contains a goal or outcome phrase (e.g. "so that", "by end of", "targeting", "for our", "to improve")
+**Rich prompt** (skip all intake questions → proceed to execution) if EITHER of these holds:
 
-**Vague prompt** (run intake): anything that doesn't meet rich-prompt criteria.
+- **A. Long + domain-signaled:** word count ≥ 20 AND contains at least one domain signal (build, ship, feature, bug, fix, campaign, marketing, SEO, content, review, audit, research, launch, release, sales, outreach, ops, finance, report).
+- **B. Concrete imperative:** contains a clear imperative verb (fix, add, remove, rename, update, refactor, migrate, upgrade, revert, patch, bump) AND names something specific enough that no reasonable person would need clarifying questions — a file/path, a function/class/component name, an error message or stack-trace fragment, a bug symptom with a concrete detail (a number, duration, status code, version), or a named third-party service/library. This counts as rich even under 20 words and without a goal/outcome phrase. Examples:
+  - "Fix the login bug where sessions expire after 5 minutes instead of 30"
+  - "Rename `getUserData` to `fetchUserProfile` in src/api/users.ts"
+  - "Update the Stripe webhook handler to retry on 502s"
+  - "Remove the unused `legacyAuth` middleware"
+
+**Vague prompt** (run intake): anything that meets neither A nor B.
 
 Even with a rich prompt, if `--confirm` flag is present: skip to execution but show the plan before spawning agents and wait for "go".
 
@@ -30,9 +34,29 @@ Even with a rich prompt, if `--confirm` flag is present: skip to execution but s
 Ask ONE question at a time. Wait for the answer before asking the next. Stop asking as soon as you have enough to proceed.
 
 **Q1 — Goal:**
-> "What outcome defines success for this run? Be as specific as you can — what will be done or produced when we're finished?"
+> "What outcome defines success for this run? Be as specific as you can — what will be done or produced when we're finished? (Or just say 'you decide' at any point and I'll infer the rest.)"
 
 **Q2 — Scope:**
+
+Infer the likely domain(s) from the Q1 answer using this keyword mapping (case-insensitive substring match; a "don't over-engineer" heuristic, not a classifier):
+
+| Domain | Keyword signals |
+|---|---|
+| build | build, ship, feature, implement, code, bug, fix, develop |
+| idea | idea, brainstorm, concept, pivot, explore |
+| marketing | marketing, campaign, SEO, ads, brand, positioning |
+| review | review, audit, evaluate, assess, critique |
+| research | research, investigate, analyze, study, benchmark |
+| content | content, blog, copy, article, docs, documentation |
+| release | release, launch, deploy, version, publish |
+| sales | sales, outreach, deal, pipeline, prospect |
+| ops | ops, operations, process, workflow, infra |
+| finance | finance, budget, cost, revenue, pricing |
+
+If one or more domains match, ask a single yes/no-shaped confirmation instead of the raw menu:
+> "This looks like <inferred domain(s), comma-joined> work — sound right, or something else?"
+
+If the user confirms, use the inferred domain(s) and move on. If the user says "something else" (or nothing matched in the first place), fall back to the raw menu:
 > "Which business domains should this touch? Options: build, idea, marketing, review, research, content, release, sales, ops, finance — or should I decide based on the goal?"
 
 **Q3 — Constraints:**
@@ -42,7 +66,7 @@ Ask ONE question at a time. Wait for the answer before asking the next. Stop ask
 > "Should I execute automatically once I have a plan, or show you the plan first and wait for your approval before spawning agents?"
 
 **Q5 — Project:**
-> "Which project is this for? I'll create or find a monotask space with that name. (Or I can infer it from context.)"
+> "Which project is this for? I'll create or find a workspace with that name. (Or I can infer it from context.)"
 
 Skip Q4 if `--auto` or `--confirm` flag was provided. Skip Q5 if `--project <name>` flag was provided.