monomind 2.5.1 → 2.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "2.5.1",
+  "version": "2.5.2",
   "description": "Open-source CLI extension for Claude Code. Adds an MCP server with a codebase knowledge graph, persistent memory, multi-agent coordination, and reusable slash commands. MIT licensed, runs locally, no data leaves your machine.",
   "main": "dist/index.js",
   "type": "module",
@@ -39,6 +39,7 @@
     "!packages/@monomind/cli/.claude/**/*.db",
     "!packages/@monomind/cli/.claude/**/.monomind/**",
     "!packages/@monomind/cli/.claude/**/*.lock",
+    "!packages/@monomind/cli/.claude/**/._*",
     "!packages/@monomind/cli/.claude/agents/generated/**",
     "!packages/@monomind/cli/.claude/agents/reengineer-squad/**",
     "README.md",

package/packages/@monomind/cli/.claude/agents/design/design-monodesign.md

@@ -71,7 +71,7 @@ Craft photography prompts for AI image generation that produce editorial-quality
 Strategic personality injection — micro-interactions, Easter eggs, brand character, memorable moments. Delight that enhances rather than distracts. See `reference/delight.md`.
 
 ### Design Critique
-24-rule antipattern detection covering slop tells, quality issues, performance problems, and accessibility failures. Run `npx impeccable detect` on any HTML/CSS target.
+46 deterministic detector rules covering slop tells (AI signatures) and quality issues (contrast, motion, readability, semantics). Run `monomind design detect` on any HTML/CSS target — the engine is bundled, no external install needed. Design-check hooks can auto-run the detector after UI file edits.
 
 ## Core Principles
 
@@ -92,20 +92,20 @@ For any design task, the sequence is:
 
 1. **Load context** — Read PRODUCT.md and DESIGN.md from the project root
 2. **Identify register** — brand or product?
-3. **Load relevant references** — from the monodesign skill's 38 reference files
+3. **Load relevant references** — from the monodesign skill's 50+ reference files
 4. **Design → implement → inspect** — in that order, no exceptions
-5. **Run antipattern check** — `npx impeccable detect` before presenting results
+5. **Run antipattern check** — `monomind design detect` before presenting results
 6. **Verify states** — all interactive states and responsive breakpoints
 
-## Reference Library (38 files)
+## Reference Library (50+ files)
 
 The monodesign skill at `.claude/skills/monodesign/` contains the authoritative reference library:
 
 **Core domains**: typography, color-and-contrast, spatial-design, motion-design, interaction-design, responsive-design, ux-writing
 
-**Commands**: craft, shape, teach, document, extract, critique, audit, polish, bolder, quieter, distill, harden, onboard, animate, colorize, typeset, layout, delight, overdrive, clarify, adapt, optimize, live
+**Commands**: craft, shape, init (alias: teach), document, extract, critique, audit, polish, bolder, quieter, distill, harden, onboard, animate, colorize, typeset, layout, delight, overdrive, clarify, adapt, optimize, live (interactive in-browser variant iteration) — plus native variants (audit.native, adapt.native) and platform guides (ios, android)
 
-**New additions**: component-system, ux-research, image-prompts
+**New additions**: component-system, ux-research, image-prompts, antipatterns-catalog, token-architecture, component-specs, component-states, brand-workflow, copy-formulas, ux-rules, pre-delivery-checklist
 
 **Context**: brand, product, personas, cognitive-load, heuristics-scoring
 

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

@@ -1,4 +1,4 @@
-<!-- Shared inter-session repeat protocol. Referenced by mastermind and monomind commands via "Follow the Repeat Preamble/Postamble from _repeat.md". -->
+<!-- Shared inter-session repeat protocol. Referenced by mastermind and monomind commands via "Follow the Repeat Preamble/Postamble from mastermind-repeat/SKILL.md". -->
 
 ## Shared Repeat Protocol
 
@@ -152,7 +152,7 @@ If neither condition is true, skip to Section 4.
      "lastRunAt": ${NOW_MS},
      "nextRunAt": ${NOW_MS},
      "status": "running",
-     "source": "_repeat.md"
+     "source": "mastermind-repeat/SKILL.md"
    }
    EOF
    ```
@@ -174,7 +174,7 @@ If neither condition is true, skip to Section 4.
      "lastRunAt": ${NOW_MS},
      "nextRunAt": ${NOW_MS},
      "status": "running",
-     "source": "_repeat.md"
+     "source": "mastermind-repeat/SKILL.md"
    }
    EOF
    ```
