#!/usr/bin/env bash
# Oracle System v3 — Project Setup Script
# Usage (로컬): bash /home/llm/projects/oracle-setup/setup.sh [options]
# Usage (원격): curl -fsSL https://setup.starian.us/setup.sh | bash -s -- [options]
#
# Options:
#   --name NAME         프로젝트 이름 (기본: 현재 폴더명)
#   --env ENV           실행 환경: server|client (기본: 자동 감지)
#                       server = GCP (모든 서비스 localhost)
#                       client = 나머지 전부 (외부 도메인으로 접근)
#   --telegram CHAT_ID  텔레그램 채팅 ID
#   --taskboard URL     Taskboard URL (기본: https://db.starian.us)
#   --token TOKEN       Taskboard 토큰 (기본: 0205)
#   --bot-token TOKEN   텔레그램 봇 토큰
#   --agents ROLES      에이전트 역할 목록 (기본: builder,planner,researcher,deployer,verifier)
#                       Starian 에이전트 역할: eno,kai,pip,qua,res,craw
#
# 동작:
#   - .claude/hooks/ 완전 교체 (기존은 backup/ 보관)
#   - .claude/rules/ 완전 교체 (환경별 tools.md 설치)
#   - .claude/skills/ 완전 교체
#   - .claude/settings.json 생성 (hook 경로 자동 치환)
#   - CLAUDE.md 병합 (Oracle 표준 헤더 + 기존 내용 보존)
#   - agents/ 폴더 생성 (이미 있으면 스킵)
#   - memory/ 폴더 생성
#   - Taskboard 프로젝트 등록

set -euo pipefail

# ── 색상 ──
RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'; BLUE='\033[0;34m'; NC='\033[0m'
info()    { echo -e "${BLUE}[oracle]${NC} $1"; }
ok()      { echo -e "${GREEN}  [+]${NC} $1"; }
warn()    { echo -e "${YELLOW}  [!]${NC} $1"; }
fail()    { echo -e "${RED}  [x]${NC} $1"; }
section() { echo -e "\n${BLUE}──${NC} $1"; }

# ═══════════════════════════════════════════════
# Phase 0: 전제조건 자동 설치
# ═══════════════════════════════════════════════

detect_platform() {
  case "$(uname -s)" in
    Darwin*) PLATFORM="macos" ;;
    Linux*)
      if [ -f /data/data/com.termux/files/usr/bin/bash ] || [ -n "${TERMUX_VERSION:-}" ]; then
        PLATFORM="termux"
      elif grep -qi microsoft /proc/version 2>/dev/null; then
        PLATFORM="wsl"
      else
        PLATFORM="linux"
      fi
      ;;
    *) PLATFORM="unknown" ;;
  esac
}

# 크로스 플랫폼 md5 헬퍼
_md5() {
  if command -v md5sum &>/dev/null; then
    md5sum "$1" | cut -d' ' -f1
  elif command -v md5 &>/dev/null; then
    md5 -q "$1"
  else
    echo ""
  fi
}

# Node.js 버전이 18 이상인지 확인
_node_version_ok() {
  if ! command -v node &>/dev/null; then
    return 1
  fi
  local ver
  ver="$(node -v 2>/dev/null | sed 's/^v//' | cut -d. -f1)"
  [ -n "$ver" ] && [ "$ver" -ge 18 ] 2>/dev/null
}

ensure_package_manager() {
  case "$PLATFORM" in
    macos)
      # Xcode Command Line Tools
      if ! xcode-select -p &>/dev/null; then
        info "Xcode Command Line Tools 설치 중..."
        xcode-select --install 2>/dev/null || true
        # headless 환경에서는 수동 설치 안내
        if ! xcode-select -p &>/dev/null; then
          warn "Xcode CLT를 수동으로 설치한 후 다시 실행하세요:"
          warn "  xcode-select --install"
          warn "또는 전체 Xcode를 App Store에서 설치하세요."
          exit 1
        fi
        ok "Xcode Command Line Tools"
      else
        ok "Xcode Command Line Tools (이미 설치됨)"
      fi
      # Homebrew
      if ! command -v brew &>/dev/null; then
        info "Homebrew 설치 중..."
        /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" </dev/null
        # Apple Silicon에서 brew PATH 추가
        if [ -f /opt/homebrew/bin/brew ]; then
          eval "$(/opt/homebrew/bin/brew shellenv)"
        elif [ -f /usr/local/bin/brew ]; then
          eval "$(/usr/local/bin/brew shellenv)"
        fi
        if ! command -v brew &>/dev/null; then
          fail "Homebrew 설치 실패. 수동 설치: https://brew.sh"
          exit 1
        fi
        ok "Homebrew 설치 완료"
      else
        ok "Homebrew (이미 설치됨)"
      fi
      ;;
    linux|wsl)
      if command -v apt-get &>/dev/null; then
        ok "apt-get 사용 가능"
      elif command -v yum &>/dev/null; then
        ok "yum 사용 가능"
      elif command -v dnf &>/dev/null; then
        ok "dnf 사용 가능"
      else
        warn "지원되는 패키지 매니저를 찾을 수 없습니다 (apt/yum/dnf)"
      fi
      ;;
    termux)
      if ! command -v pkg &>/dev/null; then
        fail "Termux pkg를 찾을 수 없습니다"
        exit 1
      fi
      ok "Termux pkg 사용 가능"

      # Termux 초기 설정 (완전 새 기기 지원)
      info "Termux 기본 패키지 업데이트 중..."
      pkg update -y 2>/dev/null && pkg upgrade -y 2>/dev/null
      ok "Termux 패키지 업데이트 완료"

      # 저장소 접근 권한 설정
      if [ ! -d "$HOME/storage" ]; then
        info "저장소 접근 권한 설정 중..."
        termux-setup-storage 2>/dev/null || true
        warn "저장소 접근 권한 팝업이 나타나면 '허용'을 누르세요"
      else
        ok "저장소 접근 권한 (이미 설정됨)"
      fi

      # 기본 도구 일괄 설치
      info "기본 도구 설치 중 (curl, git, openssh, nodejs)..."
      pkg install -y curl git openssh nodejs 2>/dev/null
      ok "Termux 기본 도구 설치 완료"

      # passwd 설정 안내
      info "SSH 접속을 위해 비밀번호를 설정하세요:"
      info "  passwd"
      info "SSH 서버 시작: sshd (포트 8022)"
      ;;
  esac
}

ensure_curl() {
  if command -v curl &>/dev/null; then
    ok "curl (이미 설치됨)"
    return 0
  fi
  info "curl 설치 중..."
  case "$PLATFORM" in
    macos)    brew install curl ;;
    linux|wsl)
      if command -v apt-get &>/dev/null; then sudo apt-get update -qq && sudo apt-get install -y -qq curl
      elif command -v yum &>/dev/null; then sudo yum install -y curl
      elif command -v dnf &>/dev/null; then sudo dnf install -y curl
      fi ;;
    termux)   pkg install -y curl ;;
  esac
  command -v curl &>/dev/null && ok "curl 설치 완료" || { fail "curl 설치 실패"; exit 1; }
}

