monomind 1.10.47 → 1.10.55

package/.claude/commands/mastermind/repeat.md

@@ -0,0 +1,257 @@
+---
+name: mastermind:repeat
+description: "Monomind — Repeat any prompt or slash command on a schedule — default 15 min interval, 10 repetitions. This is the universal loop wrapper for all commands."
+---
+
+## Argument Parsing
+
+Parse `$ARGUMENTS` for the following flags. **Everything after the first `--` (double dash) is the prompt — no further flag parsing, even if subsequent `--` tokens appear.** If no `--` is present, extract known flags in any order and treat the remainder as the prompt:
+
+- `--every <minutes>` — interval between repetitions in minutes (default: `15`). Minimum 1.
+- `--times <count>` — total number of repetitions (default: `10`). Ignored when `--tillend` is present.
+- `--tillend` — run until a complete round produces no findings and no actions. Overrides `--times`.
+- `--maxruns <N>` — safety cap for `--tillend` (default: `50`). Stops the loop even if the AI hasn't signaled done.
+- `--rep <N>` — (internal continuation flag injected by ScheduleWakeup; do not expose to user). Must be a positive integer ≤ MAX_REPS+1; reject otherwise.
+- `--loop <id>` — (internal continuation flag; preserves loop identity across runs). Must match format `repeat-[digits]-[digits]-[digits]`; reject otherwise.
+- `--` — end of flags; everything after this is the prompt verbatim
+- Everything else (after flag extraction) is the **prompt** to repeat
+
+If `INTERVAL` is less than 1, set it to 1 and output: `[mastermind:repeat] Interval clamped to 1 minute (minimum).`
+
+If `MAX_REPS` is less than 1, set it to 1 and output: `[mastermind:repeat] Repetitions clamped to 1 (minimum).`
+
+If `MAX_REPS` is greater than 1000, set it to 1000 and output: `[mastermind:repeat] Repetitions clamped to 1000 (maximum).`
+
+If `--every` is present but its value is missing or not a number, use the default (15).
+
+If `--loop` is present but does not match the pattern `repeat-<digits>-<digits>-<digits>`, output `[mastermind:repeat] ERROR: invalid loop ID` and STOP.
+
+**Examples:**
+```
+/mastermind:repeat --every 5 --times 9 /mastermind:architect --iterate 2 review this project
+/mastermind:repeat --every 1 --times 20 /mastermind:review check for security issues
+/mastermind:repeat --every 30 /mastermind:do --space abc --board def
+/mastermind:repeat check deployment status
+```
+
+If `$ARGUMENTS` is empty or contains only flags with no prompt, output this and STOP:
+> **Usage:** `/mastermind:repeat [--every <minutes>] [--times <count>] [--tillend [--maxruns <N>]] <prompt>`
+>
+> Defaults: every 15 minutes, 10 times.
+>
+> **Fixed-count mode** (default): runs the prompt N times, then stops.
+> **Tillend mode** (`--tillend`): runs until a complete round produces no findings and no actions. Safety cap: `--maxruns N` (default 50).
+>
+> This is the universal loop wrapper. Wrap any slash command to repeat it:
+> - `/mastermind:repeat --every 5 --times 9 /mastermind:architect review this project`
+> - `/mastermind:repeat --every 1 --times 20 /mastermind:review check for security issues`
+> - `/mastermind:repeat --tillend /mastermind:review 1` ← runs until clean pass
+> - `/mastermind:repeat --every 30 /mastermind:do --space abc --board def`
+> - `/mastermind:repeat check deployment status`
+
+---
+
+## Internal Flag: `--rep` and `--loop`
+
+When `--rep <N>` is present in arguments, this is a continuation from a previous wake-up:
+- `INTERVAL`, `MAX_REPS`, and `PROMPT` are already set by argument parsing above (they arrive via the ScheduleWakeup prompt)
+- Set `CURRENT_REP` to `N` instead of `1`
+- Set `LOOP_ID` from `--loop <id>`
+- Skip Step 1 initialization entirely
+- Go directly to Step 2 (execute) with output:
+  - **If `--tillend` active:** `[mastermind:repeat] Tillend run N (cap: MAXRUNS) starting...`
+  - **Otherwise:** `[mastermind:repeat] Run N/MAX_REPS starting...`
+
+---
+
+## Step 1: Initialize
+
+Extract:
+- `INTERVAL` — from `--every` flag, default `15` (minutes), minimum 1
+- `MAX_REPS` — from `--times` flag, default `10`
+- `PROMPT` — everything remaining after flags are removed
+- `CURRENT_REP` — starts at `1`
+
+Write the initial loop state file so the dashboard can track this run. **You MUST run this bash block now via the Bash tool.** Before running, substitute `<INTERVAL>` and `<MAX_REPS>` with the parsed integer values, `<TILLEND_ACTIVE>` with `true` or `false` based on whether `--tillend` was provided, and `<MAXRUNS>` with the safety cap value. For `<PROMPT>`, substitute the raw prompt text inside the heredoc below — the single-quoted delimiter (`'MONOMIND_PROMPT_7x9k2m'`) prevents all bash expansion, and python3 handles JSON encoding. **If the prompt text contains the literal string `MONOMIND_PROMPT_7x9k2m`, replace that string in the prompt with `MONOMIND_PROMPT` before substitution** (this prevents heredoc delimiter collision):
+
+```bash
+mkdir -p .monomind/loops
+NOW_MS=$(python3 -c 'import time;print(int(time.time()*1000))' 2>/dev/null || echo "$(date +%s)000")
+LOOP_ID="repeat-${NOW_MS}-${RANDOM}-$$"
+PROMPT_JSON=$(python3 -c "import sys,json; sys.stdout.write(json.dumps(sys.stdin.read().rstrip(chr(10))))" << 'MONOMIND_PROMPT_7x9k2m'
+<PROMPT>
+MONOMIND_PROMPT_7x9k2m
+)
+if [ -z "$PROMPT_JSON" ]; then PROMPT_JSON='"(prompt unavailable)"'; fi
+LOOP_TYPE=$( [ '<TILLEND_ACTIVE>' = 'true' ] && echo 'tillend' || echo 'repeat' )
+LOOP_MAXREPS=$( [ '<TILLEND_ACTIVE>' = 'true' ] && echo '<MAXRUNS>' || echo '<MAX_REPS>' )
+cat > ".monomind/loops/${LOOP_ID}.json" << EOF
+{
+  "id": "${LOOP_ID}",
+  "sessionId": "${LOOP_ID}",
+  "type": "${LOOP_TYPE}",
+  "command": "/mastermind:repeat",
+  "prompt": ${PROMPT_JSON},
+  "interval": <INTERVAL>,
+  "currentRep": 1,
+  "maxReps": ${LOOP_MAXREPS},
+  "startedAt": ${NOW_MS},
+  "lastRunAt": ${NOW_MS},
+  "nextRunAt": ${NOW_MS},
+  "status": "running"
+}
+EOF
+echo "LOOP_ID=${LOOP_ID}"
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "{\"type\":\"loop:start\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/mastermind:repeat\",\"mode\":\"${LOOP_TYPE}\",\"maxReps\":${LOOP_MAXREPS},\"interval\":<INTERVAL>,\"ts\":$(date +%s)000}" || true
+```
+
+Capture the `LOOP_ID` value echoed by the script — you will need it for all subsequent bash blocks.
+
+Output:
+- **If `--tillend` active:**
+  ```
+  [mastermind:repeat] Starting tillend loop: "<PROMPT>"
+    Interval: every INTERVAL minutes
+    Safety cap: MAXRUNS runs
+    Run 1 starting now...
+  ```
+- **Otherwise:**
+  ```
+  [mastermind:repeat] Starting: "<PROMPT>"
+    Interval: every INTERVAL minutes
+    Repetitions: MAX_REPS total
+    Run 1/MAX_REPS starting now...
+  ```
+
+---
+
+## Step 2: Execute the Prompt
+
+Run the `PROMPT` as if the user typed it directly. This means:
+- If the prompt starts with `/`, invoke it as a slash command via the Skill tool
+- Otherwise, treat it as a normal user message and respond accordingly
+
+---
+
+## Step 3: Report and Schedule Next
+
+**IMPORTANT:** In every bash block below, `<LOOP_ID>` must be substituted with the literal LOOP_ID value you captured from Step 1 (or from `--loop` on continuation runs). Shell variables do NOT persist between bash blocks.
+
+Before scheduling the next run, check if a stop was requested:
+```bash
+[ -f ".monomind/loops/<LOOP_ID>.stop" ] && echo "STOP_REQUESTED=true" || echo "STOP_REQUESTED=false"
+```
+If `STOP_REQUESTED=true`, output `[mastermind:repeat] Stop requested via dashboard. Halting.` and remove the state files:
+```bash
+rm -f ".monomind/loops/<LOOP_ID>.json" ".monomind/loops/<LOOP_ID>.stop"
+```
+Then STOP.
+
+After execution completes, save the current rep as `PREV_REP`, then increment `CURRENT_REP`. Output:
+- **If `--tillend` active:** `[mastermind:repeat] Tillend run PREV_REP complete.`
+- **Otherwise:** `[mastermind:repeat] Run PREV_REP/MAX_REPS complete.`
+
+**If `--tillend` was active:** evaluate whether this round produced **zero findings AND zero actions**. Answer these two questions:
+1. Were any findings produced? (issues, problems, errors, tasks, items flagged, anything detected)
+2. Were any actions taken? (files edited, tasks created, commits made, content written, anything changed)
+
+Set `TILLEND_EMPTY=true` only if both answers are "no". **If the round found things and fixed them, `TILLEND_EMPTY=false` — run again to verify.** Only an actually empty round (nothing found, nothing done) stops the loop.
+
+If `TILLEND_EMPTY=true`:
+- Output: `[mastermind:repeat] Empty round — nothing found and nothing changed. Tillend loop complete after PREV_REP run(s).`
+- Remove state file and emit loop:complete:
+  ```bash
+  rm -f ".monomind/loops/<LOOP_ID>.json" ".monomind/loops/<LOOP_ID>.stop"
+  REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+  CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+  curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+    -H "Content-Type: application/json" \
+    -d "{\"type\":\"loop:complete\",\"loopId\":\"<LOOP_ID>\",\"command\":\"/mastermind:repeat\",\"mode\":\"tillend\",\"ranReps\":<PREV_REP>,\"reason\":\"empty-round\",\"ts\":$(date +%s)000}" || true
+  ```
+- STOP. Do NOT schedule another wake-up.
+
+If `--tillend` is active AND `CURRENT_REP > MAXRUNS` (safety cap reached):
+- Output: `[mastermind:repeat] Safety cap reached (MAXRUNS runs). Stopping tillend loop. If work remains, re-run with a higher --maxruns.`
+- Remove state file and emit loop:complete:
+  ```bash
+  rm -f ".monomind/loops/<LOOP_ID>.json" ".monomind/loops/<LOOP_ID>.stop"
+  REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+  CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+  curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+    -H "Content-Type: application/json" \
+    -d "{\"type\":\"loop:complete\",\"loopId\":\"<LOOP_ID>\",\"command\":\"/mastermind:repeat\",\"mode\":\"tillend\",\"ranReps\":<PREV_REP>,\"reason\":\"safety-cap\",\"ts\":$(date +%s)000}" || true
+  ```
+- STOP.
+
+If `CURRENT_REP > MAX_REPS` (fixed-count: all runs done), output:
+```
+[mastermind:repeat] All MAX_REPS repetitions complete.
+```
+Remove the state file and emit loop:complete:
+```bash
+rm -f ".monomind/loops/<LOOP_ID>.json" ".monomind/loops/<LOOP_ID>.stop"
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "{\"type\":\"loop:complete\",\"loopId\":\"<LOOP_ID>\",\"command\":\"/mastermind:repeat\",\"ranReps\":<MAX_REPS>,\"ts\":$(date +%s)000}" || true
+```
+STOP. Do NOT schedule another wake-up.
+
+Otherwise, update the loop state before scheduling. **Run this bash block** (substitute `<LOOP_ID>`, `<INTERVAL>`, `<CURRENT_REP>`, `<MAX_REPS>`, `<PREV_REP>`, `<TILLEND_ACTIVE>`, and `<MAXRUNS>` with their literal values):
+```bash
+NOW_MS=$(python3 -c 'import time;print(int(time.time()*1000))' 2>/dev/null || echo "$(date +%s)000")
+NEXT_AT=$(( NOW_MS + <INTERVAL> * 60 * 1000 ))
+PROMPT_JSON=$(jq '.prompt' ".monomind/loops/<LOOP_ID>.json" 2>/dev/null \
+  || python3 -c "import json,sys; json.dump(json.load(open('.monomind/loops/<LOOP_ID>.json'))['prompt'], sys.stdout)" 2>/dev/null \
+  || echo '"(prompt unavailable)"')
+STARTED_AT=$(jq '.startedAt' ".monomind/loops/<LOOP_ID>.json" 2>/dev/null \
+  || python3 -c "import json; print(json.load(open('.monomind/loops/<LOOP_ID>.json'))['startedAt'])" 2>/dev/null \
+  || echo "${NOW_MS}")
+LOOP_TYPE=$( [ '<TILLEND_ACTIVE>' = 'true' ] && echo 'tillend' || echo 'repeat' )
+LOOP_MAXREPS=$( [ '<TILLEND_ACTIVE>' = 'true' ] && echo '<MAXRUNS>' || echo '<MAX_REPS>' )
+cat > ".monomind/loops/<LOOP_ID>.json" << EOF
+{
+  "id": "<LOOP_ID>",
+  "sessionId": "<LOOP_ID>",
+  "type": "${LOOP_TYPE}",
+  "command": "/mastermind:repeat",
+  "prompt": ${PROMPT_JSON},
+  "interval": <INTERVAL>,
+  "currentRep": <CURRENT_REP>,
+  "maxReps": ${LOOP_MAXREPS},
+  "startedAt": ${STARTED_AT},
+  "lastRunAt": ${NOW_MS},
+  "nextRunAt": ${NEXT_AT},
+  "status": "running"
+}
+EOF
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "{\"type\":\"loop:tick\",\"loopId\":\"<LOOP_ID>\",\"command\":\"/mastermind:repeat\",\"mode\":\"${LOOP_TYPE}\",\"completedRep\":<PREV_REP>,\"nextRep\":<CURRENT_REP>,\"nextAt\":${NEXT_AT},\"ts\":$(date +%s)000}" || true
+```
+
+Output:
+- **If `--tillend` active:** `[mastermind:repeat] Next tillend run in INTERVAL minutes (run CURRENT_REP, cap: MAXRUNS)...`
+- **Otherwise:** `[mastermind:repeat] Next run in INTERVAL minutes (run CURRENT_REP/MAX_REPS)...`
+
+Use `ScheduleWakeup` with:
+- `delaySeconds`: `INTERVAL * 60`
+- **If `--tillend` active:** `prompt`: `/mastermind:repeat --tillend --maxruns <MAXRUNS> --every <INTERVAL> --rep <CURRENT_REP> --loop <LOOP_ID> -- <PROMPT>`; `reason`: `"tillend run <CURRENT_REP> (cap: <MAXRUNS>) of /mastermind:repeat"`
+- **Otherwise:** `prompt`: `/mastermind:repeat --every <INTERVAL> --times <MAX_REPS> --rep <CURRENT_REP> --loop <LOOP_ID> -- <PROMPT>`; `reason`: `"repeat run <CURRENT_REP>/<MAX_REPS> of /mastermind:repeat"`
+
+The `--` before `<PROMPT>` ensures the prompt text is never parsed as flags, even if it contains `--every` or `--times`. Substitute all angle-bracket values with their literals.
+
+---
+
+## Interruption
+
+The user can stop the loop at any time by:
+- Interrupting the session (the next scheduled wake-up simply won't fire)
+- Creating `.monomind/loops/<LOOP_ID>.stop` (or clicking Stop in the dashboard)

package/.claude/commands/mastermind/runorg.md

@@ -107,3 +107,6 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
 ```
 
 Follow _protocol.md Brain Write Procedure for domain `ops`.
+
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/.claude/commands/mastermind/skill-builder.md

@@ -0,0 +1,20 @@
+---
+name: mastermind-skill-builder
+description: Use when creating, editing, or verifying mastermind skills — guides the full TDD-for-docs cycle from baseline test through deployment
+---
+
+**First — extract repeat flags:** Follow REPEAT PREAMBLE from `_repeat.md`.
+
+Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text.
+
+Load brain context (follow `_protocol.md` Brain Load Procedure).
+
+Default mode: **auto**.
+
+---
+
+Invoke `Skill("mastermind:skill-builder")` passing: brain_context, params, mode.
+
+After skill returns: follow `_protocol.md` Brain Write Procedure.
+
+Invoke `Skill("mastermind:_repeat")` now. Required — do not skip.

package/.claude/commands/mastermind/specialagents.md

@@ -0,0 +1,125 @@
+---
+name: mastermind-specialagents
+description: Activate a specialist agent persona — browse by category, activate by slug, or auto-select based on conversation context
+---
+
+Activate a specialist agent persona. Three modes:
+
+**Direct:** `/mastermind:specialagents <slug>` — skip selection, activate immediately.
+
+**Interactive:** `/mastermind:specialagents` — guided category → agent selection.
+
+**Auto:** `/mastermind:specialagents auto` — LLM picks the best match from conversation context.
+
+---
+
+## Step 0 — Detect mode
+
+- If `$ARGUMENTS` is a non-empty string that is **not** `auto`:
+  - Treat it as a slug/name → jump to **Step 4: Activate**.
+- If `$ARGUMENTS` is `auto` or the user's message contains words like "auto", "automatically", "pick for me", "best agent", "suggest an agent":
+  - Jump to **Auto flow**.
+- Otherwise → **Interactive flow**.
+
+---
+
+## Interactive flow
+
+### Step 1 — List categories
+
+Run:
+```bash
+node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/hook-handler.cjs" list-extras 2>/dev/null
+```
+
+Parse the output. Extract the category names (lines like `=== ACADEMIC ===` → `academic`). Display them as a numbered list:
+
+```
+Available agent categories:
+1. academic
+2. design
+3. marketing
+4. paid-media
+5. product
+6. project-management
+7. sales
+8. specialized
+9. support
+
+Enter a number or category name:
+```
+
+Wait for the user to reply with their choice.
+
+### Step 2 — List agents in chosen category
+
+Map the user's reply to the lowercase category slug (e.g. "1" → `academic`, "Project Management" → `project-management`).
+
+Run:
+```bash
+node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/hook-handler.cjs" list-extras <category> 2>/dev/null
+```
+
+Parse the agents listed. Display them numbered:
+
+```
+Agents in <category>:
+1. slug-name — Short description
+2. ...
+
+Enter a number or agent slug:
+```
+
+Wait for the user to reply.
+
+### Step 3 — Confirm selection
+
+Echo back: `Activating agent: <slug>`
+
+Jump to **Step 4: Activate**.
+
+---
+
+## Auto flow
+
+### Auto Step 1 — Fetch all categories
+
+Run:
+```bash
+node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/hook-handler.cjs" list-extras 2>/dev/null
+```
+
+Read the full output. Based on the current conversation context (the user's request, task description, or recent messages), decide which **category** is the best fit. Do not ask the user — choose silently.
+
+### Auto Step 2 — Fetch agents in chosen category
+
+Run:
+```bash
+node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/hook-handler.cjs" list-extras <chosen-category> 2>/dev/null
+```
+
+Read the agent list. Based on the same conversation context, decide which **agent** is the best fit. Do not ask the user — choose silently.
+
+Announce your reasoning in one sentence:
+> "Auto-selected **<slug>** from **<category>** because <brief reason>."
+
+Jump to **Step 4: Activate**.
+
+---
+
+## Step 4 — Activate
+
+Run:
+```bash
+node "${CLAUDE_PROJECT_DIR:-$(pwd)}/.claude/helpers/router.cjs" --load-agent "<slug>" 2>/dev/null
+```
+
+Read the output. It will contain the agent's persona definition, capabilities, and behavioral rules.
+
+**Adopt the agent identity fully:**
+- Introduce yourself in the agent's voice: name, specialty, how you can help.
+- Apply all behavioral rules from the loaded persona for the rest of this conversation.
+- If the agent definition includes example openers or greetings, use one.
+- Remain in character unless the user explicitly asks to switch agents or end the session.
+
+If `router.cjs` returns an error or empty output, say: "Could not load agent `<slug>`. Run `/mastermind:specialagents` to browse available agents."

package/.claude/commands/mastermind/swarm.md

@@ -0,0 +1,161 @@
+---
+name: mastermind-swarm
+description: Multi-agent swarm coordination — init, start, status, stop, scale, and coordinate agent teams
+---
+
+# Monomind Swarm Coordination
+
+Multi-agent swarm coordination with hierarchical topology, distributed memory, and load balancing.
+
+## Subcommands
+
+| Subcommand | Description |
+|---|---|
+| `init` | Initialize a new swarm (topology + strategy) |
+| `start` | Start swarm execution with an objective |
+| `status` | Show current swarm status and progress |
+| `stop` | Stop swarm execution |
+| `scale` | Scale swarm agent count up or down |
+| `coordinate` | Launch v1 15-agent hierarchical-mesh coordination |
+
+## init — Initialize a Swarm
+
+```bash
+# Default (hierarchical, 15 agents)
+npx monomind swarm init
+
+# Anti-drift configuration (recommended)
+npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
+
+# v1 15-agent hierarchical-mesh
+npx monomind swarm init --v1-mode
+npx monomind swarm init --topology hierarchical-mesh --max-agents 15 --strategy specialized
+```
+
+**Flags:**
+
+| Flag | Short | Default | Description |
+|---|---|---|---|
+| `--topology` | `-t` | `hierarchical` | Swarm topology (see table below) |
+| `--max-agents` | `-m` | `15` | Maximum concurrent agents |
+| `--strategy` | `-s` | — | Coordination strategy |
+| `--auto-scale` | — | `true` | Enable automatic scaling |
+| `--v1-mode` | — | `false` | Enable v1 hierarchical-mesh with 15 agents |
+
+## Topologies
+
+| Topology | Use When |
+|---|---|
+| `hierarchical` | Feature dev, bug fixes — anti-drift, tight control |
+| `hierarchical-mesh` | Large teams 10-15 agents — v1 queen + peer communication |
+| `mesh` | Research, analysis — broad coverage |
+| `star` | Parallel testing, parallel maintenance |
+| `ring` | Sequential pipeline processing |
+| `hybrid` | Dynamic topology switching |
+
+## Strategies
+
+`specialized` (anti-drift, clear roles), `balanced`, `adaptive`, `development`, `research`, `testing`, `optimization`, `maintenance`, `analysis`
+
+## start — Start Swarm Execution
+
+```bash
+# Start a development swarm
+npx monomind swarm start -o "Build REST API with authentication" -s development
+
+# Parallel research swarm
+npx monomind swarm start -o "Analyze performance bottlenecks" -s research --parallel
+```
+
+**Flags:**
+
+| Flag | Short | Default | Description |
+|---|---|---|---|
+| `--objective` | `-o` | — | Swarm objective/task (required) |
+| `--strategy` | `-s` | `development` | Execution strategy |
+| `--parallel` | `-p` | `true` | Enable parallel execution |
+| `--monitor` | — | `true` | Enable real-time monitoring |
+
+## status — Check Swarm Progress
+
+```bash
+# Overall status
+npx monomind swarm status
+
+# Status for a specific swarm ID
+npx monomind swarm status swarm-abc123
+```
+
+## stop — Stop a Swarm
+
+```bash
+# Graceful stop (saves state by default)
+npx monomind swarm stop swarm-abc123
+
+# Force immediate stop
+npx monomind swarm stop swarm-abc123 --force
+```
+
+**Flags:**
+
+| Flag | Short | Default | Description |
+|---|---|---|---|
+| `--force` | `-f` | `false` | Force immediate stop |
+| `--save-state` | — | `true` | Save state for potential resume |
+
+## scale — Adjust Agent Count
+
+```bash
+# Scale to 12 agents
+npx monomind swarm scale swarm-abc123 --agents 12
+
+# Scale a specific agent type
+npx monomind swarm scale swarm-abc123 --agents 8 --type coder
+```
+
+## coordinate — v1 15-Agent Coordination
+
+```bash
+# Full v1 15-agent hierarchical mesh
+npx monomind swarm coordinate
+
+# Subset of agents
+npx monomind swarm coordinate --agents 8
+```
+
+Activates the v1 agent roster: Queen Coordinator, Security Architect, Security Auditor, Test Architect, Core Architect, Memory Specialist, Swarm Specialist, Integration Architect, Performance Engineer, CLI Developer, Hooks Developer, MCP Specialist, Project Coordinator, Documentation Lead, DevOps Engineer.
+
+## MCP Tools
+
+```javascript
+// Initialize swarm
+mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
+
+// Check status
+mcp__monomind__swarm_status({})
+
+// Health check
+mcp__monomind__swarm_health({})
+
+// Shutdown swarm
+mcp__monomind__swarm_shutdown({})
+```
+
+## Agent Team Routing
+
+| Task Type | Agents | Topology |
+|---|---|---|
+| Bug Fix | coordinator, researcher, coder, tester | hierarchical |
+| Feature | coordinator, architect, coder, tester, reviewer | hierarchical |
+| Refactor | coordinator, architect, coder, reviewer | hierarchical |
+| Performance | coordinator, perf-engineer, coder | hierarchical |
+| Security | coordinator, security-architect, auditor | hierarchical |
+| Research | coordinator, researcher x4, analyst x2 | mesh |
+
+## See Also
+
+- `npx monomind agent spawn` — Spawn individual agents
+- `npx monomind hive-mind init` — Byzantine fault-tolerant consensus
+- `/mastermind` — Interactive swarm topology selection
+
+Documentation: https://github.com/nokhodian/monomind

package/.claude/commands/mastermind/taskdev.md

@@ -0,0 +1,26 @@
+---
+name: mastermind-taskdev
+description: Execute an implementation plan task-by-task using fresh subagents with two-stage review per task. Default mode: auto.
+---
+
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-prompt check and intake below.
+
+Parse `$ARGUMENTS` for:
+- `--auto` flag → mode = auto
+- `--confirm` flag → mode = confirm
+- `--project <name>` → project_name = <name>
+- Remaining text = plan_file path (path to the plan `.md` file to execute)
+
+If plan_file is empty: ask "Which plan file should I execute? (provide an absolute path)"
+
+Load brain context (follow `_protocol.md` Brain Load Procedure).
+
+Default mode: **auto** (unless `--confirm` flag is present).
+
+---
+
+Invoke `Skill("mastermind:taskdev")` passing: brain_context, plan_file, project_name, mode.
+
+After skill returns: follow `_protocol.md` Brain Write Procedure.
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/.claude/commands/mastermind/tdd.md

@@ -0,0 +1,22 @@
+---
+name: mastermind-tdd
+description: Implement a feature or bugfix using Test-Driven Development — Red-Green-Refactor with the Iron Law enforced.
+---
+
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`.
+
+Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text = feature_or_bug.
+
+Load brain context for the `tdd` domain (follow `_protocol.md` Brain Load Procedure).
+
+If feature_or_bug is empty: ask "What feature or bug should be implemented with TDD?"
+
+Default mode: **auto**.
+
+---
+
+Invoke `Skill("mastermind:tdd")` passing: brain_context, feature_or_bug, project_name, mode.
+
+After skill returns: follow `_protocol.md` Brain Write Procedure for domain `tdd`.
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/.claude/commands/mastermind/techport.md

@@ -14,6 +14,8 @@ Parse `$ARGUMENTS` for:
 
 If source_path is empty: ask "What is the path to the project you want to analyze?"
 
+Load brain context for the `techport` domain (follow `_protocol.md` Brain Load Procedure).
+
 Default mode: **confirm** (show analysis + port plan, wait before executing anything).
 
 > **Note for `--tillend` / `--repeat` loops:** This command defaults to `--confirm`, which presents a plan but doesn't execute it. In an unattended loop, this means each run will find items (findings = yes) but take no action (actions = no), so `TILLEND_EMPTY` never becomes true and the loop runs until the safety cap. Always add `--auto` when using this command in a loop:
@@ -23,4 +25,6 @@ Default mode: **confirm** (show analysis + port plan, wait before executing anyt
 
 Invoke `Skill("mastermind:techport")` passing: source_path, focus_hint, mode.
 
+After skill returns: follow `_protocol.md` Brain Write Procedure for domain `techport`.
+
 Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.