@@ -443,7 +443,7 @@ cat > ".monomind/loops/${LOOP_ID}.json" << EOF
   "lastRunAt": ${NOW_MS},
   "nextRunAt": ${NEXT_AT},
   "status": "running",
-  "source": "_repeat.md"
+  "source": "mastermind-repeat/SKILL.md"
 }
 EOF
 ```

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

@@ -57,7 +57,7 @@ Validate the org file exists:
 [ -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`).
+Load brain context for the `ops` domain (follow mastermind-protocol/SKILL.md Brain Load Procedure, namespace: `ops`).
 
 Generate a session ID:
 ```bash
@@ -77,7 +77,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "
     '{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-skills:approvev1")` passing: brain_context, org_name, action, approval_id, reason, caller: "command".
+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
@@ -89,6 +89,6 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "
     '{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`.
+Follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+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,6 +1,6 @@
 <!-- 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.
+**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
@@ -13,9 +13,9 @@ Parse `$ARGUMENTS` for:
 
 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).
+Load brain context for the `architect` domain (follow mastermind-protocol/SKILL.md Brain Load Procedure).
 
-Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `architect`).
+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).
 
@@ -40,13 +40,13 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "
   -d '{"type":"domain:dispatch","session":"<sessionId>","domain":"architect","ts":'"$(date +%s)"'000}' || true
 ```
 
-Invoke `Skill("mastermind-skills: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".
+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>`:
+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-skills:_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.
+**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

@@ -2,7 +2,7 @@
 
 **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.
+**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)
@@ -17,12 +17,12 @@ 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 _protocol.md Brain Load Procedure).
+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-skills:autodev")` passing: brain_context, count, newfeature_count, focus, mode, board_id (create if needed).
+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`.
+After skill returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `autodev`.
 
-**MANDATORY — invoke `Skill("mastermind-skills:_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.
+**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,6 +1,6 @@
 <!-- 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.
+**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.
 
@@ -96,4 +96,4 @@ If `--confirm` is present:
 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-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+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/build.md

@@ -1,6 +1,6 @@
 <!-- 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.
+**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
@@ -10,14 +10,14 @@ Parse `$ARGUMENTS` for:
 
 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).
+Load brain context for the `build` domain (follow mastermind-protocol/SKILL.md Brain Load Procedure).
 
-Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `build`).
+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-skills:build")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+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`.
+After skill returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `build`.
 
-**MANDATORY — invoke `Skill("mastermind-skills:_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.
+**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/code-review.md

@@ -1,6 +1,6 @@
 <!-- "Monomind — Multi-agent iterative review loop: runs Code Reviewer, Security Engineer, and domain specialists in parallel, auto-fixes findings each iteration, and captures human-in-loop items to a dated 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-arguments check below.
+**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-arguments check below.
 
 Parse remaining `$ARGUMENTS` as `TOTAL_ITERATIONS` (integer, min 1, max 10).
 
@@ -311,4 +311,4 @@ If `ALL_HIL` is empty, omit the HIL section and congratulate:
 
 To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.
 
-**MANDATORY — invoke `Skill("mastermind-skills:_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.
+**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/content.md

@@ -1,6 +1,6 @@
 <!-- Mastermind content domain — blog posts, threads, docs, newsletters. 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.
+**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
@@ -10,14 +10,14 @@ Parse `$ARGUMENTS` for:
 
 If prompt is empty: ask "What content would you like created?"
 
-Load brain context for the `content` domain (follow _protocol.md Brain Load Procedure).
+Load brain context for the `content` domain (follow mastermind-protocol/SKILL.md Brain Load Procedure).
 
-Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `content`).
+Run intake if prompt is vague (follow mastermind-intake/SKILL.md — stop at Q3, domain is already known as `content`).
 
 Default mode for this command: **confirm** (unless `--auto` flag present or intake Q4 says auto).
 
-Invoke `Skill("mastermind-skills:content")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+Invoke `Skill("mastermind-content")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
 
-After skill returns: follow _protocol.md Brain Write Procedure for domain `content`.
+After skill returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `content`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+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/createorg.md

@@ -95,7 +95,7 @@ If neither `--auto` nor `--confirm` was provided, default: **mode = confirm**.
 
 If prompt is empty (and not list/delete mode): ask "Describe your org's goal and optionally list the roles you want (e.g. 'a content team with a boss, writer, reviewer, and marketer to produce 10 blog posts per month')."
 
-Load brain context for the `ops` domain (follow _protocol.md Brain Load Procedure, namespace: `ops`).
+Load brain context for the `ops` domain (follow mastermind-protocol/SKILL.md Brain Load Procedure, namespace: `ops`).
 
 Generate a session ID as a real shell variable:
 ```bash
@@ -125,7 +125,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "
     '{type:"domain:dispatch",session:$session,domain:"ops",cmd:"Designing and saving org definition",ts:(now*1000|floor)}')" || true
 ```
 
