@chorus-aidlc/chorus 0.16.4 → 0.17.0

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

@@ -1,353 +1,29 @@
 #!/usr/bin/env bash
-# Chorus + Kiro CLI one-shot installer
+# Chorus + Kiro CLI installer — DEPRECATED.
 #
-# Usage:
-#   curl -fsSL "$CHORUS_URL/install-kiro.sh" | bash
-#   # or non-interactive:
-#   CHORUS_URL=https://... CHORUS_API_KEY=cho_... \
-#     bash <(curl -fsSL https://chorus.example.com/install-kiro.sh)
-#   # workspace-local (writes <cwd>/.kiro/ instead of ~/.kiro/):
-#   bash <(curl -fsSL "$CHORUS_URL/install-kiro.sh") --workspace
+# Chorus setup is now a global install plus a single command that configures
+# every supported agent (claude / codex / opencode / kiro / openclaw / dsh):
 #
-# What this does (idempotent, safe to re-run):
-#   1. Verifies a Kiro CLI (`kiro-cli` or `kiro`) is installed.
-#   2. Collects CHORUS_URL + CHORUS_API_KEY (env or TTY prompt) and
-#      normalizes the URL to end in exactly one /api/mcp.
-#   3. Installs the Chorus `.kiro/` template — the chorus-* skills, the
-#      `chorus` main agent + 3 read-only reviewer subagents, and the Chorus
-#      steering doc — into ~/.kiro/ (global, default) or <cwd>/.kiro/
-#      (--workspace).
-#   4. Copies the session-automation hook scripts (+ chorus-api.sh) into
-#      <KIRO_DIR>/chorus-bin/, chmod +x, and substitutes the __CHORUS_BIN__
-#      placeholder in the installed agents/chorus.json hook commands with
-#      the resolved ABSOLUTE chorus-bin path.
-#   5. MERGES the `chorus` MCP server into <KIRO_DIR>/settings/mcp.json,
-#      preserving any pre-existing user servers, backing the original up to
-#      mcp.json.chorus-bak first.
+#   npm install -g @chorus-aidlc/chorus@0.17.0
+#   chorus agents add
 #
-# Bash 3.2 compatible (CLAUDE.md pitfall #10): no ${VAR,,}/${VAR^^},
-# no `declare -A`, no `readarray`/`mapfile`, no `&>>`, no `|&`.
+# This script is still fetched via curl for backward compatibility, but it no
+# longer installs anything itself — it just points you at `chorus agents add`.
+#
+# Bash 3.2 compatible (macOS /bin/bash): no case-conversion parameter expansion,
+# no associative arrays.
 
 set -euo pipefail
 
