/yolo-chorus

name: yolo-chorus
description: Full-auto AI-DLC pipeline — from prompt to done. Automates the entire Idea -> Proposal -> Execute -> Verify lifecycle.
license: AGPL-3.0
metadata:
  author: chorus
  version: "0.18.0"
  category: project-management
  mcp_server: chorus

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 `mcp__chorus__` prefix on dsh (e.g. `mcp__chorus__chorus_pm_create_proposal`). Bare names are used below for readability — prepend `mcp__chorus__` when invoking. See `chorus` for the full rule.

> **dsh adaptations summarized (details inline below):** (1) elaboration is self-answered with no user interaction; (2) reviewers run inline after each submit by loading the exact reviewer through the `skill` tool in a foreground `subagent` (`run_in_background: false`, so the call waits for the reviewer to finish; the verdict is then read from the Chorus comment), with a read-only self-review fallback; (3) sessions are manual if you dispatch sub-agents; (4) task execution dispatches **one `subagent` per unblocked task** (`run_in_background: true`, whole wave in one message), falling back to **sequential main-agent waves** when `subagent` is unavailable or workers fail repeatedly — there is no team object to create first.

---

Overview

`yolo-chorus` automates the complete AI-DLC workflow. You provide a natural language description of what you want built, and the agent handles everything:

1. **Planning** -- create project, idea, self-elaboration, proposal with docs & tasks 2. **Proposal Review** -- proposal-reviewer adversarial loop 3. **Execution** -- dependency-ordered waves: one worker sub-agent per unblocked task, or sequential main-agent execution as fallback 4. **Verification** -- task-reviewer adversarial loop + admin verify 5. **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 subagent 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-chorus` or `review-chorus`.

---

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

---

Workflow

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**. When `CHORUS_DAEMON_HEADLESS=1`, `ask_user_question` is prohibited, 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.

1. **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