-Invoke `Skill("mastermind-skills:createorg")` passing: brain_context, prompt, org_name, roles_desc, schedule, mode, session_id: `$session_id`, caller: "command".
+Invoke `Skill("mastermind-createorg")` passing: brain_context, prompt, org_name, roles_desc, schedule, mode, session_id: `$session_id`, caller: "command".
 
 After skill returns: note the status (`complete`, `partial`, or `blocked`). Emit `session:complete`:
 ```bash
@@ -137,7 +137,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "
     '{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`.
+Follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.
 
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+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/createtask.md

@@ -55,7 +55,7 @@ Bundle everything into `FULL_CONTEXT`.
 
 **File mode (default, `USE_MONOTASK=false`):**
 
-Compute the output path (follow slug rules from `_taskfile.md`):
+Compute the output path (follow slug rules from `mastermind-taskfile/SKILL.md`):
 ```bash
 DATE=$(date +%Y-%m-%d)
 SLUG=$(echo "$INPUT_LABEL" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g; s/-\+/-/g; s/^-//; s/-$//' | cut -c1-40)
@@ -161,7 +161,7 @@ Store as `TASKS` array.
 
 **File mode (default, `USE_MONOTASK=false`):**
 
-Write the file using the Write tool. Follow the task section format from `_taskfile.md` exactly. The file structure:
+Write the file using the Write tool. Follow the task section format from `mastermind-taskfile/SKILL.md` exactly. The file structure:
 
 1. **Write frontmatter + header** (once):
 ```markdown
@@ -180,7 +180,7 @@ recommended_mode: <parallel|minimal|sequential>
 ---
 ```
 
-2. **Append one section per task** (initial status = `todo` if no prerequisites, `backlog` if has prerequisites), following the task section format from `_taskfile.md`:
+2. **Append one section per task** (initial status = `todo` if no prerequisites, `backlog` if has prerequisites), following the task section format from `mastermind-taskfile/SKILL.md`:
 ```markdown
 ## Task N: <title>
 

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

@@ -1,10 +1,10 @@
 <!-- Systematic root-cause debugging — use before ANY fix attempt for bugs, test failures, unexpected behavior, build failures, or performance regressions. Enforces Phase 1 root-cause investigation before proposing fixes. -->
 
-**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`.
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`.
 
 Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text = problem description.
 
-Load brain context for the `debug` domain (follow `_protocol.md` Brain Load Procedure).
+Load brain context for the `debug` domain (follow `mastermind-protocol/SKILL.md` Brain Load Procedure).
 
 If problem description is empty: ask "What issue are you debugging?"
 