-# ---------- cosmetics ----------
-BOLD=$'\033[1m'; DIM=$'\033[2m'; GREEN=$'\033[32m'; YELLOW=$'\033[33m'; RED=$'\033[31m'; RESET=$'\033[0m'
-ok()   { printf "${GREEN}\xe2\x9c\x93${RESET} %s\n" "$*"; }
-warn() { printf "${YELLOW}!${RESET} %s\n" "$*" >&2; }
-die()  { printf "${RED}\xe2\x9c\x97${RESET} %s\n" "$*" >&2; exit 1; }
-hdr()  { printf "\n${BOLD}%s${RESET}\n" "$*"; }
-
-is_tty() { [ -t 0 ] && [ -t 1 ]; }
-
-# ---------- config: the artifact manifest (single source of truth) ----------
-# These lists drive BOTH the local copy and the remote download, so the two
-# source modes can never diverge.
-SKILLS="chorus-idea chorus-proposal chorus-develop chorus-yolo chorus-review chorus-quick-dev chorus-brainstorm chorus-openspec-aware chorus-docs"
-REVIEWER_AGENTS="chorus-code-reviewer chorus-proposal-reviewer chorus-task-reviewer"
-HOOK_SCRIPTS="on-agent-spawn.sh on-stop.sh on-post-submit-proposal.sh on-post-submit-for-verify.sh on-post-verify-task.sh chorus-api.sh verify-document-roundtrip.sh test-syntax.sh"
-
-CHORUS_URL_DEFAULT="${CHORUS_URL_DEFAULT:-http://localhost:8637/api/mcp}"
-
-# ---------- argument parsing ----------
-SCOPE="global"
-for arg in "$@"; do
-  case "$arg" in
-    --workspace) SCOPE="workspace" ;;
-    --global)    SCOPE="global" ;;
-    -h|--help)
-      cat <<'USAGE'
-install-kiro.sh — install the Chorus plugin for Kiro CLI.
-
-Options:
-  --workspace   Write to <cwd>/.kiro/ (project-local) instead of ~/.kiro/.
-  --global      Write to ~/.kiro/ (default).
-  -h, --help    Show this help.
-
-Environment:
-  CHORUS_URL      Chorus base URL (e.g. https://chorus.example.com). Normalized
-                  to end in /api/mcp. Prompted on a TTY if unset.
-  CHORUS_API_KEY  Chorus agent API key (starts with cho_). Prompted (echo off)
-                  on a TTY if unset; required — no TTY + unset is a hard error.
-USAGE
-      exit 0
-      ;;
-    *) die "Unknown argument: $arg (try --help)" ;;
-  esac
-done
-
-# If piped through `curl | bash`, stdin is the script body. Re-open from
-# /dev/tty so interactive prompts still work — but only when a real TTY is
-# available AND we actually need to prompt (the key is unset). Both CHORUS_URL
-# and CHORUS_API_KEY being set lets us run fully non-interactively (CI /
-# sandboxed / unified-exec environments).
-if [ -z "${CHORUS_API_KEY:-}" ] && ! is_tty; then
-  # Probe that /dev/tty is actually openable before exec'ing onto it. In a
-  # detached/headless environment (CI, daemon-spawned) /dev/tty can pass the
-  # -r/-w file-mode test yet fail to open ("No such device or address"), and a
-  # bare `exec < /dev/tty` would abort the shell with that raw error instead of
-  # reaching the explanatory die below. The subshell open-test runs inside an
-  # `if` so its failure never trips set -e.
-  if ( : < /dev/tty ) >/dev/null 2>&1; then
-    exec < /dev/tty
-  fi
-fi
-
-# ---------- step 1: check Kiro CLI ----------
-hdr "1/5  Checking Kiro CLI"
-KIRO_BIN=""
-if command -v kiro-cli >/dev/null 2>&1; then
-  KIRO_BIN="kiro-cli"
-elif command -v kiro >/dev/null 2>&1; then
-  KIRO_BIN="kiro"
-fi
-[ -n "$KIRO_BIN" ] || die "No Kiro CLI found in PATH (looked for 'kiro-cli' and 'kiro'). Install it first: https://kiro.dev/docs/cli"
-ok "Found $($KIRO_BIN --version 2>/dev/null | head -1 || echo "$KIRO_BIN")"
-
-# ---------- step 2: collect Chorus URL + API key ----------
-hdr "2/5  Configuring the Chorus connection"
-
-# URL
-if [ -n "${CHORUS_URL:-}" ]; then
-  url="$CHORUS_URL"
-  ok "Using CHORUS_URL from env: $url"
-elif [ -t 0 ]; then
-  printf "  Chorus URL ${DIM}[default: $CHORUS_URL_DEFAULT]${RESET}: "
-  read -r url
-  url="${url:-$CHORUS_URL_DEFAULT}"
-else
-  url="$CHORUS_URL_DEFAULT"
-  warn "No TTY and CHORUS_URL unset — using default: $url"
-fi
-
-# API key
-if [ -n "${CHORUS_API_KEY:-}" ]; then
-  apikey="$CHORUS_API_KEY"
-  ok "Using CHORUS_API_KEY from env"
-elif [ -t 0 ]; then
-  printf "  Chorus API key (starts with cho_): "
-  stty -echo 2>/dev/null || true
-  read -r apikey
-  stty echo 2>/dev/null || true
-  printf "\n"
-  [ -n "$apikey" ] || die "API key is required"
-else
-  die "No TTY and CHORUS_API_KEY unset — cannot continue. Export CHORUS_API_KEY (create one under Settings -> Agents in the Chorus UI) and re-run."
-fi
-
-# Must be http(s).
-case "$url" in
-  http://*|https://*) ;;
-  *) die "URL must start with http:// or https:// — got: $url" ;;
-esac
-
-# Normalize: the Chorus MCP endpoint lives under /api/mcp. If the user gave us
-# just a host (or a host with trailing slash, or any path that doesn't already
-# end in /api/mcp), append it so the MCP handshake hits the right route.
-case "$url" in
-  */api/mcp)  ;;
-  */api/mcp/) url="${url%/}" ;;
-  */)         url="${url}api/mcp" ;;
-  *)          url="${url}/api/mcp" ;;
-esac
-ok "MCP endpoint: $url"
-
-# The base for fetching static plugin assets is the same origin minus /api/mcp
-# (public/ is served at web root, so public/kiro-plugin/... => <base>/kiro-plugin/...).
-ASSET_BASE="${url%/api/mcp}"
-
-# ---------- step 3: locate the template source ----------
-hdr "3/5  Locating the Chorus .kiro/ template"
-
-# Resolve the directory of this script (only meaningful when run from a file,
-# not via `curl | bash`).
-SCRIPT_SRC="${BASH_SOURCE:-$0}"
-SCRIPT_DIR=""
-if [ -f "$SCRIPT_SRC" ]; then
-  SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_SRC")" >/dev/null 2>&1 && pwd)"
-fi
-
-# Candidate local template roots (script lives in public/, or repo root).
-SRC_ROOT=""
-if [ -n "$SCRIPT_DIR" ]; then
-  for cand in "$SCRIPT_DIR/kiro-plugin" "$SCRIPT_DIR/public/kiro-plugin" "$SCRIPT_DIR/../public/kiro-plugin"; do
-    if [ -f "$cand/.kiro/settings/mcp.json" ] && [ -f "$cand/.kiro/agents/chorus.json" ]; then
-      SRC_ROOT="$(cd "$cand" >/dev/null 2>&1 && pwd)"
-      break
-    fi
-  done
-fi
-
-CLEANUP_SRC=""
-if [ -n "$SRC_ROOT" ]; then
-  ok "Using local template: $SRC_ROOT"
-else
-  # Remote mode: download the manifest from the Chorus instance's static assets.
-  command -v curl >/dev/null 2>&1 || die "No local template found and 'curl' is unavailable — cannot download the plugin. Run this from a Chorus checkout, or install curl."
-  SRC_ROOT="$(mktemp -d "${TMPDIR:-/tmp}/chorus-kiro.XXXXXX")"
-  CLEANUP_SRC="$SRC_ROOT"
-  ok "Downloading template from ${ASSET_BASE}/kiro-plugin/"
-
-  fetch() {
-    # fetch <relpath-under-kiro-plugin> <dest-abs-path>
-    local rel="$1" dest="$2"
-    mkdir -p "$(dirname "$dest")"
-    curl -fsSL "${ASSET_BASE}/kiro-plugin/${rel}" -o "$dest" \
-      || die "Failed to download kiro-plugin/${rel} from ${ASSET_BASE}. Is CHORUS_URL correct and reachable?"
-  }
-
-  fetch ".kiro/settings/mcp.json" "$SRC_ROOT/.kiro/settings/mcp.json"
-  fetch ".kiro/steering/chorus.md" "$SRC_ROOT/.kiro/steering/chorus.md"
-  fetch ".kiro/agents/chorus.json" "$SRC_ROOT/.kiro/agents/chorus.json"
-  fetch ".kiro/agents/chorus.md" "$SRC_ROOT/.kiro/agents/chorus.md"
-  for a in $REVIEWER_AGENTS; do
-    fetch ".kiro/agents/${a}.json" "$SRC_ROOT/.kiro/agents/${a}.json"
-  done
-  for s in $SKILLS; do
-    fetch ".kiro/skills/${s}/SKILL.md" "$SRC_ROOT/.kiro/skills/${s}/SKILL.md"
-  done
-  for b in $HOOK_SCRIPTS; do
-    fetch "bin/${b}" "$SRC_ROOT/bin/${b}"
-  done
-fi
-
-# Clean up any downloaded temp on exit (no-op for local mode).
-cleanup() { [ -n "$CLEANUP_SRC" ] && rm -rf "$CLEANUP_SRC" 2>/dev/null || true; }
-trap cleanup EXIT
-
-# ---------- step 4: determine KIRO_DIR + write skills / agents / steering / hooks ----------
-if [ "$SCOPE" = "workspace" ]; then
-  KIRO_DIR="$(pwd)/.kiro"
-else
-  KIRO_DIR="$HOME/.kiro"
-fi
-CHORUS_BIN_ABS="$KIRO_DIR/chorus-bin"
-
-hdr "4/5  Installing into $KIRO_DIR (scope: $SCOPE)"
-mkdir -p "$KIRO_DIR/skills" "$KIRO_DIR/agents" "$KIRO_DIR/steering" "$KIRO_DIR/chorus-bin" "$KIRO_DIR/settings"
-
-# Skills (chorus-* only — never touches a user's own skills).
-for s in $SKILLS; do
-  mkdir -p "$KIRO_DIR/skills/$s"
-  cp "$SRC_ROOT/.kiro/skills/$s/SKILL.md" "$KIRO_DIR/skills/$s/SKILL.md"
-done
-ok "Installed skills: $SKILLS"
-
-# Reviewer subagents (raw copy) + the main-agent prompt sidecar.
-for a in $REVIEWER_AGENTS; do
-  cp "$SRC_ROOT/.kiro/agents/$a.json" "$KIRO_DIR/agents/$a.json"
-done
-cp "$SRC_ROOT/.kiro/agents/chorus.md" "$KIRO_DIR/agents/chorus.md"
-ok "Installed agents: chorus (main) + $REVIEWER_AGENTS"
-
-# Steering (Chorus platform-overview / AI-DLC context).
-cp "$SRC_ROOT/.kiro/steering/chorus.md" "$KIRO_DIR/steering/chorus.md"
-ok "Installed steering: chorus.md"
-
-# Hook scripts -> chorus-bin/ (executable). Copying them INTO the Kiro dir keeps
-# the install self-contained and removable.
-for b in $HOOK_SCRIPTS; do
-  cp "$SRC_ROOT/bin/$b" "$CHORUS_BIN_ABS/$b"
-  chmod +x "$CHORUS_BIN_ABS/$b"
-done
-ok "Installed hook scripts -> $CHORUS_BIN_ABS/ (chmod +x)"
-
-# Main agent: substitute the __CHORUS_BIN__ placeholder in the hook `command`
-# strings with the resolved ABSOLUTE chorus-bin path. The repo copy keeps the
-# placeholder; only this installed copy is concretized. Absolute paths are
-# scope-independent and survive Kiro being launched from any cwd.
-# (Use '|' as the sed delimiter since the replacement is a filesystem path.)
-sed "s|__CHORUS_BIN__|$CHORUS_BIN_ABS|g" \
-  "$SRC_ROOT/.kiro/agents/chorus.json" > "$KIRO_DIR/agents/chorus.json"
-
-# Fail loudly if the placeholder survived (it must not).
-if grep -q '__CHORUS_BIN__' "$KIRO_DIR/agents/chorus.json" 2>/dev/null; then
-  die "Internal error: __CHORUS_BIN__ placeholder was not fully substituted in agents/chorus.json"
-fi
-ok "Wrote agents/chorus.json (hook commands -> $CHORUS_BIN_ABS)"
-
-# ---------- step 5: merge the chorus MCP server into settings/mcp.json ----------
-hdr "5/5  Wiring the Chorus MCP server into settings/mcp.json"
-
-MCP_JSON="$KIRO_DIR/settings/mcp.json"
-# Seed a valid empty document if the file is missing so the merge has a target.
-if [ ! -f "$MCP_JSON" ]; then
-  printf '%s\n' '{"mcpServers":{}}' > "$MCP_JSON"
-fi
-
-# Back up ONCE (idempotent — a second run keeps the single original backup).
-if [ ! -f "$MCP_JSON.chorus-bak" ]; then
-  cp "$MCP_JSON" "$MCP_JSON.chorus-bak"
-  ok "Backed up original to ${MCP_JSON}.chorus-bak"
-fi
-
-# The chorus server object. BOTH the URL and the API key stay ${...} references
-# (not baked literals) so Kiro CLI interpolates them from the environment at
-# runtime — this is what makes a single daemon serving MULTIPLE agents work: each
-# woken Kiro child inherits that agent's own CHORUS_URL / CHORUS_API_KEY, so the
-# same mcp.json resolves to the right server + key per agent. The API key is never
-# written to disk. Single-quote both refs so the shell never expands ${...} here.
-URL_REF='${CHORUS_URL}/api/mcp'
-AUTH_REF='Bearer ${env:CHORUS_API_KEY}'
-
-merged=""
-if command -v jq >/dev/null 2>&1; then
-  # Build the server object, then set only .mcpServers.chorus (in place if it
-  # already exists — preserving position and every other user server).
-  server_json="$(jq -n --arg url "$URL_REF" --arg auth "$AUTH_REF" \
-    '{type:"http", url:$url, headers:{Authorization:$auth}, disabled:false}')"
-  merged="$(jq --argjson srv "$server_json" \
-    '(.mcpServers // {}) as $m | .mcpServers = ($m + {chorus:$srv})' "$MCP_JSON")" \
-    || die "Failed to merge mcp.json with jq (is $MCP_JSON valid JSON?)"
-elif command -v node >/dev/null 2>&1; then
-  merged="$(CHORUS_MCP_URL="$URL_REF" CHORUS_MCP_AUTH="$AUTH_REF" node - "$MCP_JSON" <<'NODE'
-const fs = require("fs");
-const file = process.argv[2];
-let data = {};
-try { data = JSON.parse(fs.readFileSync(file, "utf8")) || {}; }
-catch (e) { console.error("mcp.json is not valid JSON: " + e.message); process.exit(1); }
-if (typeof data !== "object" || Array.isArray(data)) data = {};
-if (typeof data.mcpServers !== "object" || data.mcpServers === null || Array.isArray(data.mcpServers)) data.mcpServers = {};
-data.mcpServers.chorus = {
-  type: "http",
-  url: process.env.CHORUS_MCP_URL,
-  headers: { Authorization: process.env.CHORUS_MCP_AUTH },
-  disabled: false,
-};
-process.stdout.write(JSON.stringify(data, null, 2) + "\n");
-NODE
-)" || die "Failed to merge mcp.json with node (is $MCP_JSON valid JSON?)"
-else
-  die "Cannot merge mcp.json safely: neither jq nor node is available. Install one (e.g. 'brew install jq') and re-run."
-fi
-
-printf '%s\n' "$merged" > "$MCP_JSON"
-ok "Merged the 'chorus' server into $MCP_JSON (other servers preserved)"
-
-# ---------- epilogue ----------
-hdr "Done."
-if [ "$SCOPE" = "workspace" ]; then
-  scope_note="this project ($KIRO_DIR)"
-else
-  scope_note="every directory (global $KIRO_DIR)"
-fi
-cat <<NEXT
-
-The Chorus plugin is installed for ${scope_note}.
-
-Make sure CHORUS_URL and CHORUS_API_KEY stay exported in your shell (Kiro
-reads \${env:CHORUS_API_KEY} at runtime — add them to ~/.bashrc / ~/.zshrc):
-
-  ${BOLD}export CHORUS_URL="${ASSET_BASE}"${RESET}
-  ${BOLD}export CHORUS_API_KEY="cho_..."${RESET}
-
-Then, in ${BOLD}${KIRO_BIN}${RESET}:
-
-  * Type ${BOLD}/chorus-idea${RESET} (or /chorus-proposal, /chorus-develop, /chorus-yolo,
-    /chorus-review, /chorus-quick-dev, ...) to activate a workflow skill.
-  * Launch the full-automation main agent with session hooks + reviewer
-    subagents:  ${BOLD}${KIRO_BIN} --agent chorus${RESET}
+BOLD=$'\033[1m'; YELLOW=$'\033[33m'; RESET=$'\033[0m'
+INSTALL_CMD="npm install -g @chorus-aidlc/chorus@0.17.0"
+INIT_CMD="chorus agents add"
 
