@chorus-aidlc/chorus 0.9.2 → 0.9.4

package/.next/standalone/public/chorus-plugin/skills/yolo/SKILL.md

@@ -4,7 +4,7 @@ description: Full-auto AI-DLC pipeline — from prompt to done. Automates the en
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.9.1"
+  version: "0.9.4"
   category: project-management
   mcp_server: chorus
 ---
@@ -138,6 +138,8 @@ chorus_claim_idea({ ideaUuid: "<idea-uuid>" })
 
 In /yolo mode, the agent generates elaboration questions and answers them itself -- no `AskUserQuestion` calls. This preserves an audit trail without interrupting the user.
 
+> **Self-elaboration is still a loop.** If answering your own questions surfaces a **new question, contradiction, or gap**, loop back to `chorus_pm_start_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({
@@ -170,15 +172,16 @@ In /yolo mode, the agent generates elaboration questions and answers them itself
    })
    ```
 
-3. **Validate** (no issues in self-mode):
+3. **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>",
-     roundUuid: "<round-uuid>",
-     issues: []
+     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
 
 1. **Detect OpenSpec mode.** Load the `openspec-aware` skill at `.claude/skills/openspec-aware/SKILL.md` and run its §1 detection contract. The result determines how the rest of this step authors documents:
@@ -224,7 +227,7 @@ In /yolo mode, the agent generates elaboration questions and answers them itself
    })
    ```
 
-3. **Add task drafts incrementally** (use returned `draftUuid` for dependency chaining):
+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({

package/.next/standalone/public/install-codex.sh

@@ -14,8 +14,8 @@
 #      [plugins."chorus@chorus-plugins"] enabled = true into ~/.codex/config.toml,
 #      so Codex auto-enables the plugin on first launch (falls back to one-click
 #      `/plugins → Install` if auto-install does not fire).
-#   4. Installs a lazy hook wrapper under ~/.codex/hooks/chorus/ so Chorus hooks
-#      work even before the plugin cache is materialized.
+#   4. Enables Codex lifecycle hooks. Chorus hook scripts are bundled in the
+#      plugin manifest and loaded by Codex after the plugin is installed/enabled.
 
 set -euo pipefail
 
@@ -35,6 +35,158 @@ CONFIG_TOML="$CODEX_HOME/config.toml"
 
 is_tty() { [ -t 0 ] && [ -t 1 ]; }
 
+clean_legacy_chorus_hooks_json() {
+  local hooks_json="$1"
+  local tmp backup removed
+
+  tmp="$(mktemp "${TMPDIR:-/tmp}/chorus-hooks.XXXXXX")"
+  backup="${hooks_json}.chorus-legacy-bak"
+  cp "$hooks_json" "$backup"
+
+  if command -v node >/dev/null 2>&1; then
+    removed="$(node - "$hooks_json" "$tmp" <<'NODE'
+const fs = require("fs");
+const input = process.argv[2];
+const output = process.argv[3];
+let removed = 0;
+
+function isLegacyCommand(value) {
+  return typeof value === "string" && value.indexOf("hooks/chorus/run-hook.sh") !== -1;
+}
+
+function clean(value, parentKey) {
+  if (Array.isArray(value)) {
+    return value
+      .map((item) => clean(item, parentKey))
+      .filter((item) => item !== undefined);
+  }
+
+  if (value && typeof value === "object") {
+    if (isLegacyCommand(value.command)) {
+      removed += 1;
+      return undefined;
+    }
+
+    const hadHooksArray = Array.isArray(value.hooks);
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      const cleaned = clean(child, key);
+      if (cleaned === undefined) continue;
+      if (Array.isArray(cleaned) && cleaned.length === 0 && (key === "hooks" || parentKey === "hooks")) continue;
+      out[key] = cleaned;
+    }
+
+    if (hadHooksArray && (!Array.isArray(out.hooks) || out.hooks.length === 0)) {
+      return undefined;
+    }
+    return out;
+  }
+
+  return value;
+}
+
+let data = JSON.parse(fs.readFileSync(input, "utf8"));
+data = clean(data, "") || {};
+if (data.hooks && typeof data.hooks === "object" && !Array.isArray(data.hooks)) {
+  for (const key of Object.keys(data.hooks)) {
+    if (Array.isArray(data.hooks[key]) && data.hooks[key].length === 0) {
+      delete data.hooks[key];
+    }
+  }
+  if (Object.keys(data.hooks).length === 0) {
+    delete data.hooks;
+  }
+}
+fs.writeFileSync(output, JSON.stringify(data, null, 2) + "\n");
+process.stdout.write(String(removed));
+NODE
+    )" || {
+      rm -f "$tmp"
+      warn "Could not parse $hooks_json with node; leaving legacy hooks unchanged."
+      warn "Backup created at $backup"
+      return 1
+    }
+  elif command -v python3 >/dev/null 2>&1; then
+    removed="$(python3 - "$hooks_json" "$tmp" <<'PY'
+import json
+import sys
+
+input_path = sys.argv[1]
+output_path = sys.argv[2]
+removed = 0
+
+def is_legacy_command(value):
+    return isinstance(value, str) and "hooks/chorus/run-hook.sh" in value
+
+def clean(value, parent_key=""):
+    global removed
+    if isinstance(value, list):
+        return [item for item in (clean(child, parent_key) for child in value) if item is not None]
+    if isinstance(value, dict):
+        if is_legacy_command(value.get("command")):
+            removed += 1
+            return None
+        had_hooks_array = isinstance(value.get("hooks"), list)
+        out = {}
+        for key, child in value.items():
+            cleaned = clean(child, key)
+            if cleaned is None:
+                continue
+            if isinstance(cleaned, list) and not cleaned and (key == "hooks" or parent_key == "hooks"):
+                continue
+            out[key] = cleaned
+        if had_hooks_array and (not isinstance(out.get("hooks"), list) or not out["hooks"]):
+            return None
+        return out
+    return value
+
+with open(input_path, "r", encoding="utf-8") as f:
+    data = json.load(f)
+
+data = clean(data) or {}
+if isinstance(data.get("hooks"), dict):
+    for key in list(data["hooks"].keys()):
+        if isinstance(data["hooks"][key], list) and not data["hooks"][key]:
+            del data["hooks"][key]
+    if not data["hooks"]:
+        del data["hooks"]
+
+with open(output_path, "w", encoding="utf-8") as f:
+    json.dump(data, f, indent=2)
+    f.write("\n")
+
+print(removed, end="")
+PY
+    )" || {
+      rm -f "$tmp"
+      warn "Could not parse $hooks_json with python3; leaving legacy hooks unchanged."
+      warn "Backup created at $backup"
+      return 1
+    }
+  else
+    rm -f "$tmp"
+    warn "Cannot auto-clean $hooks_json because neither node nor python3 is available."
+    warn "Backup created at $backup"
+    return 1
+  fi
+
+  if [ "${removed:-0}" = "0" ]; then
+    rm -f "$tmp"
+    warn "No legacy Chorus hook entries were removed from $hooks_json."
+    warn "Backup created at $backup"
+    return 1
+  fi
+
+  if grep -q '[^[:space:]{}]' "$tmp" 2>/dev/null; then
+    mv "$tmp" "$hooks_json"
+    ok "Removed $removed legacy Chorus hook entr$( [ "$removed" = "1" ] && printf 'y' || printf 'ies' ) from $hooks_json"
+  else
+    rm -f "$tmp" "$hooks_json"
+    ok "Removed $removed legacy Chorus hook entr$( [ "$removed" = "1" ] && printf 'y' || printf 'ies' ) and deleted now-empty $hooks_json"
+  fi
+  ok "Backup saved at $backup"
+}
+
 # If piped through `curl | bash`, stdin is the script body. Re-open from /dev/tty
 # so interactive prompts still work — but only if a real TTY is available AND we
 # actually need to prompt for input. Both CHORUS_URL and CHORUS_API_KEY being set
@@ -181,104 +333,61 @@ TOML
 
 ok "Wrote [mcp_servers.chorus] and [plugins.\"chorus@chorus-plugins\"] → ${CONFIG_TOML}"
 
-# ---------- step 5: install hooks ----------
-hdr "5/5  Installing Chorus hooks"
+# ---------- step 5: enable hooks ----------
+hdr "5/5  Enabling Codex lifecycle hooks"
 
-# Install a tiny wrapper that lazily resolves the newest plugin cache at
-# hook-run time. This lets us write hooks.json BEFORE `/plugins → Install`
-# has materialized the plugin cache — first-run UX becomes truly one-shot.
-WRAPPER_DIR="$CODEX_HOME/hooks/chorus"
-WRAPPER="$WRAPPER_DIR/run-hook.sh"
-mkdir -p "$WRAPPER_DIR"
-cat > "$WRAPPER" <<'WRAP'
-#!/usr/bin/env bash
-# Chorus hook wrapper (installed by public/install-codex.sh).
-# Resolves the newest installed Chorus plugin version at runtime and execs
-# the named hook script from its hooks/ directory. Exits 0 (no-op) if the
-# plugin has not been installed yet, so Codex sessions still start cleanly.
-set -eu
-HOOK_NAME="${1:-}"
-if [ -z "$HOOK_NAME" ]; then
-  echo '{}' ; exit 0
-fi
-shift
-CODEX_HOME_RESOLVED="${CODEX_HOME:-$HOME/.codex}"
-PLUGIN_ROOT="$CODEX_HOME_RESOLVED/plugins/cache/chorus-plugins/chorus"
-if [ ! -d "$PLUGIN_ROOT" ]; then
-  echo '{}' ; exit 0
-fi
-VER="$(ls -1 "$PLUGIN_ROOT" 2>/dev/null | sort -V | tail -1)"
-if [ -z "$VER" ]; then
-  echo '{}' ; exit 0
-fi
-SCRIPT="$PLUGIN_ROOT/$VER/hooks/$HOOK_NAME"
-if [ ! -x "$SCRIPT" ]; then
-  if [ -f "$SCRIPT" ]; then
-    chmod +x "$SCRIPT" 2>/dev/null || true
+HOOKS_JSON="$CODEX_HOME/hooks.json"
+if [ -f "$HOOKS_JSON" ] && grep -q "hooks/chorus/run-hook.sh" "$HOOKS_JSON" 2>/dev/null; then
+  warn "Found legacy copied Chorus hook entries in $HOOKS_JSON."
+  warn "These can duplicate the plugin-bundled Chorus hooks now loaded by Codex."
+  warn "Legacy entries:"
+  grep -n "hooks/chorus/run-hook.sh" "$HOOKS_JSON" 2>/dev/null | sed 's/^/    /' >&2 || true
+
+  if [ -r /dev/tty ] && [ -w /dev/tty ]; then
+    printf "  Clean legacy Chorus entries from %s now? [y/N]: " "$HOOKS_JSON" > /dev/tty
+    read -r clean_legacy_hooks_answer < /dev/tty
+    case "$clean_legacy_hooks_answer" in
+      y|Y|yes|YES|Yes)
+        clean_legacy_chorus_hooks_json "$HOOKS_JSON" || true
+        ;;
+      *)
+        warn "Keeping legacy hooks unchanged. Use /hooks to disable them or remove matching entries manually to avoid duplicates."
+        ;;
+    esac
   else
-    echo '{}' ; exit 0
+    warn "No interactive TTY available; keeping legacy hooks unchanged."
+    warn "Re-run this installer in a terminal to auto-clean them, or remove matching entries manually."
   fi
 fi
-exec "$SCRIPT" "$@"
-WRAP
-chmod +x "$WRAPPER"
-ok "Installed hook wrapper → $WRAPPER"
 
-HOOKS_JSON="$CODEX_HOME/hooks.json"
-if [ -f "$HOOKS_JSON" ] && ! grep -q "hooks/chorus/run-hook.sh\|chorus-plugins/chorus" "$HOOKS_JSON" 2>/dev/null; then
-  warn "Found a non-Chorus $HOOKS_JSON — not overwriting."
-  warn "  Add Chorus hook entries manually (command = $WRAPPER on-session-start.sh | on-post-submit-proposal.sh | on-post-submit-for-verify.sh)."
-else
-  cat > "$HOOKS_JSON" <<HJSON
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "startup|resume|clear",
-        "hooks": [
-          { "type": "command", "command": "$WRAPPER on-session-start.sh", "timeout": 20, "statusMessage": "Chorus: checkin" }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": ".*chorus_pm_submit_proposal",
-        "hooks": [
-          { "type": "command", "command": "$WRAPPER on-post-submit-proposal.sh", "timeout": 10 }
-        ]
-      },
-      {
-        "matcher": ".*chorus_submit_for_verify",
-        "hooks": [
-          { "type": "command", "command": "$WRAPPER on-post-submit-for-verify.sh", "timeout": 10 }
-        ]
-      }
-    ]
-  }
-}
-HJSON
-  ok "Wrote $HOOKS_JSON (routing through $WRAPPER)"
-fi
-
-# Enable the codex_hooks feature flag in config.toml (idempotent).
+# Keep the current canonical feature key. `codex_hooks` is a deprecated alias;
+# remove any old hook feature setting from [features] before writing `hooks = true`
+# so reruns do not create duplicate TOML keys.
 if grep -qE "^\[features\]" "$CONFIG_TOML"; then
-  if ! grep -qE "^codex_hooks\s*=\s*true" "$CONFIG_TOML"; then
-    tmp="$(mktemp "${TMPDIR:-/tmp}/chorus-features.XXXXXX")"
-    awk '
-      /^\[features\][[:space:]]*$/ { print; print "codex_hooks = true"; inserted=1; next }
-      { print }
-    ' "$CONFIG_TOML" > "$tmp" && mv "$tmp" "$CONFIG_TOML"
-    ok "Added codex_hooks = true under existing [features]"
-  else
-    ok "codex_hooks feature flag already enabled"
-  fi
+  tmp="$(mktemp "${TMPDIR:-/tmp}/chorus-features.XXXXXX")"
+  awk '
+    /^\[features\][[:space:]]*$/ {
+      in_features = 1
+      print
+      print "hooks = true"
+      next
+    }
+    /^\[/ {
+      in_features = 0
+    }
+    in_features && /^[[:space:]]*(hooks|codex_hooks)[[:space:]]*=/ {
+      next
+    }
+    { print }
+  ' "$CONFIG_TOML" > "$tmp" && mv "$tmp" "$CONFIG_TOML"
+  ok "Set [features] hooks = true"
 else
   cat >> "$CONFIG_TOML" <<'TFEAT'
 
 [features]
-codex_hooks = true
+hooks = true
 TFEAT
-  ok "Appended [features] codex_hooks = true"
+  ok "Appended [features] hooks = true"
 fi
 
 # ---------- epilogue ----------
@@ -296,7 +405,8 @@ so one manual click is the fallback path).
 
 Verify anytime:
   ${BOLD}codex mcp list${RESET}         # 'chorus' row, Auth = 'Bearer token'
-  ${BOLD}codex features list${RESET}    # codex_hooks + plugins both true
+  ${BOLD}codex features list${RESET}    # hooks + plugins both true
+  ${BOLD}/hooks${RESET}                 # review/trust bundled Chorus hooks after launch
 
 Then in Codex type ${BOLD}\$chorus${RESET} (or \$develop, \$review, \$proposal, …) to
 activate a skill. To change your API key later, just re-run this installer.

package/.next/standalone/public/skill/brainstorm-chorus/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: brainstorm-chorus
-description: Optional divergent-then-convergent dialogue for fuzzy ideas. Invoked from the idea skill as a prelude to structured elaboration; produces one ElaborationRound of decision-point Q&A and returns control. Never writes files, never posts comments, never validates elaboration.
+description: Optional divergent-then-convergent dialogue for fuzzy ideas. Invoked from the idea skill as a prelude to structured elaboration; produces one ElaborationRound of decision-point Q&A and returns control. Never writes files, never posts comments, never resolves elaboration.
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.3.1"
+  version: "0.9.4"
   category: project-management
   mcp_server: chorus
 ---
@@ -13,7 +13,7 @@ metadata:
 
 A divergent-then-convergent dialogue cadence for ideas whose direction is still being formed. Compresses the conversation into one `ElaborationRound` of decision-point Q&A — same shape as a structured elaboration round, but the questions, options and answers are synthesized at the end of the conversation rather than asked up front.
 
-This skill is a **producer** of one elaboration round; the **scheduler** decision (validate vs. follow-up) belongs to the calling idea skill.
+This skill is a **producer** of one elaboration round; the **scheduler** decision (resolve vs. follow-up) belongs to the calling idea skill.
 
 ---
 
@@ -32,7 +32,7 @@ Only as a sub-step of the idea skill, only after the user has explicitly opted i
 5. **No files written.** Do NOT write any markdown, design doc, scratch file, or any other file to disk. The conversation produces an `ElaborationRound` and nothing else on disk.
 6. **No comments posted.** Do NOT call `chorus_add_comment` from this skill. Comments belong to the idea skill or the user, not to the brainstorm step.
 7. **No design-doc handoff.** Do NOT invoke `writing-plans`, `writing-skills`, or any skill whose purpose is to produce a design document. The brainstorm output is the synthesized round — there is no separate doc.
-8. **No `validate_elaboration` call.** Do NOT call `chorus_pm_validate_elaboration` from this skill. Whether to validate (resolve elaboration) or follow up (issues + followUpQuestions) is the calling idea skill's decision, not this skill's.
+8. **No `validate_elaboration` call.** Do NOT call `chorus_pm_validate_elaboration` from this skill. Whether to resolve the elaboration or open a follow-up round (`chorus_pm_start_elaboration` again) is the calling idea skill's decision, not this skill's.
 
 ---
 
@@ -126,8 +126,8 @@ chorus_answer_elaboration({
 
 Stop here. Do **NOT** call `chorus_pm_validate_elaboration`. The idea skill's caller now decides:
 
-- If the synthesized round answers cover everything → caller validates with `issues: []`.
-- If gaps remain → caller validates with `issues + followUpQuestions` to start a structured Round 2.
+- If the synthesized round answers cover everything → caller obtains human confirmation, then resolves with `chorus_pm_validate_elaboration`.
+- If gaps remain → caller opens a structured Round 2 by calling `chorus_pm_start_elaboration` again.
 
 The depth of any follow-up round is the caller's call, not yours.
 
@@ -160,7 +160,7 @@ Do not do any of the following. Each has a specific failure mode that this skill
 - **Single-summary `customText` blob.** Compressing the entire conversation into one ElaborationQuestion with a long markdown summary in `customText`. The schema is multi-question for a reason — preserve the decision granularity.
 - **Transcript-as-comment.** Posting the raw conversation log as a comment on the idea (or anywhere). The synthesized round IS the artifact. Raw transcripts pollute the audit trail with noise.
 - **File writes.** Writing any markdown, design doc, plan, or scratch file to disk. There is no design doc in this flow. This is a deliberate divergence from the upstream `superpowers/brainstorming` cadence — read the design.md if confused.
-- **`validate_elaboration` calls.** Closing the elaboration phase from this skill. The lifecycle decision belongs to the idea skill. Calling validate here strips the caller of its scheduler role.
+- **`validate_elaboration` calls.** Closing the elaboration phase from this skill. The lifecycle decision belongs to the idea skill. Calling it here strips the caller of its scheduler role.
 - **`writing-plans` / design-doc handoff.** Invoking any skill that produces an implementation plan or design document. The Chorus pipeline already has Proposal → Document Drafts → Task Drafts for that — the brainstorm output feeds them through ElaborationRound, not through external doc skills.
 - **Length-2 binary "yes / no" framings.** Reducing every decision to "do this thing — yes / no". Almost always the genuine alternatives are 3+ approaches with meaningfully different tradeoffs. Length-2 framings often mean the divergent phase ended too early.
 - **Asking multiple questions in one `AskUserQuestion`.** The cadence is one question per turn during divergence, then one final convergence question with 2-3 options. Combining unrelated questions is a sign you are rushing.

package/.next/standalone/public/skill/chorus/SKILL.md

@@ -4,7 +4,7 @@ description: Chorus AI Agent collaboration platform — overview, common tools,
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.3.1"
+  version: "0.9.3"
   category: project-management
   mcp_server: chorus
 ---
@@ -30,18 +30,28 @@ Skill files are hosted under the `<BASE_URL>/skill/` path.
 | **proposal-chorus** | Proposal creation, drafts, DAG, submission | `/skill/proposal-chorus/SKILL.md` |
 | **develop-chorus** | Task execution workflow | `/skill/develop-chorus/SKILL.md` |
 | **review-chorus** | Proposal approval, task verification, governance | `/skill/review-chorus/SKILL.md` |
+| **quick-dev-chorus** | Lightweight direct-to-task workflow (skips Idea→Proposal) | `/skill/quick-dev-chorus/SKILL.md` |
+| **brainstorm-chorus** | Optional divergent→convergent dialogue, prelude to elaboration | `/skill/brainstorm-chorus/SKILL.md` |
+| **proposal-reviewer-chorus** | Read-only adversarial proposal reviewer (posts VERDICT) | `/skill/proposal-reviewer-chorus/SKILL.md` |
+| **task-reviewer-chorus** | Read-only adversarial task reviewer (posts VERDICT) | `/skill/task-reviewer-chorus/SKILL.md` |
+| **yolo-chorus** | Full-auto AI-DLC pipeline — prompt to done | `/skill/yolo-chorus/SKILL.md` |
 | **package.json** | Version & download metadata | `/skill/package.json` |
 
 ### Install (Claude Code, project-level)
 
 ```bash
 BASE_URL="<BASE_URL>"
