monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/commands/mastermind/_taskfile.md

@@ -0,0 +1,235 @@
+---
+name: _taskfile
+description: Shared file-based task/idea/improvement format for mastermind commands. Defines markdown structure, status enum, status transitions, prerequisite-unblock logic, and file paths. Referenced by createtask, do, ideate, and improve — do NOT duplicate this spec.
+---
+
+# Task File Format Spec
+
+**Referenced by:** `mastermind:createtask`, `mastermind:do`, `mastermind:ideate`, `mastermind:improve`
+
+---
+
+## File Locations
+
+| Command | Output path |
+|---|---|
+| `mastermind:createtask` | `docs/tasks/YYYY-MM-DD-<slug>.md` |
+| `mastermind:ideate` | `docs/ideas/YYYY-MM-DD-<slug>.md` |
+| `mastermind:improve` | `docs/improvements/YYYY-MM-DD-<slug>.md` |
+
+**Slug generation:** Take the first 40 characters of the user's prompt/input label. Lowercase, replace spaces and non-alphanumeric chars with `-`, collapse consecutive `-`, strip leading/trailing `-`.
+
+Example: `"Build a webhook delivery system"` → `build-a-webhook-delivery-system`
+
+---
+
+## Task File Structure
+
+Every task file produced by `mastermind:createtask` (and by the decomposition step in `ideate`/`improve`):
+
+```
+---
+source: mastermind:createtask
+repo: <REPO_NAME>
+created: YYYY-MM-DD
+prompt: <first 100 chars of input>
+recommended_mode: parallel | minimal | sequential
+---
+
+# Tasks: <INPUT_LABEL>
+
+<2-3 sentence summary of what these tasks implement>
+
+---
+
+## Task 1: <Action-oriented title (verb + noun + context)>
+
+> status: todo
+> agent: <agent_type>
+> priority: critical | high | medium | low
+> effort: <1-10>
+> context_group: <group_name> | independent
+> prerequisites: none | <comma-separated task titles exactly as written above>
+> parallel_safe: true | false
+
+### What
+<Exact deliverable — 1-3 sentences>
+
+### Why
+<Motivation — 1-2 sentences>
+
+### Where
+<File paths and module boundaries>
+
+### Context
+<All relevant context: patterns, related files, API shapes, data models. Include file paths from monograph.>
+
+### Definition of Done
+- [ ] <Specific, binary, verifiable condition>
+- [ ] <Specific, binary, verifiable condition>
+
+### Testing Criteria
+- Unit: `function(input) → expected outcome`
+- Integration: `endpoint + method → status + response shape`
+- Edge case: `boundary condition → expected behavior`
+
+### Checklist
+- [ ] <Step 1>
+- [ ] <Step 2>
+- [ ] Run tests — verify green
+- [ ] Commit: '<type>: <description>'
+
+---
+```
+
+Repeat `## Task N: ...` blocks for each task. Use `---` horizontal rules to visually separate tasks.
+
+---
+
+## Status Values
+
+The `> status:` blockquote line in each task section is the single source of truth for lifecycle state:
+
+| Value | Meaning |
+|---|---|
+| `backlog` | Has unmet prerequisites — not ready to start |
+| `todo` | Ready to be picked up |
+| `in_progress` | Agent is actively working |
+| `review` | Agent reported DONE/DONE_WITH_CONCERNS — pending reviewer approval |
+| `blocked` | Agent reported BLOCKED, or reviewer failed after 3 cycles — human decision needed |
+| `done` | Reviewer approved — all checklist items complete |
+
+---
+
+## Status Transitions (`mastermind:do` applies these)
+
+**Edit mechanism:** Use the `Edit` tool to replace `> status: <old_value>` with `> status: <new_value>` within the specific task's section. Match by task heading (`## Task N: <title>`) to scope the edit to the right task.
+
+1. **Claim task**: `todo` → `in_progress`
+2. **Agent reports DONE/DONE_WITH_CONCERNS**: `in_progress` → `review` (hold here until reviewer approves)
+3. **Reviewer approves**: `review` → `done` AND replace all `- [ ]` with `- [x]` in that task's Checklist section
+4. **Agent reports BLOCKED**: `in_progress` → `blocked` AND append a new blockquote line `> blocked_reason: <question or issue>`
+5. **Review failed after 3 cycles**: `review` → `blocked` AND append `> blocked_reason: max review cycles reached — <unresolved issues>`
+6. **DONE_WITH_CONCERNS**: after reviewer approves, append `> concerns: <concerns text>` line
+
+---
+
+## Prerequisite Unblock Logic (`mastermind:do`)
+
+After any task transitions to `status: done`:
+
+1. Note the task's exact title text (everything after `## Task N: `)
+2. Scan the same file for ALL task sections where the `> prerequisites:` line contains that exact title as one of the comma-separated values
+3. For each such dependent task:
+   - Read each prerequisite listed for it
+   - Check whether ALL those prerequisites have `> status: done` in their section
+   - If yes → Edit `> status: backlog` to `> status: todo` in the dependent's section
+   - If any prerequisite is not yet `done` → leave the dependent's status unchanged
+
+---
+
+## Scanning for Pending Tasks (`mastermind:do` parse spec)
+
+To find work from a file:
+1. Read the entire file with the `Read` tool
+2. Find all sections with heading `## Task \d+: ` (level-2 headings starting with "Task N: ")
+3. For each section, read the `> status:` line
+4. **Todo tasks** = sections with `status: todo`
+5. **Backlog tasks** = sections with `status: backlog`
+6. To read a task's full context: read from `## Task N: <title>` to the next `---` separator or next `## Task` heading
+
+---
+
+## Idea File Structure (`mastermind:ideate` output)
+
+File: `docs/ideas/YYYY-MM-DD-<slug>.md`
+
+Ideas are appended chronologically. Status is tracked in-place via `> status:` — sections are NOT physically moved between column headings. The column headings (New/Evaluated/etc.) are used only for initial placement during creation; subsequent updates only change the `> status:` line.
+
+```
+---
+source: mastermind:ideate
+repo: <REPO_NAME>
+created: YYYY-MM-DD
+prompt: <prompt>
+---
+
+# Ideas: <prompt>
+
+---
+
+### <Idea Title>
+> status: new | evaluated | iced | rejected | elaborated | tasked
+> category: feature | technical-baseline
+> impact: <0-10 once evaluated>
+> effort: <0-10 once evaluated>
+> skip_elaboration: true | false
+
+<2-3 sentence description>
+
+**Value:** <value statement once evaluated>
+**Blocked by:** <blocking question if iced>
+**Rejected reason:** <reason if rejected>
+**Edge cases:** <findings if elaborated>
+**Technical notes:** <notes if elaborated>
+**Subtasks file:** `docs/tasks/<task-file>.md` (N tasks created)
+
+---
+```
+
+Repeat `### <Idea Title>` blocks for each idea.
+
+**Idea status values:** `new` → `evaluated` | `iced` | `rejected` → `elaborated` | `iced` → `tasked`
+
+---
+
+## Improvement File Structure (`mastermind:improve` output)
+
+File: `docs/improvements/YYYY-MM-DD-<slug>.md`
+
+Same flat-with-status-in-place pattern as idea files.
+
+```
+---
+source: mastermind:improve
+repo: <REPO_NAME>
+created: YYYY-MM-DD
+component: <component name>
+---
+
+# Improvements: <component>
+
+---
+
+### <Improvement Title>
+> status: discovered | evaluated | approved | deferred | rejected | tasked
+> category: performance | security | reliability | maintainability | dx | testing | architecture
+> impact: <0-10 once evaluated>
+> effort: <0-10 once evaluated>
+> skip_elaboration: true | false
+
+<2-3 sentence description>
+
+**Evidence:** <pain point or best practice reference>
+**Estimated impact:** <concrete expected outcome>
+**Value:** <value statement once evaluated>
+**Implementation path:** <files and functions to change, once elaborated>
+**Risks:** <breaking changes, migration needs>
+**Research:** <patterns and references found>
+**Deferred reason:** <reason if deferred>
+**Rejected reason:** <reason if rejected>
+**Subtasks file:** `docs/tasks/<task-file>.md` (N tasks created)
+
+---
+```
+
+**Improvement status values:** `discovered` → `evaluated` | `deferred` | `rejected` → `approved` | `deferred` → `tasked`
+
+---
+
+## Format Contract Notes
+
+- `> status:` lines use blockquote syntax so they're visually distinct from body text and parseable by `grep '^> status:'`
+- Prerequisites reference task titles **exactly as written** — case-sensitive, full title text after `## Task N: `
+- The `---` separator after each task/idea/improvement block is required — it's what `mastermind:do` uses to delimit sections
+- All `- [ ]` and `- [x]` checklist items are standard GFM checkboxes — use the `Edit` tool to flip `[ ]` → `[x]`