-Live in-Kiro activation is your manual verification step — see docs/CONNECT_KIRO.md.
-To change your API key or URL later, just re-run this installer.
+printf "${YELLOW}!${RESET} install-kiro.sh is deprecated and installs nothing.\n" >&2
+printf "  Chorus setup is now: ${BOLD}%s${RESET} then ${BOLD}%s${RESET}\n" "$INSTALL_CMD" "$INIT_CMD" >&2
 
-NEXT
+# This stub installs nothing. Print the exact commands and exit non-zero so
+# both interactive users and automation that piped the old installer notice
+# they must install the Chorus CLI globally, then run `chorus agents add`.
+printf "\n  Run these to set up Chorus:\n\n    %s\n    %s\n\n" "$INSTALL_CMD" "$INIT_CMD" >&2
+exit 1

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

@@ -1,284 +1,29 @@
 #!/usr/bin/env bash
-# Chorus + OpenCode one-shot plugin installer
+# Chorus + OpenCode installer — DEPRECATED.
 #
-# Usage:
-#   curl -fsSL https://<your-chorus>/install-opencode.sh | bash
+# Chorus setup is now a global install plus a single command that configures
+# every supported agent (claude / codex / opencode / kiro / openclaw / dsh):
 #
-# What this does (idempotent, safe to re-run):
-#   1. Verifies `opencode` CLI is installed.
-#   2. Adds "opencode-chorus" to the `plugin` array in
-#      ~/.config/opencode/opencode.json. Creates the file if missing.
-#      Preserves any existing plugins.
-#   3. Sets file permissions to 600.
+#   npm install -g @chorus-aidlc/chorus@0.17.0
+#   chorus agents add
 #