ensure_git() {
  if command -v git &>/dev/null; then
    ok "git (이미 설치됨)"
    return 0
  fi
  info "git 설치 중..."
  case "$PLATFORM" in
    macos)    brew install git ;;
    linux|wsl)
      if command -v apt-get &>/dev/null; then sudo apt-get update -qq && sudo apt-get install -y -qq git
      elif command -v yum &>/dev/null; then sudo yum install -y git
      elif command -v dnf &>/dev/null; then sudo dnf install -y git
      fi ;;
    termux)   pkg install -y git ;;
  esac
  command -v git &>/dev/null && ok "git 설치 완료" || { fail "git 설치 실패"; exit 1; }
}

ensure_nodejs() {
  if _node_version_ok; then
    ok "Node.js $(node -v) (이미 설치됨)"
    return 0
  fi
  # 기존 Node가 있지만 버전이 낮은 경우
  if command -v node &>/dev/null; then
    warn "Node.js $(node -v) 감지됨 — v18+ 필요. 업그레이드합니다..."
  else
    info "Node.js 설치 중..."
  fi
  case "$PLATFORM" in
    macos)
      MACOS_VER=$(sw_vers -productVersion 2>/dev/null | cut -d. -f1)
      if [ -n "$MACOS_VER" ] && [ "$MACOS_VER" -ge 13 ] 2>/dev/null; then
        # macOS 13+ → Node 22
        brew install node@22 2>/dev/null || brew install node
        brew link --overwrite node@22 2>/dev/null || brew link --overwrite node 2>/dev/null || true
      else
        # macOS 12 이하 (Big Sur 등) — 호환 안 되는 Node 제거 후 fallback 체인
        info "macOS ${MACOS_VER:-unknown} 감지 — 호환 Node.js 설치 시도"
        # 기존 호환 안 되는 Node 제거
        if command -v node &>/dev/null; then
          NODE_CUR=$(node -v 2>/dev/null | sed 's/^v//' | cut -d. -f1)
          if [ -n "$NODE_CUR" ] && [ "$NODE_CUR" -gt 18 ] 2>/dev/null; then
            warn "Node.js v${NODE_CUR}은 macOS ${MACOS_VER}에서 호환 안 됨 — 제거합니다"
            brew uninstall "node@${NODE_CUR}" 2>/dev/null
            brew uninstall node 2>/dev/null
          fi
        fi
        if brew install node@18 2>/dev/null && brew link --overwrite node@18 2>/dev/null; then
          ok "Node.js 18 설치 성공"
        elif brew install node@16 2>/dev/null && brew link --overwrite node@16 2>/dev/null; then
          ok "Node.js 16 설치 성공"
        else
          # brew 실패 시 nvm으로 시도
          info "Homebrew Node 설치 실패 — nvm으로 시도합니다"
          if ! command -v nvm &>/dev/null; then
            curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash 2>/dev/null
            export NVM_DIR="$HOME/.nvm"
            [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
          fi
          if command -v nvm &>/dev/null; then
            nvm install 18 2>/dev/null || nvm install 16 2>/dev/null
            nvm use --lts 2>/dev/null
          else
            fail "Node.js 설치 실패. 수동 설치: https://nodejs.org/en/download/"
            fail "macOS ${MACOS_VER:-}에서는 Node.js 16 또는 18 LTS를 설치하세요"
            exit 1
          fi
        fi
      fi
      ;;
    linux|wsl)
      # NodeSource 22.x LTS
      if command -v apt-get &>/dev/null; then
        if [ ! -f /etc/apt/sources.list.d/nodesource.list ] && [ ! -f /etc/apt/keyrings/nodesource.gpg ]; then
          curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - 2>/dev/null
        fi
        sudo apt-get install -y -qq nodejs
      elif command -v yum &>/dev/null || command -v dnf &>/dev/null; then
        curl -fsSL https://rpm.nodesource.com/setup_22.x | sudo -E bash - 2>/dev/null
        if command -v dnf &>/dev/null; then sudo dnf install -y nodejs
        else sudo yum install -y nodejs; fi
      fi
      ;;
    termux)
      pkg install -y nodejs ;;
  esac
  if _node_version_ok; then
    ok "Node.js $(node -v) 설치 완료"
  else
    fail "Node.js 18+ 설치 실패. 수동 설치: https://nodejs.org"
    exit 1
  fi
}

