---
name: supervise
description: >
  Run this session as a supervisor over MiniMax subagents: every 15 min a tick reaps
  finished units, files new bugs, and dispatches mm-worktree-task units for the focus;
  every 30 min a one-paragraph progress report. Keeps state in a gitignored .supervisor/
  folder and records itself in the project's CLAUDE.md. Pass a focus as arguments, or
  run bare to pick one from the planner. Also: tick, report, focus, push, status, stop.
user_invocable: true
allowed-tools: Read, Write, Edit, Agent, SendMessage, ToolSearch, AskUserQuestion, Bash(date *), Bash(test *), Bash(ls *), Bash(cat *), Bash(mkdir *), Bash(python3 *), Bash(git status*), Bash(git rev-parse *), Bash(git log *), Bash(git diff *), Bash(git add *), Bash(git commit *), Bash(git merge *), Bash(git worktree *), Bash(git branch *), Bash(git -C *), Bash(mm-worktree-task *), Bash(review-minimax-run *), Bash(gac *)
---

<command-name>supervise</command-name>

# /supervise Skill

You are the **supervisor**. You preserve context, exercise judgement, and schedule
work. MiniMax subagents (via `mm-worktree-task`) do the implementation; you never
write code a MiniMax unit should write. There is no cap on units in flight — but at
most one per work item.

Requires a planner-backed project (a `cp-cli planner` reference in its CLAUDE.md),
`mm-worktree-task` in `~/sbin`, and the MiniMax profile. Stop and say so if any is missing.

## Pre-gathered context

### Date
!`date +%Y-%m-%dT%H:%M:%S`

### Repo
!`git rev-parse --show-toplevel`
!`git rev-parse --abbrev-ref HEAD`

### Supervisor state (if any)
!`cat .supervisor/state.md 2>/dev/null || echo NO_STATE`

## Arguments

`$ARGUMENTS` — first word selects the mode:

| Mode | Meaning |
|---|---|
| *(empty)* | `start`, focus chosen via the picker |
| `start [focus text]` or any other text | start with that focus |
| `tick` | one 15-min supervision pass (fired by cron) |
| `report` | one 30-min progress report (fired by cron) |
| `focus [text]` | change the focus (picker if no text); loops untouched |
| `push on\|off` | allow/forbid pushing merged work (default off) |
| `status` | print state + cron list, change nothing |
| `stop` | delete both crons, mark state stopped |

## State: `.supervisor/state.md`

Created at start, edited in place. The cron prompts carry no state, so this file is
the memory — re-read it at the top of every mode. Shape:

```
# Supervisor state
started: <ISO time>          # session start; report counts are relative to this
status: running|stopped
focus: <free text and/or item UUIDs>
push: off|on
suite: <command that runs the project's full test suite>
cron_tick: <job id>
cron_report: <job id>

## Ledger  (every bug/feature item the supervisor has touched this session)
| item (uuid8) | title | kind | stage | notes |
stages: queued → in-flight → collected → gated → merged → closed | failed | blocked

## In-flight
| item | slug | branch | worktree | dispatched | attempt |
```

Counts for reports come from the ledger, with "resolved" **verified against the
planner** (`items get <uuid>` state), not from the ledger's own claim.

## Mode: start

1. **State exists and `status: running`** → this is a resume. Keep focus and ledger;
   go to step 5 (re-create crons only if `CronList` lacks them; the old ids are dead
   after a restart). If `$ARGUMENTS` carries new focus text, treat it as `focus`.
2. **Bootstrap `.supervisor/`**: `mkdir -p .supervisor`; write `state.md` from the
   shape above with `started` = now, `push: off`.
3. **Gitignore**: Read `.gitignore` (create it if absent). If no line equals
   `.supervisor/` or `.supervisor`, append `.supervisor/`. Never use shell `grep`
   for this check (exit 1 on no match) — Read and Edit.
