---
name: board
description: Show the repo workboard and clear it in the fewest PRs.
---

# /board — your workboard, and the fastest way through it

Show the dev their board for this repo, then plan the whole board into the **fewest pull requests** that can
safely be opened and run those lanes in parallel. Read-only until the dev says go; rendering is not
permission to take anything.

## Step 1 — read the board

```bash
mmi-cli oracle board read --json --out .jerv/tmp/board.json
```

One call; the JSON carries `viewer`, `repo` and the project title. Use `primary` for this repo and
`secondary` for other repos on the Project. Partial reads exit nonzero; `--allow-partial` only when the dev
accepts an incomplete board. The CLI partitions rows into **Yours**, **Free to claim** and **Taken**; stale
stamps (4 hours without work) hold nothing. Partition rules, stamp details and `--out` rationale:
[reference.md](reference.md).

## Step 2 — render it

Plain markdown, never a fenced block. Flat `-` lists under bold heads, never `##` headings, never tables.
Refs are `[RepoName#N](url) · short title`, no `owner/` prefix, no `[type]` brackets. **Taken** renders
id · status · owner only, never the title. Skip empty sections. One screen. Example: [examples.md](examples.md).

Status moves happen automatically as work flows. Never offer a status move.

## Step 3 — plan the fewest PRs

Never one item at a time, never one PR per issue. Fetch bodies:

```bash
mmi-cli oracle board read --json --bodies --out .jerv/tmp/board-full.json
```

(Bodies and comments are at `row.details.body` and `row.details.comments`. Skip Done.)

1. **Derive each issue's touch-set** from body, comments and `surface:*` label. If you cannot name it, leave
   the issue out and say so.
2. **Join overlapping touch-sets**, transitively. Each group is one worktree and **one PR**; groups are
   disjoint, so all run in parallel.

Forced splits, each its own PR: another repo; irreversible or gated work (migrations, secret rotation,
release-train changes; principle 12); an issue that must stay open; a group past roughly ten issues or
spanning unrelated subsystems. Reasons: [reference.md](reference.md).

Present the plan — batch count, issue count, one line per batch naming its shared surface — then wait for go.

## Step 4 — on go, claim and run

```bash
mmi-cli oracle board claim <ref> <ref> <ref> --json
```

Say the size first: how many issues, how many PRs. Read per-item results; any failure exits nonzero. **Route
is `oracle board claim` only**; `oracle issue claim` and flat `board claim` refuse.

The claim prints the issue's recorded owner rulings; follow them. Record a new one with `mmi-cli oracle issue decision`.

One worktree per batch, all concurrently. Windows setup and ref renames: [reference.md](reference.md).

## Step 5 — land one PR per batch

No `--issues` or `--closes` flag; put `Closes #6395, #6396, #6397` in the **body**. After merge, board
advance moves each closed issue to Done.

```bash
mmi-cli devops pr create --body-file .jerv/tmp/pr-batch-a.md
mmi-cli devops pr land <pr> --json
```

Write the body as a UTF-8 file; run `mmi-cli explain devops pr create --json` first. An issue that stays
open: `Part of #N` or `Refs #N`, never `Does not close #N`. Guidance-learning gate: read
[reference.md](reference.md) first. Clean up only after a merged receipt (`state` `MERGED`, matching head
ref and OID, clean worktree); otherwise retain and report. Show any `gh` / `mmi-cli` error verbatim.

## Retro — one check before you finish

Did this skill's own instructions misfire this run (process only, never the user's code)? If yes, file one:
`mmi-cli learning skill-lesson --skill board --title "<what misfired>" --body "<what; evidence; proposed amendment>"`
File one per run; a clean run is silent; if the call fails, note it and continue.