setup

#!/usr/bin/env bash
# Perry setup — install perry/ into the host's skills directory (Claude Code
# at ~/.claude/skills/, Codex CLI at ~/.agents/skills/, OpenCode at
# ~/.config/opencode/skills/) so it surfaces /perry.
#
# ONE skill is registered. goals, work and decide are lanes inside it, reached as
# `/perry goals …`, and loaded on demand by the router. Earlier versions also
# symlinked them as sibling skills; this script now removes those links,
# because `design` and `okr` are common words in a shared namespace and Perry
# should not claim them (see install_at for the full reasoning).
#
# All hosts read SKILL.md frontmatter for skill discovery; the
# install is just a symlink in the host's canonical skills directory.
#
# Host selection:
#   No flag         → auto-detect; install for whichever host(s) are present
#                     in PATH (claude / codex / opencode). Fails if none is detected
#                     and no flag forces.
#   --claude        → force install for Claude Code (~/.claude/skills/)
#   --codex         → force install for Codex CLI (~/.agents/skills/)
#   --opencode      → force install for OpenCode (~/.config/opencode/skills/)
#
# Before the symlink phase, runs a dependency check (Phase 0). On a fresh
# macOS, several deps may be missing — git (Xcode CLT), Homebrew, gtimeout
# (coreutils), Node.js (for codex), codex CLI. The script reports each, and
# with --yes-deps will auto-install the ones that can be installed
# non-interactively.
set -e

SETUP_DIR="$(cd "$(dirname "$0")" && pwd)"
SOURCE_DIR="$(cd "$(dirname "$0")" && pwd -P)"   # resolves symlinks

# ─── Parse flags ──────────────────────────────────────────────
LOCAL=0
QUIET=0
EXPLICIT_CLAUDE=0
EXPLICIT_CODEX=0
EXPLICIT_OPENCODE=0
ANY_EXPLICIT=0
DEPS_MODE="prompt"  # prompt | yes | no | check-only
while [ $# -gt 0 ]; do
  case "$1" in
    --local)            LOCAL=1; shift ;;
    --claude)           EXPLICIT_CLAUDE=1; ANY_EXPLICIT=1; shift ;;
    --codex)            EXPLICIT_CODEX=1;  ANY_EXPLICIT=1; shift ;;
    --opencode)         EXPLICIT_OPENCODE=1; ANY_EXPLICIT=1; shift ;;
    --quiet)            QUIET=1; shift ;;
    --yes-deps)         DEPS_MODE="yes"; shift ;;
    --no-deps)          DEPS_MODE="no"; shift ;;
    --check-deps-only)  DEPS_MODE="check-only"; shift ;;
    -h|--help)
      cat <<'USAGE'
Perry setup — register the one Perry skill with Claude Code, Codex CLI, and/or OpenCode.

Usage: setup [--claude] [--codex] [--opencode] [--local] [--yes-deps|--no-deps|--check-deps-only] [--quiet]

Host selection:
  (no flag)   Auto-detect: install for whichever of claude / codex / opencode
              is in PATH. Multiple found → install all. None → fail.
  --claude    Force install for Claude Code (~/.claude/skills/).
  --codex     Force install for Codex CLI    (~/.agents/skills/).
  --opencode  Force install for OpenCode     (~/.config/opencode/skills/).
              Combine host flags to force multiple targets.

  --local     Per-project install for Claude Code (./.claude/skills/) and
              OpenCode (./.opencode/skills/). Codex remains global.

Dependency handling (Phase 0, runs before symlink phase):
  (default)            Check deps; prompt for each missing one.
  --yes-deps           Auto-install everything that can be installed
                       non-interactively (Homebrew, coreutils, Node, codex).
                       Items needing GUI / sudo / external download still
                       require user action and are flagged.
  --no-deps            Skip the dep check entirely; just do the symlink phase.
  --check-deps-only    Report dep status and exit; do not install or symlink.

  --quiet     Suppress non-error output.