package/packages/@monomind/cli/.claude/commands/mastermind/adr.md

@@ -0,0 +1,11 @@
+---
+description: Draft an Architecture Decision Record from accumulated decision markers in this session's prompts
+---
+
+Run the hook handler's adr-draft action to scan `.monomind/decisions.jsonl` for the last 7 days of decision markers (e.g. "let's go with X", "we chose Y", "decision: Z") and produce an ADR template in `docs/adrs/`.
+
+```bash
+node "$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs" adr-draft
+```
+
+After running, open the generated `docs/adrs/ADR-NNNN-YYYY-MM-DD-session-decisions.md`, fill in the Context and Consequences sections, and change Status to Accepted/Rejected.

package/packages/@monomind/cli/.claude/commands/mastermind/approve.md

@@ -0,0 +1,94 @@
+---
+name: mastermind-approve
+description: Review and action pending approval requests from agents in a running org.
+---
+
+**If $ARGUMENTS is empty:** Output the following and wait.
+
+---
+
+**MASTERMIND: APPROVE**
+
+Review and action pending approval requests from agents running inside an autonomous org. Agents request human approval before executing sensitive actions (publishing content, sending emails, making purchases, modifying infrastructure).
+
+**Usage:**
+
+```
+/mastermind:approve --org <name>                   List all pending approvals
+/mastermind:approve --org <name> --action approve --id <id>
+/mastermind:approve --org <name> --action reject  --id <id> --reason "Too risky"
+/mastermind:approve --org <name> --action inspect --id <id>
+```
+
+**Options:**
+`--org <name>` — org to check (required)
+`--action list|approve|reject|inspect` — what to do (default: list)
+`--id <approval_id>` — specific approval to approve/reject/inspect
+`--reason <text>` — reason for rejection (optional)
+
+No running orgs yet? Run `/mastermind:createorg` then `/mastermind:runorg`.
+
+---
+
+**If $ARGUMENTS is non-empty:** Execute the flow below.
+
+---
+
+Parse `$ARGUMENTS` for:
+- `--org <name>` → org_name = <name>
+- `--action <action>` → action = <action> (default: "list")
+- `--id <id>` → approval_id = <id>
+- `--reason <text>` → reason = <text>
+- Remaining text = additional context
+
+If `--org` is not provided, list running orgs and ask which to check:
+```bash
+orgs=$(ls .monomind/orgs/*.json 2>/dev/null | xargs -I{} basename {} .json 2>/dev/null | grep -v "\-state\|-goals\|-routines\|-approvals\|-issues\|-members\|-projects")
+if [ -z "$orgs" ]; then
+  echo "No saved orgs found. Run /mastermind:createorg first."
+  exit 1
+fi
+echo "Available orgs: $orgs"
+```
+Ask: "Which org would you like to check approvals for?"
+
+Validate the org file exists:
+```bash
+[ -f ".monomind/orgs/${org_name}.json" ] || { echo "Org '${org_name}' not found."; exit 1; }
+```
+
+Load brain context for the `ops` domain (follow _protocol.md Brain Load Procedure, namespace: `ops`).
+
+Generate a session ID:
+```bash
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+session_id="mm-$(date -u +%Y%m%dT%H%M%S)"
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+```
+
+Emit `session:start`:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg org "$org_name" \
+    --arg proj "$REPO_ROOT" \
+    '{type:"session:start",session:$session,domain:"ops",prompt:("Approve requests for org: "+$org),mode:"confirm",project:$proj,ts:(now*1000|floor)}')" || true
+```
+
+Invoke `Skill("mastermind:approve")` passing: brain_context, org_name, action, approval_id, reason, caller: "command".
+
+After skill returns: note the status. Emit `session:complete`:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg status "<status>" \
+    '{type:"session:complete",session:$session,domain:"ops",status:$status,domains:["ops"],ts:(now*1000|floor)}')" || true
+```
+
+Follow _protocol.md Brain Write Procedure for domain `ops`.
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/packages/@monomind/cli/.claude/commands/mastermind/architect.md