-mkdir -p .claude/skills/chorus .claude/skills/idea-chorus .claude/skills/proposal-chorus .claude/skills/develop-chorus .claude/skills/review-chorus
+mkdir -p .claude/skills/chorus .claude/skills/idea-chorus .claude/skills/proposal-chorus .claude/skills/develop-chorus .claude/skills/review-chorus .claude/skills/quick-dev-chorus .claude/skills/brainstorm-chorus .claude/skills/proposal-reviewer-chorus .claude/skills/task-reviewer-chorus .claude/skills/yolo-chorus
 curl -s $BASE_URL/skill/chorus/SKILL.md > .claude/skills/chorus/SKILL.md
 curl -s $BASE_URL/skill/idea-chorus/SKILL.md > .claude/skills/idea-chorus/SKILL.md
 curl -s $BASE_URL/skill/proposal-chorus/SKILL.md > .claude/skills/proposal-chorus/SKILL.md
 curl -s $BASE_URL/skill/develop-chorus/SKILL.md > .claude/skills/develop-chorus/SKILL.md
 curl -s $BASE_URL/skill/review-chorus/SKILL.md > .claude/skills/review-chorus/SKILL.md
+curl -s $BASE_URL/skill/quick-dev-chorus/SKILL.md > .claude/skills/quick-dev-chorus/SKILL.md
+curl -s $BASE_URL/skill/brainstorm-chorus/SKILL.md > .claude/skills/brainstorm-chorus/SKILL.md
+curl -s $BASE_URL/skill/proposal-reviewer-chorus/SKILL.md > .claude/skills/proposal-reviewer-chorus/SKILL.md
+curl -s $BASE_URL/skill/task-reviewer-chorus/SKILL.md > .claude/skills/task-reviewer-chorus/SKILL.md
+curl -s $BASE_URL/skill/yolo-chorus/SKILL.md > .claude/skills/yolo-chorus/SKILL.md
 curl -s $BASE_URL/skill/package.json > .claude/skills/chorus/package.json
 ```
 
@@ -49,12 +59,17 @@ curl -s $BASE_URL/skill/package.json > .claude/skills/chorus/package.json
 
 ```bash
 BASE_URL="<BASE_URL>"
