@chorus-aidlc/chorus 0.13.2 → 0.14.1

package/.next/standalone/public/kiro-plugin/bin/on-post-verify-task.sh

@@ -0,0 +1,119 @@
+#!/usr/bin/env bash
+# on-post-verify-task.sh — Kiro `postToolUse` hook matched to
+# @chorus/chorus_admin_verify_task.
+#
+# Kiro contract: postToolUse delivers {tool_name, tool_input,
+# tool_response, ...} on STDIN; on exit 0 the hook's STDOUT is added to
+# the agent's context as PLAIN TEXT (no additionalContext JSON envelope).
+#
+# Behavior (design D5 — code-review gateway): when the just-verified task
+# is the LAST task of an idea-rooted proposal, emit a nudge to spawn the
+# read-only `chorus-code-reviewer` subagent for the idea's AGGREGATE code
+# change (the whole feature across all its tasks). Ported from the
+# code-review branch of CC's on-post-verify-task.sh; the CC OpenSpec-archive
+# and completion-report branches are out of scope for this hook per D5.
+#
+# Silent exit 0 (no nudge) when: no parseable taskUuid, the task has no
+# proposal (Quick Task), the proposal is not idea-rooted, tasks remain
+# non-terminal, or Chorus is unreachable.
+#
+# Bash 3.2 compatible (CLAUDE.md pitfall #10). All JSON is parsed with
+# `printf '%s' "$VAR" | jq ...` (echo corrupts multi-line JSON on \n).
+
+set -euo pipefail
+
+# Config toggle — default enabled (Kiro analog of CC's ENABLECODEREVIEWER).
+if [ "${CHORUS_ENABLE_CODE_REVIEWER:-true}" != "true" ]; then
+  exit 0
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+API="${SCRIPT_DIR}/chorus-api.sh"
+
+# jq is required to resolve the proposal/task graph; without it we cannot
+# safely decide "last task of the idea", so degrade to a silent no-op.
+if ! command -v jq >/dev/null 2>&1; then
+  exit 0
+fi
+
+# Read the event JSON from STDIN.
+EVENT=""
+if [ ! -t 0 ]; then
+  EVENT=$(cat)
+fi
+if [ -z "$EVENT" ]; then
+  exit 0
+fi
+
+# Extract taskUuid from tool_input; no UUID -> silent exit 0 (no broken nudge).
+TASK_UUID=$(printf '%s' "$EVENT" | jq -r '.tool_input.taskUuid // empty' 2>/dev/null) || true
+if [ -z "$TASK_UUID" ]; then
+  exit 0
+fi
+
+# Resolve the verified task -> proposalUuid + project.uuid. If the lookup
+# fails or there is no proposal (Quick Task), the gateway can't fire.
+TASK_JSON=$("$API" mcp-tool chorus_get_task "$(printf '{"taskUuid":"%s"}' "$TASK_UUID")" 2>/dev/null) || exit 0
+if [ -z "$TASK_JSON" ]; then
+  exit 0
+fi
+
+PROPOSAL_UUID=$(printf '%s' "$TASK_JSON" | jq -r '.proposalUuid // empty' 2>/dev/null) || true
+PROJECT_UUID=$(printf '%s' "$TASK_JSON" | jq -r '.project.uuid // empty' 2>/dev/null) || true
+if [ -z "$PROPOSAL_UUID" ] || [ -z "$PROJECT_UUID" ]; then
+  exit 0
+fi
+
+# Fetch the proposal — need inputType (idea-rooted only) + the idea UUID.
+PROPOSAL_JSON=$("$API" mcp-tool chorus_get_proposal "$(printf '{"proposalUuid":"%s"}' "$PROPOSAL_UUID")" 2>/dev/null) || exit 0
+if [ -z "$PROPOSAL_JSON" ]; then
+  exit 0
+fi
+
+INPUT_TYPE=$(printf '%s' "$PROPOSAL_JSON" | jq -r '.inputType // empty' 2>/dev/null) || true
+if [ "$INPUT_TYPE" != "idea" ]; then
+  exit 0
+fi
+
+IDEA_UUID=$(printf '%s' "$PROPOSAL_JSON" | jq -r '(.inputUuids // [])[0] // empty' 2>/dev/null) || true
+if [ -z "$IDEA_UUID" ]; then
+  exit 0
+fi
+
+# All tasks of this proposal must be terminal (done/closed). pageSize=200
+# with a total>returned guard so a wide proposal can't fool the gate by
+# fitting only terminal tasks on page 1.
+TASKS_JSON=$("$API" mcp-tool chorus_list_tasks "$(printf '{"projectUuid":"%s","proposalUuids":["%s"],"pageSize":200}' "$PROJECT_UUID" "$PROPOSAL_UUID")" 2>/dev/null) || exit 0
+if [ -z "$TASKS_JSON" ]; then
+  exit 0
+fi
+
+TASKS_TOTAL=$(printf '%s' "$TASKS_JSON" | jq -r '.total // 0' 2>/dev/null) || exit 0
+TASKS_RETURNED=$(printf '%s' "$TASKS_JSON" | jq -r '(.tasks // []) | length' 2>/dev/null) || exit 0
+if [ -n "$TASKS_TOTAL" ] && [ -n "$TASKS_RETURNED" ] && [ "$TASKS_TOTAL" -gt "$TASKS_RETURNED" ]; then
+  exit 0
+fi
+# Defensive: a zero-task proposal can't be "complete" in a meaningful way.
+if [ -z "$TASKS_RETURNED" ] || [ "$TASKS_RETURNED" -eq 0 ]; then
+  exit 0
+fi
+
+NON_TERMINAL_COUNT=$(printf '%s' "$TASKS_JSON" | jq -r '[(.tasks // [])[] | select(.status != "done" and .status != "closed")] | length' 2>/dev/null) || exit 0
+if [ "$NON_TERMINAL_COUNT" != "0" ]; then
+  exit 0
+fi
+
+# Last task of an idea-rooted proposal verified -> emit the gateway nudge.
+printf '%s\n' "[Chorus Plugin — Code-Review Gateway]
+All tasks of idea-rooted proposal ${PROPOSAL_UUID} are now verified. This is the final ship-time gateway for idea ${IDEA_UUID}.
+
+ACTION REQUESTED: spawn the read-only \`chorus-code-reviewer\` subagent for this idea — an independent review of the idea's AGGREGATE code change (the whole feature across all its tasks), not a single task. It is auto-selected by its description; you can also invoke it as /chorus-code-reviewer.
+
+1. Spawn the code-reviewer synchronously, passing ideaUuid=\"${IDEA_UUID}\" and the review round number (read prior code-review VERDICT comments on the idea to determine it). It reviews cross-task integration, architecture/convention consistency, security, regression/performance, feature-level test coverage, and overall soundness, then posts ONE VERDICT comment on the idea.
+2. Read its VERDICT on the idea (chorus_get_comments targetType=\"idea\").
+3. VERDICT: PASS / PASS WITH NOTES — the feature may ship.
+4. VERDICT: FAIL — create new fix tasks on this approved proposal (chorus_create_tasks) targeting the BLOCKERs; do NOT reopen old tasks. When the fix tasks are done, re-run the code-reviewer (next round).
+
+Run this code-review gateway BEFORE writing any idea-completion report — the report must not be written while a FAIL verdict is outstanding."
+
+exit 0

package/.next/standalone/public/kiro-plugin/bin/on-stop.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# on-stop.sh — Kiro `stop` hook for the `chorus` main agent.
+#
+# Kiro contract (kiro.dev/docs/cli/hooks): the stop event delivers
+# {hook_event_name, cwd, session_id, assistant_response} on STDIN. Kiro
+# parses the hook's STDOUT as JSON ONLY to look for
+# {"decision":"block","reason":"..."} — which would PREVENT the turn from
+# stopping. Any other output (or none) lets the turn stop normally.
+#
+# This hook is a best-effort session heartbeat/checkout: it NEVER emits a
+# block decision and NEVER fails the turn, even if Chorus is unreachable.
+# It prints nothing to STDOUT so the turn always stops cleanly.
+#
+# Bash 3.2 compatible (CLAUDE.md pitfall #10).
+
+# Deliberately NOT `set -e`: a stop hook must never turn a Chorus outage
+# into a failed turn. Every Chorus call below is guarded with `|| true`.
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+API="${SCRIPT_DIR}/chorus-api.sh"
+
+# Drain STDIN if present (assistant_response etc. — not needed here).
+if [ ! -t 0 ]; then
+  cat >/dev/null 2>&1 || true
+fi
+
+# Nothing to do if Chorus isn't configured.
+if [ -z "${CHORUS_URL:-}" ] || [ -z "${CHORUS_API_KEY:-}" ]; then
+  exit 0
+fi
+
+# Best-effort: if a Chorus session was cached (swarm-mode flow), send a
+# final heartbeat and check out of any task it holds. All calls are
+# fire-and-forget; failures are swallowed so the turn always stops.
+MAIN_SESSION=$("$API" state-get "main_session_uuid" 2>/dev/null) || true
+if [ -n "${MAIN_SESSION:-}" ]; then
+  "$API" mcp-tool "chorus_session_heartbeat" \
+    "$(printf '{"sessionUuid":"%s"}' "$MAIN_SESSION")" >/dev/null 2>&1 || true
+  "$API" mcp-tool "chorus_session_checkout_task" \
+    "$(printf '{"sessionUuid":"%s"}' "$MAIN_SESSION")" >/dev/null 2>&1 || true
+fi
+
+# Print nothing (no block decision) -> the turn stops normally.
+exit 0

package/.next/standalone/public/kiro-plugin/bin/test-syntax.sh

@@ -0,0 +1,108 @@
+#!/usr/bin/env bash
+# Test all Kiro-plugin hook scripts for compatibility with the current bash
+# version. Runs each script with a mock Kiro hook event on STDIN and mock
+# env to catch runtime errors (e.g. ${VAR,,} bad substitution on Bash 3.2).
+#
+# Mirrors public/chorus-plugin/bin/test-syntax.sh, adapted to Kiro's hook
+# event JSON shape (kiro.dev/docs/cli/hooks): agentSpawn/stop carry base
+# fields only; postToolUse carries tool_name + tool_input + tool_response.
+#
+# Usage:
+#   /bin/bash public/kiro-plugin/bin/test-syntax.sh   # test with macOS system bash 3.2
+#   bash public/kiro-plugin/bin/test-syntax.sh         # test with default bash
+
+set -euo pipefail
+
+DIR="$(cd "$(dirname "$0")" && pwd)"
+PASS=0
+FAIL=0
+FAILED=""
+
+echo "Using: $BASH ($("$BASH" --version | head -1))"
+echo ""
+
+# Mock env so scripts don't exit early on env guards. Use a bogus URL —
+# scripts will fail on actual API calls but that's fine; we only care about
+# bash syntax/substitution errors before the API call.
+export CHORUS_URL="http://localhost:0"
+export CHORUS_API_KEY="cho_test"
+export CLAUDE_PROJECT_DIR="/tmp/kiro-test-$$"
+mkdir -p "$CLAUDE_PROJECT_DIR"
+
+cleanup() { rm -rf "$CLAUDE_PROJECT_DIR"; }
+trap cleanup EXIT
+
+# First-class syntax parse (`bash -n`) for every *.sh in the dir, including
+# chorus-api.sh which is a library (never executed standalone here).
+echo "--- bash -n parse check (all *.sh) ---"
+for f in "$DIR"/*.sh; do
+  base=$(basename "$f")
+  if "$BASH" -n "$f" 2>/tmp/kiro-parse-err-$$; then
+    printf "  PARSE OK  %s\n" "$base"
+  else
+    printf "  PARSE FAIL  %s\n" "$base"
+    sed 's/^/           /' /tmp/kiro-parse-err-$$
+    FAIL=$((FAIL + 1))
+    FAILED="$FAILED $base(parse)"
+  fi
+  rm -f /tmp/kiro-parse-err-$$
+done
+echo ""
+
+# Run each hook with a mock Kiro event; grep stderr for bash version issues.
+run_test() {
+  local name="$1"
+  local input="$2"
+  local script="$DIR/$name"
+  local err_file="/tmp/kiro-test-err-$$"
+
+  if printf '%s' "$input" | "$BASH" "$script" >"$err_file" 2>&1; then
+    printf "  PASS  %s\n" "$name"
+    PASS=$((PASS + 1))
+  else
+    if grep -qi "bad substitution\|syntax error\|unexpected token" "$err_file"; then
+      printf "  FAIL  %s (bash compatibility error)\n" "$name"
+      sed 's/^/         /' "$err_file"
+      FAIL=$((FAIL + 1))
+      FAILED="$FAILED $name"
+    else
+      # Non-zero exit from an API/curl failure is expected — not a bash issue.
+      printf "  PASS  %s (exited non-zero but no bash error)\n" "$name"
+      PASS=$((PASS + 1))
+    fi
+  fi
+  rm -f "$err_file"
+}
+
+echo "--- runtime smoke tests (mock Kiro events) ---"
+
+# agentSpawn — base fields only.
+run_test "on-agent-spawn.sh" '{"hook_event_name":"agentSpawn","cwd":"/tmp","session_id":"sess-1"}'
+
+# stop — base fields + assistant_response.
+run_test "on-stop.sh"        '{"hook_event_name":"stop","cwd":"/tmp","session_id":"sess-1","assistant_response":"done"}'
+
+# postToolUse — tool_name + tool_input + tool_response (happy path).
+run_test "on-post-submit-proposal.sh"   '{"hook_event_name":"postToolUse","tool_name":"@chorus/chorus_pm_submit_proposal","tool_input":{"proposalUuid":"prop-uuid"},"tool_response":{"success":true,"result":["{\"uuid\":\"prop-uuid\",\"title\":\"Test proposal\"}"]},"title":"Test proposal"}'
+run_test "on-post-submit-for-verify.sh" '{"hook_event_name":"postToolUse","tool_name":"@chorus/chorus_submit_for_verify","tool_input":{"taskUuid":"task-uuid"},"tool_response":{"success":true,"result":["ok"]}}'
+run_test "on-post-verify-task.sh"       '{"hook_event_name":"postToolUse","tool_name":"@chorus/chorus_admin_verify_task","tool_input":{"taskUuid":"task-uuid"},"tool_response":{"success":true,"result":["ok"]}}'
+
+# postToolUse — no parseable UUID (must exit 0 with no broken nudge).
+run_test "on-post-submit-proposal.sh"   '{"hook_event_name":"postToolUse","tool_name":"@chorus/chorus_pm_submit_proposal","tool_input":{}}'
+run_test "on-post-submit-for-verify.sh" '{"hook_event_name":"postToolUse","tool_name":"@chorus/chorus_submit_for_verify","tool_input":{}}'
+run_test "on-post-verify-task.sh"       '{"hook_event_name":"postToolUse","tool_name":"@chorus/chorus_admin_verify_task","tool_input":{}}'
+
+# Empty STDIN edge case (all hooks must survive).
+run_test "on-agent-spawn.sh"            ''
+run_test "on-stop.sh"                   ''
+run_test "on-post-submit-proposal.sh"   ''
+run_test "on-post-submit-for-verify.sh" ''
+run_test "on-post-verify-task.sh"       ''
+
+echo ""
+echo "Results: $PASS passed, $FAIL failed"
+
+if [ "$FAIL" -gt 0 ]; then
+  echo "Failed:$FAILED"
+  exit 1
+fi

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.13.2"
+  version: "0.14.1"
   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.13.2"
+  version: "0.14.1"
   category: project-management
   mcp_server: chorus
 ---
@@ -198,6 +198,12 @@ Results can be filtered by project(s) using optional HTTP headers in your MCP co
 
 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 tool's description carries the section template — read it there. The `yolo` skill writes one mandatorily; the `develop` skill 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.
+
+**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 the `idea-chorus` skill (`<BASE_URL>/skill/idea-chorus/SKILL.md`), Step 4.4, for the type-selection criteria and a worked example.
+
 ### Proposals
 
 | Tool | Purpose |
@@ -352,6 +358,7 @@ The table below shows default tool availability for each preset (no custom permi
 | `chorus_claim_idea` / `chorus_release_idea` / `chorus_move_idea` / `chorus_pm_create_idea` / `chorus_edit_idea` / `chorus_pm_*_elaboration` | `idea:write` | No | Yes | Yes |
 | `chorus_pm_create_proposal` / `chorus_pm_*_proposal` / `chorus_pm_*_draft` / `chorus_create_tasks` / `chorus_pm_assign_task` | `proposal:write` | No | Yes | Yes |
 | `chorus_pm_create_document` / `chorus_pm_update_document` / `chorus_create_report` | `document:write` | No | Yes | Yes |
+| `chorus_add_reference` / `chorus_update_reference` / `chorus_remove_reference` | `document:write` | No | Yes | Yes |
 | `chorus_admin_create_project` / `chorus_admin_*_project_group` / `chorus_admin_move_project_to_group` | `project:write` | No | **Yes** (0.7.0+) | Yes |
 | `chorus_admin_approve_proposal` / `chorus_admin_close_proposal` | `proposal:admin` | No | No | Yes |
 | `chorus_admin_verify_task` / `chorus_admin_reopen_task` / `chorus_admin_close_task` / `chorus_mark_acceptance_criteria` / `chorus_admin_delete_task` | `task:admin` | No | No | Yes |

package/.next/standalone/public/skill/code-reviewer-chorus/SKILL.md

@@ -4,7 +4,7 @@ description: Read-only adversarial Chorus code-review gateway — independently
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.13.2"
+  version: "0.14.1"
   category: project-management
   mcp_server: chorus
 ---

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.13.2"
+  version: "0.14.1"
   category: project-management
   mcp_server: chorus
 ---

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.13.2"
+  version: "0.14.1"
   category: project-management
   mcp_server: chorus
 ---
@@ -115,6 +115,37 @@ Before elaborating, understand the full picture:
    chorus_get_comments({ targetType: "idea", targetUuid: "<idea-uuid>" })
    ```
 
