@monoes/monomindcli 1.8.0 → 1.9.1

package/.claude/commands/monomind/repeat.md

@@ -0,0 +1,201 @@
+---
+name: monomind: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`)
+- `--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: `[monomind:repeat] Interval clamped to 1 minute (minimum).`
+
+If `MAX_REPS` is less than 1, set it to 1 and output: `[monomind:repeat] Repetitions clamped to 1 (minimum).`
+
+If `MAX_REPS` is greater than 1000, set it to 1000 and output: `[monomind: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 `[monomind:repeat] ERROR: invalid loop ID` and STOP.
+
+**Examples:**
+```
+/monomind:repeat --every 5 --times 9 /mastermind:architect --iterate 2 review this project
+/monomind:repeat --every 1 --times 20 /mastermind:review check for security issues
+/monomind:repeat --every 30 /monomind:do --space abc --board def
+/monomind:repeat check deployment status
+```
+
+If `$ARGUMENTS` is empty or contains only flags with no prompt, output this and STOP:
+> **Usage:** `/monomind:repeat [--every <minutes>] [--times <count>] <prompt>`
+>
+> Defaults: every 15 minutes, 10 times.
+>
+> This is the universal loop wrapper. Wrap any slash command to repeat it:
+> - `/monomind:repeat --every 5 --times 9 /mastermind:architect review this project`
+> - `/monomind:repeat --every 1 --times 20 /mastermind:review check for security issues`
+> - `/monomind:repeat --every 30 /monomind:do --space abc --board def`
+> - `/monomind: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:
+  ```
+  [monomind: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. 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
+cat > ".monomind/loops/${LOOP_ID}.json" << EOF
+{
+  "id": "${LOOP_ID}",
+  "sessionId": "${LOOP_ID}",
+  "type": "repeat",
+  "command": "/monomind:repeat",
+  "prompt": ${PROMPT_JSON},
+  "interval": <INTERVAL>,
+  "currentRep": 1,
+  "maxReps": <MAX_REPS>,
+  "startedAt": ${NOW_MS},
+  "lastRunAt": ${NOW_MS},
+  "nextRunAt": ${NOW_MS},
+  "status": "running"
+}
+EOF
+echo "LOOP_ID=${LOOP_ID}"
+curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "{\"type\":\"loop:start\",\"loopId\":\"${LOOP_ID}\",\"command\":\"/monomind:repeat\",\"maxReps\":<MAX_REPS>,\"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:
+```
+[monomind: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 `[monomind: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:
+```
+[monomind:repeat] Run PREV_REP/MAX_REPS complete.
+```
+
+If `CURRENT_REP > MAX_REPS` (all runs done), output:
+```
+[monomind: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"
+curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "{\"type\":\"loop:complete\",\"loopId\":\"<LOOP_ID>\",\"command\":\"/monomind: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>`, and `<PREV_REP>` 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}")
+cat > ".monomind/loops/<LOOP_ID>.json" << EOF
+{
+  "id": "<LOOP_ID>",
+  "sessionId": "<LOOP_ID>",
+  "type": "repeat",
+  "command": "/monomind:repeat",
+  "prompt": ${PROMPT_JSON},
+  "interval": <INTERVAL>,
+  "currentRep": <CURRENT_REP>,
+  "maxReps": <MAX_REPS>,
+  "startedAt": ${STARTED_AT},
+  "lastRunAt": ${NOW_MS},
+  "nextRunAt": ${NEXT_AT},
+  "status": "running"
+}
+EOF
+curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "{\"type\":\"loop:tick\",\"loopId\":\"<LOOP_ID>\",\"command\":\"/monomind:repeat\",\"completedRep\":<PREV_REP>,\"nextRep\":<CURRENT_REP>,\"nextAt\":${NEXT_AT},\"ts\":$(date +%s)000}" || true
+```
+
+Output: `[monomind:repeat] Next run in INTERVAL minutes (run CURRENT_REP/MAX_REPS)...`
+
+Use `ScheduleWakeup` with:
+- `delaySeconds`: `INTERVAL * 60`
+- `prompt`: `/monomind:repeat --every <INTERVAL> --times <MAX_REPS> --rep <CURRENT_REP> --loop <LOOP_ID> -- <PROMPT>`
+- `reason`: `"repeat run <CURRENT_REP>/<MAX_REPS> of /monomind: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/monomind/review.md

@@ -0,0 +1,313 @@
+---
+name: monomind:review
+description: "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."
+---
+
+Parse `$ARGUMENTS` as `TOTAL_ITERATIONS` (integer, min 1, max 10).
+
+If `$ARGUMENTS` is empty, not a positive integer, or greater than 10, output this and STOP:
+
+> **Usage:** `/monomind:review <iterations>`
+>
+> Examples:
+> - `/monomind:review 1` — single review pass
+> - `/monomind:review 3` — three fix-and-re-review cycles
+>
+> Runs parallel review agents each iteration, auto-fixes what can be fixed, and saves items requiring human judgment to `humaninloopreview-YYYY-MM-DD.md`.
+
+Do NOT proceed further if no valid number was provided.
+
+---
+
+## Terminology
+
+- **Finding**: An issue reported by any review agent.
+- **Auto-fixable**: Claude can apply the fix without ambiguity and without changing intended behavior.
+- **Human-in-loop (HIL)**: Requires a product/design/architecture decision, a credential, a policy choice, or something Claude cannot safely assume. These are written to the HIL file and skipped.
+- **HIL file**: `humaninloopreview-<YYYY-MM-DD>.md` in the project root. Appended each loop; never overwritten.
+
+---
+
+## Step 0: Setup
+
+Parse `$ARGUMENTS` as `TOTAL_ITERATIONS` (integer, min 1, max 10).
+
+Collect the following in parallel:
+
+1. **Git context**: Run the following to get recently changed files. Store result as `CHANGED_FILES`.
+   ```bash
+   CHANGED_FILES=$(git diff --name-only HEAD~1 HEAD 2>/dev/null)
+   [ -z "$CHANGED_FILES" ] && CHANGED_FILES=$(git ls-files -m 2>/dev/null)
+   [ -z "$CHANGED_FILES" ] && CHANGED_FILES=$(git diff --name-only HEAD~5 HEAD 2>/dev/null)
+   ```
+2. **Repo structure**: Run `git ls-files | head -80` to get a representative file list. Store as `FILE_LIST`.
+3. **Branch info**: Run `git log --oneline -5` to get recent commit context. Store as `RECENT_COMMITS`.
+4. **Stack detection**: Run `ls package.json pyproject.toml go.mod Cargo.toml 2>/dev/null; find . -maxdepth 3 \( -name "*.swift" -o -name "*.kt" \) | head -3` to detect language/framework. Store detected stacks as `STACK`.
+5. **HIL file path**: Compute `HIL_FILE=humaninloopreview-$(date +%Y-%m-%d).md` in the project root.
+
+Initialize tracking state:
+```
+ITERATION = 1
+ITERATIONS_RUN = 0       # how many iterations actually executed (for final report)
+ALL_FIXED = []           # auto-fixed items (across all iterations)
+ALL_HIL = []             # human-in-loop items (across all iterations)
+HIL_COUNT = 0            # global counter for HIL-N labels
+PENDING_FIXED = []       # staging: auto-fixed this batch, not yet verified
+ITERATION_FIXED_FILES = []  # file paths edited this iteration
+```
+
+---
+
+## Step 1: Select Review Agents for This Stack
+
+Based on `STACK`, determine which specialist agents to run beyond the always-on core set.
+
+**Always run (every stack):**
+- `Code Reviewer` — correctness, maintainability, performance, naming, dead code
+- `Security Engineer` — injection, auth gaps, secrets exposure, CVE-prone patterns, OWASP Top 10
+- `Reality Checker` — evidence-based assessment: does the code actually do what it claims?
+
+**Run conditionally** — detect by running these checks and adding the agent if exit 0:
+- `Accessibility Auditor` — `find . -maxdepth 5 \( -name "*.html" -o -name "*.jsx" -o -name "*.tsx" \) -not -path "*/node_modules/*" | head -1 | grep -q .`
+- `API Tester` — `find . -maxdepth 5 \( -name "*.route.*" -o -name "openapi.yml" -o -name "openapi.json" -o -name "swagger.*" \) -not -path "*/node_modules/*" | head -1 | grep -q . || grep -rqEl "express\(|fastify|hono|koa|router\." --include="*.ts" --include="*.js" . 2>/dev/null`
+- `Database Optimizer` — `find . -maxdepth 5 \( -name "*.sql" -o -name "*migration*" -o -name "*schema*" \) -not -path "*/node_modules/*" | head -1 | grep -q . || grep -rqEl "prisma|typeorm|sequelize|drizzle|knex" --include="*.ts" --include="*.js" . 2>/dev/null`
+- `SRE` — `find . -maxdepth 3 \( -name "Dockerfile" -o -name "docker-compose*" -o -name "*.yml" -path "*/.github/workflows/*" \) | head -1 | grep -q .`
+- `Mobile App Builder` — `find . -maxdepth 3 \( -name "*.swift" -o -name "*.kt" \) | head -1 | grep -q . || grep -q "react-native" package.json 2>/dev/null`
+
+Store the selected set as `ACTIVE_REVIEWERS`.
+
+---
+
+## Loop: Run `TOTAL_ITERATIONS` times
+
+For each iteration, first reset per-iteration state:
+```
+PENDING_FIXED = []
+ITERATION_FIXED_FILES = []
+```
+
+---
+
+### Step 2: Run All Reviewers in Parallel
+
+Spawn one agent per reviewer in `ACTIVE_REVIEWERS` using the `Task` tool — all in a **single message** so they run concurrently.
+
+Each agent receives:
+- `CHANGED_FILES`, `FILE_LIST`, `RECENT_COMMITS`, `STACK`
+- The list of findings already auto-fixed in prior iterations (so they don't re-report them)
+- The list of HIL items already deferred (same reason)
+- Their specific review focus (below)
+
+#### Agent Instructions by Role
+
+All agent prompts share this finding schema. `hil_reason` and `context` are only required when `auto_fixable: false`:
+```
+{
+  file, line,
+  severity: critical|high|medium|low,
+  category: "...",
+  description,
+  suggested_fix,
+  auto_fixable: true|false,
+  hil_reason?: "only if auto_fixable=false — why Claude cannot safely apply this",
+  context?: "only if auto_fixable=false — 2-4 sentences: what the code does, why this is a problem, what the risk is"
+}
+```
+
+**Code Reviewer prompt:**
+> Review the codebase for: logic errors, off-by-one bugs, null/undefined handling, dead code, overly complex functions (>50 lines or >3 nesting levels), naming inconsistencies, missing error propagation, and performance anti-patterns (N+1, blocking I/O, unnecessary allocations). Focus on `CHANGED_FILES` first, then related files. Return findings using the shared schema above.
+
+**Security Engineer prompt:**
+> Audit for: hardcoded secrets or API keys, SQL/command/path injection, missing input validation at system boundaries, insecure deserialization, broken auth/authz, sensitive data in logs, unpatched dependency versions with known CVEs, missing rate limiting on public endpoints, and CORS misconfigurations. Categories: injection|secrets|auth|deps|logging|config. Return findings using the shared schema above.
+
+**Reality Checker prompt:**
+> Check: does each function do what its name/docs claim? Are there missing test assertions? Are there commented-out code blocks, TODO/FIXME/HACK markers, or debug statements left in? Are there import cycles? Are env vars assumed to exist without validation? Categories: correctness|tests|debt|env. Return findings using the shared schema above.
+
+**Accessibility Auditor prompt (if applicable):**
+> Check: missing alt text, non-semantic HTML, keyboard-inaccessible interactive elements, insufficient color contrast (< 4.5:1 for text), missing ARIA labels, focus trap issues, and missing skip navigation. Category: a11y. Return findings using the shared schema above.
+
+**API Tester prompt (if applicable):**
+> Check: endpoints missing auth middleware, routes with no input validation, missing HTTP status codes on error paths, inconsistent response shapes, pagination not implemented where expected, and missing rate-limit headers. Category: api. Return findings using the shared schema above.
+
+**Database Optimizer prompt (if applicable):**
+> Check: missing indexes on foreign keys and frequently-queried columns, N+1 query patterns in ORM code, unparameterized queries, missing transactions around multi-step writes, and schema column type mismatches. Category: database. Return findings using the shared schema above.
+
+**SRE prompt (if applicable):**
+> Check: Docker images without pinned versions, CI jobs with no timeout, missing health check endpoints, hardcoded environment assumptions (localhost, fixed ports), missing retry logic on external calls, and secrets in CI config files. Categories: reliability|infra. Return findings using the shared schema above.
+
+**Mobile App Builder prompt (if applicable):**
+> Check: missing permission explanations, sensitive data stored in plain UserDefaults/SharedPreferences, missing loading/error states, hard-coded URLs, deprecated API usage, and missing offline/degraded-mode handling. Category: mobile. Return findings using the shared schema above.
+
+---
+
+### Step 3: Merge and Deduplicate Findings
+
+Collect all agent outputs. As you collect each agent's findings, annotate each finding with `reporter: <agent role name>` (e.g., `"Code Reviewer"`, `"Security Engineer"`, `"Reality Checker"`). Merge into a single `ITERATION_FINDINGS` list. Deduplicate by `(file, category, description[:60])` — keep highest severity when duplicates exist. Do NOT deduplicate by line number, as applied fixes shift line numbers across iterations. Exclude anything already in `ALL_FIXED` or `ALL_HIL` by matching on `(file, description[:60])`.
+
+Sort by severity: critical → high → medium → low.
+
+---
+
+### Step 4: Classify and Act
+
+For each finding in `ITERATION_FINDINGS`:
+
+**If `auto_fixable: true`:**
+- Apply the fix using `Edit` (or `Write` for new files). Add the file path to `ITERATION_FIXED_FILES` list. Add the finding to a staging list `PENDING_FIXED`.
+
+**If `auto_fixable: false` (HIL):**
+- Add to `ALL_HIL`. Do NOT attempt to fix.
+
+After processing all findings, if `PENDING_FIXED` is empty, skip verification and proceed to Step 5. Otherwise, run verification **once** for the whole batch. Run only commands appropriate for `STACK`:
+
+**Node.js / TypeScript:**
+```bash
+npm run --if-present lint 2>&1 | tail -5
+npm run --if-present typecheck 2>&1 | tail -5
+npm run --if-present test 2>&1 | tail -10
+```
+
+**Python** (if `pyproject.toml` or `*.py` detected):
+```bash
+ruff check . 2>&1 | tail -5
+python -m pytest --tb=short -q 2>&1 | tail -10
+```
+
+**Go** (if `go.mod` detected):
+```bash
+go vet ./... 2>&1 | tail -5
+go test ./... 2>&1 | tail -10
+```
+
+**Rust** (if `Cargo.toml` detected):
+```bash
+cargo check 2>&1 | tail -5
+cargo test 2>&1 | tail -10
+```
+- If all checks pass: move all `PENDING_FIXED` entries into `ALL_FIXED`.
+- If any check fails: run `git restore` on each file in `ITERATION_FIXED_FILES` to undo all changes, move all `PENDING_FIXED` entries to `ALL_HIL` with `hil_reason: "batch auto-fix caused verification failure — apply individually"`. Print the error output.
+
+---
+
+### Step 5: Commit Fixes for This Iteration
+
+If `ALL_FIXED` gained any new entries this iteration:
+
+Stage only the files that were actually edited (tracked from `ITERATION_FIXED_FILES` collected in Step 4):
+```bash
+git add <space-separated list of ITERATION_FIXED_FILES paths>
+```
+
+Then commit with each fixed item on its own line in the body:
+```bash
+git commit -m "fix(review): iteration <ITERATION> — <count> findings fixed by monomind:review
+
+<file>:<line> — <description>
+<file>:<line> — <description>
+
+Co-Authored-By: nokhodian <nokhodian@gmail.com>"
+```
+
+---
+
+### Step 6: Write HIL Items to File
+
+If any new HIL items were added this iteration, **append** to `HIL_FILE`. For each new HIL item, increment `HIL_COUNT` by 1 and use it as the label number:
+
+```markdown
+## Review Iteration <ITERATION> — <YYYY-MM-DD HH:MM>
+
+<!-- One block per HIL finding; HIL_COUNT increments globally across all iterations -->
+### HIL-<HIL_COUNT>: <description> [`<severity>`]
+
+**File:** `<file>:<line>`
+**Category:** <category>
+**Reported by:** <agent name>
+
+**Context:**
+<context from agent finding, or derive from description if context field absent>
+
+**Suggested fix:**
+<suggested_fix from agent, verbatim>
+
+**Why human decision needed:**
+<hil_reason>
+
+**Your options:**
+- [ ] Apply the suggested fix as-is
+- [ ] Apply a modified fix (describe below)
+- [ ] Defer — not a priority right now
+- [ ] Reject — not applicable for this project
+
+**Your response (fill in and save):**
+> 
+
+---
+```
+
+After writing, print:
+> `HIL_FILE` updated with <count> new items requiring human judgment.
+
+---
+
+### Step 7: Iteration Summary
+
+Increment `ITERATIONS_RUN` by 1. Then print a table:
+
+```
+### Iteration <ITERATION> / <TOTAL_ITERATIONS>
+
+| Reviewer            | Findings | Auto-Fixed | HIL |
+|---------------------|----------|------------|-----|
+| Code Reviewer       | N        | N          | N   |
+| Security Engineer   | N        | N          | N   |
+| Reality Checker     | N        | N          | N   |
+| ...                 | ...      | ...        | ... |
+| **Total**           | **N**    | **N**      | **N**|
+
+Severity breakdown: X critical, Y high, Z medium, W low
+```
+
+If zero findings remain after dedup and exclusions, print:
+> No new findings. Review complete.
+> Break out of the loop early.
+
+Increment `ITERATION`. Continue to next iteration.
+
+---
+
+## Step 8: Final Report
+
+After all iterations complete (or early exit), output:
+
+```markdown
+## monomind:review — Complete
+
+**Iterations run:** <ITERATIONS_RUN> / <TOTAL_ITERATIONS>
+**Reviewers active:** <list>
+
+### Auto-Fixed (<N> total)
+| File | Line | Severity | Category | Description |
+|------|------|----------|----------|-------------|
+| ... | ... | ... | ... | ... |
+
+### Human-in-Loop (<N> items)
+Saved to: `humaninloopreview-<date>.md`
+
+| # | File | Severity | Category | Why HIL |
+|---|------|----------|----------|---------|
+| 1 | ... | ... | ... | ... |
+
+### How to resolve HIL items
+1. Open `humaninloopreview-<date>.md`
+2. For each item, fill in **Your response** and check the option box
+3. Apply your chosen fixes manually, or run `/monomind:review 1` again after fixing to re-verify
+
+### Commits created
+<list of commit SHAs and messages from this session>
+```
+
+If `ALL_HIL` is empty, omit the HIL section and congratulate:
+> All findings were auto-fixed. No human decisions required.
+
+To repeat this command on a schedule, wrap it with `/monomind:repeat`.

package/.claude/commands/monomind/specialagents.md

@@ -0,0 +1,125 @@
+---
+name: monomind-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:** `/monomind:specialagents <slug>` — skip selection, activate immediately.
+
+**Interactive:** `/monomind:specialagents` — guided category → agent selection.
+
+**Auto:** `/monomind: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 `/monomind:specialagents` to browse available agents."