@@ -12,8 +12,8 @@ Default mode: **auto** (proceed immediately; the skill gates on root-cause inves
 
 ---
 
-Invoke `Skill("mastermind-skills:debug")` passing: brain_context, problem_description, mode.
+Invoke `Skill("mastermind-debug")` passing: brain_context, problem_description, mode.
 
-After skill returns: follow `_protocol.md` Brain Write Procedure for domain `debug`.
+After skill returns: follow `mastermind-protocol/SKILL.md` Brain Write Procedure for domain `debug`.
 
-**MANDATORY — invoke `Skill("mastermind-skills:_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.
+**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/design.md

@@ -1,17 +1,17 @@
 <!-- Collaborative design session — explore intent, clarify requirements, propose approaches, and produce an approved spec before any implementation begins. -->
 
-**First — extract repeat flags:** Follow REPEAT PREAMBLE from `_repeat.md`.
+**First — extract repeat flags:** Follow REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`.
 
 Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text.
 
-Load brain context (follow `_protocol.md` Brain Load Procedure).
+Load brain context (follow `mastermind-protocol/SKILL.md` Brain Load Procedure).
 
 Default mode: **confirm**.
 
 ---
 
-Invoke `Skill("mastermind-skills:design")` passing: brain_context, params, mode.
+Invoke `Skill("mastermind-design")` passing: brain_context, params, mode.
 
-After skill returns: follow `_protocol.md` Brain Write Procedure.
+After skill returns: follow `mastermind-protocol/SKILL.md` Brain Write Procedure.
 
-Invoke `Skill("mastermind-skills:_repeat")` now. Required — do not skip.
+Invoke `Skill("mastermind-repeat")` now. Required — do not skip.

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

@@ -67,7 +67,7 @@ Otherwise:
 
 ### 2a: Load all pending tasks
 
-**File mode:** Read `TASK_FILE`. Find all `## Task N: <title>` sections with `> status: todo` or `> status: backlog`. Follow the parsing spec in `_taskfile.md`. If `--filter` was set, keep only tasks whose title contains the filter text (case-insensitive).
+**File mode:** Read `TASK_FILE`. Find all `## Task N: <title>` sections with `> status: todo` or `> status: backlog`. Follow the parsing spec in `mastermind-taskfile/SKILL.md`. If `--filter` was set, keep only tasks whose title contains the filter text (case-insensitive).
 
 **Monotask mode:** 
 ```bash
@@ -437,7 +437,7 @@ Proceed to Step 9.
 1. Change `> status: review` → `> status: done` in that task's section
 2. Replace all `- [ ]` with `- [x]` in that task's Checklist section
 3. If DONE_WITH_CONCERNS: append `> concerns: <concerns>` after the status line
-4. **Unblock dependents**: Follow the "Prerequisite Unblock Logic" from `_taskfile.md` — find tasks whose prerequisites are now all `done` and change their status from `backlog` to `todo`.
+4. **Unblock dependents**: Follow the "Prerequisite Unblock Logic" from `mastermind-taskfile/SKILL.md` — find tasks whose prerequisites are now all `done` and change their status from `backlog` to `todo`.
 
 *Monotask mode:*
 ```bash

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

@@ -1,17 +1,17 @@
 <!-- Execute a written implementation plan step by step with review checkpoints and finishing handoff. -->
 
-**First — extract repeat flags:** Follow REPEAT PREAMBLE from `_repeat.md`.
+**First — extract repeat flags:** Follow REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`.
 
 Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text (treated as plan path or goal).
 
-Load brain context (follow `_protocol.md` Brain Load Procedure).
+Load brain context (follow `mastermind-protocol/SKILL.md` Brain Load Procedure).
 
 Default mode: **auto**.
 
 ---
 
-Invoke `Skill("mastermind-skills:execute")` passing: brain_context, params, mode.
+Invoke `Skill("mastermind-execute")` passing: brain_context, params, mode.
 
-After skill returns: follow `_protocol.md` Brain Write Procedure.
+After skill returns: follow `mastermind-protocol/SKILL.md` Brain Write Procedure.
 
-Invoke `Skill("mastermind-skills:_repeat")` now. Required — do not skip.
+Invoke `Skill("mastermind-repeat")` now. Required — do not skip.

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

@@ -1,6 +1,6 @@
 <!-- Mastermind finance domain — invoicing, budget tracking, financial forecasting. 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.
+**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
@@ -10,14 +10,14 @@ Parse `$ARGUMENTS` for:
 
 If prompt is empty: ask "What financial task would you like to handle?"
 
-Load brain context for the `finance` domain (follow _protocol.md Brain Load Procedure).
+Load brain context for the `finance` domain (follow mastermind-protocol/SKILL.md Brain Load Procedure).
 
-Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `finance`).
+Run intake if prompt is vague (follow mastermind-intake/SKILL.md — stop at Q3, domain is already known as `finance`).
 
 Default mode for this command: **confirm** (unless `--auto` flag present or intake Q4 says auto).
 
-Invoke `Skill("mastermind-skills:finance")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+Invoke `Skill("mastermind-finance")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
 
-After skill returns: follow _protocol.md Brain Write Procedure for domain `finance`.
+After skill returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `finance`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+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/finish.md

@@ -1,17 +1,17 @@
 <!-- Use when implementation is complete and you need to decide how to integrate the work — merge locally, create a PR, keep the branch, or discard -->
 
-**First — extract repeat flags:** Follow REPEAT PREAMBLE from `_repeat.md`.
+**First — extract repeat flags:** Follow REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`.
 
 Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text.
 
-Load brain context (follow `_protocol.md` Brain Load Procedure).
+Load brain context (follow `mastermind-protocol/SKILL.md` Brain Load Procedure).
 
 Default mode: **confirm**.
 
 ---
 
-Invoke `Skill("mastermind-skills:finish")` passing: brain_context, params, mode.
+Invoke `Skill("mastermind-finish")` passing: brain_context, params, mode.
 
-After skill returns: follow `_protocol.md` Brain Write Procedure.
+After skill returns: follow `mastermind-protocol/SKILL.md` Brain Write Procedure.
 
-Invoke `Skill("mastermind-skills:_repeat")` now. Required — do not skip.
+Invoke `Skill("mastermind-repeat")` now. Required — do not skip.

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

@@ -1,6 +1,6 @@
 <!-- Mastermind idea domain — brainstorm products, features, pivots. 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.
+**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
@@ -10,14 +10,14 @@ Parse `$ARGUMENTS` for:
 
 If prompt is empty: ask "What would you like to brainstorm or ideate on?"
 
-Load brain context for the `idea` domain (follow _protocol.md Brain Load Procedure).
+Load brain context for the `idea` domain (follow mastermind-protocol/SKILL.md Brain Load Procedure).
 
-Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `idea`).
+Run intake if prompt is vague (follow mastermind-intake/SKILL.md — stop at Q3, domain is already known as `idea`).
 
 Default mode for this command: **confirm** (unless `--auto` flag present or intake Q4 says auto).
 
