next

Files (7)

• SKILL.md
• contradiction-check.sh · scripts/
• is-pre-completed.sh · scripts/
• log-decision.sh · scripts/
• preflight-due.sh · scripts/
• review-ready.sh · scripts/
• status.sh · scripts/

SKILL.md (first lines)

# /next

Orchestrator that handles preflight maintenance, then tries to move the
backlog forward. With **no argument** a direct `/next` turn ends by
either starting the next obvious backlog action or asking the user to
clarify what should be next; a looped `/next` turn must not expect user
input, dispatches only unambiguous work, and otherwise idles until the
loop-exhausted guard stops it.

When given a **count or scope** (`N`, `blocked`, `all`, or a group
name), `/next` runs a **bounded internal sequence** instead: it works
several backlog items in one turn, skipping the heavy preflight between
steps (see **Sequencing**). How wide it runs — one worker at a time or a
fan-out batch — is the orchestrator's judgment call, sized to how
independent the selected work is (see **Concurrency**). It never waits for
user input mid-sequence. **For an attended multi-step push,
reach for a sequence first** — it is cheaper than an external loop (heavy
preflight only at the start and end, not every tick) and stays in one
turn. `/loop /next` still works and remains the right tool for genuinely
unattended or scheduled runs that span many turns; it benefits from the
same preflight cadence.

## Project Amendments

At the start of every invocation, check whether
`docs/rpm/skills/next.md` exists in the consuming project. If it
does, read it and apply its contents as additional project-specific
instructions for this skill. Amendments may add preflight steps,
narrow dispatch criteria, add output requirements, or extend the
worker contract. They cannot remove or override plugin defaults —
on conflict, this SKILL.md wins.

## Routing

Parse `$ARGUMENTS` into a first token and an optional second token:

- **empty** → run one orchestrator step (the single-step flow below).
- **`status`** → run the status formatter and stop:

  !`bash ${CLAUDE_SKILL_DIR}/scripts/status.sh`

  Render the output verbatim. Do not interpret, summarize, or add
  commentary — the user wants the raw view.
- **integer `N` (≥ 1)** → run a sequence of up to N cycles (see
  **Sequencing**). `N = 1` is identical to the single-step flow.
- **`blocked`** → run a sequence until a task needs the user, or no
  actionable task remains.
- **`all`** → run a sequence until no actionable task remains, skipping
  tasks that need the user and continuing with the rest.
- **anything else** → treat the first token as a `* Parent` **group
  name** in `docs/rpm/future/tasks.org` (match the heading text exactly,
  then case-insensitively). An optional second token scopes the run
  within that group: `N`, `all`, or `blocked` (default: drain the group
  until it has no actionable task or one needs the user). If no parent
  matches, print the usage block below and stop.

Reserved first tokens (`status`, `blocked`, `all`, and any integer) are
never interpreted as group names.

Usage block (print only when the argument is unrecognized):

```
/next               — one orchestrator step
/next N             — up to N steps; width per step is the orchestrator's call (one worker, or a fan-out batch); heavy preflight only at start + end
/next blocked       — run until a task needs you, or nothing is actionable
/next all           — run everything actionable, skipping tasks that need you
/next <group> [N]   — work only that backlog group (drain it, or N steps)
/next status        — in-flight subagents, recent decisions, idle streak, counters
(prefer the sequence forms above; `/loop /next` still wraps the one-step form for unattended, multi-turn runs)
```

## Mode

There are three modes:

- **Direct (single-step)** — no argument, run interactively. May ask one
  concise clarification question when no obvious next backlog action can
  be started safely.
- **Loop** — this invocation is visibly part of `/loop /next`, an
  unattended dynamic loop, or repeated automatic invocation. Must not ask
  for input. If there is no unambiguous action, log `idle` with the
  reason and stop; after 3 consecutive idle ticks, emit `loop-exhausted`.
- **Sequence** — `/next` was given a count or scope (`N` / `blocked` /
  `all` / `<group>`). Runs a bounded internal loop (see **Sequencing**).
  Like loop mode it never asks for input mid-sequence; it stops at the
  argument's termination condition or the safety ceiling.

## Sequencing

Triggered by a count or scope argument. A sequence runs cycles **in the
foreground**. Each cycle's width — a single worker or a fan-out batch — is
the orchestrator's call, sized to how independent the selected work is
(see **Concurrency**).

1. **Full preflight once, at the start.** Run the delegated preflight
   (Preflight step 3) with `phases=full` — bypassing the cadence gate,
   since a sequence always forces full at its start — act on its report,
   and log a marker:

   ```bash
   bash ${CLAUDE_SKILL_DIR}/scripts/log-decision.sh preflight-full "" "sequence start"
   ```

2. **Cycle loop.** Repeat until a termination condition (below) or the
   safety ceiling:
   - **a. Cheap inline gate.** Check the termination conditions and the
     outstanding-user-blocker rule (Preflight step 1). **Do not** run the
     drift scan, the contradiction check, or the preflight subagent
     here — that overhead is exactly what a sequence exists to avoid.
   - **b. Task Selection.** Recompute in-flight, walk the tree,
     goal-aligned dispatch, apply the group filter if scoped, and run the
     `is-pre-completed.sh` skip check.
   - **c. Dispatch.** Dispatch using the Worker Contract, **in the
     foreground** — await results, do not background. Log one
     `actionable-backlog` per worker. Width is the orchestrator's call
     (see **Concurrency**): one worker when the next candidates are
     coupled, or a fan-out batch when they are independent — awaited
     together before reviewing.
   - **d. Review inline.** Evaluate each returned result, mark the backlog

From dppdppd/rpm, MIT.

More from dppdppd/rpm