@@ -0,0 +1,55 @@
+---
+name: mastermind-architect
+description: Mastermind architect domain — architecture review, file structure deduplication, coupling analysis, design pattern audit, DDD mapping, and system design. 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 (default)
+- `--project <name>` → project_name = <name> (if omitted, default to `basename "$PWD"`)
+- `--scope <scope>` → scope = review | design | deduplicate | migrate | all (default: infer from prompt using these keyword rules: "review"/"audit"/"check"/"assess" → review; "deduplicate"/"dedup"/"consolidate" → deduplicate; "design"/"architect"/"model"/"bounded context" → design; "migrate"/"migration"/"port to"/"convert" → migrate; no keyword match → all; if more than one scope keyword matches, use `all`)
+- `--stack <stack>` → stack hint (e.g. typescript, python, react, go) — auto-detected if omitted
+- `--iterate <N>` → iterate = N (integer ≥ 1; default 0 = no iteration) — run N autonomous fix+review cycles after the initial architect pass
+- Remaining text = prompt
+
+If prompt is empty: ask "What would you like the architect to do? (e.g. 'review the codebase structure', 'deduplicate files', 'design the API layer', 'map bounded contexts')"
+
+Load brain context for the `architect` domain (follow _protocol.md Brain Load Procedure).
+
+Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `architect`).
+
+Default mode for this command: **confirm** (show architecture plan before executing, unless `--auto` flag present).
+
+Generate a session ID and resolve the dashboard URL:
+```bash
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+sessionId="mm-$(date -u +%Y%m%dT%H%M%S)"
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+```
+
+Emit `session:start` before invoking the skill (use curl — WebFetch is blocked for localhost in Claude Code runtimes). Before executing the curl below, substitute the generated sessionId for `<sessionId>`:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d '{"type":"session:start","session":"<sessionId>","domain":"architect","prompt":'"$(jq -Rn --arg p "$prompt" '$p')"',"ts":'"$(date +%s)"'000}' || true
+```
+
+Emit `domain:dispatch` immediately after session:start. Before executing the curl below, substitute the generated sessionId for `<sessionId>`:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d '{"type":"domain:dispatch","session":"<sessionId>","domain":"architect","ts":'"$(date +%s)"'000}' || true
+```
+
+Invoke `Skill("mastermind:architect")` passing: brain_context, prompt, project_name, board_id (create board named "architect" inside the project_name monotask space if not already present), mode, scope, stack, sessionId, iterate, caller: "command".
+
+After skill returns: note the status from the skill's output (`complete`, `partial`, or `blocked`). Emit `session:complete` using that status, then follow _protocol.md Brain Write Procedure for domain `architect`. Before executing the curl below, substitute the generated sessionId for `<sessionId>` and the skill's actual status for `<status>`:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d '{"type":"session:complete","session":"<sessionId>","domain":"architect","status":"<status>","domains":["architect"],"ts":'"$(date +%s)"'000}' || true
+```
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/packages/@monomind/cli/.claude/commands/mastermind/autodev.md

@@ -0,0 +1,32 @@
+---
+name: mastermind-autodev
+description: Autonomous research → build → review loop. Researches the project, picks the best improvement, builds it, and reviews until clean. Repeat N times with a leading integer (e.g. `/mastermind:autodev 9`). Use --newfeature N to discover and fully deliver N brand-new features (build → review → document → stage). Supports --tillend.
+---
+
+**Pre-PREAMBLE compatibility check:** Before following the REPEAT PREAMBLE, scan `$ARGUMENTS` for both `--newfeature` and `--tillend` present simultaneously. If both are found, emit `[autodev] Warning: --tillend is not supported with --newfeature and will be ignored.` and remove `--tillend` from `$ARGUMENTS` now — before the PREAMBLE processes it — so the PREAMBLE never creates a tillend loop state file.
+
+**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:
+- **Leading integer** (first token is a bare number, e.g. `9`) → `count = 9` (how many improvements to build)
+- `--count <N>` → `count = N`
+- `--newfeature <N>` → activate feature mode; `newfeature_count = N`. Discovers N best genuinely-new features and runs full pipeline: Build → Review → Documentation → Delivery for each. Overrides the normal improvement loop.
+- `--focus <topic>` → focus hint (e.g. "performance", "security", "dx")
+- `--auto` flag → mode = auto
+- `--confirm` flag → mode = confirm
+- Remaining text → additional focus context
+
+If no count is set, default `count = 1`.
+If `--newfeature` is present without a valid N, default `newfeature_count = 3`.
+If `newfeature_count > 10`: warn the user and set `newfeature_count = 10`.
+(The `--newfeature + --tillend` incompatibility is already handled by the pre-PREAMBLE check above.)
+
+Load brain context for the `autodev` domain (follow _protocol.md Brain Load Procedure).
+
+Default mode for this command: **auto** (unless `--confirm` flag present).
+
+Invoke `Skill("mastermind:autodev")` passing: brain_context, count, newfeature_count, focus, mode, board_id (create if needed).
+
+After skill returns: follow _protocol.md Brain Write Procedure for domain `autodev`.
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/packages/@monomind/cli/.claude/commands/mastermind/brain.md

@@ -0,0 +1,102 @@
+---
+name: mastermind-brain
+description: Mastermind brain management — inspect, compact, refresh, and control the three-tier business memory (LanceDB + Monograph)
+---
+
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing.
+
+Parse `$ARGUMENTS` to determine the sub-command and flags.
+
+## Sub-Commands
+
+### `status` (default if no sub-command given)
+
+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
+
+Display as a table:
+
+```
+MASTERMIND BRAIN STATUS
+════════════════════════════════════════════════
+Domain     │ Tier 1 (raw) │ Tier 2 (weekly) │ Tier 3 (principles)
+───────────┼──────────────┼─────────────────┼────────────────────
+build      │ 14 entries   │ 2 summaries     │ shared (see below)
+marketing  │ 8 entries    │ 1 summary       │
+...        │              │                 │
+───────────┼──────────────┼─────────────────┼────────────────────
+PRINCIPLES │              │                 │ 7 core principles
+════════════════════════════════════════════════
+Last compaction: 2026-04-28 | Next due: 2026-05-05
+Avg memory score: 0.64 | Entries below archive threshold: 3
+```
+
+---
+
+### `compact`
+
+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`)
+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`)
+4. Archive Tier 1 entries with score < 0.1 (update metadata: `{ archived: true }`)
+5. Report: "Compacted <domain>: <N> entries → <M> summary, <K> archived"
+
+---
+
+### `refresh --domain <name>`
+
+Re-cluster the knowledge graph for a specific domain and rebuild Tier 3 principles from it.
+
+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`
+5. Report: "Refreshed <domain>: <N> clusters found, <M> principles updated, <K> exceptions noted"
+
+---
+
+### `inspect --tier <1|2|3> [--domain <name>] [--limit <N>]`
+
+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.
+
+Default limit: 10. Use `--limit N` to override.
+
+---
+
+### `forget --query "<text>"`
+
+Find and archive all brain entries semantically matching the query.
+
+1. Call `mcp__monomind__lancedb_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 }`
+5. Report: "Archived N entries matching '<query>'"
+
+---
+
+### `reset --domain <name> --confirm`
+
+**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`
+3. Remove domain nodes from Monograph graph
+4. Report: "Reset complete for domain <name>. All memory wiped."
+
+If `--confirm` is missing:
+> "This will permanently delete all brain memory for domain '<name>'. To confirm, run: `/mastermind:brain reset --domain <name> --confirm`"
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/packages/@monomind/cli/.claude/commands/mastermind/budget.md

@@ -0,0 +1,7 @@
+---
+description: Show current budget status — today, month, limits, autotuned flag
+---
+
+```bash
+node "$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs" budget-status
+```

package/packages/@monomind/cli/.claude/commands/mastermind/build.md

@@ -0,0 +1,26 @@
+---
+name: mastermind-build
+description: Mastermind build domain — ship features, fix bugs, refactor code. Spawns a Development Manager who creates monotask tasks and coordinates specialized dev agents. Default mode: auto.
+---
+
+**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 = prompt
+
+If prompt is empty: ask "What would you like to build or fix?"
+
+Load brain context for the `build` domain (follow _protocol.md Brain Load Procedure).
+
+Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `build`).
+
+Default mode for this command: **auto** (unless `--confirm` flag present or intake Q4 says confirm).
+
+Invoke `Skill("mastermind:build")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+
+After skill returns: follow _protocol.md Brain Write Procedure for domain `build`.
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.