monomind 1.16.6 → 1.16.7

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

@@ -0,0 +1,26 @@
+---
+name: mastermind-research
+description: Mastermind research domain — market research, competitor analysis, user research, trend scanning. Default mode: auto.
+---
+
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-prompt check and intake below.
+
+Parse `$ARGUMENTS` for:
+- `--auto` flag → mode = auto
+- `--confirm` flag → mode = confirm
+- `--project <name>` → project_name = <name>
+- Remaining text = prompt
+
+If prompt is empty: ask "What would you like researched?"
+
+Load brain context for the `research` domain (follow _protocol.md Brain Load Procedure).
+
+Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `research`).
+
+Default mode for this command: **auto** (unless `--confirm` flag present or intake Q4 says confirm).
+
+Invoke `Skill("mastermind:research")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+
+After skill returns: follow _protocol.md Brain Write Procedure for domain `research`.
+
+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/review.md

@@ -0,0 +1,26 @@
+---
+name: mastermind-review
+description: Mastermind review domain — code review, security audit, content and strategy review. Default mode: auto.
+---
+
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-prompt check and intake below.
+
+Parse `$ARGUMENTS` for:
+- `--auto` flag → mode = auto
+- `--confirm` flag → mode = confirm
+- `--project <name>` → project_name = <name>
+- Remaining text = prompt
+
+If prompt is empty: ask "What would you like reviewed?"
+
+Load brain context for the `review` domain (follow _protocol.md Brain Load Procedure).
+
+Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `review`).
+
+Default mode for this command: **auto** (unless `--confirm` flag present or intake Q4 says confirm).
+
+Invoke `Skill("mastermind:review")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+
+After skill returns: follow _protocol.md Brain Write Procedure for domain `review`.
+
+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/runorg.md

