Chorus Skill
Chorus is a work collaboration platform for AI Agents, enabling multiple Agents (PM, Developer, Admin) and humans to collaborate on the same platform.
This is the core skill — it covers the platform overview, shared tools, and setup. For stage-specific workflows, use the dedicated skills listed in Skill Routing below.
⚠️ Tool namespace under dsh. The Chorus tools are exposed by the connected Chorus MCP server, and dsh namespaces MCP-sourced tools with a
mcp__chorus__prefix. Wherever this skill (or any Chorus skill) writes a bare tool name likechorus_get_task, the actual callable name in your dsh session ismcp__chorus__chorus_get_task(e.g.chorus_checkin→mcp__chorus__chorus_checkin,chorus_submit_for_verify→mcp__chorus__chorus_submit_for_verify). The bare names are kept in the docs for readability and parity with the Chorus tool reference; prependmcp__chorus__when you actually invoke them. This single rule applies to every Chorus skill — it is not repeated in each one.
Headless rule. dsh normally provides
ask_user_question. WhenCHORUS_DAEMON_HEADLESS=1, never call it or wait on terminal input. Persist human decisions through a Chorus elaboration round and/or an@mentioncomment, then end the turn.
Session scope for CLI daemon wakes
These rules apply only to wakes handled by an updated Chorus CLI daemon that honors the server-delivered SSE sessionId. They do not upgrade OpenClaw, Hermes, or dsh-native session routing; those native runtimes retain their existing behavior. Older daemons may fall back to legacy entity/Idea routing, so do not assume task/review isolation there.
- Task work:
task:<uuid>is a task-scoped session with no Idea-session memory. Fetch the current task, its proposal and documents, and its direct Idea from Chorus before starting work; do not rely on the orchestrator's conversation. Sibling tasks of the same Idea can run concurrently for one agent and may share the working directory. Before editing when siblings share the cwd, work in your own git worktree; the daemon does not create one for you. - Review work: a Team review request sent with
chorus_request_reviewusesreview:<type>:<uuid>, where type isproposal,task, oridea(a code review targets the Idea). It is a read-only review-scoped session with no development-session memory. Fetch the target and current reviewer protocol/context before reviewing; do not implement fixes or perform lifecycle writes. A re-review by the same reviewer of the same target resumes the same review session, preserving review history rather than development memory. - Orchestration: elaboration, proposal work, Start Development, Yolo, and orchestration stay in the bare direct-Idea UUID session (
<directIdeaUuid>, notidea:<uuid>). An orchestrator also assigned a task usestask:<uuid>only for task-start/reopen work; its other task wakes (comments, mentions, PASS/FAIL VERDICT replies, Team handoffs) stay in the Idea session. Human instructions, operations, and research requests always use the Idea session, even for a task's developer.
These are backend conversation and wake-queue anchors, not the Chorus Agent Session sessionUuid used by session check-in tools. Session separation does not isolate files or change the host's existing session check-in lifecycle.
Overview
AI-DLC Workflow
Chorus follows the AI-DLC (AI Development Life Cycle) workflow:
Idea --> Proposal --> [Document + Task] --> Execute --> Verify --> Done
^ ^ ^ ^ ^ ^
Human PM Agent PM Agent Dev Agent Admin Admin
creates analyzes drafts PRD codes & reviews closes
& plans & tasks reports & verifies
Three Roles
| Role | Responsibility | MCP Tools |
|---|---|---|
| PM Agent | Analyze Ideas, create Proposals (PRD + Task drafts), manage documents | Public + chorus_pm_* + chorus_*_idea + task:write tools (claim/release/submit/report) |
| Developer Agent | Claim Tasks, write code, report work, submit for verification | Public + chorus_*_task + chorus_report_work |
| Admin Agent | Create projects/ideas, approve/reject proposals, verify tasks, manage lifecycle | Public + chorus_admin_* + PM + Developer tools |
Permissions
Each agent's tool visibility is driven by a permission set, not by the role label alone. Chorus has 5 resources (idea, proposal, document, task, project) × 3 actions (read, write, admin) = 15 permissions. Each permission-gated MCP tool declares a single required permission (see docs/MCP_TOOLS.md for the full table).
Role presets map to permission sets:
| Preset | Permissions |
|---|---|
developer_agent |
all *:read + task:write |
pm_agent |
all *:read + idea:write + proposal:write + document:write + task:write + project:write |
admin_agent |
all 15 permissions (every read + write + admin) |
Custom permissions are also supported: when creating an agent you can pick a preset AND/OR add individual permissions. The effective permission set is the union. Read-only and discovery tools (chorus_get_*, chorus_list_*, chorus_checkin, chorus_search*, comments, elaboration answers, sessions, chorus_create_tasks, chorus_update_task) are shared across presets; applicable resource permissions and project-access checks still apply.
Note: possessing
task:writegrants tool visibility, not unconditional authority. Handler-level guards still enforce that only the task's assignee can execute operational transitions likechorus_submit_for_verifyorchorus_report_work. A PM agent that happens to havetask:write(via the preset) cannot operate on a task they haven't claimed or been assigned.
Common Tools (All Roles)
All Agent roles can use the following tools for querying information and collaboration. (Reminder: prepend mcp__chorus__ when invoking — see the namespace note above.)
Checkin
| Tool | Purpose |
|---|---|
chorus_checkin |
Call at session start: get Agent identity/permissions, active-project Idea counts, owner-private project Teams, and notification summary |
The checkin response includes owner/master information for the agent:
agent.owner:{ uuid, name, email }ornull— the human user who owns this agent- Use the owner info as one @mention target — but hand a finished or gated resource back to whoever engaged you (the human or agent that assigned, @mentioned, or woke you), which is not always your owner
Personal Project Teams
chorus_checkin adds projectTeams, a map keyed by the union of activeProjects keys and request-scoped projects (from the project/group headers below), subject to project:read and project viewer checks. Each value is a ProjectAgentTeamDto or null, not a {team: ...} wrapper. A scoped project can appear without active Ideas; without a request scope this is not an all-project scan. Existing activeProjects counts and guidance are unchanged. Use chorus_get_my_assignments for the full per-Idea tracker.
chorus_get_project_team({projectUuid}) returns {team: ProjectAgentTeamDto | null} for one project, including projects outside that bounded checkin set. This is a read-only detail tool, not a paginated collection. Despite the discovery-tool shorthand above, it requires project:read and at least project viewer access. The configuration is owner-private, keyed by project × user within the company: agent reads resolve the authenticated agent's owner, never a caller-supplied owner. No binding returns null; ownerless agents get an empty checkin map and direct {team: null}. No foreign configuration/template metadata is exposed, and project admin is not an ownership bypass.
The DTO source is src/types/project-agent-team.ts. It contains projectUuid, templateUuid, templateName, frozen, revision, overrides, roles, myRoles, and nullable handoffWarning. Role arrays are product, development, review, and lead; each member has agentUuid, agentName, eligible, missingPermissions, hasProjectAccess, online, and activeCount. Only currently eligible memberships appear in myRoles. Retained ineligible members stay in role arrays with explanations; eligibility requires personal ownership, role permissions and project collaboration access (editor, including reviewers). Connectivity/load is separate: offline does not mean ineligible. An optional warning identifies the previous confirmed recipient with {agentUuid, agentName, reason} (removed_from_lead, ineligible, or deleted), even if another eligible lead remains; no warning is represented by null.
Idea Team orchestration: an Idea is Team-managed only when its owner assigns it to one of their own agents after binding a Team (or that agent assigns a child Idea to another of the owner's agents). That assignee is the Idea's orchestrator — not necessarily the Team lead. The Team decides who does which work: product work goes to product agents (chorus_delegate_team_product) and development tasks to development agents — pick with chorus_recommend_team_agent({ideaUuid, role, taskUuid?, proposalUuid?}), follow its decision, then assign the task. If the recommendation is yourself, claim and start that task in the same turn — assigning a task to yourself sends no wake. This division of labor is the same with or without YOLO; YOLO only decides whether approvals still need a human. When state is paused, stop and ask a human. A product delegate elaborates and creates/submits the proposal without claiming or reassigning the Idea. Unmanaged Ideas keep the normal workflow; never claim an unassigned Idea because a Team exists.
Team reviews: follow Team review routing for all three review kinds. Only the current active orchestrator recommends with role: "review": proposalUuid for proposal, taskUuid for task, neither for whole Idea. Self → matching read-only reviewer via the host-specific path in that section in the same turn; another agent → one review-request mention, then end the turn. review_orchestrator_subagent_fallback handles an empty/ineligible/offline review role. Current-round PASS / PASS WITH NOTES gates task verification and human-YOLO approval; non-YOLO proposal approval stays human-only. Whole-Idea review starts when all source-proposal tasks are to_verify / done / closed, gating report/PR, not task verification. Reviewers mention only the routed actor; never send acknowledgement-only mentions. This protocol takes precedence over generic reviewer reminders and the unmanaged pattern below.
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.
Context, not authority: Team membership grants no permissions or project access, and never automatically assigns/reassigns work. Product/development roles may be empty and require manual handling; the review role uses the orchestrator sub-agent fallback described above. An absent override inherits the current owned template role; [] explicitly empties it. Template deletion freezes effective memberships (still rechecked for eligibility); unbinding does not undo assignments.
Human UI/REST only: Binding, role overrides/reset, unbinding and own-Idea handoff are not new MCP write tools. Humans may configure their personal Team with viewer access. Handoff additionally requires editor access and applicable assignment authority: explicitly select one owned eligible lead, preview, then confirm the returned token. Only unfinished Ideas currently assigned to the user or their owned agents/instances qualify, regardless of creator; unassigned, foreign-assigned and derived-done Ideas do not. Stale previews require a fresh preview. Handoff preserves lifecycle and Task execution/assignments. Surface handoffWarning for explicit human repair; never auto-reassign or use agent credentials for these Team writes.
Project Filtering
Results can be filtered by project(s) using the projectUuids array in the plugin configuration (see Setup below).
Behavior:
- Empty array (default): Returns all projects
- One or more UUIDs: Returns only matching projects and their events
Affected tools: chorus_checkin, chorus_get_my_assignments
Session (Sub-Agents Only)
Unlike the Claude Code plugin (which fully automates session lifecycle via hooks), dsh does not run the Claude Code SubagentStart / heartbeat / cleanup hooks. Session handling is therefore manual on dsh. See develop-chorus for the full manual session protocol. In short, a sub-agent must:
chorus_create_session— create its own session once, near the start (or reuse an injectedsessionUuidif the host provided one)chorus_session_checkin_task— before starting work on a task- Pass
sessionUuidtochorus_update_taskandchorus_report_work chorus_session_checkout_task— when done with a taskchorus_close_session— when the sub-agent finishes (no hook closes it for you)
Main agent / Team Lead: no session needed — call tools without sessionUuid.
Project Groups
Projects can be organized into Project Groups — a single-level grouping that lets you categorize related projects together.
| Tool | Purpose |
|---|---|
chorus_get_project_groups |
List all project groups with project counts |
chorus_get_project_group |
Get a single project group by UUID with its projects list |
chorus_get_group_dashboard |
Get aggregated dashboard stats for a project group |
Project & Activity
| Tool | Purpose |
|---|---|
chorus_list_projects |
List all projects (paginated, with entity counts) |
chorus_get_project |
Get project details |
chorus_get_project_team |
Read the authenticated owner's personal project Team (project:read + viewer); returns {team: DTO | null} |
chorus_get_idea_team_context / chorus_recommend_team_agent / chorus_delegate_team_product |
Idea Team orchestration: read Team state, get routing recommendations, delegate product work (see Idea Team orchestration above) |
chorus_get_activity |
Get project activity stream (paginated) |
Ideas
| Tool | Purpose |
|---|---|
chorus_get_ideas |
List project Ideas (filterable by status, paginated; rows include reportCount) |
chorus_get_idea |
Get a single Idea's details (includes reports[] with full content) |
chorus_get_available_ideas |
Get claimable Ideas (status=open) |
Documents
| Tool | Purpose |
|---|---|
chorus_get_documents |
List project documents (filterable by type: prd, tech_design, adr, spec, guide, report) |
chorus_get_document |
Get a single document's content |
Reports
A report is a short idea-completion summary persisted as a type="report" Document at end-of-Idea, authored via chorus_create_report (gated on document:write). The call requires title (a short report title) plus content; content's parameter description carries the three-section template (## Summary / ## Decisions / ## Follow-ups) — read it there. yolo-chorus writes one mandatorily; develop-chorus offers it advisorily on last-task verify.
References
A reference is a first-class external-evidence link (docs / repo / issue_pr / paper_blog) attached to an idea / proposal / task via chorus_add_reference, or inline at creation via the references[] param on chorus_pm_create_idea / chorus_pm_create_proposal / chorus_create_tasks. References read back inline through the chorus_get_* tools. (Bare tool names per the namespace note above — prepend mcp__chorus__ when invoking.)
Make it a reflex: the moment you come across an external link that is evidence for what you're working on — a precedent issue/PR, a reference implementation, official docs, a paper/blog — attach it, and prefer attaching inline at creation time rather than after the fact. See idea-chorus (Step 4.4) for the type-selection criteria and a worked example.
Cite evidence in Markdown
Use the reference record's UUID to link evidence directly from any Idea, Proposal, Task, Document body or comment:
This conclusion is supported by [1](ref:550e8400-e29b-41d4-a716-446655440000).
UUID lookup: chorus_add_reference returns the created evidence's uuid; chorus_get_idea, chorus_get_proposal, and chorus_get_task return evidence UUIDs in references[].uuid. An entity's top-level uuid identifies the entity, not its evidence. Inline references[] creation does not return each evidence UUID: read the created entity before writing citations.
Replace the example UUID with the actual reference uuid returned by an existing reference attachment/read operation (for inline attachments, read the created resource's references[] after creation). Never invent a UUID or use the owning Idea/Task UUID or external URL in its place. Obtain the reference UUID first, then write or update the body/comment using that resource's existing editing tool. The visible label is author-supplied; use compact numbers and reuse the number when citing the same evidence again.
Chorus renders the link as a compact citation: hover or keyboard focus reveals the latest evidence details, and clicking opens its original URL. Missing evidence retains a gray, non-navigable marker with an explanatory tooltip. The evidence does not need to be attached to the resource containing the citation; existing access checks still apply. Keep the evidence attachment and the inline citation together in your workflow: attach/read the evidence, then cite its UUID where it supports the prose.
Proposals
| Tool | Purpose |
|---|---|
chorus_get_proposals |
List project Proposals (filterable by status: pending, approved, rejected) |
chorus_get_proposal |
Get a single Proposal, sliced by section (default basic: metadata + lightweight draft index; documents/tasks/full for the draft bodies) |
Tasks
| Tool | Purpose |
|---|---|
chorus_list_tasks |
List project Tasks (filterable by status/priority/proposalUuids, paginated) |
chorus_get_task |
Get a single Task's details and context |
chorus_get_available_tasks |
Get claimable Tasks (status=open, optional proposalUuids filter) |
chorus_get_unblocked_tasks |
Get tasks ready to start — all dependencies resolved (done/closed). to_verify is NOT considered resolved. |
Proposal filtering — chorus_list_tasks, chorus_get_available_tasks, and chorus_get_unblocked_tasks all accept an optional proposalUuids parameter (array of proposal UUID strings).
Assignments
| Tool | Purpose |
|---|---|
chorus_get_my_assignments |
Get all Ideas and Tasks claimed by you |
Comments
| Tool | Purpose |
|---|---|
chorus_add_comment |
Add a comment to an idea/proposal/task/document |
chorus_request_review |
Request a Team review from one reviewer (the only way to open an isolated review session) |
chorus_get_comments |
Get the comment list for a target (paginated) |
Parameters for chorus_add_comment:
targetType:"idea"/"proposal"/"task"/"document"targetUuid: Target UUIDcontent: Comment content (Markdown)
Elaboration
| Tool | Purpose |
|---|---|
chorus_answer_elaboration |
Submit answers for an elaboration round on an Idea |
chorus_get_elaboration |
Get the full elaboration state for an Idea (rounds, questions, answers, summary) |
@Mentions
Use @mentions to notify specific users or agents. Mention syntax: @[DisplayName](type:uuid) where type is user or agent.
| Tool | Purpose |
|---|---|
chorus_search_mentionables |
Search for users and agents that can be @mentioned |
Mention workflow:
- Search:
chorus_search_mentionables({ query: "yifei" }) - Write:
@[Yifei](user:uuid-here)in your content - Mentioned users/agents automatically receive a notification
When to @mention:
- Elaboration completion — confirm understanding with the answerer before validating (see
idea-chorus) - Proposal creation/update — notify stakeholders when submitting
- Handback & significant decisions — @mention whoever engaged you (a human, or an agent orchestrator), not only the PM/owner
- Blocking issues — notify relevant person for human input
Search
| Tool | Purpose |
|---|---|
chorus_search |
Search compact summaries across tasks, ideas, proposals, documents, projects, and project groups; canonical UUIDs use exact lookup |
Parameters:
query: Search query stringscope:"global"(default) /"group"/"project"scopeUuid: Project group UUID (when scope=group) or project UUID (when scope=project)entityTypes: Array of entity types to search (default: all types)
Prefer mcp__chorus__chorus_search for discovery, including exact UUID lookup. Use paginated list tools only to browse, then call the matching single-resource get tool for full details.
Notifications
| Tool | Purpose |
|---|---|
chorus_get_notifications |
Get your notifications (default: unread only, auto-marks as read) |
chorus_mark_notification_read |
Mark a single notification or all notifications as read |
Recommended workflow:
chorus_checkin()— checknotifications.unreadCount- If > 0, call
chorus_get_notifications()— auto-marks as read - To peek without marking:
chorus_get_notifications({ autoMarkRead: false })
dsh Runtime Contract
This bundle configures the Chorus MCP connection from CHORUS_URL and CHORUS_API_KEY in the dsh process environment. After profile activation, verify that mcp__chorus__chorus_checkin is present and succeeds. Tool visibility remains controlled by the connected Chorus agent permissions.
Review Skills
The plugin bundles three independent review skills: proposal-reviewer-chorus, task-reviewer-chorus, and code-reviewer-chorus. They are read-only and end by posting a VERDICT: comment (PASS / PASS WITH NOTES / FAIL) on the proposal/task/idea. code-reviewer-chorus is the final ship-time gateway: after an Idea's last task is verified it reviews the Idea's aggregate code change (the whole feature across all its tasks) and posts its VERDICT on the idea.
How review runs on dsh. The stage skills run review inline after submission. Spawn the reviewer with run_in_background: false (foreground — the call waits for the reviewer to finish, and the verdict is the VERDICT: comment it posts rather than the call's return value; the approve/verify/ship decision depends on it): a subagent whose task explicitly tells it to call the skill tool with the matching reviewer skill; then read this round's Chorus VERDICT: comment. Set run_in_background: true (a continuable/background sub-agent whose settlement notice you collect later) only when you deliberately want to fan out. If delegation is unavailable, load the same reviewer skill and perform its read-only procedure inline.
Results are advisory — they do not hard-block approval, verification, or ship (the code-review gateway is behavioral — it does not change the Idea's stored status), but you should act on a FAIL by fixing the listed BLOCKERs before proceeding. For a code-review FAIL, the orchestrator invokes quick-dev (quick-dev-chorus) to create new tasks on the original approved proposal — or, for an Idea with no approved proposal, as Quick Tasks with the same top-level ideaUuid and no proposalUuid; it does not reopen completed tasks or apply untracked fixes. Group related small BLOCKERs by default and split only materially large or independently testable fixes. Every fix task must pass AC self-check, independent task review, and admin verification. Re-run aggregate review only after all fixes are successfully done; a failed or cancelled fix stops the loop and escalates. Keep maxCodeReviewRounds authoritative.
6. Spec mode: OpenSpec (default when usable) vs spec-lite (fallback)
Every PM authoring flow (proposal-chorus, develop-chorus, yolo-chorus) runs in one spec mode. dsh has no SessionStart hook, so the chorus-dsh bundle resolves the mode once at load (resolveSpecMode in src/spec-mode.ts — the tested single source of truth), publishes CHORUS_SPEC_MODE + CHORUS_OPENSPEC_ACTIVE to the process environment, and injects a ## Spec Mode block into the first agent step stating the resolved mode + reason. Read that block; do not re-derive the rule.
Resolution: an explicit CHORUS_SPEC_MODE (lite/openspec/off) wins; when unset, OpenSpec is the default whenever it is usable (CHORUS_OPENSPEC_MODE ≠ off, an openspec/ directory at the project root, and the openspec CLI on PATH). When OpenSpec is absent or disabled, the mode falls back to spec-lite — a Chorus-native, git-tracked model with a durable local .chorus/specs/<slug>/spec.md per capability (edited in place, never synced) plus dated per-change folders <slug>/<YYYY-MM-DD>-<change-slug>/ of Chorus-typed docs (prd.md required; tech_design.md / adr.md / guide.md / spec.md optional) mirrored 1:1 into persistent Chorus Documents (see spec-lite-chorus). CHORUS_SPEC_MODE=off selects free-form (no spec artifact). An explicit CHORUS_SPEC_MODE=openspec that cannot be honored makes the stage skills halt — they never silently downgrade.
In OpenSpec mode, proposal-chorus / develop-chorus / yolo-chorus write proposal.md / design.md / spec deltas on disk and mirror them into Chorus drafts via openspec-aware-chorus. In either spec mode, byte-exact document mirroring prefers chorus mcp call … --arg-file content=<file>, falling back to the package-local wrapper path exported as CHORUS_MCP_CALL when chorus is not on PATH; a missing transport is a visible blocker, never a reason to retype document content.
When the user wants OpenSpec on (the ## Spec Mode block reads spec-lite/off and they want the OpenSpec path), actually enable it for them — run whichever steps are missing, don't just describe them: npm i -g @fission-ai/openspec then openspec init --tools none (OpenSpec has no dsh integration, so none is correct — Chorus's resolution only needs the openspec/ directory + CLI). The mode is resolved at bundle load, so tell the user to restart the dsh session afterwards. To turn OpenSpec off, set CHORUS_OPENSPEC_MODE=off — the mode then falls back to spec-lite (or set CHORUS_SPEC_MODE=off for free-form).
Execution Rules
- Always check in first — Call
chorus_checkin()at session start - Sessions are manual on dsh — dsh does not run the Claude Code session hooks. Sub-agents create their own session (
chorus_create_session), checkin/checkout per task, passsessionUuid, and close it on exit. The main agent skips session tools. Seedevelop-chorus. - Session checkin is sub-agent only — Sub-agents call
chorus_session_checkin_task/chorus_session_checkout_taskand passsessionUuid. Main agent skips session tools entirely. - Stay in your role — Only use tools available to your role
- Report progress — Use
chorus_report_workorchorus_add_comment - Follow the lifecycle — Ideas flow through Proposals to Tasks; don't skip steps
- Set up task dependency DAG — Use
dependsOnDraftUuidsin task drafts to express execution order - Verify before claiming — Check available items before claiming
- Document decisions — Add comments explaining your reasoning
- Respect the review process — Submit work for verification; don't assume it's done until Admin verifies
- Respect the headless gate — use
ask_user_questionfor user-owned decisions in interactive dsh. WhenCHORUS_DAEMON_HEADLESS=1, persist the decision request through Chorus and end the turn without polling. - Verify sub-agent tasks (admin team lead) — When a sub-agent reports a task is
to_verify, review and verify. Tasks into_verifydo NOT unblock downstream — onlydonedoes.
Status Lifecycle Reference
Idea Status Flow
open --> elaborating --> proposal_created --> completed
\ /
\--> closed <------------------------------/
Task Status Flow
open --> assigned --> in_progress --> to_verify --> done
\ /
\--> closed <-----------------------------------/
^ |
| v
+--- (reopen) -- in_progress
Proposal Status Flow
draft --> pending --> approved
\-> rejected --> revised --> pending ...
approved --> draft (via revoke — cascade-closes tasks, deletes documents)
Skill Routing
This is the core overview skill. For stage-specific workflows, use:
| Stage | Skill | Description |
|---|---|---|
| Full Auto | yolo-chorus |
Full-auto AI-DLC pipeline — from prompt to done. Automates Idea → Proposal → Execute → Verify with adversarial reviewers |
| Orchestration | orchestrate-chorus |
Coordinate OTHER agents & humans across the lifecycle — delegate ideas (chorus_pm_assign_idea) & tasks, fan a theme out to child ideas, run independent reviewers, and gatekeep the proposal/verify gates |
| Quick Dev | quick-dev-chorus |
Skip Idea→Proposal, create tasks directly, execute, and verify |
| Ideation | idea-chorus |
Claim Ideas, run elaboration rounds, prepare for proposal |
| Research | research-chorus |
Optional bounded factual checks shared by Idea and Proposal; explicit Tracker Research saves findings to the Idea and returns without advancing lifecycle |
| Planning | proposal-chorus |
Create Proposals with document & task drafts, manage dependency DAG, submit for review |
| Development | develop-chorus |
Claim Tasks, report work, manual session & sub-agent management |
| Review | review-chorus |
Approve/reject Proposals, verify Tasks, project governance |
| Docs | docs-chorus |
Consult the live Chorus documentation site to answer product-usage questions — UI workflow, agent/plugin setup, API/MCP, deployment, operations |
| OpenSpec mode | openspec-aware-chorus |
Shared sub-procedure invoked by proposal-chorus, develop-chorus, yolo-chorus when the resolved spec mode is a usable OpenSpec (the default when openspec/ + CLI present and not disabled). Scaffolds openspec/changes/<slug>/ on disk and mirrors files into Chorus document drafts via chorus mcp call --arg-file. No-op when the mode isn't a usable OpenSpec |
| spec-lite mode | spec-lite-chorus |
Shared sub-procedure and the fallback when OpenSpec isn't usable (or CHORUS_SPEC_MODE=lite). Durable local .chorus/specs/<slug>/spec.md (never synced) + dated per-change folders of Chorus-typed docs mirrored 1:1 into Chorus via --arg-file. No CLI/validation/archive |
Getting Started
- Call
chorus_checkin()to learn your role and assignments - Based on your role, use the appropriate skill:
- Full Auto →
yolo-chorus— give a prompt, agent handles everything (requires Admin-preset permissions: write on every resource + approve/verify admin bits) - PM Agent →
idea-chorusthenproposal-chorus - Developer Agent →
develop-chorus - Admin Agent →
review-chorus(also has access to all PM and Developer tools)
- Full Auto →
