Yolo Skill
Full-auto AI-DLC pipeline. User provides a prompt; agent drives the entire lifecycle: Idea -> Elaboration -> Proposal -> Review -> Execute -> Verify -> Done.
Overview
/yolo automates the complete AI-DLC workflow. You provide a natural language description of what you want built, and the agent handles everything:
- Planning -- create project, idea, self-elaboration, proposal with docs & tasks
- Proposal Review -- proposal-reviewer adversarial loop
- Execution -- wave-based Agent Team parallel task dispatch
- Verification -- task-reviewer adversarial loop + admin verify 4.5. Code-Review Gateway -- code-reviewer reviews the Idea's aggregate change before ship (FAIL → add fix tasks → re-run)
- Report -- completion summary
/yolo <prompt>
|
v
Project + Idea + Elaboration + Proposal
|
v
Proposal Reviewer (auto, up to maxProposalReviewRounds)
|
v
Admin Approve --> Tasks materialize
|
v
Wave-based Agent Team execution
| (dev agent + task-reviewer per task)
v
Admin Verify each wave --> unblock next
|
v
Code-Review Gateway (auto, up to maxCodeReviewRounds)
| PASS --> ship | FAIL --> add fix tasks --> re-run
v
Done. Report summary.
First-principles alignment (a stage-tailored instruction in every reviewer). The proposal-, task-, and code-reviewer each also verify, top-down, that the work still serves the original Idea's intent — building the intent baseline from the Idea it resolves from the entity under review — via the existing chorus_get_idea + chorus_get_elaboration + chorus_get_comments, counting human-authored content only — and flagging scope creep, requirement loss/shrink, or semantic drift. Unauthorized drift is a BLOCKER → FAIL / reject, downgraded to a NOTE only when traceable to a human-originated authorization (a human-authored Idea comment, a human-answered elaboration, or an explicit human override) — an agent's own comment never authorizes. In /yolo there is no human at the gate, so a self-generated (agent-authored) elaboration or comment does NOT clear alignment drift: fix the drift (reject/reopen + revise) rather than rationalizing it.
Escape hatch: Ctrl+C at any time. All created entities (project, idea, proposal, tasks) persist in Chorus. Resume manually via /develop or /review.
Prerequisites
The API key needs write + admin on every resource it touches:
| Needs | Why |
|---|---|
idea: [write] |
Create ideas, run elaboration |
proposal: [write, admin] |
Create proposals; approve them |
task: [write, admin] |
Create, execute, verify tasks |
project: [write] |
Create the project if none is given |
Check at startup:
perms = chorus_checkin().agent.permissions
need = { idea: ["write"], proposal: ["write","admin"],
task: ["write","admin"], project: ["write"] }
for resource, actions in need:
missing = [a for a in actions if a not in (perms[resource] or [])]
if missing: ABORT "/yolo needs {resource}: {missing}. Use an Admin-preset API key."
Input
/yolo <natural language prompt>
/yolo <prompt> --project <project-uuid>
<prompt>-- what you want built (becomes the Idea content)--project <uuid>-- optional; use an existing project instead of creating a new one
Research routing
During planning, follow the Idea and Proposal routes to /chorus:research (shared rules): Idea before formal clarification once focused, Proposal after reusing evidence and only for new gaps or an explicit request. Carry findings and the request context across wakes and brainstorm; do not restart the same investigation on resume. Preserve the existing yolo decision/review gates. A Tracker Research action is research-only even inside a yolo-associated conversation: use the Idea research-only branch, save/report, and return without advancing to elaboration, proposal submission, or development. A yolo request alone does not prove development started; use actual execution facts.
Team-managed Ideas (check first)
Call chorus_get_idea_team_context({ideaUuid}) before executing. If managed: true and you are the orchestrator, YOLO keeps the Team's division of labor — it only removes the need for a human to approve:
- Product work: delegate via
chorus_recommend_team_agent({ideaUuid, role: "product"})+chorus_delegate_team_product, instead of elaborating and writing the proposal yourself (if the recommendation is yourself, do it yourself). - Reviews: follow Team review routing for proposal, task and whole-Idea reviews. Recommend with
role: "review"andproposalUuid/taskUuid/ neither respectively, rather than always spawning your own reviewer. Self → matching fresh reviewer sub-agent in this turn; another agent → one review-request mention, then end the turn. Generic hook reminders below do not override Team routing.
Direct Team review requests: send them with chorus_request_review (target, reviewer, round). The server renders the Team review request — <kind>, round N envelope and routes only that reviewer into its review session; a hand-written chorus_add_comment envelope never opens a review session. A request must never start a line with VERDICT:.
Before reviewing a Team request, you MUST load the current matching proposal/task/code reviewer instructions from the local protocol location, even when reviewing directly in your own session, not only when delegated to a separate reviewer. A wake or mention is not a substitute for loading those instructions. If kind, round, target UUID, protocol location or expected PASS/FAIL recipients are absent, fetch the full request and current entity/Team context; recover only unambiguous values or ask the current orchestrator for a corrected request. Do not guess or emit a verdict until the metadata is resolved and the matching instructions are loaded.
The actual verdict MUST be exactly one plain unformatted line starting at column 1: VERDICT: PASS, VERDICT: PASS WITH NOTES, or VERDICT: FAIL. No bold, backticks, bullets, quotes, fences or extra verdict line in the posted result; the backticks here only delimit documentation examples. Place exactly one actionable routed @mention before that final line, using the recipient table, and re-read current entity/Team context before posting. Remain read-only; no lifecycle writes.
- Approval: only the current orchestrator may approve with existing
proposal:adminpermission after current-round PASS / PASS WITH NOTES and server-confirmed human YOLO for this exact Idea. Otherwise request human approval once and stop. - Development: for each ready task use
chorus_recommend_team_agent({ideaUuid, role: "development", taskUuid})and assign the recommended agent, instead of spawning sub-agents or implementing yourself. If the recommendation is yourself, claim and implement it in this turn. - Verification: only the current orchestrator verifies with existing permissions after a current-round task PASS / PASS WITH NOTES. Re-read all source Idea contexts before acting. After self-submission, route review immediately (no self-wake), including the all-source-proposals last-task check; start aggregate review in parallel at
to_verify, not after every task is verified. Its PASS gates report/PR only. Honor paused state, routed mentions, stable IDs, batching and the 3-round human escalation cap. - Unmanaged Ideas (
managed: false): follow the workflow below unchanged.
Workflow
The detailed spawn-based execution and review loops below are the unmanaged flow. Managed Ideas use Team review routing and the Team division of labor above, including the 3-round cap even where legacy configuration permits unlimited rounds. A worker or product delegate must not take over orchestration or verification.
Phase 1: Planning
Step 1.1: Resolve Project
Parse the arguments for --project <uuid>.
If --project is provided:
chorus_get_project({ projectUuid: "<uuid>" })
Verify it exists and proceed.
If not provided, search for a suitable existing project first:
# 1. Search for projects matching the prompt topic
chorus_search({ query: "<key terms from prompt>", entityTypes: ["project"] })
# 2. Or list recent projects to find a match
chorus_list_projects()
Review the results. If a project clearly matches the user's intent (same topic, active, relevant scope), use it. If no suitable project exists, create a new one:
chorus_admin_create_project({
name: "<short title derived from prompt>",
description: "<1-2 sentence summary of the prompt>"
})
Step 1.2: Create Idea
chorus_pm_create_idea({
projectUuid: "<project-uuid>",
title: "<concise title derived from prompt>",
content: "<full user prompt as-is>"
})
Then claim it:
chorus_claim_idea({ ideaUuid: "<idea-uuid>" })
Step 1.3: Self-Elaboration
In /yolo mode, the agent generates elaboration questions and answers them itself -- no AskUserQuestion calls. This preserves an audit trail without interrupting the user.
Self-elaboration is still a loop. If answering your own questions surfaces a new question, contradiction, or gap, loop back to
chorus_pm_start_elaborationfor another self-answered round before resolving — don't force a resolve over unresolved ambiguity. There is no human gate in YOLO, so the loop exits on your judgment that nothing material is left open (round cap 10). Steps 1–2 are one round; repeat them as needed, then resolve once in Step 3.
Generate and submit questions:
chorus_pm_start_elaboration({ ideaUuid: "<idea-uuid>", depth: "standard", questions: [ { id: "q1", text: "<question about scope, architecture, etc.>", category: "functional", options: [ { id: "a", label: "<option A>" }, { id: "b", label: "<option B>" } ] } // ... 5-8 questions covering functional, technical_context, scope aspects ] })Answer immediately (agent selects best options based on the prompt):
chorus_answer_elaboration({ ideaUuid: "<idea-uuid>", roundUuid: "<round-uuid>", answers: [ { questionId: "q1", selectedOptionId: "a", customText: "Rationale: ..." }, // ... ] })Resolve — in YOLO mode the agent resolves elaboration autonomously, with no human-confirmation gate (the human-confirmation requirement that applies to the interactive
/ideaflow is explicitly waived under/yoloautomation):chorus_pm_validate_elaboration({ ideaUuid: "<idea-uuid>" })chorus_pm_validate_elaborationrequiresidea:admin./yoloalready mandates an Admin-preset key in Prerequisites, so this is satisfied. To open another self-elaboration round instead of resolving, just callchorus_pm_start_elaborationagain.
Step 1.4: Create Proposal
Read the spec mode (already computed). The SessionStart hook (
bin/resolve-spec-mode.sh) has already resolved it — do NOT re-derive. Read the## Spec Modesection: it statesCHORUS_SPEC_MODE=<lite|openspec|off>+ a routing note. (Spawned without that context? Source the samebin/resolve-spec-mode.shforSPEC_MODE/SPEC_FAIL— never hand-roll the rule.) Act on that value:openspec→ 2a,off→ 2b,lite→ 2c. If the section says the mode cannot be honored (e.g. explicitopenspecbut unusable — it prints the config-conflict or install-hint reason), halt and surface it; do NOT silently fall back or enter 2a with no OpenSpec to author. (This matters because yolo runs unattended — the hook, not the agent, is the single source of the decision.)Create the empty proposal container. In OpenSpec mode the
descriptionMUST containOpenSpec change slug: <slug>; in spec-lite mode the locator lineSpec-lite: .chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/(use the$SLUGyou'll pick in 2a / 2c); in free-form mode omit any slug line.chorus_pm_create_proposal({ projectUuid: "<project-uuid>", title: "<feature name>", description: "<summary>\n\nSpec-lite: .chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/", // spec-lite mode // description: "<summary>\n\nOpenSpec change slug: <slug>", // OpenSpec mode // description: "<summary>", // free-form mode inputType: "idea", inputUuids: ["<idea-uuid>"] })Then branch:
2a. OpenSpec mode (resolved mode = openspec;
CHORUS_OPENSPEC_ACTIVE=1). Followopenspec-aware§3 end-to-end:- Pick
$SLUG, runopenspec new change "$SLUG"(§3.1–§3.2). - Author
proposal.md,design.md, and onespecs/<capability>/spec.mdper capability locally on disk (§3.3). ADDED Requirements only; per-spec fallback to free-form Markdown if MODIFIED/REMOVED is needed. - Define the
chorus_check_responsehelper (§6); preferchorus mcp call … --arg-file content=<file>for mirrors (§3.4/§3.6) — the bash-wrapper fallback's$API+json_encode_fileare only needed whenchorusis not onPATH. - Mirror each local file via
chorus mcp call chorus_pm_add_document_draft … --arg-file content=<file>(§3.6; fallback ="$API" mcp-tool chorus_pm_add_document_draft "$PAYLOAD") — one call per file, with the document type fromopenspec-aware§5.
⛔ Do not invoke
chorus_pm_add_document_draft/chorus_pm_update_document_draft/chorus_pm_update_documentfrom the MCP harness with a hand-typedcontentfield in this branch. Re-typing the markdown body wastes 20k+ tokens per proposal and breaks byte-equality with the local files. Seeopenspec-aware§2 Rule 1.Then continue to step 3 (task drafts).
2b. Free-form mode (resolved mode = free-form). Only when step 1 resolved to free-form — i.e. explicit
CHORUS_SPEC_MODE=off. (Unset never resolves here — it resolves to OpenSpec when usable, else spec-lite.) Add a tech design document draft directly via MCP, content authored inline:chorus_pm_add_document_draft({ proposalUuid: "<proposal-uuid>", type: "tech_design", title: "Tech Design: <feature>", content: "<markdown tech design covering architecture, data model, API, module contracts>" })2c. spec-lite mode (resolved mode = lite). Load the
spec-liteskill (skills/spec-lite/SKILL.md) and follow it: pick$SLUG(a capability/feature name —.chorus/specs/<slug>/holds the durable local specspec.md, edited in place across changes, not one folder per change). Ensure the durablespec.mdexists, using thespec-liteskill's inline durable-spec template the first time this capability is specced — local-only, no Chorus ids: Intent / plain-prose Requirements +- [ ]acceptance points / Non-goals — and update it in place to the new truth. Create this change's dated folder.chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/and write its synced Chorus-typed docs (shape = thespec-liteskill's inline dated-folder document template) —prd.md(primary), plustech_design.mdetc. only if warranted. The proposaldescriptionMUST carry the literal locator lineSpec-lite: .chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/(the deterministic link develop uses). Mirror each dated-folder<type>.mdto its persistent Document byte-exact — first time a doc is authored e.g.chorus mcp call chorus_pm_add_document_draft "{\"proposalUuid\":\"<uuid>\",\"type\":\"prd\",\"title\":\"PRD: <feature>\"}" --arg-file content=.chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/prd.md, later edits viachorus_pm_update_documentagainst the recordeddocumentUuid.spec.mdis never mirrored. NoOpenSpec change slug:line and noopenspec/changes/scaffold; there is notasks.md. Then continue to step 3 for task drafts.- Pick
Add task drafts incrementally (use returned
draftUuidfor dependency chaining).acceptanceCriteriaItemsis required on every draft — at least one non-blank criterion, or the call is rejected:# First task result1 = chorus_pm_add_task_draft({ proposalUuid: "<proposal-uuid>", title: "<module name>", kind: "implementation", description: "<what to build, referencing tech design>", priority: "high", storyPoints: 3, acceptanceCriteriaItems: [ { description: "<testable criterion>", required: true }, // ... ] }) # Second task, depends on first chorus_pm_add_task_draft({ proposalUuid: "<proposal-uuid>", title: "<dependent module>", kind: "implementation", description: "...", priority: "medium", storyPoints: 2, acceptanceCriteriaItems: [...], dependsOnDraftUuids: ["<result1.draftUuid>"] })Task kind:
implementation,verification,docs, orother. Setkindon each draft to describe its actual purpose. Bothchorus_pm_add_task_draftandchorus_pm_update_task_draftaccept it; omittingkindon update preserves the existing value. It is optional for compatibility with older proposals. Kind is draft-only metadata, visible intaskDraftIndex, and is not copied to materialized Tasks; do not add it tochorus_create_tasksorchorus_update_task.Validate:
chorus_pm_validate_proposal({ proposalUuid: "<proposal-uuid>" })Dependency errors block submission. Repair drafts while the proposal is in
draft; if it is pending, use the normal authorizedchorus_pm_reject_proposalrevision flow first.E-DEP-UNKNOWN: replace unknown or foreign dependencies with task-draft UUIDs returned bychorus_pm_add_task_draftin this same proposal (confirm withchorus_get_proposal,section: "tasks"), or remove invalid edges. Do not use materialized Task UUIDs.E-DEP-SELF: remove the current draft's own UUID from itsdependsOnDraftUuids.E-DEP-CYCLE: inspect the reported cycle path and remove or redirect edges to match the real execution order; reordering the displayed task list does not break a cycle.
Replace the affected dependency list with
chorus_pm_update_task_draft, retaining valid edges (use[]if none remain). This update deliberately omitskind, preserving its existing value:chorus_pm_update_task_draft({ proposalUuid: "<proposal-uuid>", draftUuid: "<affected-draft-uuid>", dependsOnDraftUuids: ["<valid-same-proposal-draft-uuid>"] }) chorus_pm_validate_proposal({ proposalUuid: "<proposal-uuid>" })Revalidate after repairs and resolve all errors before
chorus_pm_submit_proposal.Kind checks are advisory:
I-KINDmeans no draft declares a kind, so classification-based implementation coverage cannot be checked;W-IMPLmeans at least one kind is declared but none isimplementation. Neither advisory blocks submission. Inspect the actual requested scope, existing repository work, task descriptions and AC rather than trusting labels alone. Add or correct real implementation coverage when required by that scope. A justified docs-only or verification-only proposal is valid: record why no new implementation is needed in its description or review context; never fabricate implementation tasks or relabel unrelated work merely to silence an advisory.Submit:
chorus_pm_submit_proposal({ proposalUuid: "<proposal-uuid>" })After this call, the PostToolUse hook injects context instructing you to spawn
chorus:proposal-reviewer. You MUST spawn it yourself — it is NOT auto-launched — and wait for it to complete before approving.
Reviewer contract (applies to every review gate below)
Every gate in Phases 2, 4 and 4.5 follows the same three steps. They are written once here; the phases below only name their entity and their stage-specific actions.
- Spawn and wait. Spawn the reviewer as a read-only sub-agent, then wait for it using this harness's waiting mechanism — in Claude Code, the sub-agent's completion notification. The launch result is not the verdict: these reviewer subagent types report an async launch regardless of the flag you pass.
- Read THIS round's VERDICT. Call
chorus_get_commentson the entity and find theVERDICT:comment posted after your dispatch, not an older round's. Do not advance the gate before you have read it. - No VERDICT for this round? Check what the reviewer did post:
- A reported round limit, or any other explicit refusal to review — a deliberate escalation to a human. STOP: do not respawn, do not self-review, do not post a VERDICT of your own.
- Nothing at all — respawn ONCE, telling it to stay within its turn budget and reserve its last turns for the VERDICT, then apply this same check again to what the retry posts. An explicit refusal from the retry still means STOP; only a second true silence lets you review the entity yourself as a read-only pass and POST the VERDICT, then proceed on what you posted rather than looping forever.
Absence is never a PASS, and a round limit reached by someone else is never yours to clear.
Phase 2: Proposal Review Loop
After chorus_pm_submit_proposal, the PostToolUse hook injects context instructing you to spawn chorus:proposal-reviewer. Apply the Reviewer contract above with the proposal as the entity. Then:
Read THIS round's VERDICT:
chorus_get_comments({ targetType: "proposal", targetUuid: "<proposal-uuid>" })Look for the
VERDICT:comment posted after your dispatch — not an older round's. Do not approve or reject before you have read it.Act on the VERDICT:
PASS or PASS WITH NOTES --
chorus_admin_approve_proposal({ proposalUuid: "<proposal-uuid>", reviewNote: "PASS from reviewer. <brief summary of notes if any>" })Tasks and documents materialize automatically. Proceed to Phase 3.
FAIL -- Read the BLOCKERs from the reviewer comment. Then:
chorus_pm_reject_proposal({ proposalUuid: "<proposal-uuid>", reviewNote: "FAIL from reviewer. Fixing BLOCKERs: <list>" })Revise the drafts (
chorus_pm_update_document_draft,chorus_pm_update_task_draft) to address each BLOCKER, then resubmit:chorus_pm_submit_proposal({ proposalUuid: "<proposal-uuid>" })After resubmission, the hook injects context again — spawn the reviewer yourself for Round 2.
Max rounds: Loop up to
maxProposalReviewRounds(from plugin config, default 3). If exhausted:STOP: "Proposal review failed after {maxRounds} rounds. Remaining BLOCKERs: <list>. Human review needed. Proposal UUID: <uuid>"No new VERDICT for this round? Apply step 3 of the Reviewer contract, reviewing the proposal yourself if the reviewer stays silent.
Phase 3: Task Execution (Wave-Based)
Completion and recovery: report completed work with chorus_report_work without a status field, then self-check AC with chorus_report_criteria_self_check, then call chorus_submit_for_verify. Submission owns the in_progress -> to_verify transition; reporting must not move the task early. If submission finds a task already at to_verify, fetch chorus_get_task and its work-report comments first. Leave a legitimately submitted task awaiting verification. Only after confirming a premature transition may the assignee call chorus_update_task({ taskUuid: "<task-uuid>", status: "in_progress" }) with normal dependency checks (no force/bypass). This rollback clears both developer and admin acceptance marks and evidence; repeat the developer self-check with fresh evidence before submitting again. Do not mechanically roll back every task awaiting verification.
After proposal approval, tasks exist in open status. Execute them in dependency-ordered waves: one sub-agent per unblocked task, the whole wave dispatched in a single message. If sub-agent dispatch is unavailable or sub-agents fail repeatedly, fall back to main agent execution.
Primary: one sub-agent per task, whole wave in a single message (parallel)
wave = 1
loop:
# 1. Find ready tasks
unblocked = chorus_get_unblocked_tasks({ projectUuid: "<project-uuid>" })
if no unblocked tasks and all tasks done:
break # All complete
if no unblocked tasks and some tasks not done:
# Stuck -- tasks failed review and can't proceed
break with escalation report
# 2. Dispatch ONE sub-agent per unblocked task, issuing the whole wave
# in a SINGLE message — that is what makes them run in parallel.
# There is no team or group object to create first.
for each task in unblocked:
Agent({
name: "task-{short-title}",
prompt: "Your Chorus task UUID: {task.uuid}\nProject UUID: {project-uuid}\n\nImplement the task per its description and acceptance criteria. Read the task, proposal, and project documents for context."
})
# 3. Wait for all sub-agents to complete
# Each sub-agent follows the /develop workflow:
# claim -> in_progress -> develop -> report -> self-check AC -> submit_for_verify
# PostToolUse hook injects context — main agent must spawn task-reviewer after submit_for_verify
# 4. Proceed to Phase 4 (verification) for this wave
wave += 1
What the sub-agent prompt needs:
- Task UUID(s)
- Project UUID
- NO session UUID, NO workflow boilerplate -- the plugin auto-injects everything via SubagentStart hook
Fallback: Main Agent (sequential)
If sub-agent dispatch is unavailable (no sub-agent primitive, permission denied) or sub-agents fail repeatedly, fall back to executing tasks sequentially as the main agent:
for each task in unblocked:
# Follow the /develop workflow directly as main agent
chorus_claim_task({ taskUuid: "<task-uuid>" })
chorus_update_task({ taskUuid: "<task-uuid>", status: "in_progress" })
# ... implement the task: read context, write code, run tests ...
chorus_report_work({ taskUuid: "<task-uuid>", report: "..." })
chorus_report_criteria_self_check({ taskUuid: "<task-uuid>", criteria: [...] })
chorus_submit_for_verify({ taskUuid: "<task-uuid>", summary: "..." })
# PostToolUse hook injects context — you must spawn task-reviewer yourself
# Proceed to Phase 4 verification for this task before moving to next
The fallback is slower (sequential, not parallel) but still completes the pipeline. The PostToolUse hook injects reviewer instructions the same way in both modes — you must always spawn the reviewer manually.
Phase 4: Verification
After each wave's sub-agents complete, verify their tasks:
for each task in wave_tasks:
# 1. Check task status
task = chorus_get_task({ taskUuid: "<task-uuid>" })
if task.status != "to_verify":
# Sub-agent may have failed; skip or handle
continue
# 2. Spawn task-reviewer (hook injects context — you must spawn it yourself),
# then wait for its completion notification. The launch result is NOT the
# verdict — the dispatch reports an async launch whatever flag you pass.
Agent({ subagent_type: "chorus:task-reviewer", prompt: "Review task <task-uuid>..." })
# 3. Read THIS round's task-reviewer VERDICT — the comment posted after your
# dispatch, not an older round's. Do not verify or reopen before you have it.
comments = chorus_get_comments({ targetType: "task", targetUuid: "<task-uuid>" })
# 4. Act on VERDICT — three possible outcomes:
if VERDICT is "PASS":
# All AC verified, no issues. Mark AC and verify.
chorus_mark_acceptance_criteria({
taskUuid: "<task-uuid>",
criteria: [
{ uuid: "<ac-uuid>", status: "passed", evidence: "<from reviewer>" },
// ...
]
})
chorus_admin_verify_task({ taskUuid: "<task-uuid>" })
# Task is now "done" -- unblocks dependents
if VERDICT is "PASS WITH NOTES":
# All AC verified, minor non-blocking notes. Still mark AC and verify.
chorus_mark_acceptance_criteria({ ... })
chorus_admin_verify_task({ taskUuid: "<task-uuid>" })
if VERDICT is "FAIL":
# BLOCKERs found. Do NOT verify. Reopen for rework.
chorus_admin_reopen_task({ taskUuid: "<task-uuid>" })
# Task returns to "open", will be picked up in next wave
After verifying all tasks in the wave, return to Phase 3 to check for newly unblocked tasks.
Max rounds per task: Tracked by maxTaskReviewRounds from plugin config (default 3). If a task has been reopened maxRounds times, skip it and flag for human escalation:
ESCALATE: "Task '{title}' failed review after {maxRounds} rounds.
Last BLOCKERs: <list>. Manual intervention needed.
Task UUID: <uuid>"
Continue with remaining tasks -- do not halt the entire pipeline for one stuck task.
No new VERDICT for this round? Apply step 3 of the Reviewer contract, reviewing the task yourself if the reviewer stays silent.
Phase 4.5: Code-Review Gateway (mandatory pre-ship)
Once every task of the idea's proposal is verified (done) — i.e. Phase 3 finds no more unblocked tasks and all are terminal — run the final ship-time code-review gateway before declaring the Idea done and before the Phase 5b completion report. After the last task is verified, the PostToolUse hook injects a reminder to spawn the code-reviewer; you MUST spawn it yourself, wait for its completion notification, then read THIS round's VERDICT comment on the idea and act on what it says.
# Spawn the code-reviewer for the IDEA (not a task). Determine the round
# number by reading prior code-review VERDICT comments on the idea.
Agent({ subagent_type: "chorus:code-reviewer",
prompt: "Review the aggregate code for idea <idea-uuid>. Round: N." })
# Wait for its completion notification, then read THIS round's VERDICT on the idea
comments = chorus_get_comments({ targetType: "idea", targetUuid: "<idea-uuid>" })
# Find the "VERDICT:" comment posted after your dispatch, not an older round's.
# Do not declare the feature shippable before you have read it.
Act on the VERDICT:
- PASS / PASS WITH NOTES — the feature is cleared to ship. Proceed to Phase 5 / 5b.
- FAIL — do NOT ship. Read the BLOCKERs, then fix them via the quick-dev workflow (
/quick-dev): callchorus_create_taskswithproposalUuidset to the current approved proposal so the fix tasks attach to it; for an Idea with no approved proposal, create them as Quick Tasks with the same top-levelideaUuidand noproposalUuid— do not reopen the already-verified tasks. Group related small BLOCKERs into one cohesive task by default; split only materially large or independently testable fixes. Drive every fix task through Phase 3 → Phase 4, including AC self-check, independent task review, and admin verification. Re-spawn the code-reviewer only after every fix task is successfullydone; a failed or cancelled fix task, stop the automatic loop and escalate. Loop bounded bymaxCodeReviewRounds(plugin config, default 3; 0 = unlimited).
# Max rounds escalation
ESCALATE: "Idea '<title>' failed code review after {maxCodeReviewRounds} rounds.
Last BLOCKERs: <list>. Manual intervention needed. Idea UUID: <uuid>"
No new VERDICT for this round? Apply step 3 of the Reviewer contract, reviewing the idea's aggregate change yourself if the reviewer stays silent.
The code-review gateway is behavioral, consistent with the proposal/task reviewers: its verdict is advisory and does not change the Idea's stored status. The /yolo orchestrator honors it — PASS to ship, FAIL to loop. It runs before the completion report so the report is never written for a feature with an outstanding FAIL.
Phase 5: Report
After all waves complete, output a markdown summary:
## /yolo Complete
**Project:** <project-name> (<project-uuid>)
**Proposal:** <proposal-title> (<proposal-uuid>)
**Idea:** <idea-title> (<idea-uuid>)
### Tasks
| Task | Status | Review Rounds |
|------|--------|---------------|
| <title> | done | 1 |
| <title> | done | 2 |
| <title> | ESCALATED | 3 (max) |
### Summary
- Total tasks: N
- Completed: X / N
- Escalated: Y (need human review)
- Waves executed: W
Phase 5b: Idea Completion Report (mandatory)
A successful /yolo run always finishes the Idea — call chorus_create_report once with proposalUuid set to the last verified proposal. The call requires title (a short report title) plus content; content's parameter description carries the three-section template (## Summary / ## Decisions / ## Follow-ups); follow it. Surface the returned documentUuid in the Phase 5 summary. Skipping is a protocol violation.
Order: the completion report is written only after the Phase 4.5 code-review gateway returns PASS / PASS WITH NOTES. Never write it while a code-review FAIL is outstanding — the report is a ship-time summary, and the gateway is what clears the feature to ship.
Error Handling
| Scenario | Action |
|---|---|
| Missing permissions at startup | Abort with message listing the missing resource/action pairs (see Prerequisites). Recommend an Admin-preset API key. |
| Project creation fails | Report error, suggest user create project manually and retry with --project |
| Proposal reviewer FAIL after maxRounds | Stop pipeline, report persisting BLOCKERs, suggest manual review |
| Task reviewer FAIL after maxRounds | Flag task as escalation-needed, continue with other tasks |
| Code-review gateway FAIL after maxCodeReviewRounds | Stop before ship, escalate the persisting feature-level BLOCKERs to a human (Idea UUID), do not write the completion report |
| Sub-agent crash / no submit | Log error, skip task, pick it up in next wave if possible |
| Ctrl+C | All entities persist in Chorus. User can resume via /develop or /review |
Tips
- Keep the initial prompt detailed -- the more context you provide, the better the auto-generated proposal quality
- The proposal-reviewer is your quality gate -- if it keeps FAILing, the prompt may be too vague
- Watch the wave count -- if tasks keep getting reopened, consider Ctrl+C and manually reviewing the feedback
- All audit trail is preserved: elaboration Q&A, reviewer VERDICTs, work reports. Check Chorus UI for full history
- For small/simple tasks, consider
/quick-devinstead -- it skips the Idea->Proposal overhead - Sub-agents share your API key; ensure it has the permissions listed in Prerequisites before starting
Next
- To manually review proposals:
/review - To manually develop tasks:
/develop - To create quick standalone tasks:
/quick-dev - For platform overview:
/chorus
