@chorus-aidlc/chorus 0.9.2 → 0.9.3

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

@@ -4,7 +4,7 @@ description: Optional divergent-then-convergent dialogue for fuzzy ideas. Invoke
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.3.1"
+  version: "0.9.3"
   category: project-management
   mcp_server: chorus
 ---

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
 

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

@@ -4,7 +4,7 @@ description: Chorus Idea workflow — claim ideas, run elaboration rounds, and p
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.3.1"
+  version: "0.9.3"
   category: project-management
   mcp_server: chorus
 ---

package/.next/standalone/public/skill/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chorus-skill",
-  "version": "0.3.1",
+  "version": "0.9.3",
   "description": "Chorus AI Agent collaboration platform skill. Supports PM, Developer, and Admin roles via MCP tools for the Idea-Proposal-Task workflow.",
   "author": "chorus",
   "license": "AGPL-3.0",
@@ -23,7 +23,12 @@
       "idea-chorus/SKILL.md": "/skill/idea-chorus/SKILL.md",
       "proposal-chorus/SKILL.md": "/skill/proposal-chorus/SKILL.md",
       "develop-chorus/SKILL.md": "/skill/develop-chorus/SKILL.md",
-      "review-chorus/SKILL.md": "/skill/review-chorus/SKILL.md"
+      "review-chorus/SKILL.md": "/skill/review-chorus/SKILL.md",
+      "quick-dev-chorus/SKILL.md": "/skill/quick-dev-chorus/SKILL.md",
+      "brainstorm-chorus/SKILL.md": "/skill/brainstorm-chorus/SKILL.md",
+      "proposal-reviewer-chorus/SKILL.md": "/skill/proposal-reviewer-chorus/SKILL.md",
+      "task-reviewer-chorus/SKILL.md": "/skill/task-reviewer-chorus/SKILL.md",
+      "yolo-chorus/SKILL.md": "/skill/yolo-chorus/SKILL.md"
     },
     "requires": {
       "mcp": ["chorus"]
@@ -38,7 +43,10 @@
       "report work",
       "verify task",
       "approve proposal",
-      "project management"
+      "project management",
+      "yolo",
+      "review agent",
+      "verify"
     ]
   },
   "moltbot": {
@@ -48,7 +56,12 @@
       "idea-chorus/SKILL.md": "/skill/idea-chorus/SKILL.md",
       "proposal-chorus/SKILL.md": "/skill/proposal-chorus/SKILL.md",
       "develop-chorus/SKILL.md": "/skill/develop-chorus/SKILL.md",
-      "review-chorus/SKILL.md": "/skill/review-chorus/SKILL.md"
+      "review-chorus/SKILL.md": "/skill/review-chorus/SKILL.md",
+      "quick-dev-chorus/SKILL.md": "/skill/quick-dev-chorus/SKILL.md",
+      "brainstorm-chorus/SKILL.md": "/skill/brainstorm-chorus/SKILL.md",
+      "proposal-reviewer-chorus/SKILL.md": "/skill/proposal-reviewer-chorus/SKILL.md",
+      "task-reviewer-chorus/SKILL.md": "/skill/task-reviewer-chorus/SKILL.md",
+      "yolo-chorus/SKILL.md": "/skill/yolo-chorus/SKILL.md"
     },
     "requires": {
       "mcp": ["chorus"]
@@ -63,7 +76,10 @@
       "report work",
       "verify task",
       "approve proposal",
-      "project management"
+      "project management",
+      "yolo",
+      "review agent",
+      "verify"
     ]
   }
 }

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

@@ -4,7 +4,7 @@ description: Chorus Proposal workflow — create proposals with document and tas
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.3.1"
+  version: "0.9.3"
   category: project-management
   mcp_server: chorus
 ---
@@ -111,6 +111,8 @@ chorus_pm_add_document_draft({
 
 Add task drafts one at a time. The response returns the new draft's `draftUuid` — use it directly for `dependsOnDraftUuids` in subsequent drafts.
 
+**`acceptanceCriteriaItems` is required** — every task draft must include at least one item with a non-blank `description`, or the call is rejected. Use the structured `acceptanceCriteriaItems` array (the legacy `acceptanceCriteria` Markdown string does not satisfy the requirement).
+
 ```
 # First task -> response includes { draftUuid, draftTitle }
 chorus_pm_add_task_draft({
@@ -119,7 +121,10 @@ chorus_pm_add_task_draft({
   description: "Detailed description of what to build...",
   priority: "high",
   storyPoints: 3,
-  acceptanceCriteria: "- [ ] Criteria 1\n- [ ] Criteria 2"
+  acceptanceCriteriaItems: [
+    { description: "Criteria 1", required: true },
+    { description: "Criteria 2", required: true }
+  ]
 })
 
 # Second task — depends on first
@@ -129,11 +134,15 @@ chorus_pm_add_task_draft({
   description: "Unit and integration tests...",
   priority: "medium",
   storyPoints: 2,
-  acceptanceCriteria: "- [ ] Test coverage > 80%",
+  acceptanceCriteriaItems: [
+    { description: "Test coverage > 80%", required: true }
+  ],
   dependsOnDraftUuids: ["<draftUuid-from-first-task>"]
 })
 ```
 
+> To edit a draft's criteria later via `chorus_pm_update_task_draft`, pass a non-empty `acceptanceCriteriaItems` to replace them; omit the field to leave them unchanged. The field cannot be used to clear criteria.
+
 **Task priority:** `low`, `medium`, `high`
 
 ### Step 4: Review and Refine Drafts
@@ -302,7 +311,7 @@ Potential issues and how to address them.
 
 Good tasks are:
 - **Module-scoped** — One cohesive functional module per task, not a single function or file
-- **Testable** — Clear, cohesive acceptance criteria (max 6 items per task; group related checks into one criterion but list key coverage, e.g. "All tests pass: service layer unit tests, API integration tests, edge case handling")
+- **Testable** — Clear, cohesive acceptance criteria are **required** on every task (at least one non-blank item; max 6; group related checks into one criterion but list key coverage, e.g. "All tests pass: service layer unit tests, API integration tests, edge case handling")
 - **Sized** — 1-8 story points (hours of agent work)
 - **Ordered** — Use `dependsOnDraftUuids` / `dependsOnTaskUuids` to express execution order
 - **Descriptive** — Include enough context for a developer agent to start without questions. For tasks with cross-module dependencies, reference the tech design's Module Contracts in the AC