@@ -0,0 +1,156 @@
+---
+name: mastermind-runorg
+description: Start a saved org as a persistent autonomous agent organization. The boss agent coordinates all roles; agents pick up tasks from a shared board and run until stopped.
+---
+
+**If $ARGUMENTS is empty:** List saved orgs and display the following.
+
+---
+
+**MASTERMIND: RUN ORG**
+
+Running an org starts an autonomous agent organization. There are two modes:
+
+**Persistent org** (no schedule): a boss agent loads the org definition, assigns work to specialists from a shared board, and loops indefinitely. Stop with `/mastermind:stoporg --org <name>`.
+
+**Scheduled org** (created with `--schedule`): sets the org to `active` and runs the first iteration immediately. Subsequent iterations are self-scheduled via ScheduleWakeup. The loop stops cleanly within one interval after `/mastermind:stoporg --org <name>`.
+
+**Your saved orgs:**
+
+```bash
+ls .monomind/orgs/*.json 2>/dev/null | xargs -I{} basename {} .json 2>/dev/null || echo "(none — run /mastermind:createorg to define one)"
+```
+
+**Usage:**
+
+```
+/mastermind:runorg --org <name>
+
+/mastermind:runorg --org content-team --task "Publish the Q2 product roundup post by Friday"
+
+/mastermind:runorg --org research-pod "Focus this week on competitor pricing changes"
+```
+
+**Options:**
+`--org <name>` — which saved org to start (required; prompted if omitted)
+`--task <task>` — override the org's default goal for this run
+Any remaining text is passed as additional context to the boss agent.
+
+No orgs yet? Run `/mastermind:createorg` to define one.
+
+---
+
+**If $ARGUMENTS is non-empty:** Execute the flow below.
+
+---
+
+**STEP 0 — Extract loop-control flags (do this FIRST, before any other parsing)**
+
+Scan `$ARGUMENTS` for these flags and store their values. Remove them from the argument string before Step 1:
+
+| Flag | Variable | Default |
+|---|---|---|
+| `--rep <N>` | `current_rep = N` | absent |
+| `--loop <id>` | `LOOP_ID = id` | absent |
+| `--tillend` | `tillend_mode = true` | false |
+| `--maxruns <N>` | `tillend_maxruns = N` | 50 |
+| `--wait <N>` | `wait_seconds = N` | 60 |
+| `--repeat <N>` | `repeat_count = N` | 0 |
+
+⚠️ **CRITICAL — CONTINUATION RUNS DO NOT SKIP WORK.** When `--rep N` is present, this is a scheduled continuation triggered by ScheduleWakeup. The org's FULL work cycle MUST still execute every time: session variables → session:start event → Skill("mastermind:runorg") → session:complete event. NEVER short-circuit or skip the org work because `--rep` is present. The `--rep` / `--loop` flags are only consumed by `Skill("mastermind:_repeat")` at the end.
+
+---
+
+**STEP 1 — Parse org-specific flags**
+
+From the remaining `$ARGUMENTS` (after loop flags removed in Step 0):
+- `--org <name>` → org_name = <name>
+- `--task <task>` → task_override = <task> (if omitted, task_override = null — the skill uses org's stored goal)
+- Remaining text = additional context passed to the boss agent
+
+If `--org` is not provided, list saved orgs and ask which to run:
+```bash
+orgs=$(ls .monomind/orgs/*.json 2>/dev/null | xargs -I{} basename {} .json 2>/dev/null)
+if [ -z "$orgs" ]; then
+  echo "No saved orgs found. Run /mastermind:createorg first."
+  exit 1
+fi
+echo "$orgs"
+```
+Ask: "Which org would you like to start? Available: <list from above>"
+
+Verify the org file exists before proceeding:
+```bash
+[ -f ".monomind/orgs/${org_name}.json" ] || { echo "Org '${org_name}' not found."; exit 1; }
+```
+If the file does not exist, stop and suggest running `/mastermind:createorg --name ${org_name}`.
+
+Load brain context for the `ops` domain (follow _protocol.md Brain Load Procedure, namespace: `ops`).
+
+Resolve session ID and project root:
+```bash
+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")
+# Reuse the loop's original sessionId for continuation runs (keeps all reps under one session)
+if [ -n "${LOOP_ID:-}" ] && [ -f ".monomind/loops/${LOOP_ID}.json" ]; then
+  session_id=$(jq -r '.sessionId // empty' ".monomind/loops/${LOOP_ID}.json" 2>/dev/null)
+fi
+session_id="${session_id:-mm-$(date -u +%Y%m%dT%H%M%S)}"
+```
+
+Emit `session:start` to dashboard:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg org "$org_name" \
+    --arg proj "$REPO_ROOT" \
+    '{type:"session:start",session:$session,domain:"ops",prompt:("Running org: "+$org),mode:"auto",project:$proj,ts:(now*1000|floor)}')" || true
+```
+
+Emit `domain:dispatch`:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg org "$org_name" \
+    --arg proj "$REPO_ROOT" \
+    '{type:"domain:dispatch",session:$session,domain:"ops",cmd:("Starting org "+$org+" as persistent daemon"),project:$proj,ts:(now*1000|floor)}')" || true
+```
+
+Invoke `Skill("mastermind:runorg")` passing: brain_context, org_name: `$org_name`, session_id: `$session_id`, task: task_override, caller: "command".
+
+After the skill spawns the boss agent and returns: note the status. Emit `session:complete`:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg status "<status>" \
+    --arg proj "$REPO_ROOT" \
+    '{type:"session:complete",session:$session,domain:"ops",status:$status,domains:["ops"],project:$proj,ts:(now*1000|floor)}')" || true
+```
+
+Follow _protocol.md Brain Write Procedure for domain `ops`.
+
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+
+After the REPEAT POSTAMBLE completes, if a loop was started or continued (LOOP_ID is set), write the org name into the loop state file so the dashboard can detect running status:
+```bash
+if [ -n "${LOOP_ID:-}" ]; then
+  LOOP_FILE=".monomind/loops/${LOOP_ID}.json"
+  if [ -f "$LOOP_FILE" ]; then
+    python3 -c "
+import json, sys
+f = sys.argv[1]; org = sys.argv[2]
+d = json.load(open(f))
+if 'orgName' not in d:
+    d['orgName'] = org
+    open(f, 'w').write(json.dumps(d, indent=2))
+" "$LOOP_FILE" "${org_name}" 2>/dev/null || true
+  fi
+fi
+```

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

@@ -0,0 +1,26 @@
+---
+name: mastermind-sales
+description: Mastermind sales domain — outreach sequences, proposals, pipeline management. Default mode: confirm.
+---
+
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-prompt check and intake below.
+
+Parse `$ARGUMENTS` for:
+- `--auto` flag → mode = auto
+- `--confirm` flag → mode = confirm
+- `--project <name>` → project_name = <name>
+- Remaining text = prompt
+
+If prompt is empty: ask "What sales task would you like to tackle?"
+
+Load brain context for the `sales` domain (follow _protocol.md Brain Load Procedure).
+
+Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `sales`).
+
+Default mode for this command: **confirm** (unless `--auto` flag present or intake Q4 says auto).
+
+Invoke `Skill("mastermind:sales")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+
+After skill returns: follow _protocol.md Brain Write Procedure for domain `sales`.
+
+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/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/packages/@monomind/cli/.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/packages/@monomind/cli/.claude/commands/mastermind/stoporg.md

