monomind 2.7.12 → 2.7.13

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

@@ -1,232 +0,0 @@
-<!-- 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

@@ -1,9 +0,0 @@
-<!-- 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/approvev1.md

@@ -1,94 +0,0 @@
-<!-- LEGACY-ORG-V1 — Review and action pending approval requests from agents in a running v1 (prompt-orchestrated) org. Reach it only via /mastermind:approvev1. -->
-
-> **LEGACY-ORG-V1 (2026-07): v2 approvals arrive as question events in the dashboard Human Input tab — no command needed.**
-> This file-based approval queue applies only to v1 orgs not yet migrated off the `board_id`/`topology` config shape. Reach this legacy path only via `/mastermind:approvev1`.
-
-**If $ARGUMENTS is empty:** Output the following and wait.
-
----
-
-**MASTERMIND: APPROVE (v1, legacy)**
-
-Review and action pending approval requests from agents running inside a v1 (prompt-orchestrated) autonomous org. Agents request human approval before executing sensitive actions (publishing content, sending emails, making purchases, modifying infrastructure). v2 orgs surface approvals directly in the dashboard Human Input tab — no command needed.
-
-**Usage:**
-
-```
-/mastermind:approvev1 --org <name>                   List all pending approvals
-/mastermind:approvev1 --org <name> --action approve --id <id>
-/mastermind:approvev1 --org <name> --action reject  --id <id> --reason "Too risky"
-/mastermind:approvev1 --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:runorgv1` (v1 orgs only — v2 orgs use `/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 mastermind-protocol/SKILL.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 "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
-  -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-approvev1")` 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 "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
-  -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 mastermind-protocol/SKILL.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

@@ -1,52 +0,0 @@
-<!-- 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 `mastermind-repeat/SKILL.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 mastermind-protocol/SKILL.md Brain Load Procedure).
-
-Run intake if prompt is vague (follow mastermind-intake/SKILL.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 "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
-  -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 "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
-  -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 mastermind-protocol/SKILL.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 "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
-  -H "Content-Type: application/json" \
-  -d '{"type":"session:complete","session":"<sessionId>","domain":"architect","status":"<status>","domains":["architect"],"ts":'"$(date +%s)"'000}' || true
-```
-
-**MANDATORY — invoke `Skill("mastermind-repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

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

@@ -1,28 +0,0 @@
-<!-- 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 `mastermind-repeat/SKILL.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`.
-
-Load brain context for the `autodev` domain (follow mastermind-protocol/SKILL.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 mastermind-protocol/SKILL.md Brain Write Procedure for domain `autodev`.
-
-**MANDATORY — invoke `Skill("mastermind-repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

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

@@ -1,99 +0,0 @@
-<!-- Mastermind brain management — inspect, compact, refresh, and control the three-tier business memory (LanceDB + 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.
-
-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

@@ -1,5 +0,0 @@
-<!-- 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

@@ -1,23 +0,0 @@
-<!-- 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 `mastermind-repeat/SKILL.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 mastermind-protocol/SKILL.md Brain Load Procedure).
-
-Run intake if prompt is vague (follow mastermind-intake/SKILL.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 mastermind-protocol/SKILL.md Brain Write Procedure for domain `build`.
-
-**MANDATORY — invoke `Skill("mastermind-repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.