/member-run

name: member-run
description: Internal skill for commands. Spawn, hand the next brief to, correct, dismiss or wait for the round report of ONE named member - any lets:* role - of a team or an execute run; the caller's record (the execute run record, the team file) is the record, and ListAgents judges who is busy. It is the single place LETS spawns, resumes, corrects or dismisses a member, and decides which member takes a dispatch (`op=route`). Do not trigger on user conversation; only when a LETS command runs or routes to a member.
user-invocable: false

Member Run

One operation on one named member - or, for `op=route`, the choice of member for a dispatch. The caller (`/lets:execute` Step 5-D, `/lets:team`, a team-mode dispatch of `/lets:plan`, `/lets:review`, `/lets:check`, `/lets:opinion`, `/lets:ask` or `/lets:review-round`, and `apply-fixes` with `apply=member`) owns the plan, the gates, the record (the execute run record, the team file), the diff check, the commits and the tracker; this skill owns only the agent call. `ListAgents` judges who is busy; no registry exists beside the caller's record. It is the single place LETS spawns, resumes, corrects or dismisses a member, and decides which member takes a dispatch (`op=route`).

> **IMPORTANT:** If the spec below invokes any deferred tool (e.g. `AskUserQuestion`, `SendMessage`), you MUST load and call it as specified. Never skip the call, never substitute a default answer of your own - the tool invocation is part of the contract. This is critical.

Args

| op | args | does | |---|---|---| | `spawn` | `scope=<s> name=<n> role=<r> brief-file=<path> report-file=<abs path> [model=<m>] [isolation=worktree]` | Step 1 when it applies, then Step 2 | | `next` | `scope=<s> name=<n> brief-file=<path> report-file=<abs path> [id=<agent_id>]` | Step 3 - the member's next brief | | `correct` | `scope=<s> name=<n> correct-file=<path> report-file=<abs path> [id=<agent_id>]` | Step 3 - an amendment to its current brief | | `dismiss` | `scope=<s> name=<n> [id=<agent_id>]` | Step 4 | | `route` | `command=<plan\|review\|opinion\|ask\|check\|execute\|review-round> roles=<role>[,<role>...] fallback=<one-shot\|inline\|run> [solo] [ask=no] [team=<c>]` | Step 5 - which member, if any, takes each role of a dispatch | | `receive` | `scope=<s> name=<n> id=<agent_id> brief-file=<path> report-file=<abs path> [dismissed]` | Step 6 - wait for a member's round report: peek, one nudge, collect |

• `scope` - the team's callsign, or `run-<RUN>` for an execute run.
• `name` - the member name, `[a-z0-9-]{1,40}`: the bare roster name in a team scope (`architect`, `architect-2`), in an execute scope `impl-<RUN>` (a replacement `impl-<RUN>-r<generation>`), `explorer-<RUN>`, `skeptic-<RUN>`, `architect-<RUN>`.
• `{agent}` below is the name the agent runs under: `<callsign>-<name>` in a team scope (pane names are machine-wide), the bare name in an execute scope.
• `id` - the agent_id the caller recorded at spawn; every op on a spawned member passes the id the caller recorded - standing-team members too (lets-mpjhc reverses lets-gbfpd's no-agent_id rule within a lead session). `{agent}` below is that id when passed, else the name: every `SendMessage` and `TaskStop` below puts the `id` where it says `{agent}`. An isolated member, which the harness runs as a background agent, is reachable only by its id.
• `role` - a shipped `lets:*` agent; `lets:actor` -> stop with `role_not_allowed`, nothing spawned.
• `brief-file` / `correct-file` - repo-root-relative paths the caller wrote. Every brief crosses as a file path, never inline.
• `model` - `opus` | `sonnet` | `fable` | `haiku`, the values the `Agent` tool accepts. Absent -> the role's own default, except for an implementer (Step 1).
• `report-file` - an absolute path the CALLER named (execute: its pinned `.lets/cache/run-...` path; team: `agent-report op=open` / `op=add`). One file per round; member-run never composes a report path. Required on `spawn`, `next`, `correct` and `receive`: missing -> stop with `report_file_missing`, nothing sent.

Every operation returns as soon as its call is issued. The member runs in the background; its report arrives later as a `REPORT_WRITTEN` pointer to the round's REPORT_FILE, and the caller reads the FILE through `agent-report` (`op=peek` on every notification, `op=collect` to conclude; Step 6 `op=receive` is that loop for one member's round) - never the message.

Step 1: Model panel (role=lets:implementer, no model, first spawn of the scope)

The caller has already passed its Start gate - delegation is approved; this only picks the model.

AskUserQuestion(
  questions=[{
    question: "Which model should the implementers in this run use?",
    header: "Model",
    options: [
      { label: "Opus (Recommended)", description: "Strong at a mid price; the default for plan implementation" },
      { label: "Fable", description: "Most capable, about twice Opus's price; for the hardest chunks" },
      { label: "Sonnet", description: "Cheaper and faster; good for mechanical chunks" },
      { label: "Haiku", description: "Cheapest; for small, well-specified edits" }
    ],
    multiSelect: false
  }]
)

**Other** -> accept only `opus`, `sonnet`, `fable` or `haiku`; for anything else, name those four values and ask again. Return the chosen value; the caller records it and passes `model=` on every later `spawn` of the scope.

Step 2: Spawn

1. The role: `lets:actor` -> stop with `role_not_allowed: {role}`; nothing is spawned. 2. The routes. A member never runs `/lets:start`, which loads them, so it gets the LETS routes as a file of its own - the caller's brief is never changed:

   R="${CLAUDE_PLUGIN_ROOT}/protocol/roles.md"; D='.lets/cache/routes-{scope}.md'
   if [ -s "$R" ] && cp "$R" "$D"; then echo ROLES_OK; else echo ROLES_FAILED; fi

`ROLES_FAILED` -> stop: name the missing or empty `protocol/roles.md` and `/lets:update`; nothing is spawned. The