monomind 2.5.1 → 2.5.3

package/README.md

@@ -365,7 +365,7 @@ Everything runs from inside Claude Code via slash commands. Here's the highlight
 graph TD
     CC["Claude Code"]
     MCP["MCP Server\nmonomind mcp start"]
-    D["Background Workers\n(@monomind/hooks, in-process)"]
+    D["Background Workers\n(@monoes/hooks, in-process)"]
     ORG["OrgDaemon\nmonomind org run\nreal SDK sessions"]
 
     CC <-->|"MCP tools: monograph, memory"| MCP

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "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/agents/github/repo-architect.md

@@ -220,7 +220,7 @@ jobs:
     key: "architecture/analysis/results",
     value: {
       timestamp: Date.now(),
-      repositories_analyzed: ["@monomind/cli", "@monomind/hooks"],
+      repositories_analyzed: ["@monomind/cli", "@monoes/hooks"],
       optimization_areas: ["structure", "workflows", "templates", "documentation"],
       recommendations: ["standardize_structure", "improve_workflows", "enhance_templates"],
       implementation_status: "in_progress"
@@ -284,10 +284,10 @@ const integrationPattern = {
   packages: {
     "@monomind/cli": {
       role: "orchestration_layer",
-      dependencies: ["@monomind/hooks", "@monomind/memory"],
+      dependencies: ["@monoes/hooks", "@monomind/memory"],
       provides: ["CLI", "workflows", "commands"],
     },
-    "@monomind/hooks": {
+    "@monoes/hooks": {
       role: "intelligence_engine",
       dependencies: ["@monomind/memory"],
       provides: ["hooks", "workers", "learning"],

package/packages/@monomind/cli/.claude/agents/github/sync-coordinator.md

@@ -182,7 +182,7 @@ Bash(`gh pr create \
     key: "sync/complete/status",
     value: {
       timestamp: Date.now(),
-      packages_synced: ["@monomind/cli", "@monomind/hooks"],
+      packages_synced: ["@monomind/cli", "@monoes/hooks"],
       version_alignment: "completed",
       documentation_sync: "completed",
       github_integration: "completed",
@@ -225,7 +225,7 @@ const docSyncPattern = {
 ### 3. **Integration Testing Matrix**
 ```javascript
 const testMatrix = {
-  packages: ["@monomind/cli", "@monomind/hooks", "@monomind/memory"],
+  packages: ["@monomind/cli", "@monoes/hooks", "@monomind/memory"],
   tests: [
     "unit_tests",
     "integration_tests",

package/packages/@monomind/cli/.claude/agents/specialists/integration-architect.md

@@ -1,7 +1,7 @@
 ---
 name: v1-integration-architect
 description: |
-  v1 Integration Architect for cross-package integration work within the Monomind monorepo. Owns the wiring between @monomind/cli, @monomind/hooks, @monomind/memory, @monomind/security, and @monoes/monograph — ensuring MCP tool contracts, hook event flows, and inter-package APIs stay coherent as each package evolves.
+  v1 Integration Architect for cross-package integration work within the Monomind monorepo. Owns the wiring between @monomind/cli, @monoes/hooks, @monomind/memory, @monomind/security, and @monoes/monograph — ensuring MCP tool contracts, hook event flows, and inter-package APIs stay coherent as each package evolves.
 ---
 
 # Integration Architect
@@ -17,7 +17,7 @@ Keep the 5 Monomind packages working as a coherent system. When a package change
 | Package | Role | Integration Surface |
 |---------|------|-------------------|
 | `@monomind/cli` | Orchestration layer | MCP server, CLI commands, init generator |
-| `@monomind/hooks` | Intelligence engine | Hook events, background workers, pattern learning |
+| `@monoes/hooks` | Intelligence engine | Hook events, background workers, pattern learning |
 | `@monomind/memory` | Persistence layer | LanceDB, HNSW search, session state |
 | `@monomind/security` | Input validation | CVE remediation, safe executor, path validator |
 | `@monoes/monograph` | Knowledge graph | Dependency analysis, community detection, impact |
@@ -40,7 +40,7 @@ type HookEvent = {
 All MCP tools exposed via `@monomind/cli/src/mcp-tools/` must:
 1. Validate inputs through `@monomind/security` before execution
 2. Persist results to `@monomind/memory` when stateful
-3. Emit hook events via `@monomind/hooks` for learning
+3. Emit hook events via `@monoes/hooks` for learning
 
 ### Memory Access Pattern
 
@@ -58,7 +58,7 @@ const result = await db.search({ query, namespace: 'package-name' });
 When a new feature spans multiple packages:
 
 - [ ] API contract defined and typed in the consuming package
-- [ ] Hook events documented in `@monomind/hooks/src/types.ts`
+- [ ] Hook events documented in `@monoes/hooks/src/types.ts`
 - [ ] MCP tool registered in `@monomind/cli/src/mcp-tools/index.ts`
 - [ ] Security validation added at system boundary
 - [ ] Memory schema migration written if LanceDB schema changes

package/packages/@monomind/cli/.claude/commands/github/repo-architect.md

@@ -143,7 +143,7 @@ See CLAUDE.md for complete integration instructions.`
 
 ```javascript
 // Synchronize structure across related repositories
-const repositories = ["@monomind/cli", "@monomind/hooks", "@monomind/memory"];
+const repositories = ["@monomind/cli", "@monoes/hooks", "@monomind/memory"];
 
 // Update common files across repositories
 repositories.forEach((repo) => {
@@ -248,7 +248,7 @@ monomind/
 │   │   ├── src/
 │   │   ├── .claude/
 │   │   └── package.json
-│   ├── @monomind/hooks/
+│   ├── @monoes/hooks/
 │   │   ├── src/
 │   │   └── package.json
 │   └── shared/
@@ -296,10 +296,10 @@ const integrationPattern = {
   packages: {
     "@monomind/cli": {
       role: "orchestration_layer",
-      dependencies: ["@monomind/hooks", "@monomind/memory"],
+      dependencies: ["@monoes/hooks", "@monomind/memory"],
       provides: ["CLI", "workflows", "commands"],
     },
-    "@monomind/hooks": {
+    "@monoes/hooks": {
       role: "coordination_engine",
       dependencies: [],
       provides: ["MCP_tools", "neural_networks", "memory"],

package/packages/@monomind/cli/.claude/commands/github/sync-coordinator.md

@@ -225,7 +225,7 @@ const docSyncPattern = {
   ],
   customSections: {
     "@monomind/cli": "GitHub Commands Integration",
-    "@monomind/hooks": "MCP Tools Reference"
+    "@monoes/hooks": "MCP Tools Reference"
   }
 }
 ```
@@ -234,7 +234,7 @@ const docSyncPattern = {
 ```javascript
 // Comprehensive testing across synchronized packages
 const testMatrix = {
-  packages: ["@monomind/cli", "@monomind/hooks"],
+  packages: ["@monomind/cli", "@monoes/hooks"],
   tests: [
     "unit_tests",
     "integration_tests", 

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.