-Invoke `Skill("mastermind-skills:idea")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+Invoke `Skill("mastermind-idea")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
 
-After skill returns: follow _protocol.md Brain Write Procedure for domain `idea`.
+After skill returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `idea`.
 
-**MANDATORY — invoke `Skill("mastermind-skills:_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.
+**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/ideate.md

@@ -1,6 +1,6 @@
 <!-- "Mastermind — Research ideas from a prompt, evaluate them with a PM lens, elaborate, and decompose into subtasks saved to docs/ideas/ (default) or monotask boards (--monotask flag)" -->
 
-**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-arguments check below.
+**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-arguments check below.
 
 If `$ARGUMENTS` is empty, output this and STOP:
 
@@ -103,7 +103,7 @@ After all agents complete:
 2. Deduplicate by title similarity (fuzzy match — drop ideas whose titles are >80% similar to an already-kept idea).
 3. Persist each unique idea:
 
-**File mode:** Append to `IDEA_FILE` using the idea section format from `_taskfile.md`:
+**File mode:** Append to `IDEA_FILE` using the idea section format from `mastermind-taskfile/SKILL.md`:
 ```markdown
 ### <Idea Title>
 > status: new
@@ -245,14 +245,14 @@ If there are todo tasks:
 
 *File mode:*
 ```
-Skill("mastermind-skills:do", "--file <TASK_FILE> --mode <parallel|minimal|sequential>")
+Skill("mastermind-do", "--file <TASK_FILE> --mode <parallel|minimal|sequential>")
 ```
 
 *Monotask mode:*
 ```
-Skill("mastermind-skills:do", "--monotask --space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
+Skill("mastermind-do", "--monotask --space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
 ```
 
 To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+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/improve.md

@@ -1,6 +1,6 @@
 <!-- "Mastermind — Deeply analyze a component, research improvements online, and create improvement tasks saved to docs/improvements/ (default) or monotask boards (--monotask flag)" -->
 
-**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-arguments check below.
+**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-arguments check below.
 
 If `$ARGUMENTS` is empty, output this and STOP:
 
@@ -47,7 +47,7 @@ Collect ALL of the following in parallel (skip any that error):
 
 Bundle all gathered information into a single `PROJECT_CONTEXT` string for downstream agents.
 
-**DELEGATION RULE:** Every agent spawned in this command MUST include the `== AGENT DELEGATION CAPABILITY ==` block (from `mastermind/_delegation.md`) in its prompt, immediately before `YOUR GOAL:`. This lets each agent spawn its own sub-agents when needed — delegation is recursive.
+**DELEGATION RULE:** Every agent spawned in this command MUST include the `== AGENT DELEGATION CAPABILITY ==` block (from `mastermind/mastermind-delegation/SKILL.md`) in its prompt, immediately before `YOUR GOAL:`. This lets each agent spawn its own sub-agents when needed — delegation is recursive.
 
 ---
 
@@ -175,7 +175,7 @@ The agent must synthesize the code analysis and online research into concrete im
 
 Persist each improvement:
 
-**File mode:** Append to `IMPROVE_FILE` using the improvement section format from `_taskfile.md`:
+**File mode:** Append to `IMPROVE_FILE` using the improvement section format from `mastermind-taskfile/SKILL.md`:
 ```markdown
 ### <Improvement Title>
 > status: discovered
@@ -329,14 +329,14 @@ If there are todo tasks:
 
 *File mode:*
 ```
-Skill("mastermind-skills:do", "--file <TASK_FILE> --mode <parallel|minimal|sequential>")
+Skill("mastermind-do", "--file <TASK_FILE> --mode <parallel|minimal|sequential>")
 ```
 
 *Monotask mode:*
 ```
-Skill("mastermind-skills:do", "--monotask --space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
+Skill("mastermind-do", "--monotask --space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
 ```
 
 To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.
 
-**MANDATORY — invoke `Skill("mastermind-skills:_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.
+**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.