-mkdir -p ~/.moltbot/skills/chorus ~/.moltbot/skills/idea-chorus ~/.moltbot/skills/proposal-chorus ~/.moltbot/skills/develop-chorus ~/.moltbot/skills/review-chorus
+mkdir -p ~/.moltbot/skills/chorus ~/.moltbot/skills/idea-chorus ~/.moltbot/skills/proposal-chorus ~/.moltbot/skills/develop-chorus ~/.moltbot/skills/review-chorus ~/.moltbot/skills/quick-dev-chorus ~/.moltbot/skills/brainstorm-chorus ~/.moltbot/skills/proposal-reviewer-chorus ~/.moltbot/skills/task-reviewer-chorus ~/.moltbot/skills/yolo-chorus
 curl -s $BASE_URL/skill/chorus/SKILL.md > ~/.moltbot/skills/chorus/SKILL.md
 curl -s $BASE_URL/skill/idea-chorus/SKILL.md > ~/.moltbot/skills/idea-chorus/SKILL.md
 curl -s $BASE_URL/skill/proposal-chorus/SKILL.md > ~/.moltbot/skills/proposal-chorus/SKILL.md
 curl -s $BASE_URL/skill/develop-chorus/SKILL.md > ~/.moltbot/skills/develop-chorus/SKILL.md
 curl -s $BASE_URL/skill/review-chorus/SKILL.md > ~/.moltbot/skills/review-chorus/SKILL.md