+### Step 4.4: Attach External References
+
+**Make attaching external references a reflex, not an afterthought.** While gathering context you will often surface external links that are *evidence* for this Idea — a precedent issue or PR, a reference implementation, official documentation, a paper or blog post. The moment you see one, attach it as a reference artifact. References are read back inline by `chorus_get_idea` / `chorus_get_proposal` / `chorus_get_task`, so they carry the "why" forward to whoever picks up the proposal or task next.
+
+**Prefer attaching at creation time** via the inline `references[]` param on `chorus_pm_create_idea` (and later `chorus_pm_create_proposal` / `chorus_create_tasks`) rather than a post-hoc `chorus_add_reference`. Attaching at create means the evidence is present from the first read; use `chorus_add_reference` only when the link surfaces after the entity already exists.
+
+**Pick the `type` that fits the link:**
+
+| `type` | Use for |
+|--------|---------|
+| `docs` | Official documentation — framework / API / library reference |
+| `repo` | A reference implementation or source repository |
+| `issue_pr` | An issue or pull-request thread — precedent, prior art, the delivering PR |
+| `paper_blog` | A paper or blog post — background or design rationale |
+
+**Example** — a new localization Idea, attaching the precedent PR and the framework docs inline at creation:
+
+```
+chorus_pm_create_idea({
+  projectUuid: "<project-uuid>",
+  title: "Add Portuguese (pt) locale",
+  content: "...",
+  references: [
+    { type: "issue_pr", url: "https://github.com/org/repo/pull/411",
+      title: "PR #411 — prior locale work (precedent to mirror)" },
+    { type: "docs", url: "https://next-intl.dev/docs/routing",
+      title: "next-intl routing docs (locale registration)" }
+  ]
+})
+```
+
 ### Step 4.5: Brainstorm Mode (Optional Prelude)
 
 If the Idea is fuzzy and you'd struggle to enumerate concrete multi-choice questions, offer the user a brainstorm prelude before structured elaboration. Use your IDE's interactive prompt mechanism if available, or present options as text — the same convention used elsewhere in this skill. Two choices: `"Already clear, run structured elaboration"` and `"Brainstorm first to explore directions"`.

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

