monomind 1.19.0 → 2.0.1

package/.claude/commands/mastermind/references/gemini-tools.md

@@ -1,63 +0,0 @@
-# Gemini CLI Tool Mapping
-
-Skills speak in actions ("dispatch a subagent", "create a todo", "read a file"). On Gemini CLI these resolve to the tools below.
-
-| Action skills request | Gemini CLI equivalent |
-|----------------------|----------------------|
-| Read a file | `read_file` |
-| Read multiple files at once | `read_many_files` |
-| Create a new file | `write_file` |
-| Edit a file | `replace` |
-| Run a shell command | `run_shell_command` |
-| Search file contents | `grep_search` |
-| Find files by name | `glob` |
-| List files and subdirectories | `list_directory` |
-| Fetch a URL | `web_fetch` |
-| Search the web | `google_web_search` |
-| Invoke a skill | `activate_skill` |
-| Dispatch a subagent (`Subagent (general-purpose):` template) | `invoke_agent` with `agent_name: "generalist"` (invocable via `@generalist` chat syntax — see [Subagent support](#subagent-support)) |
-| Multiple parallel dispatches | Multiple `invoke_agent` calls in the same response |
-| Task tracking ("create a todo", "mark complete") | `write_todos` (statuses: pending, in_progress, completed, cancelled, blocked) |
-
-## Instructions file
-
-When a skill mentions "your instructions file", on Gemini CLI this is **`GEMINI.md`**. Gemini CLI loads `GEMINI.md` hierarchically: global at `~/.gemini/GEMINI.md`, project-level files in workspace directories and their ancestors, and sub-directory `GEMINI.md` files when a tool accesses files in those directories.
-
-## Personal skills directory
-
-User-level skills live at **`~/.gemini/skills/`**, with **`~/.agents/skills/`** as a cross-runtime alias (shared with Codex and Copilot CLI). When both directories exist at the same scope, `.agents/skills/` takes precedence. Each skill is a subdirectory containing a `SKILL.md` (with `name` and `description` frontmatter).
-
-## Subagent support
-
-Gemini CLI dispatches subagents through the `invoke_agent` tool, which takes `agent_name` and `prompt` parameters. The same dispatch is also surfaced as a chat-syntax shortcut: typing `@generalist <prompt>` is equivalent to calling `invoke_agent` with `agent_name: "generalist"`. Built-in agent names include `generalist`, `cli_help`, `codebase_investigator`, and (with browser tooling enabled) `browser_agent`.
-
-Skills dispatch with `Subagent (general-purpose):` and either reference a prompt-template file or supply an inline prompt. On Gemini CLI:
-
-| Skill dispatch form | Gemini CLI equivalent |
-|---------------------|----------------------|
-| References an implementer template (writes code, runs tests) | Fill the template, then `invoke_agent` with `agent_name: "generalist"` and the filled prompt |
-| References a code-reviewer template (`mastermind:review`) | `invoke_agent` with `agent_name: "generalist"` and the filled review template |
-| Inline prompt (no template referenced) | `invoke_agent` with `agent_name: "generalist"` and your inline prompt |
-
-### Prompt filling
-
-Skills provide prompt templates with placeholders like `{WHAT_WAS_IMPLEMENTED}` or `[FULL TEXT of task]`. Fill all placeholders before passing the complete prompt to `invoke_agent`. The prompt template itself contains the agent's role, review criteria, and expected output format — the subagent will follow it.
-
-### Parallel dispatch
-
-Gemini CLI supports parallel subagent dispatch. Issue multiple `invoke_agent` calls in the same response to run independent subagent work in parallel. Keep dependent tasks sequential, but do not serialize independent subagent tasks just to preserve a simpler history.
-
-## Additional Gemini CLI tools
-
-These tools are unique to Gemini CLI:
-
-| Tool | Purpose |
-|------|---------|
-| `save_memory` (legacy) | Persist facts across sessions when `experimental.memoryV2 = false` |
-| `get_internal_docs` | Look up Gemini CLI's bundled documentation |
-| `ask_user` | Pose structured questions to the user (text / single-select / multi-select) |
-| `enter_plan_mode` / `exit_plan_mode` | Switch into and out of read-only plan mode |
-| `update_topic` | Update the current conversation's topic / strategic-intent metadata |
-| `complete_task` | Signal that a Gemini subagent has completed and return its result to the parent agent |
-| `tracker_create_task`, `tracker_update_task`, `tracker_get_task`, `tracker_list_tasks`, `tracker_add_dependency`, `tracker_visualize` | Rich task tracker with dependency and visualization support |
-| `read_mcp_resource`, `list_mcp_resources` | MCP resource access |

package/.claude/commands/mastermind/references/pi-tools.md

@@ -1,28 +0,0 @@
-# Pi Tool Mapping
-
-Skills speak in actions ("dispatch a subagent", "create a todo", "read a file"). On Pi these resolve to the tools below.
-
-| Action skills request | Pi equivalent |
-| --- | --- |
-| Invoke a skill | Pi native skills: load the relevant `SKILL.md` with `read`, or let the human use `/skill:name` |
-| Read a file | `read` |
-| Create a file | `write` |
-| Edit a file | `edit` |
-| Run a shell command | `bash` |
-| Search file contents | `grep` when active; otherwise `bash` with `rg`/`grep` |
-| Find files by name | `find` or `bash` with shell globs |
-| List files and subdirectories | `ls` when active; otherwise `bash` with `ls` |
-| Dispatch a subagent (`Subagent (general-purpose):` template) | Use an installed subagent tool such as `subagent` from `pi-subagents` if available |
-| Task tracking ("create a todo", "mark complete") | Use an installed todo/task tool if available, otherwise track tasks in the plan or `TODO.md` |
-
-## Skills
-
-Pi discovers skills from configured skill directories and installed Pi packages. A Mastermind Pi package should expose `skills/` through its `pi.skills` manifest entry. Pi does not expose Claude Code's `Skill` tool, but the agent should still follow the Mastermind rule: when a skill applies, load and follow it before responding.
-
-## Subagents
-
-Pi core does not ship a standard subagent tool. The `pi-subagents` package is a strong optional companion and provides a `subagent` tool with single-agent, chain, parallel, async, forked-context, and resume/status workflows. If no subagent tool is available, do not fabricate `Task` calls; execute sequentially in the current session or explain that the optional subagent capability is not installed.
-
-## Task lists
-
-Pi core does not ship a standard task-list tool. If a todo/task extension is installed, use its documented tool. Otherwise use Mastermind plan files, checklists in Markdown, or a repo-local `TODO.md` for task tracking. Older docs may refer to `TodoWrite`; treat that as the task-tracking action above.

package/.claude/commands/mastermind/release.md

@@ -1,23 +0,0 @@
-<!-- Mastermind release domain — versioning, changelog, deployment. 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 to release or deploy?"
-
-Load brain context for the `release` domain (follow _protocol.md Brain Load Procedure).
-
-Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `release`).
-
-Default mode for this command: **auto** (unless `--confirm` flag present or intake Q4 says confirm).
-
-Invoke `Skill("mastermind-skills:release")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
-
-After skill returns: follow _protocol.md Brain Write Procedure for domain `release`.
-
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

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

@@ -1,254 +0,0 @@
-<!-- "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/research.md

@@ -1,23 +0,0 @@
-<!-- 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-skills: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`.
-
-**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.

package/.claude/commands/mastermind/review.md

@@ -1,34 +0,0 @@
-<!-- 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-skills:review")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
-
-**After review findings are collected — AUTO-FIX STEP (mode = auto only):**
-
-When `mode = auto` (the default): if the review produced any fixable findings (code issues, bugs, style problems, security vulnerabilities with clear fixes), apply the fixes immediately in this same run. Do not ask the user whether to fix — auto mode means fix without asking. Specifically:
-1. For each fixable finding, edit the file directly to resolve it.
-2. After all fixes are applied, output a summary: `[review] Auto-fixed N issues. Remaining M issues require manual intervention.`
-3. Non-fixable findings (architectural concerns, design questions, trade-off decisions) are reported but not acted on.
-
-When `mode = confirm`: present findings and ask the user which to fix. This is the ONLY mode where asking is appropriate.
-
-**When `--tillend` is active:** auto-fix is especially critical. Without it, the loop finds the same unfixed issues every round and either loops forever or the AI falsely declares an empty round. The tillend contract is: find → fix → verify (next round) → stop when clean.
-
-After skill returns: follow _protocol.md Brain Write Procedure for domain `review`.
-
-**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.

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

@@ -1,153 +0,0 @@
-<!-- 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-skills: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-skills:_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-skills: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`.
-
-
-**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.
-
-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/.claude/commands/mastermind/sales.md

@@ -1,23 +0,0 @@
-<!-- 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-skills: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-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

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

@@ -1,17 +0,0 @@
-<!-- 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-skills:skill-builder")` passing: brain_context, params, mode.
-
-After skill returns: follow `_protocol.md` Brain Write Procedure.
-
-Invoke `Skill("mastermind-skills:_repeat")` now. Required — do not skip.