+curl -s $BASE_URL/skill/quick-dev-chorus/SKILL.md > ~/.moltbot/skills/quick-dev-chorus/SKILL.md
+curl -s $BASE_URL/skill/brainstorm-chorus/SKILL.md > ~/.moltbot/skills/brainstorm-chorus/SKILL.md
+curl -s $BASE_URL/skill/proposal-reviewer-chorus/SKILL.md > ~/.moltbot/skills/proposal-reviewer-chorus/SKILL.md
+curl -s $BASE_URL/skill/task-reviewer-chorus/SKILL.md > ~/.moltbot/skills/task-reviewer-chorus/SKILL.md
+curl -s $BASE_URL/skill/yolo-chorus/SKILL.md > ~/.moltbot/skills/yolo-chorus/SKILL.md
 curl -s $BASE_URL/skill/package.json > ~/.moltbot/skills/chorus/package.json
 ```
 
@@ -385,17 +400,54 @@ approved --> draft  (via revoke — cascade-closes tasks, deletes documents)
 
 ---
 
+## Independent Review
+
+Chorus uses **independent, read-only adversarial reviewers** at two gates: before a proposal is approved, and before a task is verified. The reviewer's job is to find what is wrong — not to rubber-stamp. Its output is **advisory**: it informs the admin's decision but does not by itself approve, reject, verify, or reopen anything.
+
+This is the **single canonical description** of the reviewer pattern. The `develop-chorus`, `review-chorus`, and `yolo-chorus` skills all point back here rather than redefining it.
+
+### The Pattern
+
+1. **Spawn a read-only sub-agent** that loads one of the two reviewer skills:
+   - `proposal-reviewer-chorus` (`<BASE_URL>/skill/proposal-reviewer-chorus/SKILL.md`) — for reviewing a **proposal** before approval. Pass it the `proposalUuid`.
+   - `task-reviewer-chorus` (`<BASE_URL>/skill/task-reviewer-chorus/SKILL.md`) — for reviewing a **task** before verification. Pass it the `taskUuid`.
+2. **The reviewer audits independently** and posts exactly **one** structured `VERDICT` comment on the proposal/task via `chorus_add_comment`. The comment ends with one literal verdict string: `VERDICT: PASS`, `VERDICT: PASS WITH NOTES`, or `VERDICT: FAIL`.
+3. **Read the verdict and act.** Fetch the comment with `chorus_get_comments({ targetType, targetUuid })`, read the BLOCKER / NOTE findings, then make the call:
+   - `PASS` / `PASS WITH NOTES` → proceed (approve the proposal / verify the task), addressing NOTEs at your discretion.
+   - `FAIL` → do **not** proceed; route the BLOCKERs back for a fix (reject/revise the proposal, or reopen/rework the task), then re-review.
+
+> The verdict is advisory: even a `FAIL` does not block the admin, and a `PASS` does not auto-approve. A human/admin makes the final decision.
+
+### Spawn Mechanism Is Harness-Specific
+
+How you spawn the read-only sub-agent depends on your agent harness — give it the reviewer skill plus the target UUID and instruct it to post a single VERDICT comment. Concrete examples:
+
+- **Claude Code** — use the Task / Agent tool to launch a sub-agent that loads `task-reviewer-chorus` (or `proposal-reviewer-chorus`) and pass the `taskUuid` / `proposalUuid`.
+- **Codex** — use `spawn_agent` with the reviewer skill and the target UUID.
+- Other harnesses: use whatever sub-agent / sub-task primitive they expose.
+
+### Inline Self-Review Fallback
+
+When sub-agents are **not** available in your harness, run the review inline yourself: load the relevant reviewer skill's procedure (`proposal-reviewer-chorus` or `task-reviewer-chorus`), audit the proposal/task against its checklist with the same adversarial posture, and post the single `VERDICT` comment yourself before acting on it. A same-agent self-review is weaker than a fresh independent reviewer, but it is far better than skipping the gate.
+
+---
+
 ## Skill Routing
 
 This is the core overview skill. For stage-specific workflows, download and read the appropriate skill:
 
 | Stage | Skill | Path |
 |-------|-------|------|
+| **Overview** (this file) | `chorus` | `<BASE_URL>/skill/chorus/SKILL.md` |
 | **Quick Dev** | `quick-dev-chorus` | `<BASE_URL>/skill/quick-dev-chorus/SKILL.md` |
+| **Brainstorm** | `brainstorm-chorus` | `<BASE_URL>/skill/brainstorm-chorus/SKILL.md` |
 | **Ideation** | `idea-chorus` | `<BASE_URL>/skill/idea-chorus/SKILL.md` |
 | **Planning** | `proposal-chorus` | `<BASE_URL>/skill/proposal-chorus/SKILL.md` |
 | **Development** | `develop-chorus` | `<BASE_URL>/skill/develop-chorus/SKILL.md` |
 | **Review** | `review-chorus` | `<BASE_URL>/skill/review-chorus/SKILL.md` |
+| **Proposal Review** | `proposal-reviewer-chorus` | `<BASE_URL>/skill/proposal-reviewer-chorus/SKILL.md` |
+| **Task Review** | `task-reviewer-chorus` | `<BASE_URL>/skill/task-reviewer-chorus/SKILL.md` |
+| **Full-Auto** | `yolo-chorus` | `<BASE_URL>/skill/yolo-chorus/SKILL.md` |
 
 ### Getting Started
 

package/.next/standalone/public/skill/develop-chorus/SKILL.md

@@ -4,7 +4,7 @@ description: Chorus Development workflow — claim tasks, report work, self-chec
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.3.1"
+  version: "0.9.3"
   category: project-management
   mcp_server: chorus
 ---
@@ -182,7 +182,7 @@ chorus_submit_for_verify({
 
 > `to_verify` does NOT unblock downstream tasks — only `done` (after admin verification) does.
 
-> **Review Agent:** After `chorus_submit_for_verify`, consider spawning `chorus:task-reviewer` — an independent, read-only review agent that adversarially checks the implementation against AC and proposal documents. It posts a VERDICT comment on the task. Its result is advisory (does not block verification).
+> **Independent Review:** After `chorus_submit_for_verify`, run an independent review of the task before it is verified. Spawn a read-only sub-agent that loads the `task-reviewer-chorus` skill (`<BASE_URL>/skill/task-reviewer-chorus/SKILL.md`), pass it the `taskUuid`, and let it post a single `VERDICT` comment (PASS / PASS WITH NOTES / FAIL) on the task; then read it with `chorus_get_comments` and act. The verdict is **advisory** (it does not block verification). The spawn mechanism is harness-specific, and an inline self-review fallback exists when sub-agents are unavailable — see the canonical **Independent Review** section in the `chorus` skill (`<BASE_URL>/skill/chorus/SKILL.md`) for the full pattern.
 
 ### Step 9: Handle Review Feedback