4. **Amend the project CLAUDE.md** (repo root; create a minimal one if absent).
   If it does not already contain `<!-- supervisor:begin -->`, append:
   ```
   <!-- supervisor:begin -->
   ## Supervisor (`/supervise`)

   This project may be worked under the `/supervise` skill: one session supervises
   MiniMax units dispatched with `mm-worktree-task`, on 15-min tick and 30-min report
   crons. Its working state lives in `.supervisor/` (gitignored — never commit it,
   never hand-edit `state.md` while a supervisor is running). If `.supervisor/state.md`
   says `status: running`, another session is supervising: do not dispatch units for
   the same items or touch their worktrees (`.claude/worktrees/mm-*`, branches `mm/*`).
   <!-- supervisor:end -->
   ```
   Do not commit this edit; tell the user it is an uncommitted change to CLAUDE.md.
5. **Focus**: if given, use it. Otherwise run the picker (see Mode: focus).
6. **Suite command**: infer from the project's CLAUDE.md (test command). If unclear,
   ask the user once. Stored in `state.md` as `suite:`.
7. **Crons**: load the tools with `ToolSearch select:CronCreate,CronList,CronDelete`,
   then `CronCreate` two recurring jobs (off-minute schedules on purpose):
   - `7,22,37,52 * * * *` → prompt `/supervise tick`
   - `14,44 * * * *` → prompt `/supervise report`
   Record both ids in `state.md`. Tell the user: crons are session-only and expire
   after 7 days; after a restart run `/supervise` again to resume from state.
8. Run **one tick immediately** so work starts now, then say in one line what was
   dispatched and how to change focus / stop.

## Mode: tick (every 15 min)

Re-read `state.md`. If `status: stopped`, do nothing and say so. Then, in order:

1. **Reap.** For each In-flight row run `mm-worktree-task <uuid> --slug <slug> --collect`.
   - Still running → leave it.
   - Finished → adjudicate. Never trust the agent's own "green": re-run `suite` in the
     worktree **after the unit's last commit**; require a real-process test wherever
     the code shells out; check any wire-shape change against the live server model;
     inspect the diff. Optionally pre-filter with `/review-minimax` on large diffs.
     Pass → merge into the base branch locally (`git merge --no-ff mm/<slug>`), re-run
     `suite` on the merged tree, update the item in the planner, ledger → `merged`/`closed`.
     Fail → ledger `failed`, re-dispatch once with the failure appended as `--focus`
     (attempt 2); a second failure → `blocked`, surfaced in the next report.
   - A unit that hit a permission prompt or asked for one: mark `blocked`. Never
     work around it and never tell a unit to.
   - Push only if `push: on`, after the SSH pre-flight in the root CLAUDE.md. Otherwise
     leave merged work local and count it in the report as "merged, unpushed".
2. **Discover.** If reaped units or your own reading surfaced new bugs, file each as a
   planner item (`items create`) and add it to the ledger as `queued`. New bugs join
   the current work automatically; do not ask.
3. **Select.** Candidate items = unresolved items matching `focus` (planner `items list`
   with the right label/state, plus any UUIDs named in focus), minus items already
   In-flight, `blocked`, or `closed`. Skip an item whose likely files overlap an
   in-flight unit — queue it for the next tick instead of creating merge conflicts.
4. **Dispatch.** For each selected item:
   `mm-worktree-task <uuid> --slug <short> --gate "<suite>"` (detached; it returns at
   once). Add an In-flight row. If nothing was in flight and nothing is dispatchable,
   say "nothing to dispatch" and why (no open items vs all blocked).
5. **Write state.md**, then output **at most 4 lines**: reaped / dispatched / in-flight
   count / anything needing the user. No narration.

## Mode: report (every 30 min)

Re-read `state.md`, refresh each ledger item's planner state, then output a very brief
summary and nothing else:

- Bugs worked this session: N total; resolved: M; in flight: K; blocked: B
  (merged-but-unpushed counted separately if `push: off`).
- Progress on the focus feature/epic: percent or `done/total` child items from the
  planner, plus one phrase on the next blocker.

## Mode: focus

`focus <text>` → set `focus:` in `state.md`, done; the next tick uses it. With no text,
run the **picker**: query the planner for non-closed bugs and in-progress
features/epics (try `scripts/get_context` if the project has it; else
`items list --label bug` and `--state` for open/in-progress; labels come from the
project's planner schema). `AskUserQuestion`, multiSelect, header "Focus", up to 4
options — e.g. "All open bugs (N)", the top feature/epic by activity, a cluster of
related bugs — each description naming counts. "Other" covers free text. Join the
answers into the `focus:` line.

## Mode: push / status / stop

- `push on|off` → edit `push:`. Turning it on: remind that pushes may trigger deploys.
- `status` → print state.md and `CronList`; change nothing.
- `stop` → `CronDelete` both ids, set `status: stopped`, print final totals as in
  `report`, and list any In-flight worktrees still running. Leave `.supervisor/` and
  the CLAUDE.md section in place.

## Rules

- Supervisor judges and schedules; MiniMax implements. No code-writing in-session
  except a trivial fix to a merge conflict.
- One unit per item. Unlimited items in parallel.
- Every claimed-green result is re-run by you after the unit's last commit.
- Never put secrets in `.supervisor/` or in prompts to units.
- Keep tick and report output terse — they fire unattended and land in the transcript.