Yolo Skill
Full-auto AI-DLC pipeline. User provides a prompt; agent drives the entire lifecycle: Idea -> Elaboration -> Proposal -> Review -> Execute -> Verify -> Done.
Tool namespace: Chorus tools are exposed by the connected MCP server under a chorus__ prefix on OpenClaw (e.g. chorus__chorus_pm_create_proposal). Bare names are used below for readability — prepend chorus__ when invoking. See /chorus for the full rule.
OpenClaw adaptations summarized (details inline below): (1) elaboration is self-answered as plain text — no AskUserQuestion, no user interaction; (2) reviewers run inline after each submit — spawn a sub-agent with the OpenClaw sessions_spawn tool and tell it to run the /proposal-reviewer or /task-reviewer skill, with a read-only self-review fallback when sessions_spawn is unavailable; (3) sessions are manual if you dispatch sub-agents (no SubagentStart hook); (4) task execution dispatches one sub-agent per unblocked task via sessions_spawn (whole wave in one message), falling back to sequential main-agent waves when sessions_spawn is unavailable or workers fail repeatedly — there is no team object to create first.
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 -- dependency-ordered waves: one worker sub-agent per unblocked task, or sequential main-agent execution as fallback
- Verification -- task-reviewer adversarial loop + admin verify
- Report -- completion summary
/yolo <prompt>
|
v
Project + Idea + Elaboration (self-answered) + Proposal
|
v
Proposal Reviewer (inline, up to maxProposalReviewRounds)
|
v
Admin Approve --> Tasks materialize
|
v
Wave execution (loop chorus_get_unblocked_tasks; one sessions_spawn worker
per task, or sequential main-agent fallback)
| (implement task + task-reviewer per task)
v
Admin Verify each task --> unblock next
|
v
Done. Report summary.
Escape hatch: interrupt 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 /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" and proposalUuid / taskUuid / neither respectively, rather than always spawning your own reviewer. Self → matching read-only reviewer via the host-specific path in that section in this turn; another agent → one review-request mention, then end the turn. Generic reviewer instructions 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:admin permission 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 user interaction at all. There is no AskUserQuestion primitive on OpenClaw, and yolo deliberately does not prompt the user; it self-answers to preserve an audit trail without interrupting the run.
Self-elaboration is still a loop. If answering your own questions surfaces a new question, contradiction, or gap, loop back to chorus_pm_start_elaboration for 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 — no user 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 /idea flow is explicitly waived under /yolo automation):
chorus_pm_validate_elaboration({
ideaUuid: "<idea-uuid>"
})
chorus_pm_validate_elaboration requires idea:admin. /yolo already mandates an Admin-preset key in Prerequisites, so this is satisfied. To open another self-elaboration round instead of resolving, just call chorus_pm_start_elaboration again.
Step 1.4: Create Proposal
Resolve the spec mode (inline). OpenClaw has no SessionStart hook to precompute it — so you resolve the whole contract yourself, not just "is OpenSpec active". Load the openspec-aware skill and run its §1 resolution block (which sources the plugin's shipped bin/resolve-spec-mode.sh), which yields one of lite / openspec / off (the canonical resolver, byte-identical to the Claude Code copy; /chorus spec prints the same result from the TS mirror src/spec-mode.ts). Rule: an explicit CHORUS_SPEC_MODE wins; when unset, OpenSpec is the default whenever usable (CHORUS_OPENSPEC_MODE ≠ off, an openspec/ directory at the project root, and the openspec CLI on PATH), else spec-lite. Route: openspec (usable) → 2a; off → 2b; lite → 2c. If the resolution says the mode cannot be honored (explicit CHORUS_SPEC_MODE=openspec but OpenSpec unusable), halt and surface it — do NOT fall back or enter 2a with no OpenSpec.
OpenClaw note: this is mandatory — yolo runs unattended, so silently picking the wrong mode is exactly the failure scenario the resolution contract exists to prevent.
Create the empty proposal container. The description MUST carry the mode's locator line — OpenSpec: OpenSpec change slug: <slug>; spec-lite: Spec-lite: .chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/; free-form: none. description is only settable at creation, so decide the slug/dated-path first.
chorus_pm_create_proposal({
projectUuid: "<project-uuid>",
title: "<feature name>",
description: "<summary>\n\nOpenSpec change slug: <slug>", // OpenSpec (2a)
// description: "<summary>\n\nSpec-lite: .chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/", // spec-lite (2c)
// description: "<summary>", // free-form (2b)
inputType: "idea",
inputUuids: ["<idea-uuid>"]
})
Then branch:
2a. OpenSpec mode (resolved mode = openspec, usable). Follow openspec-aware §3 end-to-end:
- Pick
$SLUG, run openspec new change "$SLUG" (§3.1–§3.2).
- Author
proposal.md, design.md, and one specs/<capability>/spec.md per 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_response helper (§6); prefer chorus mcp call … --arg-file content=<file> for mirrors (§3.4/§3.6) — the bash-wrapper fallback's json_encode_file is only needed when chorus is not on PATH.
- Mirror each local file via
chorus mcp call chorus_pm_add_document_draft … --arg-file content=<file> (§3.6; fallback = chorus-api.sh mcp-tool chorus_pm_add_document_draft "$PAYLOAD") — one call per file, with the document type from openspec-aware §5.
⛔ Do not invoke chorus_pm_add_document_draft / chorus_pm_update_document_draft / chorus_pm_update_document from the MCP harness with a hand-typed content field in this branch. Re-typing the markdown body wastes 20k+ tokens per proposal and breaks byte-equality with the local files. See openspec-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 comes here: it resolves to OpenSpec when usable, else spec-lite/2c). 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-lite skill. Pick $SLUG (a capability). Ensure the durable .chorus/specs/<slug>/spec.md exists (local-only, no ids; use the spec-lite skill's inline durable-spec template) and update it in place. Create this change's dated folder .chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/ with its synced Chorus-typed docs (shape = the spec-lite skill's inline dated-folder document template) — prd.md (primary), optional tech_design.md… The description carries the Spec-lite: .chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/ locator (step 2). Mirror each dated-folder <type>.md to its persistent Document byte-exact — first time 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 via chorus_pm_update_document against the recorded documentUuid (chorus-api.sh mcp-tool … fallback when chorus not on PATH). spec.md is never mirrored. No openspec/changes/ scaffold; no tasks.md. Then continue to step 3.
Add task drafts incrementally (use returned draftUuid for dependency chaining). acceptanceCriteriaItems is 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, or other. Set kind on each draft to describe its actual purpose. Both chorus_pm_add_task_draft and chorus_pm_update_task_draft accept it; omitting kind on update preserves the existing value. It is optional for compatibility with older proposals. Kind is draft-only metadata, visible in taskDraftIndex, and is not copied to materialized Tasks; do not add it to chorus_create_tasks or chorus_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 authorized chorus_pm_reject_proposal revision flow first.
E-DEP-UNKNOWN: replace unknown or foreign dependencies with task-draft UUIDs returned by chorus_pm_add_task_draft in this same proposal (confirm with chorus_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 its dependsOnDraftUuids.
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 omits kind, 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-KIND means no draft declares a kind, so classification-based implementation coverage cannot be checked; W-IMPL means at least one kind is declared but none is implementation. 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>" })
Immediately proceed to Phase 2 and run the proposal reviewer inline — OpenClaw has no PostToolUse hook to remind you.
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: spawn it with
sessions_spawn and wait by polling the subagents tool or via sessions_yield — do not detach. The verdict is the VERDICT: comment the reviewer posts, not the spawn result.
- Read THIS round's VERDICT. Call
chorus_get_comments on the entity and find the VERDICT: 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
OpenClaw difference: there is no PostToolUse hook injecting a "spawn the reviewer" reminder. Run the reviewer inline, right after chorus_pm_submit_proposal.
Obtain an independent VERDICT on the proposal:
- Preferred — spawn a reviewer sub-agent. Use the OpenClaw
sessions_spawn tool to spawn a sub-agent whose task instructs it to invoke the /proposal-reviewer skill (bundled with this plugin) against the proposal, then wait for it (poll the subagents tool, or use sessions_yield — do not detach; you need the VERDICT before proceeding). The sub-agent inherits the plugin's skills, so /proposal-reviewer is available to it; that skill is read-only and ends with a VERDICT: comment on the proposal. Example task prompt:
Run the /proposal-reviewer skill to review proposalUuid <uuid>. This is review round <N>. Read the proposal, its documents, the idea, and the elaboration; classify findings as BLOCKER/NOTE; post your VERDICT comment on the proposal when done.
- Fallback — review it yourself. If
sessions_spawn is unavailable (e.g. spawning disabled by policy), do the review yourself as a focused, read-only pass following the /proposal-reviewer skill's procedure (read proposal + comments + idea + elaboration; check doc completeness, task granularity, AC↔requirement coverage, the DAG, and integration checkpoints; classify BLOCKER/NOTE) and record the result via chorus_add_comment ending with a VERDICT: line. Do not modify drafts during the review pass.
Then:
Read the reviewer's VERDICT:
chorus_get_comments({ targetType: "proposal", targetUuid: "<proposal-uuid>" })
Look for THIS round's VERDICT: comment — the one posted after your dispatch, not an older round's.
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, run the reviewer inline again for Round 2 (same as above).
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 (Waves)
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.
OpenClaw difference: there is no team or group object to create — parallelism comes from dispatching one sub-agent per unblocked task with OpenClaw's own sessions_spawn tool, issuing the whole wave in a single message. If your host does not expose sessions_spawn, or spawned workers fail repeatedly, run waves sequentially as the main agent: loop chorus_get_unblocked_tasks, implement each ready task yourself, verify it, then loop again for the next wave. The sequential loop below is written for that fallback and is always safe; see /develop §"Optional: sub-agent dispatch" for the parallel form (workers need the manual session instructions, since there is no SubagentStart hook).
wave = 1
loop:
# 1. Find ready tasks (all dependencies done/closed)
unblocked = chorus_get_unblocked_tasks({ projectUuid: "<project-uuid>" })
if no unblocked tasks and all tasks done/closed:
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. Implement each unblocked task, in order, AS THE MAIN AGENT:
for each task in unblocked:
chorus_claim_task({ taskUuid: task.uuid })
chorus_update_task({ taskUuid: task.uuid, status: "in_progress" })
# ... read task + proposal + project documents for 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: "..." })
# 3. Proceed to Phase 4 (verification) for THIS task before moving to the next.
wave += 1
Parallel form: to run a wave in parallel instead of serially, dispatch one worker sub-agent per unblocked task with sessions_spawn, issuing the whole wave in a single message, then wait for the wave before verifying. Because there is no SubagentStart hook, each worker prompt must include the manual session instructions explicitly — see /develop "Optional: sub-agent dispatch". The main agent still owns review + verification, and the wave-by-wave dependency structure above is unchanged.
Phase 4: Verification
After each task is submitted (Phase 3 step 3), verify it before moving on:
for the just-submitted task:
# 1. Check task status
task = chorus_get_task({ taskUuid: "<task-uuid>" })
if task.status != "to_verify":
# implementation may have failed; handle or skip
continue
# 2. Run the task-reviewer INLINE (no hook on OpenClaw):
# - Preferred: use the sessions_spawn tool to spawn a sub-agent whose task is
# "Run the /task-reviewer skill to verify taskUuid <uuid> (round <N>); post your
# VERDICT comment on the task when done." Wait for it (poll the subagents tool /
# sessions_yield — do NOT detach; you need the VERDICT). The sub-agent inherits the
# plugin skills, so /task-reviewer is available to it.
# - Fallback (sessions_spawn unavailable): review it yourself as a focused read-only
# pass following the /task-reviewer procedure (read task + proposal + docs + code,
# run read-only tests, classify findings BLOCKER/NOTE) and post the VERDICT via
# chorus_add_comment.
# 3. Read task-reviewer VERDICT
comments = chorus_get_comments({ targetType: "task", targetUuid: "<task-uuid>" })
# Find THIS round's "VERDICT:" comment — the one posted after your dispatch, not an older round's
# 4. Act on VERDICT — three possible outcomes:
if VERDICT is "PASS":
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 for the next wave
if VERDICT is "PASS WITH NOTES":
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>" })
# Fix the BLOCKERs in a later pass (the task returns to in_progress/open)
After verifying the wave's tasks, return to Phase 3's loop to pick up newly unblocked tasks. Remember: only done (not to_verify) unblocks dependents.
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) — Phase 3 finds no more unblocked tasks and none remain non-terminal — run the final ship-time code-review gateway before the Phase 5b completion report. It reviews the whole Idea's aggregate code change across all tasks (not a single task) and posts its verdict on the idea. Inline (no hook on OpenClaw), same mechanism as Phase 4:
- Preferred — spawn a reviewer sub-agent. Use
sessions_spawn to spawn a sub-agent whose task tells it to invoke the /code-reviewer skill against the idea, then wait for it (poll subagents / sessions_yield — do NOT detach). Example task prompt: Run the /code-reviewer skill to review the aggregate code for ideaUuid <uuid> (round <N>); post your VERDICT comment on the idea when done.
- Fallback — review it yourself. If
sessions_spawn is unavailable, perform the review as a focused read-only pass following the /code-reviewer procedure (read the idea, its approved proposals + documents + tasks, plus the Quick Tasks linked to it via ideaUuid; infer the aggregate diff from task reports + git log/diff; review cross-task integration, architecture, security, regression, feature-level coverage; run the project build/test) and post the VERDICT: comment on the idea yourself.
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): call chorus_create_tasks with proposalUuid set 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-level ideaUuid and no proposalUuid — do not reopen the already-verified tasks or apply untracked fixes. 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-run the gateway only after every fix task is successfully done; a failed or cancelled fix task, stop the automatic loop and escalate. Loop bounded by maxCodeReviewRounds (default 3; 0 = unlimited).
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 gateway is behavioral like the other two reviewers: its verdict is advisory and does not change the Idea's stored status; the orchestrator honors it. It runs before the completion report so the report is never written while a FAIL is outstanding.
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: write the completion report only after the Phase 4.5 code-review gateway returns PASS / PASS WITH NOTES — never while a code-review FAIL is outstanding.
OpenSpec archive: if you ran in OpenSpec mode (Step 1.4 branch 2a), the last verified task also triggers the archive flow. OpenClaw has no PostToolUse hook to remind you — after verifying the final task, run openspec-aware §3.9 yourself (openspec archive <slug> --yes, then mirror each emitted openspec/specs/<capability>/spec.md back via §3.8).
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 |
| Task implementation fails / no submit |
Log error, skip task, pick it up in next wave if possible |
Reviewer sub-agent unavailable (sessions_spawn disabled) |
Run the review yourself as a focused read-only pass following the /proposal-reviewer or /task-reviewer skill, then post the VERDICT |
| Interrupted |
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 stopping and reviewing the feedback manually
- All audit trail is preserved: elaboration Q&A, reviewer VERDICTs, work reports. Check Chorus UI for full history
- For small/simple tasks, consider
/quick-dev instead -- it skips the Idea->Proposal overhead
- Sub-agents (if you dispatch any) 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
1---2name: yolo-43description: Full-auto AI-DLC pipeline — from prompt to done. Automates the entire Idea -> Proposal -> Execute -> Verify lifecycle.4license: AGPL-3.05metadata:6 source: https://skillmd.com/skills/chorus-aidlc/yolo-47 author: chorus8 version: "0.24.1"9 category: project-management10 mcp_server: chorus11---1213# Yolo Skill1415Full-auto AI-DLC pipeline. User provides a prompt; agent drives the entire lifecycle: Idea -> Elaboration -> Proposal -> Review -> Execute -> Verify -> Done.1617> **Tool namespace:** Chorus tools are exposed by the connected MCP server under a `chorus__` prefix on OpenClaw (e.g. `chorus__chorus_pm_create_proposal`). Bare names are used below for readability — prepend `chorus__` when invoking. See `/chorus` for the full rule.1819> **OpenClaw adaptations summarized (details inline below):** (1) elaboration is **self-answered as plain text** — no `AskUserQuestion`, no user interaction; (2) reviewers run **inline** after each submit — spawn a sub-agent with the OpenClaw `sessions_spawn` tool and tell it to run the `/proposal-reviewer` or `/task-reviewer` skill, with a read-only self-review fallback when `sessions_spawn` is unavailable; (3) sessions are **manual** if you dispatch sub-agents (no SubagentStart hook); (4) task execution dispatches **one sub-agent per unblocked task via `sessions_spawn`** (whole wave in one message), falling back to **sequential main-agent waves** when `sessions_spawn` is unavailable or workers fail repeatedly — there is no team object to create first.2021---2223## Overview2425`/yolo` automates the complete AI-DLC workflow. You provide a natural language description of what you want built, and the agent handles everything:26271. **Planning** -- create project, idea, self-elaboration, proposal with docs & tasks282. **Proposal Review** -- proposal-reviewer adversarial loop293. **Execution** -- dependency-ordered waves: one worker sub-agent per unblocked task, or sequential main-agent execution as fallback304. **Verification** -- task-reviewer adversarial loop + admin verify315. **Report** -- completion summary3233```34/yolo <prompt>35 |36 v37 Project + Idea + Elaboration (self-answered) + Proposal38 |39 v40 Proposal Reviewer (inline, up to maxProposalReviewRounds)41 |42 v43 Admin Approve --> Tasks materialize44 |45 v46 Wave execution (loop chorus_get_unblocked_tasks; one sessions_spawn worker47 per task, or sequential main-agent fallback)48 | (implement task + task-reviewer per task)49 v50 Admin Verify each task --> unblock next51 |52 v53 Done. Report summary.54```5556**Escape hatch:** interrupt at any time. All created entities (project, idea, proposal, tasks) persist in Chorus. Resume manually via `/develop` or `/review`.5758---5960## Prerequisites6162The API key needs write + admin on every resource it touches:6364| Needs | Why |65|------|-----|66| `idea: [write]` | Create ideas, run elaboration |67| `proposal: [write, admin]` | Create proposals; approve them |68| `task: [write, admin]` | Create, execute, verify tasks |69| `project: [write]` | Create the project if none is given |7071**Check at startup:**7273```74perms = chorus_checkin().agent.permissions75need = { idea: ["write"], proposal: ["write","admin"],76 task: ["write","admin"], project: ["write"] }7778for resource, actions in need:79 missing = [a for a in actions if a not in (perms[resource] or [])]80 if missing: ABORT "/yolo needs {resource}: {missing}. Use an Admin-preset API key."81```8283---8485## Input8687```88/yolo <natural language prompt>89/yolo <prompt> --project <project-uuid>90```9192- `<prompt>` -- what you want built (becomes the Idea content)93- `--project <uuid>` -- optional; use an existing project instead of creating a new one9495---9697## Research routing9899During planning, follow the Idea and Proposal routes to `/research` ([shared rules](../research/SKILL.md)): 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.100101## Team-managed Ideas (check first)102103Call `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:104105- **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).106- **Reviews**: follow [Team review routing](../orchestrate/SKILL.md#team-review-routing) for proposal, task and whole-Idea reviews. Recommend with `role: "review"` and `proposalUuid` / `taskUuid` / neither respectively, rather than always spawning your own reviewer. Self → matching read-only reviewer via the host-specific path in that section in this turn; another agent → one review-request mention, then end the turn. Generic reviewer instructions below do not override Team routing.107108**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:`.109110Before 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.111112The 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.113- **Approval**: only the current orchestrator may approve with existing `proposal:admin` permission after current-round PASS / PASS WITH NOTES and server-confirmed human YOLO for this exact Idea. Otherwise request human approval once and stop.114- **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.115- **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.116- Unmanaged Ideas (`managed: false`): follow the workflow below unchanged.117118## Workflow119120The detailed spawn-based execution and review loops below are the **unmanaged flow**. Managed Ideas use [Team review routing](../orchestrate/SKILL.md#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.121122### Phase 1: Planning123124#### Step 1.1: Resolve Project125126Parse the arguments for `--project <uuid>`.127128**If `--project` is provided:**129```130chorus_get_project({ projectUuid: "<uuid>" })131```132Verify it exists and proceed.133134**If not provided**, search for a suitable existing project first:135```136# 1. Search for projects matching the prompt topic137chorus_search({ query: "<key terms from prompt>", entityTypes: ["project"] })138139# 2. Or list recent projects to find a match140chorus_list_projects()141```142143Review 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:144```145chorus_admin_create_project({146 name: "<short title derived from prompt>",147 description: "<1-2 sentence summary of the prompt>"148})149```150151#### Step 1.2: Create Idea152153```154chorus_pm_create_idea({155 projectUuid: "<project-uuid>",156 title: "<concise title derived from prompt>",157 content: "<full user prompt as-is>"158})159```160161Then claim it:162```163chorus_claim_idea({ ideaUuid: "<idea-uuid>" })164```165166#### Step 1.3: Self-Elaboration167168In /yolo mode, the agent generates elaboration questions and answers them itself -- **no user interaction at all**. There is no `AskUserQuestion` primitive on OpenClaw, and yolo deliberately does not prompt the user; it self-answers to preserve an audit trail without interrupting the run.169170> **Self-elaboration is still a loop.** If answering your own questions surfaces a **new question, contradiction, or gap**, loop back to `chorus_pm_start_elaboration` for 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.1711721. **Generate and submit questions:**173 ```174 chorus_pm_start_elaboration({175 ideaUuid: "<idea-uuid>",176 depth: "standard",177 questions: [178 {179 id: "q1",180 text: "<question about scope, architecture, etc.>",181 category: "functional",182 options: [183 { id: "a", label: "<option A>" },184 { id: "b", label: "<option B>" }185 ]186 }187 // ... 5-8 questions covering functional, technical_context, scope aspects188 ]189 })190 ```1911922. **Answer immediately** (agent selects best options based on the prompt — no user prompt):193 ```194 chorus_answer_elaboration({195 ideaUuid: "<idea-uuid>",196 roundUuid: "<round-uuid>",197 answers: [198 { questionId: "q1", selectedOptionId: "a", customText: "Rationale: ..." },199 // ...200 ]201 })202 ```2032043. **Resolve** — in YOLO mode the agent resolves elaboration **autonomously, with no human-confirmation gate** (the human-confirmation requirement that applies to the interactive `/idea` flow is explicitly waived under `/yolo` automation):205206 ```207 chorus_pm_validate_elaboration({208 ideaUuid: "<idea-uuid>"209 })210 ```211212 > `chorus_pm_validate_elaboration` requires `idea:admin`. `/yolo` already mandates an Admin-preset key in Prerequisites, so this is satisfied. To open another self-elaboration round instead of resolving, just call `chorus_pm_start_elaboration` again.213214#### Step 1.4: Create Proposal2152161. **Resolve the spec mode (inline).** OpenClaw has no SessionStart hook to precompute it — so you resolve the **whole** contract yourself, not just "is OpenSpec active". Load the `openspec-aware` skill and run its **§1 resolution block (which sources the plugin's shipped `bin/resolve-spec-mode.sh`)**, which yields one of `lite` / `openspec` / `off` (the canonical resolver, byte-identical to the Claude Code copy; `/chorus spec` prints the same result from the TS mirror `src/spec-mode.ts`). Rule: an explicit `CHORUS_SPEC_MODE` wins; when unset, **OpenSpec is the default whenever usable** (`CHORUS_OPENSPEC_MODE` ≠ `off`, an `openspec/` directory at the project root, and the `openspec` CLI on `PATH`), else **spec-lite**. Route: `openspec` (usable) → **2a**; `off` → **2b**; `lite` → **2c**. If the resolution says the mode **cannot be honored** (explicit `CHORUS_SPEC_MODE=openspec` but OpenSpec unusable), **halt** and surface it — do NOT fall back or enter 2a with no OpenSpec.217218 > **OpenClaw note:** this is mandatory — yolo runs unattended, so silently picking the wrong mode is exactly the failure scenario the resolution contract exists to prevent.2192202. **Create the empty proposal container.** The `description` MUST carry the mode's locator line — OpenSpec: `OpenSpec change slug: <slug>`; spec-lite: `Spec-lite: .chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/`; free-form: none. `description` is only settable at creation, so decide the slug/dated-path first.221222 ```223 chorus_pm_create_proposal({224 projectUuid: "<project-uuid>",225 title: "<feature name>",226 description: "<summary>\n\nOpenSpec change slug: <slug>", // OpenSpec (2a)227 // description: "<summary>\n\nSpec-lite: .chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/", // spec-lite (2c)228 // description: "<summary>", // free-form (2b)229 inputType: "idea",230 inputUuids: ["<idea-uuid>"]231 })232 ```233234 Then branch:235236 **2a. OpenSpec mode (resolved mode = openspec, usable).** Follow `openspec-aware` §3 end-to-end:237 - Pick `$SLUG`, run `openspec new change "$SLUG"` (§3.1–§3.2).238 - Author `proposal.md`, `design.md`, and one `specs/<capability>/spec.md` per capability locally on disk (§3.3). ADDED Requirements only; per-spec fallback to free-form Markdown if MODIFIED/REMOVED is needed.239 - Define the `chorus_check_response` helper (§6); prefer `chorus mcp call … --arg-file content=<file>` for mirrors (§3.4/§3.6) — the bash-wrapper fallback's `json_encode_file` is only needed when `chorus` is not on `PATH`.240 - Mirror each local file via `chorus mcp call chorus_pm_add_document_draft … --arg-file content=<file>` (§3.6; fallback = `chorus-api.sh mcp-tool chorus_pm_add_document_draft "$PAYLOAD"`) — one call per file, with the document type from `openspec-aware` §5.241242 > **⛔ Do not** invoke `chorus_pm_add_document_draft` / `chorus_pm_update_document_draft` / `chorus_pm_update_document` from the MCP harness with a hand-typed `content` field in this branch. Re-typing the markdown body wastes 20k+ tokens per proposal and breaks byte-equality with the local files. See `openspec-aware` §2 Rule 1.243244 Then continue to step 3 (task drafts).245246 **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 comes here: it resolves to OpenSpec when usable, else spec-lite/2c). Add a tech design document draft directly via MCP, content authored inline:247248 ```249 chorus_pm_add_document_draft({250 proposalUuid: "<proposal-uuid>",251 type: "tech_design",252 title: "Tech Design: <feature>",253 content: "<markdown tech design covering architecture, data model, API, module contracts>"254 })255 ```256257 **2c. spec-lite mode (resolved mode = lite).** Load the `spec-lite` skill. Pick `$SLUG` (a **capability**). Ensure the durable `.chorus/specs/<slug>/spec.md` exists (local-only, no ids; use the `spec-lite` skill's inline durable-spec template) and update it in place. Create this change's **dated folder** `.chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/` with its **synced** Chorus-typed docs (shape = the `spec-lite` skill's inline dated-folder document template) — `prd.md` (primary), optional `tech_design.md`… The `description` carries the `Spec-lite: .chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/` locator (step 2). Mirror **each** dated-folder `<type>.md` to its persistent Document byte-exact — first time `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 via `chorus_pm_update_document` against the recorded `documentUuid` (`chorus-api.sh mcp-tool …` fallback when `chorus` not on `PATH`). **`spec.md` is never mirrored.** No `openspec/changes/` scaffold; no `tasks.md`. Then continue to step 3.2582593. **Add task drafts incrementally** (use returned `draftUuid` for dependency chaining). `acceptanceCriteriaItems` is **required** on every draft — at least one non-blank criterion, or the call is rejected:260 ```261 # First task262 result1 = chorus_pm_add_task_draft({263 proposalUuid: "<proposal-uuid>",264 title: "<module name>",265 kind: "implementation",266 description: "<what to build, referencing tech design>",267 priority: "high",268 storyPoints: 3,269 acceptanceCriteriaItems: [270 { description: "<testable criterion>", required: true },271 // ...272 ]273 })274275 # Second task, depends on first276 chorus_pm_add_task_draft({277 proposalUuid: "<proposal-uuid>",278 title: "<dependent module>",279 kind: "implementation",280 description: "...",281 priority: "medium",282 storyPoints: 2,283 acceptanceCriteriaItems: [...],284 dependsOnDraftUuids: ["<result1.draftUuid>"]285 })286 ```287288 **Task kind:** `implementation`, `verification`, `docs`, or `other`. Set `kind` on each draft to describe its actual purpose. Both `chorus_pm_add_task_draft` and `chorus_pm_update_task_draft` accept it; omitting `kind` on update preserves the existing value. It is optional for compatibility with older proposals. Kind is draft-only metadata, visible in `taskDraftIndex`, and is not copied to materialized Tasks; do not add it to `chorus_create_tasks` or `chorus_update_task`.2892904. **Validate:**291 ```292 chorus_pm_validate_proposal({ proposalUuid: "<proposal-uuid>" })293 ```294 Dependency errors block submission. Repair drafts while the proposal is in `draft`; if it is pending, use the normal authorized `chorus_pm_reject_proposal` revision flow first.295296 - `E-DEP-UNKNOWN`: replace unknown or foreign dependencies with task-draft UUIDs returned by `chorus_pm_add_task_draft` in this same proposal (confirm with `chorus_get_proposal`, `section: "tasks"`), or remove invalid edges. Do not use materialized Task UUIDs.297 - `E-DEP-SELF`: remove the current draft's own UUID from its `dependsOnDraftUuids`.298 - `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.299300 Replace the affected dependency list with `chorus_pm_update_task_draft`, retaining valid edges (use `[]` if none remain). This update deliberately omits `kind`, preserving its existing value:301302 ```303 chorus_pm_update_task_draft({304 proposalUuid: "<proposal-uuid>",305 draftUuid: "<affected-draft-uuid>",306 dependsOnDraftUuids: ["<valid-same-proposal-draft-uuid>"]307 })308 chorus_pm_validate_proposal({ proposalUuid: "<proposal-uuid>" })309 ```310311 Revalidate after repairs and resolve all errors before `chorus_pm_submit_proposal`.312313 Kind checks are advisory: `I-KIND` means no draft declares a kind, so classification-based implementation coverage cannot be checked; `W-IMPL` means at least one kind is declared but none is `implementation`. 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.3143155. **Submit:**316 ```317 chorus_pm_submit_proposal({ proposalUuid: "<proposal-uuid>" })318 ```319 Immediately proceed to Phase 2 and run the proposal reviewer **inline** — OpenClaw has no PostToolUse hook to remind you.320321---322323### Reviewer contract (applies to every review gate below)324325Every 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.3263271. **Spawn and wait.** Spawn the reviewer as a read-only sub-agent, then wait for it: spawn it with `sessions_spawn` and wait by polling the `subagents` tool or via `sessions_yield` — do **not** detach. The verdict is the `VERDICT:` comment the reviewer posts, not the spawn result.3282. **Read THIS round's VERDICT.** Call `chorus_get_comments` on the entity and find the `VERDICT:` comment posted **after your dispatch**, not an older round's. Do not advance the gate before you have read it.3293. **No VERDICT for this round?** Check what the reviewer *did* post:330 - **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.331 - **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.332333**Absence is never a PASS**, and a round limit reached by someone else is never yours to clear.334335---336337### Phase 2: Proposal Review Loop338339> **OpenClaw difference:** there is no PostToolUse hook injecting a "spawn the reviewer" reminder. Run the reviewer **inline**, right after `chorus_pm_submit_proposal`.340341Obtain an independent VERDICT on the proposal:342343- **Preferred — spawn a reviewer sub-agent.** Use the OpenClaw `sessions_spawn` tool to spawn a sub-agent whose `task` instructs it to **invoke the `/proposal-reviewer` skill** (bundled with this plugin) against the proposal, then wait for it (poll the `subagents` tool, or use `sessions_yield` — do **not** detach; you need the VERDICT before proceeding). The sub-agent inherits the plugin's skills, so `/proposal-reviewer` is available to it; that skill is read-only and ends with a `VERDICT:` comment on the proposal. Example task prompt:344 > `Run the /proposal-reviewer skill to review proposalUuid <uuid>. This is review round <N>. Read the proposal, its documents, the idea, and the elaboration; classify findings as BLOCKER/NOTE; post your VERDICT comment on the proposal when done.`345- **Fallback — review it yourself.** If `sessions_spawn` is unavailable (e.g. spawning disabled by policy), do the review yourself as a **focused, read-only pass** following the `/proposal-reviewer` skill's procedure (read proposal + comments + idea + elaboration; check doc completeness, task granularity, AC↔requirement coverage, the DAG, and integration checkpoints; classify BLOCKER/NOTE) and record the result via `chorus_add_comment` ending with a `VERDICT:` line. Do not modify drafts during the review pass.346347Then:3483491. **Read the reviewer's VERDICT:**350 ```351 chorus_get_comments({ targetType: "proposal", targetUuid: "<proposal-uuid>" })352 ```353 Look for THIS round's `VERDICT:` comment — the one posted after your dispatch, not an older round's.3543552. **Act on the VERDICT:**356357 - **PASS** or **PASS WITH NOTES** --358 ```359 chorus_admin_approve_proposal({360 proposalUuid: "<proposal-uuid>",361 reviewNote: "PASS from reviewer. <brief summary of notes if any>"362 })363 ```364 Tasks and documents materialize automatically. Proceed to Phase 3.365366 - **FAIL** --367 Read the BLOCKERs from the reviewer comment. Then:368 ```369 chorus_pm_reject_proposal({370 proposalUuid: "<proposal-uuid>",371 reviewNote: "FAIL from reviewer. Fixing BLOCKERs: <list>"372 })373 ```374 Revise the drafts (`chorus_pm_update_document_draft`, `chorus_pm_update_task_draft`) to address each BLOCKER, then resubmit:375 ```376 chorus_pm_submit_proposal({ proposalUuid: "<proposal-uuid>" })377 ```378 After resubmission, run the reviewer inline again for Round 2 (same as above).3793803. **Max rounds:** Loop up to `maxProposalReviewRounds` (from plugin config, default 3). If exhausted:381 ```382 STOP: "Proposal review failed after {maxRounds} rounds.383 Remaining BLOCKERs: <list>. Human review needed.384 Proposal UUID: <uuid>"385 ```3863874. **No new VERDICT for this round?** Apply step 3 of the **Reviewer contract**, reviewing the proposal yourself if the reviewer stays silent.388389---390391### Phase 3: Task Execution (Waves)392393**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.394395After proposal approval, tasks exist in `open` status. Execute them in dependency-ordered waves.396397> **OpenClaw difference:** there is no team or group object to create — parallelism comes from dispatching **one sub-agent per unblocked task** with OpenClaw's own `sessions_spawn` tool, issuing the whole wave in a single message. If your host does not expose `sessions_spawn`, or spawned workers fail repeatedly, run waves **sequentially as the main agent**: loop `chorus_get_unblocked_tasks`, implement each ready task yourself, verify it, then loop again for the next wave. The sequential loop below is written for that fallback and is always safe; see `/develop` §"Optional: sub-agent dispatch" for the parallel form (workers need the manual session instructions, since there is no SubagentStart hook).398399```400wave = 1401402loop:403 # 1. Find ready tasks (all dependencies done/closed)404 unblocked = chorus_get_unblocked_tasks({ projectUuid: "<project-uuid>" })405406 if no unblocked tasks and all tasks done/closed:407 break # All complete408409 if no unblocked tasks and some tasks not done:410 # Stuck -- tasks failed review and can't proceed411 break with escalation report412413 # 2. Implement each unblocked task, in order, AS THE MAIN AGENT:414 for each task in unblocked:415 chorus_claim_task({ taskUuid: task.uuid })416 chorus_update_task({ taskUuid: task.uuid, status: "in_progress" })417418 # ... read task + proposal + project documents for context,419 # write code, run tests ...420421 chorus_report_work({ taskUuid: task.uuid, report: "..." })422 chorus_report_criteria_self_check({ taskUuid: task.uuid, criteria: [...] })423 chorus_submit_for_verify({ taskUuid: task.uuid, summary: "..." })424425 # 3. Proceed to Phase 4 (verification) for THIS task before moving to the next.426427 wave += 1428```429430> **Parallel form:** to run a wave in parallel instead of serially, dispatch one worker sub-agent per unblocked task with `sessions_spawn`, issuing the whole wave in a single message, then wait for the wave before verifying. Because there is no SubagentStart hook, each worker prompt **must** include the manual session instructions explicitly — see `/develop` "Optional: sub-agent dispatch". The main agent still owns review + verification, and the wave-by-wave dependency structure above is unchanged.431432---433434### Phase 4: Verification435436After each task is submitted (Phase 3 step 3), verify it before moving on:437438```439for the just-submitted task:440 # 1. Check task status441 task = chorus_get_task({ taskUuid: "<task-uuid>" })442443 if task.status != "to_verify":444 # implementation may have failed; handle or skip445 continue446447 # 2. Run the task-reviewer INLINE (no hook on OpenClaw):448 # - Preferred: use the sessions_spawn tool to spawn a sub-agent whose task is449 # "Run the /task-reviewer skill to verify taskUuid <uuid> (round <N>); post your450 # VERDICT comment on the task when done." Wait for it (poll the subagents tool /451 # sessions_yield — do NOT detach; you need the VERDICT). The sub-agent inherits the452 # plugin skills, so /task-reviewer is available to it.453 # - Fallback (sessions_spawn unavailable): review it yourself as a focused read-only454 # pass following the /task-reviewer procedure (read task + proposal + docs + code,455 # run read-only tests, classify findings BLOCKER/NOTE) and post the VERDICT via456 # chorus_add_comment.457458 # 3. Read task-reviewer VERDICT459 comments = chorus_get_comments({ targetType: "task", targetUuid: "<task-uuid>" })460 # Find THIS round's "VERDICT:" comment — the one posted after your dispatch, not an older round's461462 # 4. Act on VERDICT — three possible outcomes:463 if VERDICT is "PASS":464 chorus_mark_acceptance_criteria({465 taskUuid: "<task-uuid>",466 criteria: [467 { uuid: "<ac-uuid>", status: "passed", evidence: "<from reviewer>" },468 // ...469 ]470 })471 chorus_admin_verify_task({ taskUuid: "<task-uuid>" })472 # Task is now "done" -- unblocks dependents for the next wave473474 if VERDICT is "PASS WITH NOTES":475 chorus_mark_acceptance_criteria({ ... })476 chorus_admin_verify_task({ taskUuid: "<task-uuid>" })477478 if VERDICT is "FAIL":479 # BLOCKERs found. Do NOT verify. Reopen for rework.480 chorus_admin_reopen_task({ taskUuid: "<task-uuid>" })481 # Fix the BLOCKERs in a later pass (the task returns to in_progress/open)482```483484After verifying the wave's tasks, return to Phase 3's loop to pick up newly unblocked tasks. Remember: only `done` (not `to_verify`) unblocks dependents.485486**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:487488```489ESCALATE: "Task '{title}' failed review after {maxRounds} rounds.490 Last BLOCKERs: <list>. Manual intervention needed.491 Task UUID: <uuid>"492```493494Continue with remaining tasks -- do not halt the entire pipeline for one stuck task.495496**No new VERDICT for this round?** Apply step 3 of the **Reviewer contract**, reviewing the task yourself if the reviewer stays silent.497498---499500### Phase 4.5: Code-Review Gateway (mandatory pre-ship)501502Once **every** task of the idea's proposal is verified (`done`) — Phase 3 finds no more unblocked tasks and none remain non-terminal — run the final ship-time code-review gateway **before** the Phase 5b completion report. It reviews the **whole Idea's aggregate code change** across all tasks (not a single task) and posts its verdict on the **idea**. Inline (no hook on OpenClaw), same mechanism as Phase 4:503504- **Preferred — spawn a reviewer sub-agent.** Use `sessions_spawn` to spawn a sub-agent whose `task` tells it to **invoke the `/code-reviewer` skill** against the idea, then wait for it (poll `subagents` / `sessions_yield` — do NOT detach). Example task prompt: `Run the /code-reviewer skill to review the aggregate code for ideaUuid <uuid> (round <N>); post your VERDICT comment on the idea when done.`505- **Fallback — review it yourself.** If `sessions_spawn` is unavailable, perform the review as a focused read-only pass following the `/code-reviewer` procedure (read the idea, its approved proposals + documents + tasks, plus the Quick Tasks linked to it via `ideaUuid`; infer the aggregate diff from task reports + `git log/diff`; review cross-task integration, architecture, security, regression, feature-level coverage; run the project build/test) and post the `VERDICT:` comment on the idea yourself.506507Act on the VERDICT:508509- **PASS** / **PASS WITH NOTES** — the feature is cleared to ship. Proceed to Phase 5 / 5b.510- **FAIL** — do NOT ship. Read the BLOCKERs, then fix them via the **quick-dev** workflow (`/quick-dev`): call `chorus_create_tasks` with `proposalUuid` set 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-level `ideaUuid` and no `proposalUuid` — do **not** reopen the already-verified tasks or apply untracked fixes. 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-run the gateway only after every fix task is successfully `done`; a failed or cancelled fix task, stop the automatic loop and escalate. Loop bounded by `maxCodeReviewRounds` (default 3; 0 = unlimited).511512```513ESCALATE: "Idea '{title}' failed code review after {maxCodeReviewRounds} rounds.514 Last BLOCKERs: <list>. Manual intervention needed. Idea UUID: <uuid>"515```516517**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.518519> The gateway is **behavioral** like the other two reviewers: its verdict is advisory and does not change the Idea's stored status; the orchestrator honors it. It runs **before** the completion report so the report is never written while a FAIL is outstanding.520521---522523### Phase 5: Report524525After all waves complete, output a markdown summary:526527```markdown528## /yolo Complete529530**Project:** <project-name> (<project-uuid>)531**Proposal:** <proposal-title> (<proposal-uuid>)532**Idea:** <idea-title> (<idea-uuid>)533534### Tasks535| Task | Status | Review Rounds |536|------|--------|---------------|537| <title> | done | 1 |538| <title> | done | 2 |539| <title> | ESCALATED | 3 (max) |540541### Summary542- Total tasks: N543- Completed: X / N544- Escalated: Y (need human review)545- Waves executed: W546```547548---549550### Phase 5b: Idea Completion Report (mandatory)551552A 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.553554> **Order:** write the completion report only **after** the Phase 4.5 code-review gateway returns PASS / PASS WITH NOTES — never while a code-review FAIL is outstanding.555556> **OpenSpec archive:** if you ran in OpenSpec mode (Step 1.4 branch 2a), the last verified task also triggers the archive flow. OpenClaw has no PostToolUse hook to remind you — after verifying the final task, run `openspec-aware` §3.9 yourself (`openspec archive <slug> --yes`, then mirror each emitted `openspec/specs/<capability>/spec.md` back via §3.8).557558---559560## Error Handling561562| Scenario | Action |563|----------|--------|564| Missing permissions at startup | Abort with message listing the missing resource/action pairs (see Prerequisites). Recommend an Admin-preset API key. |565| Project creation fails | Report error, suggest user create project manually and retry with `--project` |566| Proposal reviewer FAIL after maxRounds | Stop pipeline, report persisting BLOCKERs, suggest manual review |567| Task reviewer FAIL after maxRounds | Flag task as escalation-needed, continue with other tasks |568| Task implementation fails / no submit | Log error, skip task, pick it up in next wave if possible |569| Reviewer sub-agent unavailable (`sessions_spawn` disabled) | Run the review yourself as a focused read-only pass following the `/proposal-reviewer` or `/task-reviewer` skill, then post the VERDICT |570| Interrupted | All entities persist in Chorus. User can resume via `/develop` or `/review` |571572---573574## Tips575576- Keep the initial prompt detailed -- the more context you provide, the better the auto-generated proposal quality577- The proposal-reviewer is your quality gate -- if it keeps FAILing, the prompt may be too vague578- Watch the wave count -- if tasks keep getting reopened, consider stopping and reviewing the feedback manually579- All audit trail is preserved: elaboration Q&A, reviewer VERDICTs, work reports. Check Chorus UI for full history580- For small/simple tasks, consider `/quick-dev` instead -- it skips the Idea->Proposal overhead581- Sub-agents (if you dispatch any) share your API key; ensure it has the permissions listed in Prerequisites before starting582583---584585## Next586587- To manually review proposals: `/review`588- To manually develop tasks: `/develop`589- To create quick standalone tasks: `/quick-dev`590- For platform overview: `/chorus`