@@ -0,0 +1,78 @@
+---
+name: mastermind-stoporg
+description: Stop a running scheduled org loop. Sets status to "stopped" — the next scheduled wakeup reads the status, skips all work, and does not reschedule. Loop dies within one interval.
+---
+
+**If $ARGUMENTS is empty:** Output the following and wait.
+
+---
+
+**MASTERMIND: STOP ORG**
+
+Stops a scheduled org loop cleanly. The org's `status` is set to `"stopped"` — the next scheduled wakeup will read the status, skip all work, and not reschedule itself. The loop is guaranteed to die within one interval (no orphaned wakeups).
+
+**Usage:**
+
+```
+/mastermind:stoporg --org <name>
+```
+
+**Examples:**
+
+```
+/mastermind:stoporg --org livarto-issue-resolver
+/mastermind:stoporg --org research-pod
+```
+
+**Lifecycle:**
+```
+stopped  →  (runorg)   →  active
+active   →  (stoporg)  →  stopped
+active   →  (HIL)      →  paused    (set manually in .monomind/orgs/<name>.json)
+paused   →  (set active) →  active  (resume by setting status back to "active" in the JSON)
+```
+
+Your scheduled orgs:
+
+```bash
+ls .monomind/orgs/*.json 2>/dev/null | grep -v -- '-approvals\|-state\|-activity' | \
+  xargs -I{} sh -c 'name=$(jq -r ".name" "{}"); status=$(jq -r ".status // \"no-loop\"" "{}"); interval=$(jq -r "if .loop.poll_interval_minutes then \"\(.loop.poll_interval_minutes)m\" else \"—\" end" "{}"); echo "  $name  ($status, $interval)"' 2>/dev/null || echo "(none)"
+```
+
+---
+
+**If $ARGUMENTS is non-empty:** Execute the flow below.
+
+---
+
+Parse `$ARGUMENTS` for:
+- `--org <name>` → org_name = <name>
+
+If `--org` is not provided, list orgs with schedules and ask which to stop.
+
+Verify the org file exists:
+```bash
+[ -f ".monomind/orgs/${org_name}.json" ] || { echo "Org '${org_name}' not found."; exit 1; }
+```
+
+Generate a session ID:
+```bash
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+session_id="mm-$(date -u +%Y%m%dT%H%M%S)"
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+```
+
+Invoke `Skill("mastermind:stoporg")` passing: org_name: `$org_name`, session_id: `$session_id`, caller: "command".
+
+After skill returns: emit `session:complete`:
+```bash
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    '{type:"session:complete",session:$session,domain:"ops",status:"complete",domains:["ops"],ts:(now*1000|floor)}')" || true
+```
+
+Follow _protocol.md Brain Write Procedure for domain `ops`.
+
+Invoke `Skill("mastermind:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/packages/@monomind/cli/.claude/commands/mastermind/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/monoes/monomind

package/packages/@monomind/cli/.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/packages/@monomind/cli/.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.