From agentops
Orchestrates the full RPI lifecycle: discovery → crank → validation → reporting. Useful for autonomously driving complete feature turns through the operating loop.
How this skill is triggered — by the user, by Claude, or both
Slash command
/agentops:rpiThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
> Quick ref: `/discovery` -> `/crank` -> `/validate`, then report.
references/agile-replan-loop.mdreferences/autonomous-execution.mdreferences/best-practices.mdreferences/codex-executor.mdreferences/complexity-scaling.mdreferences/context-windowing.mdreferences/discovery-artifact-mode.mdreferences/error-handling.mdreferences/examples.mdreferences/gate-retry-logic.mdreferences/gate4-loop-and-spawn.mdreferences/installed-plugin-version-not-repo-head.mdreferences/isolation-contract.mdreferences/orchestrator-compression-anti-pattern.mdreferences/phase-budgets.mdreferences/phase-data-contracts.mdreferences/report-template.mdreferences/rpi.featurereferences/troubleshooting.mdscripts/validate.shQuick ref:
/discovery->/crank->/validate, then report.
Execute this workflow. Do not only describe it. RPI is autonomous unless
--interactive is set. The user touchpoint is after validation, or after a
real blocked state exhausts retries. Read
references/autonomous-execution.md when
you need the full autonomy contract.
--auto means pivot autonomously, NOT execute the initial plan to the letter. Autonomy is agility, not waterfall: between waves the orchestrator re-plans the remaining work and changes course on its own — refactoring, adding, dropping, reordering waves as evidence arrives — without the operator saying so (touched only at the terminal objective or a circuit-breaker trip). See Agile Re-Plan Loop.
/rpi is the orchestrator across every move of the operating loop: BDD intent → vertical slices → conflict-free wave → bead acceptance → evidence + learning capture. It delegates each move to the skill that owns it (/discovery, /plan, /crank, /validate, /forge//post-mortem), and enforces these loop-level invariants:
--auto)./validate --mixed, /pre-land-refuters) fire once, at the bead-acceptance / merge-to-main pawl (the ratchet's lock). Intermediate slices are chaos: cheap local checks (build, TDD red→green, light inline wave-acceptance judges) run freely; the heavy panel never fires per slice. A pawl on every tread is the waterfall the ratchet exists to avoid.--test-first on (the default), /crank is invoked with the TDD-per-slice discipline; --no-test-first is an explicit opt-out, not a fast path.shape_intent, persist_intent, plan_slices, execute_wave, validate_acceptance, and record_evidence.operating-loop-skill + operating-loop-workflow route here/rpi <bead-id> runs that exact arc./rpi is the in-session orchestrator of the same seven moves.RPI delegates via Skill(skill="discovery", ...),
Skill(skill="crank", ...), and Skill(skill="validate", ...) as separate
tool invocations. Keep strict delegation on by default; do not compress phases,
replace phase skills with direct agent spawns, or skip validation. Read
../shared/references/strict-delegation-contract.md
for the full anti-compression contract.
See references/isolation-contract.md for
the four-lever model, phase-isolated skill transport, and the compression
patterns scripts/check-skill-isolation.sh flags. See
references/best-practices.md for the principle
and anti-pattern citation table.
When the runtime supports phase isolation, keep /rpi visible in the main
session and run each phase contract through isolated transport: phase skill name in, bounded handoff artifact in, phase artifact/verdict/next action out.
The transport may be a daemon job, process runner, or subagent wrapper, but it must execute the declared phase skill contract rather than doing phase work directly.
RPI owns one lifecycle objective across all phases. Preserve the discovered
epic_id when present; otherwise preserve the original goal and execution
packet objective. A child bead or one ready slice is context, not a replacement
objective. <promise>PARTIAL</promise> from /crank means retry Phase 2 on the
same objective.
.agents/rpi/.--from:
research, plan, pre-mortem, brainstorm -> discoveryimplementation or crank -> implementationvalidation, vibe, or post-mortem -> validation--from is absent, resolve it with br show:
fast: short/simple goal or --fast-pathstandard: medium goal or one scope keywordfull: --deep, complex-operation keyword, 2+ scope keywords, or >120 charsRPI mode: rpi-phased (complexity: <level>).Track state compactly:
rpi_state = {
goal: "<goal string>",
epic_id: null,
phase: "<discovery|implementation|validation>",
complexity: "<fast|standard|full>",
test_first: <true by default; false only when --no-test-first>,
cycle: 1,
verdicts: {}
}
Complex-operation keywords include refactor, migrate, rewrite,
redesign, rearchitect, overhaul, decouple, deprecate, split,
extract module, and port. Scope keywords include all, entire, across,
everywhere, every file, system-wide, global, and codebase.
Enter at the routed phase and run every phase after it.
/discovery <goal> [--interactive] --complexity=<level>
directly or through phase-isolated skill transport.
On DONE, read .agents/rpi/execution-packet.json or the run archive and
preserve its objective spine. On BLOCKED, stop with the discovery verdict./crank <epic-id> when the packet has epic_id;
otherwise invoke /crank .agents/rpi/execution-packet.json, directly or
through phase-isolated skill transport. Pass --test-first or
--no-test-first through. On DONE, record ao ratchet record implement 2>/dev/null || true and continue. On PARTIAL or BLOCKED, retry the same
objective up to 3 total attempts./validate <epic-id> --complexity=<level> when an
epic exists; otherwise invoke /validate --complexity=<level>, directly
or through phase-isolated skill transport. Add --strict-surfaces when
--quality is set. On FAIL, extract findings, re-run /crank on the same
objective, then re-run /validate, up to 3 total validation attempts. On
DONE, record ao ratchet record vibe 2>/dev/null || true. This Phase-3 /validate is the bead-acceptance pawl (docs/contracts/pawls.md) — once per RPI objective at acceptance, not per slice. The merge-to-main pawl fires regardless of complexity: any work crossing the shared-trunk door — fast/standard included — invokes the pawl gate /pre-land-refuters before push (pawls.md makes mutate-shared-trunk complexity-independent). Complexity scales the gate's DEPTH, never exempts it: every door gets at least the fresh-context default (≥1 fresh-context refuter, model-agnostic); higher-irreversibility doors are opted up to multi-model (≥2 distinct families), and full arcs (100+ files, factory regen, contract-test repoints, capability removal) get full council — neither skips the gate. REFUTED → AUTO-REDO: refuted findings re-crank like a validation FAIL, autonomously and with no human (the default self-correcting path); a human is escalated to only when a tunable circuit breaker trips (max-attempts — here the 3-attempt cap — time budget, cost/quota, or oscillation), per pawls.md "Escalation — the circuit-breaker model". The gate is the door, never per slice.--auto). No remaining waves → straight to Report.--loop, restart from discovery on FAIL while cycle < max_cycles. With
--spawn-next, read .agents/rpi/next-work.jsonl and suggest the next
command without invoking it. Before emitting the report, apply the Context
Density Rule: every line should carry intent, boundary, evidence, decision,
constraint, or next action.The initial plan is a hypothesis; each wave is an experiment whose evidence re-plans the rest. At every wave boundary (and after validation): reflect (a bounded /post-mortem + /discovery re-plan delta over what shipped/broke) → re-plan the REMAINING waves (refactor / insert / drop / reorder / re-scope / escalate, persisting the mutated plan so the next wave reads the current one) → proceed. Under --auto this is autonomous, bounded by the run's circuit breakers (budget / attempt cap / oscillation detection) and the ≥5-ship post-mortem checkpoint; the operator is touched only at the terminal objective or a breaker trip. /crank and /validate surface findings UP for re-planning (never a silent local retry); /discovery is the re-plan engine. Anti-patterns: waterfall (run the plan to the letter), retry-not-replan (re-crank forever instead of changing the remaining plan), permission-seeking (pause to approve a pivot --auto already authorizes). Full detail: references/agile-replan-loop.md.
The execution packet carries the repo execution profile through
contract_surfaces, done_criteria, and queue claim/finalize metadata. Keep
the latest alias at .agents/rpi/execution-packet.json and read
references/phase-data-contracts.md for
schemas and archive paths.
The pawl gates (pawls.md) fire at the irreversible doors — bead-acceptance and merge-to-main — never per slice/wave; chaos between pawls. The merge-to-main pawl fires regardless of complexity (see Phase 3); complexity below only scales the DEPTH of the gate, never whether it runs.
Complexity scales the gate's depth: low/fast and medium/standard → 2-judge minimum panel (inline / --quick); high/full → full council; max 3 total attempts. The gate still fires at the door at every complexity.
high/full → full council, 2-judge minimum; max 3 total attempts. Pre-mortem stress-tests the plan before work; it is not an irreversible door and carries no heavy gate of its own outside this optional full-arc depth.high/full → full council, 2-judge minimum; max 3 total attempts.high/full → full council; same scale as above.| Flag | Default | Purpose |
|---|---|---|
--from=<phase> | discovery | Start at discovery, implementation, or validation |
--discovery-artifact=<path> | unset | With implementation start, convert an existing artifact into the handoff packet |
--interactive | off | Human gates in discovery/validate |
--auto | on | Fully autonomous default — pivots between waves on its own (re-plans remaining work; not a fixed-plan/waterfall executor). See Agile Re-Plan Loop |
--loop --max-cycles=<n> | off / 3 | Iterate when validation fails |
--spawn-next | off | Surface follow-up work after reporting |
--test-first | on | Pass strict-quality preference to /crank |
--no-test-first | off | Explicitly opt out of strict-quality |
--fast-path / --deep | auto | Force fast or full complexity |
--quality | off | Make validation strict surfaces blocking |
--dry-run / --no-budget | off | Report only, or disable phase time budgets |
User says: /rpi "add user authentication"
Run discovery, implementation, validation, then report.
User says: /rpi --from=implementation ag-23k
Resolve the bead scope, run implementation and validation, then report.
User says: /rpi --deep "refactor payment module"
Use full council gates across the lifecycle.
Read references/examples.md for resume, interactive, loop, and artifact-mode examples.
| Problem | Response |
|---|---|
| Discovery BLOCKED | Stop and report discovery's manual-intervention reason |
/crank returns PARTIAL | Retry /crank on the same objective; do not narrow to a child slice |
| Validation FAIL | Re-crank with findings, then re-validate, up to 3 total attempts |
| Packet shape unclear | Read references/phase-data-contracts.md |
| External executor fails | Read references/codex-executor.md, run direct Codex validation, and only create follow-up work for reproducible source failures |
/using-atm — out-of-session ATM substrate for running whole /rpi loops over a bead queue.--auto-pivot bounds, anti-patterns/rpi loads from ~/.claude/plugins/cache/, not the repo working tree; verify which version is active before measuring--large-repo); NOT part of the default RPI path. Default discovery/research does not generate .agents/rpi/context-shards/latest.json.npx claudepluginhub boshu2/agentops --plugin agentopsOrchestrates multi-phase project execution by dispatching dedicated persona agents for planning, execution, verification, and review. Use after spec approval for automated phase chaining.
Executes 6-phase gated workflow for complex tasks: Questions, Research, Design Discussion, Structure Outline, Plan, Implement. Pauses for user approval after each markdown artifact.
Orchestrates an adversarial plan-implement-review pipeline using native Claude Code subagents. Run after intake skills like /brainstorm produce a starting doc.