-# What this does NOT do:
-#   - Write to ~/.bashrc / ~/.zshrc. You must export CHORUS_URL and
-#     CHORUS_API_KEY yourself before launching opencode (the plugin reads
-#     process.env on startup).
-#   - Invoke jq / node / python. Pure POSIX awk/sed/grep only.
+# This script is still fetched via curl for backward compatibility, but it no
+# longer installs anything itself — it just points you at `chorus agents add`.
+#
+# Bash 3.2 compatible (macOS /bin/bash): no case-conversion parameter expansion,
+# no associative arrays.
 
 set -euo pipefail
 
-# ---------- cosmetics ----------
-BOLD=$'\033[1m'; DIM=$'\033[2m'; GREEN=$'\033[32m'; YELLOW=$'\033[33m'; RED=$'\033[31m'; RESET=$'\033[0m'
-ok()   { printf "${GREEN}\xe2\x9c\x93${RESET} %s\n" "$*"; }
-warn() { printf "${YELLOW}!${RESET} %s\n" "$*" >&2; }
-die()  { printf "${RED}\xe2\x9c\x97${RESET} %s\n" "$*" >&2; exit 1; }
-hdr()  { printf "\n${BOLD}%s${RESET}\n" "$*"; }
-
-# ---------- config ----------
-PLUGIN_NAME="opencode-chorus"
-CONFIG_DIR="${OPENCODE_CONFIG_DIR:-$HOME/.config/opencode}"
-CONFIG_FILE="$CONFIG_DIR/opencode.json"
-BACKUP_FILE="$CONFIG_FILE.chorus-bak"
-
-# ---------- step 1: check opencode ----------
-hdr "1/3  Checking OpenCode CLI"
-if command -v opencode >/dev/null 2>&1; then
-  ok "Found $(opencode --version 2>/dev/null | head -1)"
-else
-  warn "opencode not found in PATH — install it first: https://opencode.ai/docs/"
-  warn "Proceeding to write the config anyway. OpenCode will pick it up on install."
-fi
-
-# ---------- step 2: ensure config dir ----------
-hdr "2/3  Updating $CONFIG_FILE"
-mkdir -p "$CONFIG_DIR"
-
-# Helper: print the manual instructions and exit 0 (non-fatal).
-print_manual_hint() {
-  warn "Could not automatically update $CONFIG_FILE."
-  warn "Please add \"$PLUGIN_NAME\" to the \"plugin\" array manually:"
-  cat >&2 <<HINT
-
-  {
-    "\$schema": "https://opencode.ai/config.json",
-    "plugin": ["$PLUGIN_NAME"${EXISTING_PLUGIN_HINT:-}]
-    ...
-  }
-
-HINT
-  exit 0
-}
-
-# ---------- Case A: file does not exist ----------
-if [ ! -f "$CONFIG_FILE" ]; then
-  cat > "$CONFIG_FILE" <<JSON
-{
-  "\$schema": "https://opencode.ai/config.json",
-  "plugin": ["$PLUGIN_NAME"]
-}
-JSON
-  chmod 600 "$CONFIG_FILE"
-  ok "Created $CONFIG_FILE with $PLUGIN_NAME"
-else
-  # File exists — back it up once.
-  if [ ! -f "$BACKUP_FILE" ]; then
-    cp "$CONFIG_FILE" "$BACKUP_FILE"
-    chmod 600 "$BACKUP_FILE"
-    ok "Backed up original config to $BACKUP_FILE"
-  fi
-
-  # Reject JSONC (comments). Presence of // or /* strongly suggests the file
-  # is hand-edited JSONC; our line-based awk would mangle it. Bail cleanly.
-  if grep -qE '^[[:space:]]*//|/\*' "$CONFIG_FILE"; then
-    warn "Detected // or /* in $CONFIG_FILE — looks like JSONC with comments."
-    print_manual_hint
-  fi
-
-  # Case C1: plugin array already contains opencode-chorus → no-op.
-  # Scope the check to the "plugin" array itself: a top-level occurrence of
-  # "opencode-chorus" outside that array (e.g. in a "lastInstalled" field)
-  # must not trigger the no-op shortcut.
-  plugin_contains_self() {
-    awk -v plugin="$PLUGIN_NAME" '
-      # Track whether we are currently inside the first "plugin" array.
-      # State machine:
-      #   0 = before the plugin key
-      #   1 = inside the plugin array (between its [ and matching ])
-      BEGIN { state = 0 }
-      state == 0 {
-        # Is the "plugin" key on this line?
-        if (match($0, /"plugin"[[:space:]]*:[[:space:]]*\[/)) {
-          # Consume the rest of the line starting at the [
-          rest = substr($0, RSTART + RLENGTH - 1)
-          state = 1
-          # Fall through to state == 1 handling for this rest.
-          $0 = rest
-        } else {
-          next
-        }
-      }
-      state == 1 {
-        # Look for the closing ] on this line (naive — good enough for
-        # standard JSON because plugin entries are plain strings).
-        close_pos = index($0, "]")
-        if (close_pos > 0) {
-          chunk = substr($0, 1, close_pos - 1)
-        } else {
-          chunk = $0
-        }
-        # Check for the quoted token inside the array chunk only.
-        if (index(chunk, "\"" plugin "\"") > 0) {
-          print "yes"
-          exit 0
-        }
-        if (close_pos > 0) exit 0
-      }
-    ' "$CONFIG_FILE"
-  }
-
-  if [ "$(plugin_contains_self)" = "yes" ]; then
-    ok "$PLUGIN_NAME already present in $CONFIG_FILE — nothing to do"
-  else
-    # Decide: Case B (no plugin key) vs Case C2 (plugin key exists without this plugin).
-    if grep -qE '"plugin"[[:space:]]*:' "$CONFIG_FILE"; then
-      # Case C2: insert into existing plugin array.
-      # Strategy: find the first "plugin" key, locate its array bracket pair,
-      # insert "opencode-chorus" before the closing ].
-      #
-      # Only handle the common cases where the array is on a single line or
-      # a multi-line array that has one entry per line. Otherwise bail to hint.
-      tmp="$(mktemp "${TMPDIR:-/tmp}/chorus-opencode.XXXXXX")"
-      if awk -v plugin="$PLUGIN_NAME" '
-        BEGIN { done = 0 }
-        # Single-line empty array: "plugin": []
-        !done && /"plugin"[[:space:]]*:[[:space:]]*\[[[:space:]]*\]/ {
-          sub(/\[[[:space:]]*\]/, "[\"" plugin "\"]")
-          done = 1
-          print
-          next
-        }
-        # Single-line non-empty array: "plugin": [ "foo", "bar" ]
-        !done && match($0, /"plugin"[[:space:]]*:[[:space:]]*\[[^\]]*\]/) {
-          line = $0
-          pre  = substr(line, 1, RSTART - 1)
-          match_text = substr(line, RSTART, RLENGTH)
-          post = substr(line, RSTART + RLENGTH)
-          # Insert before the closing ]
-          sub(/\][[:space:]]*$/, ", \"" plugin "\"]", match_text)
-          # If the match still ends in ] (no trailing whitespace stripped), fall through
-          print pre match_text post
-          done = 1
-          next
-        }
-        # Multi-line array opener: "plugin": [ (and not on same line closer)
-        !done && /"plugin"[[:space:]]*:[[:space:]]*\[[[:space:]]*$/ {
-          print
-          getline nextline
-          # Empty multi-line array: next line is just ]
-          if (nextline ~ /^[[:space:]]*\][[:space:]]*,?[[:space:]]*$/) {
-            print "    \"" plugin "\""
-            print nextline
-            done = 1
-            next
-          }
-          # Non-empty multi-line: emit entries verbatim until we hit the ]
-          buffer[++bn] = nextline
-          while ((getline nextline) > 0) {
-            if (nextline ~ /^[[:space:]]*\][[:space:]]*,?[[:space:]]*$/) {
-              # Last existing entry may not have trailing comma; add one.
-              last = buffer[bn]
-              if (last !~ /,[[:space:]]*$/) {
-                sub(/[[:space:]]*$/, ",", buffer[bn])
-              }
-              for (i = 1; i <= bn; i++) print buffer[i]
-              # Insert new entry before the closing ]
-              # Determine indentation from first buffered entry.
-              match(buffer[1], /^[[:space:]]*/)
-              indent = substr(buffer[1], 1, RLENGTH)
-              print indent "\"" plugin "\""
-              print nextline
-              done = 1
-              bn = 0
-              break
-            }
-            buffer[++bn] = nextline
-          }
-          next
-        }
-        { print }
-        END {
-          if (!done) exit 2
-        }
-      ' "$CONFIG_FILE" > "$tmp"; then
-        mv "$tmp" "$CONFIG_FILE"
-        chmod 600 "$CONFIG_FILE"
-        ok "Added $PLUGIN_NAME to existing \"plugin\" array"
-      else
-        rm -f "$tmp"
-        warn "The \"plugin\" key exists but I could not safely determine where to insert the new entry."
-        EXISTING_PLUGIN_HINT=", ...your existing entries..."
-        print_manual_hint
-      fi
-    else
-      # Case B: no plugin key in file → inject it.
-      # We look for the first top-level "{" then insert `"plugin": [...]` on the next line.
-      # Safer: look for the first line containing just "{" optionally with whitespace.
-      tmp="$(mktemp "${TMPDIR:-/tmp}/chorus-opencode.XXXXXX")"
-      if awk -v plugin="$PLUGIN_NAME" '
-        BEGIN { inserted = 0 }
-        !inserted && /^[[:space:]]*\{[[:space:]]*$/ {
-          print
-          print "  \"plugin\": [\"" plugin "\"],"
-          inserted = 1
-          next
-        }
-        { print }
-        END { if (!inserted) exit 2 }
-      ' "$CONFIG_FILE" > "$tmp"; then
-        mv "$tmp" "$CONFIG_FILE"
-        chmod 600 "$CONFIG_FILE"
-        ok "Added \"plugin\" field with $PLUGIN_NAME to $CONFIG_FILE"
-      else
-        rm -f "$tmp"
-        warn "Could not find a line with just \"{\" to inject the plugin array."
-        print_manual_hint
-      fi
-    fi
-  fi
-fi
-
-# ---------- step 3: reminders ----------
-hdr "3/3  Final reminders"
-
-# Environment check — read-only warning, don't export.
-missing_env=""
-if [ -z "${CHORUS_URL:-}" ]; then
-  missing_env="$missing_env CHORUS_URL"
-fi
-if [ -z "${CHORUS_API_KEY:-}" ]; then
-  missing_env="$missing_env CHORUS_API_KEY"
-fi
-
-if [ -n "$missing_env" ]; then
-  warn "The following environment variables are not set in this shell:$missing_env"
-  warn "The plugin reads them on OpenCode startup. Please export them in your shell rc:"
-  cat >&2 <<'HINT'
-
-  export CHORUS_URL="https://<your-chorus-instance>"
-  export CHORUS_API_KEY="cho_..."
-
-HINT
-  warn "Then re-source your shell rc, or launch opencode from a shell where they are exported."
-else
-  ok "CHORUS_URL and CHORUS_API_KEY are set in this shell"
-fi
-
-hdr "Done."
-cat <<'NEXT'
-Start OpenCode — Bun will fetch opencode-chorus on first launch:
-
-  opencode
-
-Then in OpenCode, ask the agent:
-
-  check in to chorus
-
-If the plugin fails to load, clear the package cache and retry:
+BOLD=$'\033[1m'; YELLOW=$'\033[33m'; RESET=$'\033[0m'
+INSTALL_CMD="npm install -g @chorus-aidlc/chorus@0.17.0"
+INIT_CMD="chorus agents add"
 
-  rm -rf ~/.cache/opencode/packages/opencode-chorus@latest
+printf "${YELLOW}!${RESET} install-opencode.sh is deprecated and installs nothing.\n" >&2
+printf "  Chorus setup is now: ${BOLD}%s${RESET} then ${BOLD}%s${RESET}\n" "$INSTALL_CMD" "$INIT_CMD" >&2
 
-To roll back this change:
-NEXT
-printf "  mv %s %s\n\n" "$BACKUP_FILE" "$CONFIG_FILE"
+# This stub installs nothing. Print the exact commands and exit non-zero so
+# both interactive users and automation that piped the old installer notice
+# they must install the Chorus CLI globally, then run `chorus agents add`.
+printf "\n  Run these to set up Chorus:\n\n    %s\n    %s\n\n" "$INSTALL_CMD" "$INIT_CMD" >&2
+exit 1