What setup does:
  Phase 0 — dependency check (skippable with --no-deps):
    git, curl, bash, perl     — always required (pre-installed on Mac;
                                Xcode CLT prompts for git on first run)
    claude                    — required only if installing for Claude Code
    codex                     — required only if installing for Codex CLI
    opencode                  — required only if installing for OpenCode
    Homebrew                  — optional gate for other Mac installs
    coreutils (gtimeout)      — soft; Perry's codex preflight uses timeout
                                if available, else runs unprotected (warning)
    Node.js + npm             — required for `npm install -g @openai/codex`

  Phase 1 — symlink (per selected host):
    For each target skills directory:
      1. Symlinks perry/ → this script's source.
      2. REMOVES any legacy sibling links (okr, pmo, design) left by older
         installs. They are lanes inside /perry now, not host commands.

Re-running is safe and idempotent.
USAGE
      exit 0 ;;
    *) echo "Unknown flag: $1 (try --help)" >&2; exit 1 ;;
  esac
done

log() { [ "$QUIET" -eq 1 ] || echo "$@"; }
warn() { echo "$@" >&2; }
fail() { echo "$@" >&2; exit 1; }

# ─── OS detection ─────────────────────────────────────────────
OS="$(uname -s)"
IS_MAC=0; IS_LINUX=0
case "$OS" in
  Darwin*) IS_MAC=1 ;;
  Linux*)  IS_LINUX=1 ;;
esac

dep_present() { command -v "$1" >/dev/null 2>&1; }

# ─── TTY / agent-context detection ────────────────────────────
# When invoked by Claude Code / Codex CLI / any agent's Bash tool, stdin
# is typically NOT a TTY. Interactive Y/N prompts (`read -r`) would hang
# or return EOF, leaving the user with no idea what was skipped. Detect
# this and switch DEPS_MODE from "prompt" to a non-blocking variant
# ("auto-skip") that still runs the dep CHECK but never tries to install
# or read from stdin.
IS_INTERACTIVE=1
if [ ! -t 0 ]; then IS_INTERACTIVE=0; fi

if [ "$IS_INTERACTIVE" -eq 0 ] && [ "$DEPS_MODE" = "prompt" ]; then
  DEPS_MODE="auto-skip"   # internal: check + report, skip all installs
fi

# Tracks items skipped in auto-skip mode so we can surface a clear "next
# steps" summary at the end of Phase 0 (the agent can relay these to the
# user as TODOs).
DEPS_SKIPPED_INSTALL=()

# ─── Host selection: which hosts are we installing for? ───────
INSTALL_CLAUDE=0
INSTALL_CODEX=0
INSTALL_OPENCODE=0

if [ "$ANY_EXPLICIT" -eq 1 ]; then
  # User specified at least one host flag — honor that exact set.
  INSTALL_CLAUDE=$EXPLICIT_CLAUDE
  INSTALL_CODEX=$EXPLICIT_CODEX
  INSTALL_OPENCODE=$EXPLICIT_OPENCODE
else
  # Auto-detect from PATH
  dep_present claude && INSTALL_CLAUDE=1 || true
  dep_present codex  && INSTALL_CODEX=1  || true
  dep_present opencode && INSTALL_OPENCODE=1 || true
fi

if [ "$INSTALL_CLAUDE" -eq 0 ] && [ "$INSTALL_CODEX" -eq 0 ] && [ "$INSTALL_OPENCODE" -eq 0 ]; then
  warn ""
  warn "❌ No host detected and no --claude/--codex/--opencode flag given."
  warn ""
  warn "Perry installs as one skill for Claude Code, Codex CLI, or OpenCode."
  warn "Detection looks for the 'claude', 'codex', or 'opencode' binaries in PATH."
  warn ""
  warn "Options:"
  warn "  1. Install Claude Code from https://claude.com/download and re-run setup."
  warn "  2. Install Codex CLI: npm install -g @openai/codex  (needs Node.js)"
  warn "  3. Run with explicit flag if a host is installed but not in PATH:"
  warn "       ~/perry/setup --claude"
  warn "       ~/perry/setup --codex"
  warn "       ~/perry/setup --claude --codex"
  warn "       ~/perry/setup --opencode"
  exit 1