ensure_claude() {
  # 바이너리 존재 + 실제 실행 가능 여부 확인
  if command -v claude &>/dev/null && claude --version &>/dev/null; then
    ok "Claude Code CLI $(claude --version 2>/dev/null) (이미 설치됨)"
    return 0
  fi

  # macOS 13 미만 (Big Sur 등) → Docker 방식으로 전환
  local MACOS_VER
  MACOS_VER=$(sw_vers -productVersion 2>/dev/null | cut -d. -f1)
  if [ "$PLATFORM" = "macos" ] && [ -n "$MACOS_VER" ] && [ "$MACOS_VER" -lt 13 ] 2>/dev/null; then
    warn "macOS ${MACOS_VER}은 Claude Code를 직접 실행할 수 없습니다 (macOS 13+ 필요)"
    info "Docker 방식으로 설치합니다..."

    # Docker 런타임 확인/설치 (Colima — Big Sur 호환)
    if ! command -v docker &>/dev/null; then
      info "Docker CLI + Colima 설치 중 (Big Sur 호환 경량 런타임)..."
      brew install docker colima 2>/dev/null
      if ! command -v docker &>/dev/null; then
        fail "Docker 설치 실패. 수동 설치: brew install docker colima"
        exit 1
      fi
    fi
    # Colima 확인/설치
    if ! command -v colima &>/dev/null; then
      brew install colima 2>/dev/null
    fi

    # Docker 데몬 실행 확인 (Colima)
    if ! docker info &>/dev/null 2>&1; then
      info "Colima 시작 중..."
      colima start --cpu 2 --memory 4 2>/dev/null
      if ! docker info &>/dev/null 2>&1; then
        fail "Docker 런타임 시작 실패. 수동 실행: colima start"
        exit 1
      fi
    fi
    ok "Docker 런타임 실행 확인 (Colima)"

    # Claude Code Docker 이미지 빌드
    local CLAUDE_DOCKER_DIR="$HOME/.starian/claude-docker"
    mkdir -p "$CLAUDE_DOCKER_DIR"

    cat > "$CLAUDE_DOCKER_DIR/Dockerfile" << 'DOCKERFILE'
FROM node:18-slim
RUN npm install -g @anthropic-ai/claude-code && \
    apt-get update && apt-get install -y git curl ssh && \
    apt-get clean && rm -rf /var/lib/apt/lists/*
WORKDIR /workspace
ENTRYPOINT ["claude"]
DOCKERFILE

    info "Claude Code Docker 이미지 빌드 중..."
    if ! docker build -t claude-code "$CLAUDE_DOCKER_DIR"; then
      fail "Docker 이미지 빌드 실패"
      exit 1
    fi
    ok "Claude Code Docker 이미지 빌드 완료"

    # claude 래퍼 스크립트 생성 — 맥 루트를 /host에, 홈을 /workspace에 마운트
    local CLAUDE_WRAPPER="$HOME/.local/bin/claude"
    mkdir -p "$HOME/.local/bin"
    cat > "$CLAUDE_WRAPPER" << 'WRAPPER'
#!/bin/bash
# Claude Code Docker Wrapper (macOS < 13 호환)
# /workspace = 맥 홈, /host = 맥 루트(전체 파일시스템)

WORK_SUBDIR=$(pwd | sed "s|^$HOME||")
docker run --rm -it \
  -v "$HOME:/workspace" \
  -v "/:/host:ro" \
  -v "$HOME/.claude:/root/.claude" \
  -v "$HOME/.anthropic:/root/.anthropic" \
  -e ANTHROPIC_API_KEY="${ANTHROPIC_API_KEY:-}" \
  -e HOME=/root \
  -w "/workspace${WORK_SUBDIR}" \
  claude-code "$@"
WRAPPER
    chmod +x "$CLAUDE_WRAPPER"

    # PATH에 ~/.local/bin 추가
    if ! echo "$PATH" | grep -q "$HOME/.local/bin"; then
      export PATH="$HOME/.local/bin:$PATH"
      local SHELL_RC="$HOME/.zshrc"
      [ ! -f "$SHELL_RC" ] && SHELL_RC="$HOME/.bash_profile"
      if ! grep -q '.local/bin' "$SHELL_RC" 2>/dev/null; then
        echo 'export PATH="$HOME/.local/bin:$PATH"' >> "$SHELL_RC"
      fi
    fi

    ok "Claude Code Docker 래퍼 설치: $CLAUDE_WRAPPER"
    info "컨테이너 내 맥 파일 접근: /host/ (루트, 읽기전용) | /workspace (홈, 읽기쓰기)"
    return 0
  fi

  # 호환 안 되는 기존 바이너리 정리
  if command -v claude &>/dev/null; then
    warn "기존 Claude Code가 실행 불가 — 재설치합니다"
    CLAUDE_PATH=$(command -v claude)
    CLAUDE_DIR=$(dirname "$CLAUDE_PATH")
    rm -f "$CLAUDE_PATH" 2>/dev/null
    # npm 글로벌 모듈도 정리
    npm uninstall -g @anthropic-ai/claude-code 2>/dev/null
    rm -rf "${CLAUDE_DIR}/../lib/node_modules/@anthropic-ai" 2>/dev/null
    hash -r 2>/dev/null
  fi
  info "Claude Code CLI 설치 중..."
  npm install -g @anthropic-ai/claude-code 2>/dev/null
  hash -r 2>/dev/null
  if command -v claude &>/dev/null && claude --version &>/dev/null; then
    ok "Claude Code CLI $(claude --version 2>/dev/null) 설치 완료"
  else
    warn "Claude Code CLI 설치 실패 — 수동 설치: npm install -g @anthropic-ai/claude-code"
  fi
}

ensure_tailscale() {
  if command -v tailscale &>/dev/null; then
    ok "Tailscale (이미 설치됨)"
  else
    info "Tailscale 설치 중..."
    case "$PLATFORM" in
      macos)    brew install --cask tailscale 2>/dev/null ;;
      linux|wsl) curl -fsSL https://tailscale.com/install.sh | sh 2>/dev/null ;;
      termux)
        warn "Termux에서 Tailscale CLI 직접 설치는 불가합니다"
        info "Google Play Store에서 'Tailscale' 앱을 설치하세요"
        info "  https://play.google.com/store/apps/details?id=com.tailscale.ipn"
        return 0
        ;;
    esac
    if command -v tailscale &>/dev/null; then
      ok "Tailscale 설치 완료"
    else
      warn "Tailscale 설치 실패 — 수동 설치: https://tailscale.com/download"
      return 0
    fi
  fi

  # Tailscale 상태 확인
  if tailscale status &>/dev/null 2>&1; then
    local ts_ip
    ts_ip="$(tailscale ip -4 2>/dev/null || echo 'IP 확인 불가')"
    ok "Tailscale 연결됨 ($ts_ip)"
  else
    info "Tailscale 로그인이 필요합니다"
    if [ "$PLATFORM" = "macos" ]; then
      if open -a Tailscale 2>/dev/null; then
        info "Tailscale 앱이 열렸습니다."
        info "시스템 트레이(메뉴 바)에서 Tailscale 아이콘을 클릭하여 로그인하세요."
        # Big Sur 이하에서 kernel extension 경고가 나올 수 있음
        local MACOS_VER_TS
        MACOS_VER_TS=$(sw_vers -productVersion 2>/dev/null | cut -d. -f1)
        if [ -n "$MACOS_VER_TS" ] && [ "$MACOS_VER_TS" -le 11 ] 2>/dev/null; then
          warn "macOS Big Sur 이하에서는 kernel extension 허용이 필요할 수 있습니다."
          warn "  시스템 환경설정 > 보안 및 개인 정보 > 일반 > '허용' 클릭"
        fi
      else
        warn "Tailscale 앱을 열 수 없습니다. 수동으로 실행하세요."
      fi
    else
      if ! sudo tailscale up 2>/dev/null && ! tailscale up 2>/dev/null; then
        warn "tailscale up 실행 실패"
        info "브라우저에서 https://login.tailscale.com/ 에 접속하여 로그인하세요."
      fi
    fi
    warn "Tailscale 로그인 후 다시 이 스크립트를 실행하세요"
  fi
}

ensure_ssh_server() {
  case "$PLATFORM" in
    macos)
      if systemsetup -getremotelogin 2>/dev/null | grep -q "On"; then
        ok "SSH 서버 활성화됨 (원격 로그인)"
      else
        warn "SSH 서버가 비활성화되어 있습니다"
        info "활성화 시도 중..."
        if sudo systemsetup -setremotelogin on 2>/dev/null; then
          ok "SSH 서버 활성화 완료"
        else
          warn "수동으로 활성화하세요: 시스템 환경설정 > 공유 > 원격 로그인"
        fi
      fi
      ;;
    linux|wsl)
      if systemctl is-active sshd &>/dev/null || systemctl is-active ssh &>/dev/null; then
        ok "SSH 서버 실행 중"
      else
        info "SSH 서버 시작 중..."
        if sudo systemctl enable --now sshd 2>/dev/null || sudo systemctl enable --now ssh 2>/dev/null; then
          ok "SSH 서버 시작 완료"
        else
          # sshd가 설치되어 있지 않을 수 있음
          if ! command -v sshd &>/dev/null; then
            info "OpenSSH Server 설치 중..."
            if command -v apt-get &>/dev/null; then
              sudo apt-get update -qq && sudo apt-get install -y -qq openssh-server
            elif command -v yum &>/dev/null; then
              sudo yum install -y openssh-server
            elif command -v dnf &>/dev/null; then
              sudo dnf install -y openssh-server
            fi
            sudo systemctl enable --now sshd 2>/dev/null || sudo systemctl enable --now ssh 2>/dev/null
            ok "SSH 서버 설치 및 시작 완료"
          else
            warn "SSH 서버 시작 실패"
          fi
        fi
      fi
      ;;
    termux)
      # Termux는 sshd를 직접 실행
      if command -v sshd &>/dev/null; then
        ok "sshd 사용 가능 (Termux)"
        info "Termux SSH 시작: sshd (포트 8022)"
      else
        info "openssh 설치 중..."
        pkg install -y openssh 2>/dev/null
        ok "openssh 설치 완료 (sshd 포트 8022)"
      fi
      ;;
  esac
}

install_prerequisites() {
  detect_platform
  section "Phase 0: 전제조건 확인 ($PLATFORM)"

  # 1. Package manager
  ensure_package_manager

  # 2. curl (원격 설치에 필요)
  ensure_curl

  # 3. Git
  ensure_git

  # 4. Node.js (18+)
  ensure_nodejs

  # 5. Claude Code CLI
  ensure_claude

  # 6. Tailscale (VPN 메시 네트워크)
  ensure_tailscale

  # 7. SSH 서버 (원격 접근)
  ensure_ssh_server

  ok "전제조건 설치 완료"
}

# Phase 0 실행
install_prerequisites

# ── 설정 ──
TASKBOARD_URL="${TASKBOARD_URL:-https://db.starian.us}"
TASKBOARD_TOKEN="${TASKBOARD_TOKEN:-0205}"
TELEGRAM_BOT_TOKEN="${TELEGRAM_BOT_TOKEN:-}"
TELEGRAM_CHAT_ID="${TELEGRAM_CHAT_ID:-6565914284}"
DEFAULT_AGENTS="builder,planner,researcher,deployer,verifier"
ENV_TYPE=""  # server|client (비어 있으면 자동 감지)

# ── 소스 경로 (로컬 설치 vs 원격 설치) ──
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" 2>/dev/null && pwd || echo "")"
if [ -n "$SCRIPT_DIR" ] && [ -d "$SCRIPT_DIR/hooks" ]; then
  # 로컬 설치 (oracle-setup 폴더에서 직접 실행)
  SOURCE_DIR="$SCRIPT_DIR"
  INSTALL_MODE="local"
else
  # 원격 설치 (curl | bash)
  SOURCE_DIR=""
  INSTALL_MODE="remote"
fi

SETUP_BASE="https://setup.starian.us"

# ── 인자 파싱 ──
PROJECT_NAME=""
AGENT_ROLES="$DEFAULT_AGENTS"

while [[ $# -gt 0 ]]; do
  case $1 in
    --name)       PROJECT_NAME="$2"; shift 2 ;;
    --env)        ENV_TYPE="$2"; shift 2 ;;
    --telegram)   TELEGRAM_CHAT_ID="$2"; shift 2 ;;
    --taskboard)  TASKBOARD_URL="$2"; shift 2 ;;
    --token)      TASKBOARD_TOKEN="$2"; shift 2 ;;
    --bot-token)  TELEGRAM_BOT_TOKEN="$2"; shift 2 ;;
    --agents)     AGENT_ROLES="$2"; shift 2 ;;
    *) shift ;;
  esac
done

# ── 환경 자동 감지 (--env 미지정 시) ──
if [ -z "$ENV_TYPE" ]; then
  if [[ "$(hostname)" == "server-main" ]] || [ -d "/home/llm/starian" ]; then
    ENV_TYPE="server"
  else
    ENV_TYPE="client"
  fi
fi

# 환경 유효성 검증
case "$ENV_TYPE" in
  server|client) ;;
  # 하위 호환: 구버전 환경명 자동 변환
  gcp) warn "--env gcp는 더 이상 사용되지 않습니다. server로 변환합니다."; ENV_TYPE="server" ;;
  mac) warn "--env $ENV_TYPE는 더 이상 사용되지 않습니다. client로 변환합니다."; ENV_TYPE="client" ;;
  *) warn "알 수 없는 환경: $ENV_TYPE — client로 설정합니다"; ENV_TYPE="client" ;;
esac

# ── 프로젝트 감지 ──
PROJECT_DIR="$(pwd)"
if [ -z "$PROJECT_NAME" ]; then
  PROJECT_NAME="$(basename "$PROJECT_DIR")"
fi

HOOKS_DIR="${PROJECT_DIR}/.claude/hooks"
RULES_DIR="${PROJECT_DIR}/.claude/rules"
SKILLS_DIR="${PROJECT_DIR}/.claude/skills"

# ── 헤더 출력 ──
echo ""
echo "  Oracle System v3 — Project Setup"
echo "  ================================="
echo ""
info "Project:    $PROJECT_NAME"
info "Directory:  $PROJECT_DIR"
info "Mode:       $INSTALL_MODE"
info "Env:        $ENV_TYPE"
info "Taskboard:  $TASKBOARD_URL"
info "Telegram:   chat=$TELEGRAM_CHAT_ID"
info "Agents:     $AGENT_ROLES"
echo ""

# ═══════════════════════════════════════════════
# Step 1: 기존 .claude/ 백업
# ═══════════════════════════════════════════════
section "Step 1: 기존 .claude/ 백업"

if [ -d ".claude" ]; then
  BACKUP_STAMP="$(date +%Y%m%d-%H%M%S)"
  BACKUP_DIR="backup/claude-backup-${BACKUP_STAMP}"
  mkdir -p "$BACKUP_DIR"
  cp -r .claude/. "$BACKUP_DIR/" 2>/dev/null || true
  ok "백업 완료: $BACKUP_DIR"
else
  ok "기존 .claude/ 없음, 백업 생략"
fi

# ── 기본 디렉토리 생성 ──
mkdir -p .claude/hooks/lib
mkdir -p .claude/hooks/memory/lib
mkdir -p .claude/hooks/trigger
mkdir -p .claude/hooks/directives
mkdir -p .claude/rules
mkdir -p .claude/skills
mkdir -p memory

# ═══════════════════════════════════════════════
# Step 2: hooks 설치 + 경로 치환
# ═══════════════════════════════════════════════
section "Step 2: hooks 설치"

# install_hook: 소스 파일을 대상에 설치하고 절대 경로 치환
install_hook() {
  local src="$1"   # 소스 파일 경로
  local dest="$2"  # 대상 파일 경로

  if [ ! -f "$src" ]; then
    warn "소스 없음: $src"
    return 0
  fi

  # 파일 복사 후 경로 치환
  # starian, wgolf 등의 하드코딩 경로를 대상 프로젝트 경로로 치환
  sed \
    -e "s|/home/llm/starian/logs/tasks|${PROJECT_DIR}/logs/tasks|g" \
    -e "s|/home/llm/starian/.claude/hooks/agent-matcher.json|${HOOKS_DIR}/agent-matcher.json|g" \
    -e "s|/home/llm/starian/scripts/dispatch-worker.mjs|${PROJECT_DIR}/scripts/dispatch-worker.mjs|g" \
    -e "s|'/home/llm/starian/deploy/claude-config'|'${PROJECT_DIR}'|g" \
    -e "s|\"/home/llm/starian/deploy/claude-config\"|\"${PROJECT_DIR}\"|g" \
    -e "s|'/home/llm/starian'|'${PROJECT_DIR}'|g" \
    -e "s|\"/home/llm/starian\"|\"${PROJECT_DIR}\"|g" \
    "$src" > "$dest"

  ok "$(basename "$dest")"
}

if [ "$INSTALL_MODE" = "local" ]; then
  # 로컬 설치: SOURCE_DIR에서 복사
  SRC_HOOKS="$SOURCE_DIR/hooks"

  # 최상위 .mjs 파일
  for f in "$SRC_HOOKS"/*.mjs; do
    [ -f "$f" ] || continue
    install_hook "$f" ".claude/hooks/$(basename "$f")"
  done

  # lib/
  for f in "$SRC_HOOKS/lib"/*.mjs; do
    [ -f "$f" ] || continue
    install_hook "$f" ".claude/hooks/lib/$(basename "$f")"
  done

  # memory/*.mjs
  for f in "$SRC_HOOKS/memory"/*.mjs; do
    [ -f "$f" ] || continue
    install_hook "$f" ".claude/hooks/memory/$(basename "$f")"
  done

  # memory/lib/
  if [ -d "$SRC_HOOKS/memory/lib" ]; then
    mkdir -p .claude/hooks/memory/lib
    for f in "$SRC_HOOKS/memory/lib"/*.mjs; do
      [ -f "$f" ] || continue
      install_hook "$f" ".claude/hooks/memory/lib/$(basename "$f")"
    done
  fi

  # memory/package.json (node_modules 의존성)
  if [ -f "$SRC_HOOKS/memory/package.json" ]; then
    cp "$SRC_HOOKS/memory/package.json" ".claude/hooks/memory/package.json"
    ok "memory/package.json"
  fi

  # trigger/
  for f in "$SRC_HOOKS/trigger"/*.mjs; do
    [ -f "$f" ] || continue
    install_hook "$f" ".claude/hooks/trigger/$(basename "$f")"
  done

  # directives/
  for f in "$SRC_HOOKS/directives"/*.mjs; do
    [ -f "$f" ] || continue
    install_hook "$f" ".claude/hooks/directives/$(basename "$f")"
  done

else
  # 원격 설치: URL에서 다운로드
  HOOK_FILES=(
    "analyze-prompt.mjs"
    "auto-verify.mjs"
    "auto-version.mjs"
    "dispatcher.mjs"
    "enforce-dispatch.mjs"
    "generate-stop-prompt.mjs"
    "log-hook-event.mjs"
    "record-instruction.mjs"
    "subagent-reminder.mjs"
    "teammate-idle.mjs"
    "telegram-forward.mjs"
    "track-task.mjs"
    "validate-workflow.mjs"
  )

  for fname in "${HOOK_FILES[@]}"; do
    TMP="/tmp/oracle-hook-$fname"
    if curl -fsSL --connect-timeout 5 --max-time 15 "${SETUP_BASE}/hooks/${fname}" -o "$TMP" 2>/dev/null; then
      install_hook "$TMP" ".claude/hooks/$fname"
      rm -f "$TMP"
    else
      fail "$fname 다운로드 실패"
    fi
  done

  # lib/log-event.mjs
  TMP="/tmp/oracle-hook-log-event.mjs"
  curl -fsSL "${SETUP_BASE}/hooks/lib/log-event.mjs" -o "$TMP" 2>/dev/null && install_hook "$TMP" ".claude/hooks/lib/log-event.mjs" && rm -f "$TMP" || fail "lib/log-event.mjs 다운로드 실패"

  # memory/*.mjs
  MEMORY_FILES=("capture-insight.mjs" "capture-subagent.mjs" "checkpoint.mjs" "compact.mjs" "parse-jsonl.mjs" "promote.mjs" "record-response.mjs" "reindex.mjs" "save.mjs" "search.mjs" "session-restore.mjs" "status.mjs")
  for fname in "${MEMORY_FILES[@]}"; do
    TMP="/tmp/oracle-hook-mem-$fname"
    curl -fsSL "${SETUP_BASE}/hooks/memory/${fname}" -o "$TMP" 2>/dev/null && install_hook "$TMP" ".claude/hooks/memory/$fname" && rm -f "$TMP" || warn "memory/$fname 다운로드 실패"
  done

  # trigger/, directives/
  for fname in "notify.mjs" "session-end.mjs" "wo-inject.mjs"; do
    TMP="/tmp/oracle-hook-trg-$fname"
    curl -fsSL "${SETUP_BASE}/hooks/trigger/${fname}" -o "$TMP" 2>/dev/null && install_hook "$TMP" ".claude/hooks/trigger/$fname" && rm -f "$TMP" || warn "trigger/$fname 다운로드 실패"
  done

  TMP="/tmp/oracle-hook-dir-bootstrap.mjs"
  curl -fsSL "${SETUP_BASE}/hooks/directives/bootstrap.mjs" -o "$TMP" 2>/dev/null && install_hook "$TMP" ".claude/hooks/directives/bootstrap.mjs" && rm -f "$TMP" || warn "directives/bootstrap.mjs 다운로드 실패"
fi

# agent-matcher.json 생성 (기본 빈 구조)
if [ ! -f ".claude/hooks/agent-matcher.json" ]; then
  cat > .claude/hooks/agent-matcher.json << 'MATCHEREOF'
{
  "intent_map": {
    "BUILD":    { "agent": "Builder", "path": "agents/builder", "emoji": "🏗️" },
    "FIX":      { "agent": "Builder", "path": "agents/builder", "emoji": "🔧" },
    "ANALYZE":  { "agent": "Researcher", "path": "agents/researcher", "emoji": "🔍" },
    "RESEARCH": { "agent": "Researcher", "path": "agents/researcher", "emoji": "📚" },
    "PLAN":     { "agent": "Planner", "path": "agents/planner", "emoji": "📋" },
    "DEPLOY":   { "agent": "Deployer", "path": "agents/deployer", "emoji": "🚀" },
    "VERIFY":   { "agent": "Verifier", "path": "agents/verifier", "emoji": "✅" },
    "DOCUMENT": { "agent": "Researcher", "path": "agents/researcher", "emoji": "📝" }
  },
  "keyword_map": []
}
MATCHEREOF
  ok "agent-matcher.json (기본 생성)"
fi

# ═══════════════════════════════════════════════
# Step 3: rules 설치
# ═══════════════════════════════════════════════
section "Step 3: rules 설치"

install_rule() {
  local src="$1"
  local dest="$2"

  if [ ! -f "$src" ]; then
    warn "소스 없음: $src"
    return 0
  fi

  # tools.md: starian 전용 서비스 정보를 범용적으로 정리
  # PROJECT_DIR만 치환하고 나머지는 그대로 보존 (환경 정보는 범용적으로 유지)
  sed \
    -e "s|/home/llm/starian|${PROJECT_DIR}|g" \
    "$src" > "$dest"

  ok "rules/$(basename "$dest")"
}

if [ "$INSTALL_MODE" = "local" ]; then
  SRC_RULES="$SOURCE_DIR/rules"
  for f in "$SRC_RULES"/*.md; do
    [ -f "$f" ] || continue
    install_rule "$f" ".claude/rules/$(basename "$f")"
  done
else
  for fname in "identity.md" "oracle.md" "agents.md" "tools.md"; do
    TMP="/tmp/oracle-rule-$fname"
    if curl -fsSL "${SETUP_BASE}/rules/${fname}" -o "$TMP" 2>/dev/null; then
      install_rule "$TMP" ".claude/rules/$fname"
      rm -f "$TMP"
    else
      fail "rules/$fname 다운로드 실패"
    fi
  done
fi

# 환경별 tools.md 설치 (tools-server.md 또는 tools-client.md → .claude/rules/tools.md 덮어쓰기)
if [ "$INSTALL_MODE" = "local" ]; then
  TOOLS_TEMPLATE_FILE="$SOURCE_DIR/templates/tools-${ENV_TYPE}.md"
  if [ -f "$TOOLS_TEMPLATE_FILE" ]; then
    install_rule "$TOOLS_TEMPLATE_FILE" ".claude/rules/tools.md"
    ok "tools.md — 환경별 버전 설치 (env=$ENV_TYPE)"
  else
    warn "templates/tools-${ENV_TYPE}.md 없음 — 기본 tools.md 유지"
  fi
else
  TMP="/tmp/oracle-tools-env.md"
  if curl -fsSL "${SETUP_BASE}/templates/tools-${ENV_TYPE}.md" -o "$TMP" 2>/dev/null; then
    install_rule "$TMP" ".claude/rules/tools.md"
    rm -f "$TMP"
    ok "tools.md — 환경별 버전 설치 (env=$ENV_TYPE)"
  else
    warn "tools-${ENV_TYPE}.md 다운로드 실패 — 기본 tools.md 유지"
  fi
fi

# ═══════════════════════════════════════════════
# Step 4: skills 설치
# ═══════════════════════════════════════════════
section "Step 4: skills 설치"

if [ "$INSTALL_MODE" = "local" ]; then
  SRC_SKILLS="$SOURCE_DIR/skills"
  for f in "$SRC_SKILLS"/*.md; do
    [ -f "$f" ] || continue
    cp "$f" ".claude/skills/$(basename "$f")"
    ok "skills/$(basename "$f")"
  done
else
  SKILL_FILES=("harness-evaluate.md" "harness-engineer.md" "dev-loop.md" "agent-picker.md" "recall.md")
  for fname in "${SKILL_FILES[@]}"; do
    if curl -fsSL "${SETUP_BASE}/skills/${fname}" -o ".claude/skills/${fname}" 2>/dev/null; then
      ok "skills/$fname"
    else
      fail "skills/$fname 다운로드 실패"
    fi
  done
fi

# ═══════════════════════════════════════════════
# Step 5: settings.json 생성
# ═══════════════════════════════════════════════
section "Step 5: settings.json 생성"

if [ "$INSTALL_MODE" = "local" ] && [ -f "$SOURCE_DIR/templates/settings.json" ]; then
  # 템플릿에서 __HOOKS_DIR__ 플레이스홀더 치환
  sed "s|__HOOKS_DIR__|${HOOKS_DIR}|g" "$SOURCE_DIR/templates/settings.json" > .claude/settings.json
else
  # 인라인 settings.json 생성
  cat > .claude/settings.json << SETTINGSEOF
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  },
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/analyze-prompt.mjs", "timeout": 5 },
          { "type": "command", "command": "node ${HOOKS_DIR}/memory/search.mjs", "timeout": 10 },
          { "type": "command", "command": "node ${HOOKS_DIR}/record-instruction.mjs", "timeout": 8 },
          { "type": "command", "command": "node ${HOOKS_DIR}/memory/checkpoint.mjs", "timeout": 8, "async": true }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          { "type": "prompt", "prompt": "매 응답의 마지막 줄에 반드시 다음 형식으로 핵심 키워드를 포함하세요: [KEYWORDS: keyword1, keyword2, keyword3]. 고유명사, 기술용어, 주제어 위주로 3~7개. 이 줄은 사용자에게 보이지 않으며 시스템이 자동 처리합니다." },
          { "type": "command", "command": "node ${HOOKS_DIR}/memory/save.mjs", "timeout": 60, "async": true },
          { "type": "command", "command": "node ${HOOKS_DIR}/memory/capture-insight.mjs", "timeout": 30, "async": true },
          { "type": "command", "command": "node ${HOOKS_DIR}/telegram-forward.mjs", "timeout": 15, "async": true },
          { "type": "command", "command": "node ${HOOKS_DIR}/memory/record-response.mjs", "timeout": 5, "async": true },
          { "type": "command", "command": "node ${HOOKS_DIR}/generate-stop-prompt.mjs", "timeout": 3 }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Write|Edit|Bash|Agent",
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/validate-workflow.mjs", "timeout": 5 }
        ]
      },
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/enforce-dispatch.mjs", "timeout": 5 }
        ]
      },
      {
        "matcher": "Agent",
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/track-task.mjs", "timeout": 10 }
        ]
      },
      {
        "matcher": "",
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/subagent-reminder.mjs" }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/memory/reindex.mjs", "timeout": 30, "async": true },
          { "type": "command", "command": "node ${HOOKS_DIR}/auto-version.mjs", "timeout": 5, "async": true }
        ]
      }
    ],
    "PreCompact": [
      {
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/memory/compact.mjs", "timeout": 10 }
        ]
      }
    ],
    "SubagentStop": [
      {
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/memory/capture-subagent.mjs", "timeout": 30, "async": true },
          { "type": "command", "command": "node ${HOOKS_DIR}/auto-verify.mjs", "timeout": 10, "async": true }
        ]
      }
    ],
    "SessionEnd": [
      {
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/trigger/session-end.mjs", "timeout": 3 }
        ]
      }
    ],
    "Notification": [
      {
        "matcher": "idle_prompt|permission_prompt",
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/trigger/notify.mjs", "timeout": 5 }
        ]
      }
    ],
    "TeammateIdle": [
      {
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/teammate-idle.mjs", "timeout": 10 }
        ]
      }
    ],
    "SubagentStart": [
      {
        "hooks": [
          { "type": "command", "command": "HOOK_EVENT=SubagentStart node ${HOOKS_DIR}/log-hook-event.mjs", "timeout": 5, "async": true }
        ]
      }
    ],
    "InstructionsLoaded": [
      {
        "hooks": [
          { "type": "command", "command": "HOOK_EVENT=InstructionsLoaded node ${HOOKS_DIR}/log-hook-event.mjs", "timeout": 5, "async": true }
        ]
      }
    ],
    "PostToolUseFailure": [
      {
        "hooks": [
          { "type": "command", "command": "HOOK_EVENT=PostToolUseFailure node ${HOOKS_DIR}/log-hook-event.mjs", "timeout": 5, "async": true }
        ]
      }
    ],
    "PermissionRequest": [
      {
        "hooks": [
          { "type": "command", "command": "HOOK_EVENT=PermissionRequest node ${HOOKS_DIR}/log-hook-event.mjs", "timeout": 5, "async": true }
        ]
      }
    ],
    "TaskCompleted": [
      {
        "hooks": [
          { "type": "command", "command": "HOOK_EVENT=TaskCompleted node ${HOOKS_DIR}/log-hook-event.mjs", "timeout": 5, "async": true }
        ]
      }
    ],
    "WorktreeCreate": [
      {
        "hooks": [
          { "type": "command", "command": "HOOK_EVENT=WorktreeCreate node ${HOOKS_DIR}/log-hook-event.mjs", "timeout": 5, "async": true }
        ]
      }
    ],
    "WorktreeRemove": [
      {
        "hooks": [
          { "type": "command", "command": "HOOK_EVENT=WorktreeRemove node ${HOOKS_DIR}/log-hook-event.mjs", "timeout": 5, "async": true }
        ]
      }
    ],
    "SessionStart": [
      {
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/memory/session-restore.mjs", "timeout": 5 }
        ]
      },
      {
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/directives/bootstrap.mjs", "timeout": 3 }
        ]
      },
      {
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/trigger/wo-inject.mjs", "timeout": 3 }
        ]
      },
      {
        "hooks": [
          { "type": "command", "command": "node ${HOOKS_DIR}/memory/reindex.mjs", "timeout": 60, "async": true }
        ]
      }
    ]
  }
}
SETTINGSEOF
fi

ok "settings.json 생성 완료"

# ═══════════════════════════════════════════════
# Step 6: oracle.env 환경 설정
# ═══════════════════════════════════════════════
section "Step 6: 환경 설정 파일"

# 환경별 서비스 URL 결정
case "$ENV_TYPE" in
  server)
    ENV_DATA_API_URL="http://localhost:14901"
    ENV_PORTAL_URL="http://localhost:7200"
    ENV_TASKBOARD_URL="http://localhost:3006"
    ENV_STARGRAM_URL="http://localhost:3005"
    ;;
  client)
    ENV_DATA_API_URL="https://data-api.starian.us"
    ENV_PORTAL_URL="https://server-main.starian.us"
    ENV_TASKBOARD_URL="https://starian.us"
    ENV_STARGRAM_URL="https://stargram.starian.us"
    ;;
esac

cat > .claude/hooks/oracle.env << ENVEOF
# Oracle System v3 Configuration
# Generated: $(date -u +%Y-%m-%dT%H:%M:%SZ)
# Environment: ${ENV_TYPE:-client}
ORACLE_ENV=${ENV_TYPE:-client}
TASKBOARD_URL=${TASKBOARD_URL:-https://starian.us}
TASKBOARD_TOKEN=${TASKBOARD_TOKEN:-0205}
TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN:-}
TELEGRAM_CHAT_ID=${TELEGRAM_CHAT_ID:-}
PROJECT_NAME=${PROJECT_NAME:-project}
PROJECT_DIR=${PROJECT_DIR:-.}
DATA_API_URL=${ENV_DATA_API_URL:-https://data-api.starian.us}
PORTAL_URL=${ENV_PORTAL_URL:-https://gcp.starian.us}
SERVICE_TASKBOARD_URL=${ENV_TASKBOARD_URL:-https://starian.us}
STARGRAM_URL=${ENV_STARGRAM_URL:-https://stargram.starian.us}
ENVEOF

ok "oracle.env 생성 (env=$ENV_TYPE, DATA_API=${ENV_DATA_API_URL})"

# ═══════════════════════════════════════════════
# Step 7: CLAUDE.md 병합
# ═══════════════════════════════════════════════
section "Step 7: CLAUDE.md 병합"

# Oracle 표준 헤더 읽기
if [ "$INSTALL_MODE" = "local" ] && [ -f "$SOURCE_DIR/templates/claude-md-header.md" ]; then
  ORACLE_HEADER="$(cat "$SOURCE_DIR/templates/claude-md-header.md")"
else
  ORACLE_HEADER='# Oracle 표준 지침

## 서브에이전트 사용 강제 (절대 준수)

코드 수정은 반드시 서브에이전트(Agent 도구)로 실행한다. 이 터미널에서 직접 코딩하지 않는다.
- 분석/리서치: Agent 도구, run_in_background: true
- 코딩/수정: Agent 도구, isolation: "worktree", run_in_background: true
- 이 터미널: 마스터와 대화 + 상태 확인 전용

## 버전 관리 의무

모든 코드 작업 시 vMAJOR.MINOR.PATCH.BUILD 버전 체계를 따른다. version.json + package.json 동기화 필수.

## 금지사항

- 표(table) 사용 금지 — 목록(list)으로 정리
- 하드코딩 금지 — 설정값은 환경변수/DB/config로 관리
- "추가 지시를 기다리겠습니다" — 금지. 자율 판단하고 실행
- "위임했습니다" 금지 — "작업을 시작했습니다"로 표현
- "대시보드에서 확인하세요" 금지 — 직접 조회해서 알려준다

---'
fi

if [ -f "CLAUDE.md" ]; then
  # 기존 CLAUDE.md가 있는 경우
  # "# Oracle 표준 지침" 섹션이 이미 있으면 교체, 없으면 상단에 추가
  if grep -q "# Oracle 표준 지침" "CLAUDE.md" 2>/dev/null; then
    # 기존 Oracle 섹션 교체: sed + 임시 파일 방식 (macOS BSD awk 호환)
    echo "$ORACLE_HEADER" > "CLAUDE.md.header"
    # Oracle 섹션 시작~--- 라인까지 제거하고 헤더 삽입
    {
      in_oracle=0
      while IFS= read -r line; do
        if [ "$line" = "# Oracle 표준 지침" ]; then
          in_oracle=1
          cat "CLAUDE.md.header"
          continue
        fi
        if [ "$in_oracle" = "1" ] && [ "$line" = "---" ]; then
          in_oracle=0
          continue
        fi
        if [ "$in_oracle" = "0" ]; then
          echo "$line"
        fi
      done < "CLAUDE.md"
    } > "CLAUDE.md.new"
    mv "CLAUDE.md.new" "CLAUDE.md"
    rm -f "CLAUDE.md.header"
    ok "CLAUDE.md — Oracle 표준 지침 섹션 업데이트"
  else
    # Oracle 섹션이 없으면 상단에 추가
    EXISTING_CONTENT="$(cat CLAUDE.md)"
    printf '%s\n\n%s\n' "$ORACLE_HEADER" "$EXISTING_CONTENT" > "CLAUDE.md"
    ok "CLAUDE.md — Oracle 표준 지침 헤더 추가 (기존 내용 보존)"
  fi
else
  # 새로 생성 (echo 방식 — heredoc 변수 치환 문제 방지)
  {
    echo "$ORACLE_HEADER"
    echo ""
    echo "# ${PROJECT_NAME:-프로젝트} — 프로젝트 지침"
    echo ""
    echo "## 역할 정의"
    echo ""
    echo "이 프로젝트는 Oracle System v3으로 구성되었습니다."
    echo ""
    echo "## Taskboard 연동"
    echo ""
    echo "- API: ${ENV_TASKBOARD_URL:-https://starian.us}"
    echo "- 프로젝트: ${PROJECT_NAME:-프로젝트}"
    echo "- 폴더: ${PROJECT_DIR:-.}"
    echo ""
    echo "## 지침 체계"
    echo ""
    echo "- \`.claude/rules/identity.md\` — Oracle 역할 정의"
    echo "- \`.claude/rules/oracle.md\` — 행동 규칙"
    echo "- \`.claude/rules/tools.md\` — 환경 정보"
    echo "- \`.claude/rules/agents.md\` — 에이전트 규칙"
  } > "CLAUDE.md"
  ok "CLAUDE.md — 새로 생성"
fi

# ═══════════════════════════════════════════════
# Step 8: agents/ 폴더 생성
# ═══════════════════════════════════════════════
section "Step 8: 에이전트 폴더 생성"

# AGENT_ROLES를 쉼표로 분리
IFS=',' read -ra ROLES_ARRAY <<< "$AGENT_ROLES"

for role in "${ROLES_ARRAY[@]}"; do
  role="$(echo "$role" | tr -d ' ')"
  if [ -z "$role" ]; then continue; fi

  if [ -f "agents/${role}/CLAUDE.md" ]; then
    warn "agents/${role}/ 이미 존재 (스킵)"
    continue
  fi

  mkdir -p "agents/${role}/memory"

  # 역할별 설명
  case "$role" in
    builder|eno)    ROLE_DESC="구현/코딩 담당. 코드 작성, 버그 수정, 기능 추가." ;;
    planner|pip)    ROLE_DESC="설계/기획 담당. PRD 작성, 아키텍처 설계, 체크리스트." ;;
    researcher|res) ROLE_DESC="조사/분석 담당. 기술 리서치, 코드 분석, 문서 정리." ;;
    deployer)       ROLE_DESC="배포/인프라 담당. 빌드, 배포, 모니터링, 인프라 관리." ;;
    verifier|qua)   ROLE_DESC="검증/QA 담당. 테스트, 코드 리뷰, 품질 검증." ;;
    kai)            ROLE_DESC="시스템 유지보수 담당. 서비스 상태 모니터링, 장애 대응." ;;
    craw)           ROLE_DESC="크롤링/데이터수집 담당. 웹 스크래핑, 데이터 파이프라인." ;;
    *)              ROLE_DESC="${role} 역할 담당." ;;
  esac

  {
    echo "# ${role} — ${PROJECT_NAME:-프로젝트}"
    echo ""
    echo "## 역할"
    echo ""
    echo "${ROLE_DESC}"
    echo ""
    echo "## Taskboard 연동"
    echo ""
    echo "- API: ${ENV_TASKBOARD_URL:-https://starian.us}"
    echo "- 프로젝트: ${PROJECT_NAME:-프로젝트}"
  } > "agents/${role}/CLAUDE.md"

  ok "agents/${role}/CLAUDE.md"
done

# ═══════════════════════════════════════════════
# Step 9: memory 폴더 초기화
# ═══════════════════════════════════════════════
section "Step 9: memory 초기화"

mkdir -p memory/daily
mkdir -p memory/long-term
mkdir -p logs/tasks

# active-tasks.json 초기화
if [ ! -f "logs/tasks/active-tasks.json" ]; then
  echo "[]" > logs/tasks/active-tasks.json
  ok "logs/tasks/active-tasks.json 초기화"
fi

ok "memory/ 구조 생성"

# ═══════════════════════════════════════════════
# Step 10: Taskboard 프로젝트 등록
# ═══════════════════════════════════════════════
section "Step 10: Taskboard 등록"

REG_RESULT=$(curl -s -X POST "${TASKBOARD_URL}/api/projects?token=${TASKBOARD_TOKEN}" \
  -H 'Content-Type: application/json' \
  -d "{\"name\": \"${PROJECT_NAME}\", \"path\": \"${PROJECT_DIR}\", \"description\": \"Oracle-managed project — v3\"}" \
  --connect-timeout 5 --max-time 10 2>/dev/null || echo '{"error":"connection failed"}')

if echo "$REG_RESULT" | grep -q '"error"'; then
  if echo "$REG_RESULT" | grep -qi 'already\|exists\|duplicate\|UNIQUE'; then
    warn "이미 Taskboard에 등록됨"
  else
    warn "Taskboard 등록 실패: $(echo "$REG_RESULT" | cut -c1-80)"
    warn "나중에 수동 등록 가능"
  fi
else
  ok "Taskboard 프로젝트 등록 완료"
fi

# ── 에이전트 레지스트리 등록 ──
for role in "${ROLES_ARRAY[@]}"; do
  role="$(echo "$role" | tr -d ' ')"
  [ -z "$role" ] && continue

  case "$role" in
    builder|eno)    AGENT_DESC="구현/코딩" ;;
    planner|pip)    AGENT_DESC="설계/기획" ;;
    researcher|res) AGENT_DESC="조사/분석" ;;
    deployer)       AGENT_DESC="배포/인프라" ;;
    verifier|qua)   AGENT_DESC="검증/QA" ;;
    kai)            AGENT_DESC="시스템 유지보수" ;;
    craw)           AGENT_DESC="크롤링/데이터수집" ;;
    *)              AGENT_DESC="${role}" ;;
  esac

  curl -s -X POST "${TASKBOARD_URL}/api/agents/registry?token=${TASKBOARD_TOKEN}" \
    -H 'Content-Type: application/json' \
    -d "{\"name\": \"${role}\", \"role\": \"${AGENT_DESC}\", \"capabilities\": \"${AGENT_DESC} 전담\", \"project_name\": \"${PROJECT_NAME}\"}" \
    --connect-timeout 5 --max-time 10 2>/dev/null > /dev/null || true
done

ok "에이전트 레지스트리 등록"

# ═══════════════════════════════════════════════
# Step 11: auto-version.mjs에 프로젝트 경로 추가
# ═══════════════════════════════════════════════
section "Step 11: auto-version 프로젝트 경로 등록"

# auto-version.mjs의 PROJECT_ROOTS 배열에 현재 PROJECT_DIR 추가
AV_FILE=".claude/hooks/auto-version.mjs"
if [ -f "$AV_FILE" ]; then
  # 이미 현재 프로젝트가 등록되어 있는지 확인
  if grep -q "\"${PROJECT_DIR}\"" "$AV_FILE" 2>/dev/null; then
    ok "auto-version.mjs — 이미 등록됨"
  else
    # PROJECT_ROOTS 배열에 현재 프로젝트 추가
    if [[ "$PLATFORM" == "macos" ]]; then
      sed -i '' "s|const PROJECT_ROOTS = \[|const PROJECT_ROOTS = [\n  '${PROJECT_DIR}',|" "$AV_FILE" 2>/dev/null && ok "auto-version.mjs — ${PROJECT_NAME} 경로 추가" || warn "auto-version.mjs 경로 추가 실패 (수동으로 추가 권장)"
    else
      sed -i "s|const PROJECT_ROOTS = \[|const PROJECT_ROOTS = [\n  '${PROJECT_DIR}',|" "$AV_FILE" 2>/dev/null && ok "auto-version.mjs — ${PROJECT_NAME} 경로 추가" || warn "auto-version.mjs 경로 추가 실패 (수동으로 추가 권장)"
    fi
  fi
fi

# record-instruction.mjs의 PROJECT_MAP에 현재 프로젝트 추가
RI_FILE=".claude/hooks/record-instruction.mjs"
if [ -f "$RI_FILE" ]; then
  PROJECT_SLUG="$(echo "${PROJECT_NAME}" | tr '[:upper:]' '[:lower:]' | tr ' ' '-')"
  if grep -q "\"${PROJECT_DIR}\"" "$RI_FILE" 2>/dev/null; then
    ok "record-instruction.mjs — 이미 등록됨"
  else
    if [[ "$PLATFORM" == "macos" ]]; then
      sed -i '' "s|const PROJECT_MAP = {|const PROJECT_MAP = {\n  '${PROJECT_DIR}': '${PROJECT_SLUG}',|" "$RI_FILE" 2>/dev/null && ok "record-instruction.mjs — ${PROJECT_NAME} 경로 추가" || warn "record-instruction.mjs 경로 추가 실패"
    else
      sed -i "s|const PROJECT_MAP = {|const PROJECT_MAP = {\n  '${PROJECT_DIR}': '${PROJECT_SLUG}',|" "$RI_FILE" 2>/dev/null && ok "record-instruction.mjs — ${PROJECT_NAME} 경로 추가" || warn "record-instruction.mjs 경로 추가 실패"
    fi
  fi
fi

# ═══════════════════════════════════════════════
# 완료
# ═══════════════════════════════════════════════
echo ""
echo "  Oracle System v3 — Setup Complete"
echo "  ==================================="
echo ""
echo "  설치된 항목:"
echo "    .claude/hooks/          — $(ls .claude/hooks/*.mjs 2>/dev/null | wc -l)개 hook 파일"
echo "    .claude/hooks/memory/   — $(ls .claude/hooks/memory/*.mjs 2>/dev/null | wc -l)개 memory hook"
echo "    .claude/hooks/trigger/  — $(ls .claude/hooks/trigger/*.mjs 2>/dev/null | wc -l)개 trigger hook"
echo "    .claude/rules/          — $(ls .claude/rules/*.md 2>/dev/null | wc -l)개 rule 파일"
echo "    .claude/skills/         — $(ls .claude/skills/*.md 2>/dev/null | wc -l)개 skill 파일"
echo "    .claude/settings.json   — hook 설정"
echo "    agents/                 — ${#ROLES_ARRAY[@]}개 에이전트 폴더"
echo "    memory/                 — 메모리 구조"
echo ""
echo "  다음 단계:"
echo "    cd ${PROJECT_DIR}"
echo "    claude --dangerously-skip-permissions"
echo ""