@@ -1,6 +1,6 @@
 {
   "name": "chorus-skill",
-  "version": "0.11.0",
+  "version": "0.14.1",
   "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",

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.13.2"
+  version: "0.14.1"
   category: project-management
   mcp_server: chorus
 ---
@@ -60,6 +60,7 @@ Elaboration resolved --> Create Proposal --> Add drafts --> Validate --> Submit
 | `chorus_pm_create_document` | Create standalone document |
 | `chorus_pm_update_document` | Update document content (increments version) |
 | `chorus_update_task` (with `addDependsOn` / `removeDependsOn`) | Manage dependencies between existing tasks (with cycle detection) |
+| `chorus_add_reference` / `chorus_update_reference` / `chorus_remove_reference` | Attach/edit/remove external-evidence web links (docs/repo/issue_pr/paper_blog) on an idea, proposal, or task; also attachable inline at creation via `references[]` on `chorus_pm_create_idea` / `chorus_pm_create_proposal` / `chorus_create_tasks`. No read tool — they come back inline on `chorus_get_idea` / `chorus_get_proposal` / `chorus_get_task` |
 
 **Shared tools** (checkin, query, comment, search, notifications): see `chorus` skill at `<BASE_URL>/skill/chorus/SKILL.md`
 

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

@@ -4,7 +4,7 @@ description: Read-only adversarial Chorus proposal reviewer — audits PRD/task
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.13.2"
+  version: "0.14.1"
   category: project-management
   mcp_server: chorus
 ---

package/.next/standalone/public/skill/quick-dev-chorus/SKILL.md

@@ -4,7 +4,7 @@ description: Quick Task workflow — skip Idea→Proposal, create tasks directly
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.13.2"
+  version: "0.14.1"
   category: project-management
   mcp_server: chorus
 ---

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

@@ -4,7 +4,7 @@ description: Chorus Review workflow — approve/reject proposals, verify tasks,
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.13.2"
+  version: "0.14.1"
   category: project-management
   mcp_server: chorus
 ---

package/.next/standalone/public/skill/task-reviewer-chorus/SKILL.md

@@ -4,7 +4,7 @@ description: Read-only adversarial Chorus task reviewer — independently verifi
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.13.2"
+  version: "0.14.1"
   category: project-management
   mcp_server: chorus
 ---

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

@@ -4,7 +4,7 @@ description: Full-auto AI-DLC pipeline — drive a single prompt from Idea throu
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.13.2"
+  version: "0.14.1"
   category: project-management
   mcp_server: chorus
 ---