fi

# ─── Phase 0: dependency check ────────────────────────────────

DEPS_MISSING_REQUIRED=()
DEPS_MISSING_SOFT=()
DEPS_MISSING_OPTIONAL=()

confirm() {
  case "$DEPS_MODE" in
    yes)                     return 0 ;;
    no|check-only|auto-skip) return 1 ;;
  esac
  # Interactive prompt (TTY only — auto-skip handles non-TTY already)
  local prompt="$1"
  local reply
  printf "%s [Y/n] " "$prompt"
  read -r reply || return 1
  case "$reply" in
    y|Y|yes|YES|"") return 0 ;;
    *) return 1 ;;
  esac
}

check_deps() {
  log ""
  log "── Phase 0: dependency check ─────────────────────────────"
  log "  Installing for: $(
    [ "$INSTALL_CLAUDE" -eq 1 ] && printf "claude-code "
    [ "$INSTALL_CODEX"  -eq 1 ] && printf "codex-cli"
    [ "$INSTALL_OPENCODE" -eq 1 ] && printf " opencode"
  )"
  if [ "$IS_INTERACTIVE" -eq 0 ]; then
    log "  ℹ️  Non-interactive stdin (likely run by an agent's Bash tool)."
    log "     Mode: $DEPS_MODE — will check + report, but skip any install that would prompt for input or sudo."
    log "     To install missing deps automatically, re-run with --yes-deps (note: Homebrew install still needs sudo)."
  fi

  # --- Always required ---
  for c in bash curl perl; do
    if dep_present "$c"; then
      log "  ✅ $c          ($(command -v "$c"))"
    else
      log "  ❌ $c          (REQUIRED, missing — unexpected on macOS / common Linux)"
      DEPS_MISSING_REQUIRED+=("$c")
    fi
  done

  # --- git ---
  if dep_present git && git --version >/dev/null 2>&1; then
    log "  ✅ git         ($(command -v git))"
  else
    if [ "$IS_MAC" -eq 1 ]; then
      log "  ❌ git         (REQUIRED. macOS: install Xcode Command Line Tools)"
      log "                 → run:  xcode-select --install   (GUI prompt, ~5–10 min)"
    else
      log "  ❌ git         (REQUIRED. install via your package manager)"
    fi
    DEPS_MISSING_REQUIRED+=("git")
  fi

  # --- claude (only required if installing Claude host) ---
  if [ "$INSTALL_CLAUDE" -eq 1 ]; then
    if dep_present claude; then
      log "  ✅ claude      ($(command -v claude))"
    else
      log "  ❌ claude      (REQUIRED for Claude Code install target)"
      log "                 → install from https://claude.com/download"
      log "                 (Or drop --claude / pass --codex only if you don't use Claude Code.)"
      DEPS_MISSING_REQUIRED+=("claude")
    fi
  else
    if dep_present claude; then
      log "  ℹ️  claude      (in PATH, but install target is Codex-only — skipping Claude install)"
    fi
  fi

  # --- codex (required if installing Codex host; otherwise optional executor) ---
  if [ "$INSTALL_CODEX" -eq 1 ]; then
    if dep_present codex; then
      log "  ✅ codex       ($(command -v codex) — $(codex --version 2>/dev/null | head -1))"
    else
      log "  ❌ codex       (REQUIRED for Codex CLI install target)"
      log "                 → install: npm install -g @openai/codex   (needs Node.js)"
      DEPS_MISSING_REQUIRED+=("codex")
    fi
  else
    if dep_present codex; then
      log "  ✅ codex       ($(command -v codex) — $(codex --version 2>/dev/null | head -1)) — available as executor"
    else
      log "  ℹ️  codex       (optional — only if you use codex executor in /perry work dispatch)"
      DEPS_MISSING_OPTIONAL+=("codex")
    fi
  fi

  # --- opencode (only required if installing OpenCode host) ---
  if [ "$INSTALL_OPENCODE" -eq 1 ]; then
    if dep_present opencode; then
      log "  ✅ opencode    ($(command -v opencode))"
    else
      log "  ❌ opencode    (REQUIRED for OpenCode install target)"
      DEPS_MISSING_REQUIRED+=("opencode")
    fi
  fi

  # --- Homebrew (Mac only) ---
  if [ "$IS_MAC" -eq 1 ]; then
    if dep_present brew; then
      log "  ✅ brew        ($(command -v brew))"
    else
      log "  ⚠️  brew        (Homebrew not installed — gate for coreutils / node)"
      DEPS_MISSING_OPTIONAL+=("brew")
    fi
  fi

  # --- timeout / gtimeout (soft) ---
  if dep_present timeout || dep_present gtimeout; then
    local which_timeout
    which_timeout="$(command -v timeout 2>/dev/null || command -v gtimeout 2>/dev/null)"
    log "  ✅ timeout     ($which_timeout)"
  else
    log "  ⚠️  timeout     (soft — perry-codex-preflight degrades gracefully without it)"
    log "                 (Mac: brew install coreutils  — installs gtimeout)"
    DEPS_MISSING_SOFT+=("coreutils")
  fi

  # --- Node.js (optional, for codex install path) ---
  if dep_present node; then
    log "  ✅ node        ($(command -v node) — $(node --version 2>/dev/null))"
  else
    log "  ℹ️  node        (optional — needed only for codex install / executor)"
    DEPS_MISSING_OPTIONAL+=("node")
  fi

  log ""

  # --- Decision summary ---
  if [ ${#DEPS_MISSING_REQUIRED[@]} -gt 0 ]; then
    log "Required missing: ${DEPS_MISSING_REQUIRED[*]}"
  fi
  if [ ${#DEPS_MISSING_SOFT[@]} -gt 0 ]; then
    log "Soft missing    : ${DEPS_MISSING_SOFT[*]}  (Perry still works)"
  fi
  if [ ${#DEPS_MISSING_OPTIONAL[@]} -gt 0 ]; then
    log "Optional missing: ${DEPS_MISSING_OPTIONAL[*]}"
  fi

  if [ "$DEPS_MODE" = "check-only" ]; then
    log ""
    log "─ --check-deps-only: not installing anything; not symlinking. Exit."
    exit 0
  fi
}

# ─── Installer helpers ────────────────────────────────────────

install_homebrew() {
  [ "$IS_MAC" -eq 0 ] && return 0
  dep_present brew && return 0
  log ""
  log "📦 Homebrew installer (needs sudo password during install):"
  log "   /bin/bash -c \"\$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\""
  if confirm "  Install Homebrew now?"; then
    # NONINTERACTIVE=1 skips "press RETURN to continue" but does NOT skip
    # sudo. On a fresh Mac, the sudo prompt will still appear (interactive
    # only). When this script is invoked by an agent's Bash tool (no TTY),
    # confirm() returns 1 in auto-skip mode and we never reach this line.
    if [ "$DEPS_MODE" = "yes" ]; then
      NONINTERACTIVE=1 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
    else
      /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
    fi
    if [ -x /opt/homebrew/bin/brew ]; then
      eval "$(/opt/homebrew/bin/brew shellenv)"
    elif [ -x /usr/local/bin/brew ]; then
      eval "$(/usr/local/bin/brew shellenv)"
    fi
    if ! dep_present brew; then
      warn "  Homebrew installed but not on PATH. Re-open the terminal or re-run setup."
      return 1
    fi
  else
    log "  Skipped Homebrew install."
    DEPS_SKIPPED_INSTALL+=("Homebrew: /bin/bash -c \"\$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\"")
    return 1
  fi
}

install_coreutils() {
  dep_present timeout && return 0
  dep_present gtimeout && return 0
  if ! dep_present brew; then
    log "  (coreutils needs Homebrew — skipping; you can install later: brew install coreutils)"
    DEPS_SKIPPED_INSTALL+=("coreutils (needs Homebrew first): brew install coreutils")
    return 0
  fi
  log ""
  log "📦 coreutils (provides gtimeout):"
  if confirm "  brew install coreutils now?"; then
    brew install coreutils
  else
    DEPS_SKIPPED_INSTALL+=("coreutils: brew install coreutils")
  fi
}

install_node() {
  dep_present node && return 0
  if ! dep_present brew; then
    log "  (Node.js needs Homebrew or a separate install — skipping)"
    DEPS_SKIPPED_INSTALL+=("Node.js (needs Homebrew first): brew install node")
    return 0
  fi
  log ""
  log "📦 Node.js (needed only for codex CLI):"
  if confirm "  brew install node now?"; then
    brew install node
  else
    DEPS_SKIPPED_INSTALL+=("Node.js: brew install node")
  fi
}

install_codex_cli() {
  dep_present codex && return 0
  if ! dep_present npm; then
    log "  (codex needs npm — skipping; install Node.js first)"
    DEPS_SKIPPED_INSTALL+=("codex CLI (needs Node.js first): npm install -g @openai/codex")
    return 0
  fi
  log ""
  log "📦 codex CLI (only needed for codex executor in /perry work dispatch):"
  if confirm "  npm install -g @openai/codex now?"; then
    npm install -g @openai/codex
  else
    DEPS_SKIPPED_INSTALL+=("codex CLI: npm install -g @openai/codex")
  fi
}

# ─── Run Phase 0 ──────────────────────────────────────────────

if [ "$DEPS_MODE" != "no" ]; then
  check_deps

  if [ ${#DEPS_MISSING_REQUIRED[@]} -gt 0 ]; then
    warn ""
    warn "❌ Required dependencies missing: ${DEPS_MISSING_REQUIRED[*]}"
    for d in "${DEPS_MISSING_REQUIRED[@]}"; do
      case "$d" in
        git)
          [ "$IS_MAC" -eq 1 ] \
            && warn "   Run:  xcode-select --install   (then re-run this setup)" \
            || warn "   Install git via your distro's package manager."
          ;;
        claude)
          warn "   Download Claude Code: https://claude.com/download"
          warn "   (Or drop --claude / pass --codex only if you don't use Claude Code.)"
          ;;
        codex)
          warn "   Install codex: npm install -g @openai/codex   (needs Node.js)"
          warn "   (Or drop --codex / pass --claude only if you don't use Codex CLI.)"
          ;;
        opencode)
          warn "   Install OpenCode, or drop --opencode and select another host."
          ;;
        *)
          warn "   $d is missing — install before re-running setup."
          ;;
      esac
    done
    warn ""
    warn "Re-run setup after installing, or pass --no-deps to skip the dep check (not recommended)."
    exit 1
  fi

  # Soft + optional installs (Mac auto-installs via brew)
  if [ "$IS_MAC" -eq 1 ]; then
    install_homebrew || true
    install_coreutils || true
    # Only offer Node + codex CLI if user is installing Codex host OR explicitly
    # told us about codex via --yes-deps. Don't push it on Claude-only users.
    if [ "$INSTALL_CODEX" -eq 1 ] || [ "$DEPS_MODE" = "yes" ]; then
      install_node || true
      install_codex_cli || true
    fi
  else
    for d in "${DEPS_MISSING_SOFT[@]}" "${DEPS_MISSING_OPTIONAL[@]}"; do
      log "  (Linux: install $d via your package manager if you need it)"
    done
  fi

  # Surface any skipped install actions as a clear "next steps" block.
  # The agent calling setup can relay this to the user as TODOs.
  if [ ${#DEPS_SKIPPED_INSTALL[@]} -gt 0 ]; then
    log ""
    log "📋 Skipped installs — run these manually if you want the soft/optional deps:"
    for item in "${DEPS_SKIPPED_INSTALL[@]}"; do
      log "   • $item"
    done
    if [ "$IS_INTERACTIVE" -eq 0 ]; then
      log ""
      log "   (Setup is in auto-skip mode because stdin isn't a TTY. To auto-install"
      log "    everything possible, ask the user to re-run setup interactively, or run with --yes-deps.)"
    fi
  fi

  log ""
  log "── Phase 0 done ──────────────────────────────────────────"
fi

# ─── Phase 1: install / symlink ───────────────────────────────

install_at() {
  local host_dir="$1"
  local label="$2"
  mkdir -p "$host_dir"

  local perry_target="$host_dir/perry"

  if [ "$SETUP_DIR" = "$perry_target" ]; then
    log "  [$label] perry/ already lives at $perry_target (running from there)"
  elif [ -L "$perry_target" ]; then
    local resolved="$(cd "$perry_target" && pwd -P)"
    if [ "$resolved" = "$SOURCE_DIR" ]; then
      log "  [$label] perry/ symlink already points at $SOURCE_DIR"
    else
      warn "  [$label] perry/ symlink points at $resolved"
      warn "  [$label] this script lives at $SOURCE_DIR — leaving existing link in place."
      warn "  [$label] rm \"$perry_target\" and re-run if you want to repoint."
      return 1
    fi
  elif [ -d "$perry_target" ]; then
    warn "  [$label] perry/ exists at $perry_target (not a symlink) — leaving in place."
    warn "  [$label] Sync new content with: rsync -a --delete \"$SOURCE_DIR/\" \"$perry_target/\""
    return 1
  elif [ -e "$perry_target" ]; then
    warn "  [$label] $perry_target exists and is not a directory — refusing to touch."
    return 1
  else
    log "  [$label] linking perry/ -> $SOURCE_DIR"
    ln -snf "$SOURCE_DIR" "$perry_target"
  fi

  if [ ! -d "$perry_target" ]; then
    warn "  [$label] perry directory not found at $perry_target — aborting child link"
    return 1
  fi

  # Perry registers ONE skill: perry. The children (okr, pmo, design) are
  # lanes inside it, loaded on demand by the router — not host commands.
  #
  # They used to be symlinked as siblings so `/okr`, `/pmo` and `/design`
  # worked directly. That was withdrawn because the names are generic and the
  # host's skill namespace is shared: `design` collides with design-review,
  # design-consultation, design-html, design-shotgun and a whole `design:`
  # plugin family; `okr` collides with lark-okr. Claiming a common English
  # word in a shared namespace is the tool taking something it was not given —
  # the same rule the state root already follows. Users reached Perry through
  # `/perry` and let it route anyway, so the siblings cost a namespace and
  # bought nothing.
  return 0
}

log ""
log "── Phase 1: skill symlink ────────────────────────────────"

INSTALL_FAILURES=0

# Claude Code install
CC_DIR=""
# Legacy sibling links, swept once from every directory Perry could have
# installed into — including the --local one, which the per-host cleanup never
# reached.
#
# The list is HISTORICAL and therefore literal. Deriving it from the current
# `$PERRY_HOME/*/` would make the loop look for links named after the lanes as
# they are named TODAY, which no installer ever created, while the real
# leftovers on an upgrading machine (`~/.claude/skills/okr` and friends) became
# invisible. A cleanup routine that reads current state cannot remove what
# current state forgot. `goals work decide` are in the list not because any
# installer made them, but because a future rename would otherwise inherit the
# same blind spot — the list is the record of every name Perry has ever put in
# a host's namespace.
#
# One function, one list, called once per directory: an earlier version had a
# second copy inside install_at, byte-identical and unreachable on any
# non---local run, so its user-facing message was dead code and the two arrays
# were a silent two-copy invariant.
PERRY_LEGACY_CHILDREN=(okr pmo design goals work decide)

sweep_legacy_links() {
  local dirs=("$HOME/.claude/skills" "$HOME/.agents/skills" "$HOME/.config/opencode/skills")
  [ "$LOCAL" -eq 1 ] && dirs+=("$(pwd)/.claude/skills" "$(pwd)/.opencode/skills")
  local removed=() d name
  for d in "${dirs[@]}"; do
    [ -d "$d" ] || continue
    for name in "${PERRY_LEGACY_CHILDREN[@]}"; do
      # Only ever remove a link this installer created. Anything else at that
      # path belongs to someone else.
      if [ -L "$d/$name" ] && [ "$(readlink "$d/$name")" = "perry/$name" ]; then
        rm -f "$d/$name"
        removed+=("$d/$name")
      fi
    done
  done
  if [ ${#removed[@]} -gt 0 ]; then
    log "  removed legacy child skill links: ${removed[*]}"
    log "  these are lanes inside /perry now — use '/perry <lane> <subcommand>'"
  fi
}
sweep_legacy_links

if [ "$INSTALL_CLAUDE" -eq 1 ]; then
  if [ "$LOCAL" -eq 1 ]; then
    CC_DIR="$(pwd)/.claude/skills"
  else
    CC_DIR="$HOME/.claude/skills"
  fi
  install_at "$CC_DIR" "claude-code" || { warn "  [claude-code] install step failed; continuing with other hosts."; INSTALL_FAILURES=$((INSTALL_FAILURES + 1)); }
fi

# Codex install
CODEX_DIR=""
if [ "$INSTALL_CODEX" -eq 1 ]; then
  if [ "$LOCAL" -eq 1 ]; then
    log ""
    log "  Note: --local does not apply to Codex; its install stays global at ~/.agents/skills/"
  fi
  CODEX_DIR="$HOME/.agents/skills"
  install_at "$CODEX_DIR" "codex" || { warn "  [codex] install step failed; continuing with other hosts."; INSTALL_FAILURES=$((INSTALL_FAILURES + 1)); }

  if [ -z "${PERRY_HOME:-}" ] || [ -z "${PERRY_HOST:-}" ]; then
    log ""
    log "  [codex] Recommended shell exports (so SKILL.md \$PERRY_HOME refs are unambiguous):"
    [ -z "${PERRY_HOME:-}" ] && log "    export PERRY_HOME=\"$CODEX_DIR/perry\""    || true
    [ -z "${PERRY_HOST:-}" ] && log "    export PERRY_HOST=codex-cli"                 || true
  fi
fi

# OpenCode install
OPENCODE_DIR=""
if [ "$INSTALL_OPENCODE" -eq 1 ]; then
  if [ "$LOCAL" -eq 1 ]; then
    OPENCODE_DIR="$(pwd)/.opencode/skills"
  else
    OPENCODE_DIR="$HOME/.config/opencode/skills"
  fi
  install_at "$OPENCODE_DIR" "opencode" || { warn "  [opencode] install step failed; continuing with other hosts."; INSTALL_FAILURES=$((INSTALL_FAILURES + 1)); }
fi

# ─── Summary ──────────────────────────────────────────────────
log ""
if [ "$INSTALL_FAILURES" -gt 0 ]; then
  warn ""
  warn "Perry setup incomplete: $INSTALL_FAILURES selected host install(s) failed."
else
  log "Perry ready."
fi
log "  source       : $SOURCE_DIR"
[ "$INSTALL_CLAUDE" -eq 1 ] && log "  claude-code  : $CC_DIR"   || true
[ "$INSTALL_CODEX"  -eq 1 ] && log "  codex        : $CODEX_DIR" || true
[ "$INSTALL_OPENCODE" -eq 1 ] && log "  opencode     : $OPENCODE_DIR" || true
log "  skill        : /perry  (one entrance; goals / work / decide are lanes inside it)"
log "  lanes        : /perry goals … · /perry work … · /perry decide … · /perry diagnose"
log ""
[ "$INSTALL_CLAUDE" -eq 1 ] && log "  Claude Code: invoke /perry inside a project for the combined dashboard." || true
[ "$INSTALL_CODEX"  -eq 1 ] && log "  Codex CLI  : invoke /skills, then pick perry — or type \$perry to mention." || true
[ "$INSTALL_OPENCODE" -eq 1 ] && log "  OpenCode   : invoke the perry skill; lanes remain arguments to that one skill." || true

if [ "$INSTALL_FAILURES" -gt 0 ]; then exit 1; fi
exit 0