@chorus-aidlc/chorus 0.7.1 → 0.8.0

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

@@ -0,0 +1,190 @@
+#!/usr/bin/env bash
+# on-post-verify-task.sh — PostToolUse hook for chorus_admin_verify_task
+#
+# Detects the "last task verified for an OpenSpec-mode idea" condition and
+# injects an additionalContext reminder telling the main agent to run
+# `openspec archive <slug>` and mirror the resulting
+# openspec/specs/<capability>/spec.md files back to the matching Chorus
+# Documents.
+#
+# Detection contract (all signals must hold to fire):
+#   1. CHORUS_OPENSPEC_MODE != "off" — explicit opt-out wins.
+#   2. The project root contains an `openspec/` directory — this repo is
+#      OpenSpec-init'd. Probed via $CLAUDE_PROJECT_DIR/openspec.
+#   3. `openspec` CLI is on PATH — needed for the agent's later
+#      `openspec archive` step. Both (2) and (3) are required because
+#      either alone leaves the archive workflow unrunnable.
+#   4. The verified task's proposal description contains a line matching
+#      ^OpenSpec change slug: <slug>$ (slug provenance from §3.5).
+#   5. Every task under the same proposal has status === "done".
+#
+# If any signal fails, the hook exits 0 silently (strict opt-in).
+#
+# Bash 3.2 compatible (per CLAUDE.md pitfall #10): no ${VAR,,}, no
+# ${VAR^^}, no `declare -A`, no `mapfile`, no `readarray`, no `|&`,
+# no `&>>`.
+#
+# All shell variable parsing of captured JSON uses
+# `printf '%s' "$VAR" | jq ...` rather than `echo "$VAR" | jq ...` —
+# echo corrupts multi-line content on `\n` (canonical §6 warning).
+
+set -euo pipefail
+
+# Check userConfig toggle — default enabled. The same `enableOpenSpec`
+# switch gates SessionStart detection; if it's off, we skip the archive
+# reminder too. (Env-level CHORUS_OPENSPEC_MODE=off is checked separately
+# at step 4 for symmetry with the SessionStart gate.)
+if [ "${CLAUDE_PLUGIN_OPTION_ENABLEOPENSPEC:-true}" != "true" ]; then
+  exit 0
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+API="${SCRIPT_DIR}/chorus-api.sh"
+
+# Read event JSON from stdin (PostToolUse hook input)
+EVENT=""
+if [ ! -t 0 ]; then
+  EVENT=$(cat)
+fi
+
+if [ -z "$EVENT" ]; then
+  exit 0
+fi
+
+# Step 2: Extract taskUuid from .tool_input
+TASK_UUID=$(printf '%s' "$EVENT" | jq -r '.tool_input.taskUuid // empty' 2>/dev/null) || true
+
+# Step 3: If taskUuid is empty -> exit 0 silently
+if [ -z "$TASK_UUID" ]; then
+  exit 0
+fi
+
+# Step 4: OpenSpec gate — explicit opt-out, then folder + CLI both required.
+# Both folder-presence and CLI-presence are necessary: the agent will run
+# `openspec archive <slug>` on receipt of the injected reminder, and that
+# command needs the openspec/ working directory AND the CLI on PATH. If
+# either is missing, the reminder would point the agent at a dead end, so
+# we silently skip injection and let the verify pass through unannotated.
+if [ "${CHORUS_OPENSPEC_MODE:-}" = "off" ]; then
+  exit 0
+fi
+PROJECT_ROOT="${CLAUDE_PROJECT_DIR:-$PWD}"
+if [ ! -d "${PROJECT_ROOT}/openspec" ]; then
+  exit 0
+fi
+if ! command -v openspec >/dev/null 2>&1; then
+  exit 0
+fi
+if ! openspec --version >/dev/null 2>&1; then
+  exit 0
+fi
+
+# Step 5: chorus_get_task -> proposalUuid
+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
+
+# Step 6: If proposalUuid empty -> exit 0 silently (Quick Tasks have no proposal)
+if [ -z "$PROPOSAL_UUID" ]; then
+  exit 0
+fi
+
+# Step 7: chorus_get_proposal -> description (for slug grep)
+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
+
+PROPOSAL_DESC=$(printf '%s' "$PROPOSAL_JSON" | jq -r '.description // empty' 2>/dev/null) || true
+
+# Step 9: grep description for ^OpenSpec change slug: (.+)$ — first match wins
+SLUG=""
+if [ -n "$PROPOSAL_DESC" ]; then
+  # POSIX-portable: print description with embedded newlines via printf %s
+  # then grep line-anchored for the slug marker.
+  SLUG_LINE=$(printf '%s\n' "$PROPOSAL_DESC" | grep -E '^OpenSpec change slug: .+' | head -1 || true)
+  if [ -n "$SLUG_LINE" ]; then
+    # Strip the prefix; trim trailing whitespace.
+    SLUG=$(printf '%s' "$SLUG_LINE" | sed -e 's/^OpenSpec change slug:[[:space:]]*//' -e 's/[[:space:]]*$//')
+  fi
+fi
+
+# Step 10: If $SLUG is empty -> exit 0 silently (free-form proposal)
+if [ -z "$SLUG" ]; then
+  exit 0
+fi
+
+# Step 8: chorus_list_tasks (filtered by proposalUuid) -> verify every task is "done".
+# (The proposal-design assumed chorus_get_idea returned tasks[], but the
+# actual MCP tool only returns IdeaResponse; chorus_list_tasks with the
+# proposalUuids filter is the closest equivalent and is the documented
+# contract.)
+#
+# We page through up to 200 tasks (pageSize=200) — far above the design
+# expectation of ~10-20 tasks per proposal. If a proposal exceeds 200
+# tasks the hook conservatively exits 0 silently, matching the
+# Tech Design "Risk: chorus_get_idea is paginated" mitigation.
+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
+
+TOTAL_TASKS=$(printf '%s' "$TASKS_JSON" | jq -r '.total // 0' 2>/dev/null) || true
+RETURNED_TASKS=$(printf '%s' "$TASKS_JSON" | jq -r '.tasks | length' 2>/dev/null) || true
+
+# Pagination guard: if total exceeds what we fetched, exit silently (better
+# safe than fire prematurely).
+if [ -n "$TOTAL_TASKS" ] && [ -n "$RETURNED_TASKS" ] && [ "$TOTAL_TASKS" -gt "$RETURNED_TASKS" ]; then
+  exit 0
+fi
+
+# Defensive: zero-task proposal would otherwise fall through with
+# NOT_DONE_COUNT=0. Proposal-submit validation prevents this in practice;
+# this guard makes the gate complete.
+if [ -z "$RETURNED_TASKS" ] || [ "$RETURNED_TASKS" -eq 0 ]; then
+  exit 0
+fi
+
+NOT_DONE_COUNT=$(printf '%s' "$TASKS_JSON" | jq -r '[.tasks[] | select(.status != "done")] | length' 2>/dev/null) || true
+
+if [ -z "$NOT_DONE_COUNT" ] || [ "$NOT_DONE_COUNT" != "0" ]; then
+  exit 0
+fi
+
+# Step 11: Build CONTEXT — instruct the agent to run `openspec archive <SLUG>`
+# and mirror the resulting specs/<capability>/spec.md files back to the
+# matching Chorus Documents.
+#
+# Note on chorus_get_documents: the canonical §3.8 mirror-back step uses
+# `chorus_get_documents(projectUuid)` (the only filter the tool supports
+# server-side is `type` — there is NO server-side title-prefix filter).
+# The agent must list all `type:"spec"` documents and filter client-side
+# by title prefix `Spec:` to find the matching capability.
+
+CONTEXT="[Chorus Plugin — OpenSpec Archive Trigger]
+The last task of OpenSpec-mode proposal ${PROPOSAL_UUID} (slug \`${SLUG}\`) has been admin-verified.
+
+ACTION REQUIRED: archive the OpenSpec change locally and mirror updated specs back to the Chorus Documents. Run the steps below in order; HALT immediately on any error (canonical §6 — no silent errors).
+
+1. Run \`openspec archive ${SLUG}\` in the repo root. This moves \`openspec/changes/${SLUG}/\` under \`openspec/changes/archive/<date>-${SLUG}/\` and emits/updates one \`openspec/specs/<capability>/spec.md\` per capability. If the CLI prompts interactively and a \`--yes\`/\`--no-confirm\` flag is available, use it (verify with \`openspec archive --help\`).
+
+2. For EACH newly-emitted \`openspec/specs/<capability>/spec.md\`:
+   - List all spec-type Documents in this project: \`chorus_get_documents({projectUuid: \"${PROJECT_UUID}\", type: \"spec\"})\`. The \`type\` filter is the only server-side filter — do client-side title matching against the documents you get back.
+   - Find the Document whose title matches the capability (canonical §3.8 mirror-back contract; typical title shape \`Spec: <capability>\`).
+   - Call \`chorus_pm_update_document\` with the new content from the on-disk spec.md.
+
+3. On any error from \`openspec archive\` or \`chorus_pm_update_document\`: print stderr verbatim, post a comment on the proposal recording the failure (\`chorus_add_comment({targetType: \"proposal\", targetUuid: \"${PROPOSAL_UUID}\", content: \"...\"})\`), and HALT. No retry, no silent skip.
+
+4. Confirm success by listing \`openspec/specs/<capability>/spec.md\` files and verifying they round-trip byte-equal (modulo trailing newline) with their Chorus Document counterparts.
+
+References: canonical openspec-aware §3.8 (mirror-back contract), §3.9 (this archive trigger), §6 (no silent errors)."
+
+# Step 12: Inject CONTEXT as additionalContext.
+"$API" hook-output "" "$CONTEXT" "PostToolUse"
+
+# Step 13: exit 0 (set -e already enforces this on success).
+exit 0

package/.next/standalone/public/chorus-plugin/bin/on-session-start.sh

@@ -61,6 +61,36 @@ if command -v jq >/dev/null 2>&1; then
 
 fi
 
+# Detect OpenSpec mode for this repo, once per session.
+# Both conditions are required for OpenSpec mode to be usable:
+#   (a) an openspec/ directory at the project root (this repo was inited via `openspec init`), AND
+#   (b) the `openspec` CLI on PATH (so we can `openspec new change`, `validate`, `archive`).
+# Overrides (precedence high -> low, first match wins):
+#   1. enableOpenSpec userConfig toggle (default true) — UI-level switch.
+#   2. CHORUS_OPENSPEC_MODE=off env var — env-level explicit opt-out.
+# When the folder is present but the CLI is missing, surface that as a
+# specific reason so the user-visible toast can hint at the install step
+# instead of silently falling back.
+PROJECT_ROOT="${CLAUDE_PROJECT_DIR:-$PWD}"
+OPENSPEC_HINT=""
+if [ "${CLAUDE_PLUGIN_OPTION_ENABLEOPENSPEC:-true}" != "true" ]; then
+  CHORUS_OPENSPEC_ACTIVE=0
+  OPENSPEC_REASON="enableOpenSpec userConfig=false (plugin-level opt-out)"
+elif [ "${CHORUS_OPENSPEC_MODE:-}" = "off" ]; then
+  CHORUS_OPENSPEC_ACTIVE=0
+  OPENSPEC_REASON="CHORUS_OPENSPEC_MODE=off (explicit opt-out)"
+elif [ ! -d "${PROJECT_ROOT}/openspec" ]; then
+  CHORUS_OPENSPEC_ACTIVE=0
+  OPENSPEC_REASON="no openspec/ directory at ${PROJECT_ROOT}/openspec"
+elif ! command -v openspec >/dev/null 2>&1; then
+  CHORUS_OPENSPEC_ACTIVE=0
+  OPENSPEC_REASON="openspec/ directory present but \`openspec\` CLI not on PATH"
+  OPENSPEC_HINT="install with: npm i -g @fission-ai/openspec"
+else
+  CHORUS_OPENSPEC_ACTIVE=1
+  OPENSPEC_REASON="openspec/ directory + openspec CLI both present"
+fi
+
 # Build context for Claude (additionalContext)
 CONTEXT="# Chorus Plugin — Active
 
@@ -70,6 +100,29 @@ Chorus is connected at ${CHORUS_URL}. Session lifecycle hooks are enabled.
 
 ${CHECKIN_RESULT}
 
+## OpenSpec Mode
+
+CHORUS_OPENSPEC_ACTIVE=${CHORUS_OPENSPEC_ACTIVE} (${OPENSPEC_REASON})"
+
+if [ "$CHORUS_OPENSPEC_ACTIVE" = "1" ]; then
+  CONTEXT="${CONTEXT}
+
+OpenSpec mode is **active** for this session. When the proposal / develop / yolo skills reach an OpenSpec-aware step, load the openspec-aware skill at \`.claude/skills/openspec-aware/SKILL.md\` and follow §3 (OpenSpec authoring) — do NOT re-run the §1 detection block, the answer is already known.
+
+Critical rule (openspec-aware §2 Rule 1): document mirror calls (\`chorus_pm_add_document_draft\` / \`chorus_pm_update_document_draft\` / \`chorus_pm_update_document\`) MUST go through \`chorus-api.sh mcp-tool\` with \`content\` produced by \`json_encode_file\`. Do NOT invoke these MCP tools directly with hand-typed \`content\` in OpenSpec mode."
+else
+  CONTEXT="${CONTEXT}
+
+OpenSpec mode is **inactive** for this session. The proposal / develop / yolo skills follow their free-form path; do NOT scaffold \`openspec/changes/\`, do NOT add an \`OpenSpec change slug:\` line to proposal descriptions, and do NOT route document mirror calls through \`chorus-api.sh\`."
+  if [ -n "$OPENSPEC_HINT" ]; then
+    CONTEXT="${CONTEXT}
+
+Note: this repo has an \`openspec/\` directory, so the user likely intends to use OpenSpec mode but the \`openspec\` CLI is not installed. Surface this to the user (e.g. \"This repo is OpenSpec-init'd but the \\\`openspec\\\` CLI isn't installed locally — ${OPENSPEC_HINT}\") before authoring documents so they can install it and re-launch the session if they want spec-driven mode."
+  fi
+fi
+
+CONTEXT="${CONTEXT}
+
 ## Quick Reference
 
 - **Idea Tracker**: Shows up to 10 most recently updated ideas. Use chorus_get_ideas() for full list.
@@ -88,6 +141,11 @@ fi
 
 # Build user-visible message
 USER_MSG="Chorus connected at ${CHORUS_URL}"
+if [ "$CHORUS_OPENSPEC_ACTIVE" = "1" ]; then
+  USER_MSG="${USER_MSG} (OpenSpec Enabled)"
+elif [ -n "$OPENSPEC_HINT" ]; then
+  USER_MSG="${USER_MSG} (OpenSpec repo detected — ${OPENSPEC_HINT})"
+fi
 if [ -n "$MAIN_SESSION" ]; then
   USER_MSG="${USER_MSG} (resumed session)"
 fi

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

@@ -72,6 +72,7 @@ run_test "on-task-completed.sh"  '{"task_id":"task-001"}'
 # --- PostToolUse hooks ---
 run_test "on-post-submit-proposal.sh"  '{"tool_input":{"proposalUuid":"test-uuid"},"tool_response":{"uuid":"test-uuid","status":"pending","title":"Test proposal"}}'
 run_test "on-post-submit-for-verify.sh" '{"tool_input":{"taskUuid":"test-uuid"},"tool_response":{"uuid":"test-uuid","status":"to_verify","title":"Test task"}}'
+run_test "on-post-verify-task.sh" '{"tool_input":{"taskUuid":"test-uuid"},"tool_response":{"uuid":"test-uuid","status":"done","title":"Test task"}}'
 
 # --- Session hooks ---
 run_test "on-session-start.sh"   '{}'

package/.next/standalone/public/chorus-plugin/bin/tests/test-on-post-verify-task.sh

@@ -0,0 +1,365 @@
+#!/usr/bin/env bash
+# test-on-post-verify-task.sh — Fixture-based shell test for the
+# on-post-verify-task.sh hooks (Claude Code + Codex variants).
+#
+# We can't talk to a real Chorus backend in CI, so we shim out the MCP
+# wrapper and the openspec CLI: the test creates a sandbox PATH and a
+# replacement "chorus-api.sh" / "chorus-mcp-call.sh" that echo canned JSON
+# responses keyed off the (tool_name, fixture_id) pair carried via the
+# CHORUS_FIXTURE env var. The replacement scripts are invoked because the
+# hook resolves them by directory next to itself (Claude Code) or sources
+# hook-output.sh by directory (Codex). We exploit this by COPYING the
+# hook into a sandbox dir alongside our shim wrapper — the hook's
+# `dirname "$0"` lookup then picks up our shim, not the real wrapper.
+#
+# Fixtures cover all gating branches:
+#   positive       — last task verified, slug present, openspec/ folder + CLI both present
+#                    -> stdout MUST contain `openspec archive my-feature`
+#   not-last-task  — slug present, both signals present, but one task still in_progress
+#                    -> stdout MUST NOT contain `openspec archive`
+#   no-slug        — proposal description has no `OpenSpec change slug:` line
+#                    -> stdout MUST NOT contain `openspec archive`
+#   no-cli         — openspec/ folder present but `openspec` CLI not on PATH
+#                    -> stdout MUST NOT contain `openspec archive`
+#   no-folder      — CLI on PATH but no openspec/ directory in project root
+#                    -> stdout MUST NOT contain `openspec archive`
+#   mode-off       — CHORUS_OPENSPEC_MODE=off (explicit opt-out), even with both signals present
+#                    -> stdout MUST NOT contain `openspec archive`
+#
+# All fixtures must end with exit 0.
+#
+# Bash 3.2 compatible. Run:
+#   /bin/bash public/chorus-plugin/bin/tests/test-on-post-verify-task.sh
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "$0")/../../../.." && pwd)"
+CLAUDE_HOOK="$REPO_ROOT/public/chorus-plugin/bin/on-post-verify-task.sh"
+CODEX_HOOK="$REPO_ROOT/plugins/chorus/hooks/on-post-verify-task.sh"
+CODEX_HOOK_OUTPUT="$REPO_ROOT/plugins/chorus/hooks/hook-output.sh"
+
+[ -x "$CLAUDE_HOOK" ] || { echo "FAIL: $CLAUDE_HOOK is not executable" >&2; exit 1; }
+[ -x "$CODEX_HOOK" ]  || { echo "FAIL: $CODEX_HOOK is not executable" >&2; exit 1; }
+
+PASS=0
+FAIL=0
+FAILED=""
+
+# ----- Build sandbox -----
+
+SANDBOX=$(mktemp -d)
+cleanup() { rm -rf "$SANDBOX"; }
+trap cleanup EXIT
+
+# Sandbox layout:
+#   $SANDBOX/claude/    — copy of Claude hook + shim chorus-api.sh
+#   $SANDBOX/codex/     — copy of Codex hook + shim chorus-mcp-call.sh + real hook-output.sh
+#   $SANDBOX/bin/       — fake openspec CLI on PATH
+#   $SANDBOX/project/   — synthetic project root (contains openspec/ for fixtures
+#                         that need the folder signal to be present)
+mkdir -p "$SANDBOX/claude" "$SANDBOX/codex" "$SANDBOX/bin" "$SANDBOX/project/openspec"
+
+cp "$CLAUDE_HOOK" "$SANDBOX/claude/on-post-verify-task.sh"
+cp "$CODEX_HOOK"  "$SANDBOX/codex/on-post-verify-task.sh"
+cp "$CODEX_HOOK_OUTPUT" "$SANDBOX/codex/hook-output.sh"
+chmod +x "$SANDBOX/claude/on-post-verify-task.sh" "$SANDBOX/codex/on-post-verify-task.sh"
+
+# ----- Shim: chorus-api.sh (Claude Code shape) -----
+# Subcommand interface:
+#   chorus-api.sh mcp-tool <tool> <json_args>   -> echo canned JSON
+#   chorus-api.sh hook-output "" "$CONTEXT" "PostToolUse"
+# We delegate hook-output to a real jq invocation so the emitted JSON
+# matches the production wrapper's shape.
+cat > "$SANDBOX/claude/chorus-api.sh" <<'SHIM_CLAUDE'
+#!/usr/bin/env bash
+set -euo pipefail
+cmd="${1:-}"; shift || true
+case "$cmd" in
+  mcp-tool)
+    tool="$1"
+    # CHORUS_FIXTURE picks the canned response set. Some fixtures
+    # (mode-off / no-folder / no-cli) test the OpenSpec gates that fire
+    # BEFORE any MCP call; we route them to the same canned data as
+    # "positive" so that if a gate is silently broken the hook reaches
+    # MCP, gets a positive result, and emits an archive reminder —
+    # failing the "no archive reminder" assertion. Without this aliasing
+    # the test would pass for the wrong reason (silent-skip at empty
+    # TASK_JSON instead of at the gate).
+    fixture="${CHORUS_FIXTURE:-positive}"
+    case "$fixture" in
+      mode-off|no-folder|no-cli) fixture=positive ;;
+    esac
+    case "${fixture}:${tool}" in
+      positive:chorus_get_task)
+        echo '{"uuid":"task-3","title":"Task 3","status":"done","proposalUuid":"prop-1","project":{"uuid":"proj-1","name":"P"}}'
+        ;;
+      positive:chorus_get_proposal)
+        printf '%s' '{"uuid":"prop-1","title":"P1","description":"Some intro line.\nOpenSpec change slug: my-feature\nMore body.","inputUuids":["idea-1"]}'
+        ;;
+      positive:chorus_list_tasks)
+        echo '{"tasks":[{"uuid":"task-1","status":"done"},{"uuid":"task-2","status":"done"},{"uuid":"task-3","status":"done"}],"total":3,"page":1,"pageSize":200}'
+        ;;
+      not-last-task:chorus_get_task)
+        echo '{"uuid":"task-2","title":"Task 2","status":"done","proposalUuid":"prop-1","project":{"uuid":"proj-1","name":"P"}}'
+        ;;
+      not-last-task:chorus_get_proposal)
+        printf '%s' '{"uuid":"prop-1","title":"P1","description":"Intro.\nOpenSpec change slug: my-feature\nMore.","inputUuids":["idea-1"]}'
+        ;;
+      not-last-task:chorus_list_tasks)
+        echo '{"tasks":[{"uuid":"task-1","status":"done"},{"uuid":"task-2","status":"done"},{"uuid":"task-3","status":"in_progress"}],"total":3,"page":1,"pageSize":200}'
+        ;;
+      no-slug:chorus_get_task)
+        echo '{"uuid":"task-3","title":"Task 3","status":"done","proposalUuid":"prop-2","project":{"uuid":"proj-1","name":"P"}}'
+        ;;
+      no-slug:chorus_get_proposal)
+        printf '%s' '{"uuid":"prop-2","title":"P2","description":"Free-form proposal description with no slug marker.","inputUuids":["idea-2"]}'
+        ;;
+      no-slug:chorus_list_tasks)
+        echo '{"tasks":[{"uuid":"task-1","status":"done"},{"uuid":"task-2","status":"done"},{"uuid":"task-3","status":"done"}],"total":3,"page":1,"pageSize":200}'
+        ;;
+      *)
+        # Unhandled (tool, fixture) — return empty, hook should silent-skip.
+        echo ""
+        ;;
+    esac
+    ;;
+  hook-output)
+    sm="${1:-}"; ac="${2:-}"; hen="${3:-}"
+    if [ -n "$ac" ]; then
+      jq -n --arg sm "$sm" --arg ac "$ac" --arg hen "$hen" \
+        '{systemMessage:$sm, hookSpecificOutput:{hookEventName:$hen, additionalContext:$ac}}'
+    else
+      jq -n --arg sm "$sm" '{systemMessage:$sm}'
+    fi
+    ;;
+  *)
+    echo "shim chorus-api.sh: unknown cmd $cmd" >&2; exit 2 ;;
+esac
+SHIM_CLAUDE
+chmod +x "$SANDBOX/claude/chorus-api.sh"
+
+# ----- Shim: chorus-mcp-call.sh (Codex shape) -----
+# Codex wrapper interface:
+#   chorus-mcp-call.sh <tool> <json_args>   -> echo canned JSON
+cat > "$SANDBOX/codex/chorus-mcp-call.sh" <<'SHIM_CODEX'
+#!/usr/bin/env bash
+set -euo pipefail
+tool="${1:-}"
+# Alias gate-test fixtures to "positive" canned data so a broken gate
+# would let the hook proceed and emit an archive reminder, failing the
+# "no archive reminder" assertion. See claude shim for full rationale.
+fixture="${CHORUS_FIXTURE:-positive}"
+case "$fixture" in
+  mode-off|no-folder|no-cli) fixture=positive ;;
+esac
+case "${fixture}:${tool}" in
+  positive:chorus_get_task)
+    echo '{"uuid":"task-3","title":"Task 3","status":"done","proposalUuid":"prop-1","project":{"uuid":"proj-1","name":"P"}}'
+    ;;
+  positive:chorus_get_proposal)
+    printf '%s' '{"uuid":"prop-1","title":"P1","description":"Some intro line.\nOpenSpec change slug: my-feature\nMore body.","inputUuids":["idea-1"]}'
+    ;;
+  positive:chorus_list_tasks)
+    echo '{"tasks":[{"uuid":"task-1","status":"done"},{"uuid":"task-2","status":"done"},{"uuid":"task-3","status":"done"}],"total":3,"page":1,"pageSize":200}'
+    ;;
+  not-last-task:chorus_get_task)
+    echo '{"uuid":"task-2","title":"Task 2","status":"done","proposalUuid":"prop-1","project":{"uuid":"proj-1","name":"P"}}'
+    ;;
+  not-last-task:chorus_get_proposal)
+    printf '%s' '{"uuid":"prop-1","title":"P1","description":"Intro.\nOpenSpec change slug: my-feature\nMore.","inputUuids":["idea-1"]}'
+    ;;
+  not-last-task:chorus_list_tasks)
+    echo '{"tasks":[{"uuid":"task-1","status":"done"},{"uuid":"task-2","status":"done"},{"uuid":"task-3","status":"in_progress"}],"total":3,"page":1,"pageSize":200}'
+    ;;
+  no-slug:chorus_get_task)
+    echo '{"uuid":"task-3","title":"Task 3","status":"done","proposalUuid":"prop-2","project":{"uuid":"proj-1","name":"P"}}'
+    ;;
+  no-slug:chorus_get_proposal)
+    printf '%s' '{"uuid":"prop-2","title":"P2","description":"Free-form proposal description with no slug marker.","inputUuids":["idea-2"]}'
+    ;;
+  no-slug:chorus_list_tasks)
+    echo '{"tasks":[{"uuid":"task-1","status":"done"},{"uuid":"task-2","status":"done"},{"uuid":"task-3","status":"done"}],"total":3,"page":1,"pageSize":200}'
+    ;;
+  *)
+    echo "" ;;
+esac
+SHIM_CODEX
+chmod +x "$SANDBOX/codex/chorus-mcp-call.sh"
+
+# ----- Fake `openspec` on PATH -----
+# Default behavior: `openspec --version` exits 0. The "no-openspec"
+# fixture rebuilds PATH without this dir to simulate CLI absence.
+cat > "$SANDBOX/bin/openspec" <<'OPENSPEC_FAKE'
+#!/usr/bin/env bash
+case "${1:-}" in
+  --version) echo "openspec 0.0.0-fixture"; exit 0 ;;
+  *) echo "openspec fixture: ignoring $*"; exit 0 ;;
+esac
+OPENSPEC_FAKE
+chmod +x "$SANDBOX/bin/openspec"
+
+# ----- Synthetic PostToolUse event JSON -----
+EVENT_JSON='{"tool_name":"chorus_admin_verify_task","tool_input":{"taskUuid":"task-3"},"tool_response":{"uuid":"task-3","status":"done","title":"Task 3"}}'
+
+# ----- Test runner -----
+
+# Args: name fixture variant expected_substring should_contain
+# variant in {claude, codex}
+# should_contain: "yes" -> stdout MUST contain expected_substring
+# should_contain: "no"  -> stdout MUST NOT contain "openspec archive"
+run_one() {
+  local name="$1"
+  local fixture="$2"
+  local variant="$3"
+  local should_contain="$4"
+  local expected="$5"
+
+  local hook_dir
+  if [ "$variant" = "claude" ]; then
+    hook_dir="$SANDBOX/claude"
+  else
+    hook_dir="$SANDBOX/codex"
+  fi
+
+  # Build PATH:
+  # - default fixtures get $SANDBOX/bin (where the fake openspec lives)
+  #   prepended in front of the inherited PATH;
+  # - "no-cli" needs to actually have NO openspec on PATH. Just removing
+  #   $SANDBOX/bin isn't enough — the dev machine often has a real
+  #   openspec under ~/.nvm/.../bin or similar. So for no-cli we strip
+  #   every PATH entry that contains an `openspec` executable.
+  local PATH_FOR_RUN
+  if [ "$fixture" = "no-cli" ]; then
+    local _filtered=""
+    local _entry
+    for _entry in $(printf '%s' "$PATH" | tr ':' '\n'); do
+      if [ -z "$_entry" ]; then continue; fi
+      if [ -x "$_entry/openspec" ]; then continue; fi
+      if [ -n "$_filtered" ]; then
+        _filtered="$_filtered:$_entry"
+      else
+        _filtered="$_entry"
+      fi
+    done
+    PATH_FOR_RUN="$_filtered"
+  else
+    PATH_FOR_RUN="$SANDBOX/bin:$PATH"
+  fi
+
+  # Pick the working directory + CLAUDE_PROJECT_DIR. The "no-folder"
+  # fixture points the hook at $SANDBOX (which contains no openspec/),
+  # everything else uses $SANDBOX/project (which has openspec/).
+  local PROJECT_DIR_FOR_RUN
+  if [ "$fixture" = "no-folder" ]; then
+    PROJECT_DIR_FOR_RUN="$SANDBOX"
+  else
+    PROJECT_DIR_FOR_RUN="$SANDBOX/project"
+  fi
+
+  # The "mode-off" fixture sets the explicit-opt-out env var; everything
+  # else leaves it unset.
+  local MODE_VAR_FOR_RUN=""
+  if [ "$fixture" = "mode-off" ]; then
+    MODE_VAR_FOR_RUN="off"
+  fi
+
+  local stdout_file
+  stdout_file=$(mktemp)
+  local stderr_file
+  stderr_file=$(mktemp)
+  local rc=0
+
+  printf '%s' "$EVENT_JSON" \
+    | env -i \
+        HOME="$HOME" \
+        CHORUS_FIXTURE="$fixture" \
+        PATH="$PATH_FOR_RUN" \
+        CLAUDE_PROJECT_DIR="$PROJECT_DIR_FOR_RUN" \
+        CHORUS_OPENSPEC_MODE="$MODE_VAR_FOR_RUN" \
+        /bin/bash -c "cd \"$PROJECT_DIR_FOR_RUN\" && /bin/bash \"$hook_dir/on-post-verify-task.sh\"" \
+        >"$stdout_file" 2>"$stderr_file" || rc=$?
+
+  if [ "$rc" -ne 0 ]; then
+    echo "  FAIL  $name [$variant] exit=$rc"
+    sed 's/^/         /' "$stderr_file"
+    FAIL=$((FAIL + 1))
+    FAILED="$FAILED $name[$variant]"
+    rm -f "$stdout_file" "$stderr_file"
+    return
+  fi
+
+  local stdout
+  stdout=$(cat "$stdout_file")
+  rm -f "$stdout_file" "$stderr_file"
+
+  if [ "$should_contain" = "yes" ]; then
+    if printf '%s' "$stdout" | grep -q "$expected"; then
+      echo "  PASS  $name [$variant]"
+      PASS=$((PASS + 1))
+    else
+      echo "  FAIL  $name [$variant]: stdout missing '$expected'"
+      printf '%s\n' "$stdout" | sed 's/^/         /'
+      FAIL=$((FAIL + 1))
+      FAILED="$FAILED $name[$variant]"
+    fi
+  else
+    # should_contain == "no": archive reminder MUST be absent.
+    if printf '%s' "$stdout" | grep -q "openspec archive"; then
+      echo "  FAIL  $name [$variant]: stdout unexpectedly contains 'openspec archive'"
+      printf '%s\n' "$stdout" | sed 's/^/         /'
+      FAIL=$((FAIL + 1))
+      FAILED="$FAILED $name[$variant]"
+    else
+      echo "  PASS  $name [$variant]"
+      PASS=$((PASS + 1))
+    fi
+  fi
+}
+
+echo "Sandbox: $SANDBOX"
+echo ""
+
+# ----- Branch 1: positive (slug + last task + CLI) -----
+run_one "positive"      "positive"      "claude" "yes" "openspec archive my-feature"
+run_one "positive"      "positive"      "codex"  "yes" "openspec archive my-feature"
+
+# ----- Branch 2: not-last-task -----
+run_one "not-last-task" "not-last-task" "claude" "no"  ""
+run_one "not-last-task" "not-last-task" "codex"  "no"  ""
+
+# ----- Branch 3: no-slug (free-form proposal) -----
+run_one "no-slug"       "no-slug"       "claude" "no"  ""
+run_one "no-slug"       "no-slug"       "codex"  "no"  ""
+
+# ----- Branch 4: no-cli (folder present, CLI absent) -----
+# Strip $SANDBOX/bin from PATH so `command -v openspec` fails. Folder is
+# still there in $SANDBOX/project/openspec. Hook must short-circuit at
+# step 4 (CLI gate) and emit no archive reminder.
+run_one "no-cli"        "no-cli"        "claude" "no"  ""
+run_one "no-cli"        "no-cli"        "codex"  "no"  ""
+
+# ----- Branch 5: no-folder (CLI present, folder absent) -----
+# CLAUDE_PROJECT_DIR points at $SANDBOX (no openspec/ dir there). Hook
+# must short-circuit at step 4 (folder gate) before trying any MCP calls.
+# We don't actually exercise any MCP fixture here — the hook should bail
+# before reaching the wrappers. We pass "positive" only because the
+# unhandled-fixture branch in the shim returns an empty body and the hook
+# would then silent-skip on get_task. Either way the assertion ("no
+# archive reminder") holds.
+run_one "no-folder"     "no-folder"     "claude" "no"  ""
+run_one "no-folder"     "no-folder"     "codex"  "no"  ""
+
+# ----- Branch 6: mode-off (explicit opt-out via env) -----
+# Both folder and CLI are present, but CHORUS_OPENSPEC_MODE=off. Hook
+# must honor the opt-out and exit silently.
+run_one "mode-off"      "mode-off"      "claude" "no"  ""
+run_one "mode-off"      "mode-off"      "codex"  "no"  ""
+
+echo ""
+echo "Results: $PASS passed, $FAIL failed"
+
+if [ "$FAIL" -gt 0 ]; then
+  echo "Failed:$FAILED"
+  exit 1
+fi
+exit 0

package/.next/standalone/public/chorus-plugin/hooks/hooks.json

@@ -39,6 +39,15 @@
             "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-post-submit-for-verify.sh"
           }
         ]
+      },
+      {
+        "matcher": ".*chorus_admin_verify_task",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-post-verify-task.sh"
+          }
+        ]
       }
     ],
     "PreToolUse": [