#!/usr/bin/env bash
# OmeniaClaw Core — Installer for Linux & macOS
# Usage: cd ~ && curl -fsSL https://omeniaclaw.com/install.sh | bash
# Alt:   cd ~ && curl -fsSL https://omeniaclaw.com/install.sh | bash
# Update: curl -fsSL https://omeniaclaw.com/install.sh | bash -s -- --update
# Rollback: curl -fsSL https://omeniaclaw.com/install.sh | bash -s -- --version 2026.4.13

# Immediately recover CWD — prevents getcwd errors if user is inside a deleted directory
cd "$HOME" 2>/dev/null || cd /tmp 2>/dev/null || cd /

set -euo pipefail

VERSION="${OMENIACLAW_VERSION:-2026.6.16}"
INSTALL_DIR="${OMENIACLAW_INSTALL_DIR:-$HOME/.omeniaclaw}"
BIN_LINK="${OMENIACLAW_BIN_LINK:-/usr/local/bin/omeniaclaw}"
BASE_URL="${OMENIACLAW_BASE_URL:-https://omeniaclaw.com}"
TARBALL="omeniaclaw-core.tar.gz"
STATE_DIR="${OMENIACLAW_STATE_DIR:-${OPENCLAW_STATE_DIR:-$INSTALL_DIR}}"
export OMENIACLAW_STATE_DIR="$STATE_DIR"
if [ -z "${OPENCLAW_STATE_DIR:-}" ]; then
  export OPENCLAW_STATE_DIR="$STATE_DIR"
fi

# ──── Flags ────
UPDATE_ONLY=false
AUTO_YES=false
SKIP_ONBOARD="${OMENIACLAW_NO_ONBOARD:-${OPENCLAW_NO_ONBOARD:-0}}"
for arg in "$@"; do
  case "$arg" in
    --update)    UPDATE_ONLY=true; SKIP_ONBOARD=1 ;;
    --yes|--non-interactive) AUTO_YES=true ;;
    --no-onboard) SKIP_ONBOARD=1 ;;
    --version=*) VERSION="${arg#--version=}"; TARBALL="omeniaclaw-${VERSION}.tar.gz" ;;
    --version)   shift_next=1 ;;
    *)
      if [ "${shift_next:-0}" = "1" ]; then
        VERSION="$arg"; TARBALL="omeniaclaw-${VERSION}.tar.gz"; shift_next=0
      fi
      ;;
  esac
done

# ════════════════════════════════════════════════════════════════
# Colors — OmeniaClaw Vivid Purple→Cyan gradient palette
# ════════════════════════════════════════════════════════════════
BOLD='\033[1m'
NC='\033[0m'
if [[ "${COLORTERM:-}" == "truecolor" ]] || [[ "${COLORTERM:-}" == "24bit" ]] || [[ -n "${WT_SESSION:-}" ]]; then
  # Gradient steps: deep purple → vivid cyan
  G1='\033[38;2;139;92;246m'    # Vivid purple
  G2='\033[38;2;120;110;248m'   # Purple-blue
  G3='\033[38;2;99;140;250m'    # Blue-purple
  G4='\033[38;2;74;170;248m'    # Blue-cyan
  G5='\033[38;2;49;200;245m'    # Cyan-blue
  G6='\033[38;2;34;211;238m'    # Vivid cyan
  # Semantic aliases
  PURPLE='\033[38;2;139;92;246m'
  CYAN='\033[38;2;34;211;238m'
  GREEN='\033[38;2;46;213;115m'
  YELLOW='\033[38;2;255;183;77m'
  RED='\033[38;2;239;83;80m'
  DIM='\033[38;2;120;120;150m'
  ACCENT='\033[38;2;160;120;255m'
  BAR_COLOR='\033[38;2;90;80;200m'
  NODE_COLOR='\033[38;2;139;92;246m'
  BG_HEADER='\033[48;2;16;14;28m'
else
  G1='\033[38;5;135m'
  G2='\033[38;5;105m'
  G3='\033[38;5;75m'
  G4='\033[38;5;45m'
  G5='\033[38;5;44m'
  G6='\033[38;5;51m'
  PURPLE='\033[38;5;135m'
  CYAN='\033[38;5;51m'
  GREEN='\033[38;5;78m'
  YELLOW='\033[38;5;214m'
  RED='\033[38;5;203m'
  DIM='\033[38;5;244m'
  ACCENT='\033[38;5;141m'
  BAR_COLOR='\033[38;5;99m'
  NODE_COLOR='\033[38;5;135m'
  BG_HEADER=''
fi

# ══════════════════════════════════════════════════════════════
# i18n — All user-facing strings in EN / ES / PT
# ══════════════════════════════════════════════════════════════
set_lang_en() {
  L_OS_UNSUPPORTED="Unsupported OS"
  L_NODE_NOT_FOUND="Node.js not found. v22+ required"
  L_NODE_TOO_OLD="detected. v22+ required"
  L_DOWNLOADING="Downloading OmeniaClaw"
  L_DOWNLOADED="Downloaded"
  L_VERIFYING="Verifying integrity..."
  L_NO_SHA="No sha256sum/shasum found, skipping verification"
  L_CHECKSUM_FAIL="Checksum mismatch!"
  L_EXPECTED="Expected"
  L_ACTUAL="Actual"
  L_SHA_OK="SHA-256 verified"
  L_INSTALLING_IN="Installing in"
  L_BACKUP_ENV="Backed up existing .env"
  L_BACKUP_CONFIG="Backed up existing config/"
  L_RESTORED_ENV="Restored previous .env"
  L_RESTORED_CONFIG="Restored previous config/"
  L_INSTALLING_DEPS="Installing core dependencies..."
  L_DEPS_INSTALLED="Core dependencies ready"
  L_DEPS_INCLUDED="Dependencies included in package"
  L_DEPS_LAZY="Other dependencies install on first use"
  L_SUDO_NEEDED="sudo required to create /usr/local/bin/omeniaclaw"
  L_CMD_AVAILABLE="Command 'omeniaclaw' available"
  L_ENV_CREATED="Created .env with Omenia defaults"
  L_EXT_VERIFIED="Extensions verified"
  L_IMPORT_DETECTED="Detected installations that can be imported:"
  L_IMPORT_OPENCLAW="Legacy OpenClaw import (old sessions, identity, personality, soul, skills)"
  L_IMPORT_CLAUDE="Claude Code (settings, subagents, skills, rules, memories, sessions, plans, MCP)"
  L_IMPORT_COPILOT="VS Code / GitHub Copilot Chat (memories, sessions, agents)"
  L_IMPORT_ANTIGRAVITY="Antigravity (session history)"
  L_IMPORT_ASK="Run import wizard?"
  L_IMPORT_FAILED="Import wizard did not complete; continuing with installed OmeniaClaw."
  L_COMPLETIONS_OK="Shell completions configured"
  L_INSTALLED_OK="installed OK"
  L_NEXT_STEPS="Next steps:"
  L_NEXT_1="Full setup (gateway, models, channels, skills):"
  L_NEXT_1A="full wizard"
  L_NEXT_1B="quick setup"
  L_NEXT_2="Start the agent:"
  L_NEXT_2A="interactive chat"
  L_NEXT_2B="local gateway (port 19017)"
  L_NEXT_2C="diagnostics"
  L_NEXT_3="Review install health:"
  L_NEXT_4="Claude Code skills (compatible):"
  L_NEXT_4B="Or use your API key:"
  L_ONBOARD_ASK="Run 'omeniaclaw onboard' now? (full setup recommended)"
  L_ONBOARD_1="Full onboarding"
  L_ONBOARD_1D="gateway + models + channels + skills"
  L_ONBOARD_2="Quick setup"
  L_ONBOARD_2D="credentials and gateway only"
  L_ONBOARD_3="Skip"
  L_ONBOARD_3D="configure manually later"
  L_ONBOARD_SKIP="Done. Run omeniaclaw onboard when you want to configure."
  L_ONBOARD_FAILED="Onboarding did not complete; install is complete. Run omeniaclaw onboard to retry."
  L_CONFIG_FAILED="Quick setup did not complete; install is complete. Run omeniaclaw configure to retry."
  L_CONSENT_TITLE="Before continuing, please review:"
  L_CONSENT_WHAT="This installer will:"
  L_CONSENT_1="Verify Node.js v22+ is installed"
  L_CONSENT_2="Download and install OmeniaClaw in ~/.omeniaclaw"
  L_CONSENT_3="Create a symlink in /usr/local/bin (may require sudo)"
  L_CONSENT_4="Modify ~/.bashrc or ~/.zshrc for shell completions"
  L_CONSENT_ASK="Do you agree to proceed?"
  L_CONSENT_NO="Installation cancelled."
  L_SKILLS_INSTALLING="Installing ClawHub skills pack..."
  L_SKILLS_INSTALLED="ClawHub skills installed"
  L_SKILLS_ASK="Install recommended ClawHub skills? (video, frontend, React, animation)"
  L_SKILLS_SKIP="Skipped. Install later: omeniaclaw skills install <name>"
  L_SKILLS_SEARCH="Search more skills:"
  L_SKILLS_INSTALL="Install a skill:"
  L_SKILLS_BROWSE="Browse all:"
  L_OPTION="Option"
  L_YES_DEFAULT="Y/n"
  L_CONNECT_TITLE="Connect to omenia.io"
  L_CONNECT_DESC="Link your Omenia account to access 25+ AI models (GPT, Claude, DeepSeek, Qwen...) without individual API keys."
  L_CONNECT_1="Login (existing account)"
  L_CONNECT_2="Create a free account"
  L_CONNECT_3="Skip (configure later)"
  L_CONNECT_EMAIL="Email: "
  L_CONNECT_PASS="Password: "
  L_CONNECT_NAME="Name: "
  L_CONNECT_PASS_RULE="(min 12 chars, upper+lower+number)"
  L_CONNECT_OK="Connected to omenia.io!"
  L_CONNECT_FAIL="Connection failed"
  L_CONNECT_SKIP="Skipped. Connect later: omeniaclaw auth login"
  L_CONNECT_VERIFY="Check your email to verify your account."
  L_CONNECT_PLAN="Plan"
  L_CONNECT_WELCOME="Welcome"
}

set_lang_es() {
  L_OS_UNSUPPORTED="Sistema no soportado"
  L_NODE_NOT_FOUND="Node.js no encontrado. Se requiere v22+"
  L_NODE_TOO_OLD="detectado. Se requiere v22+"
  L_DOWNLOADING="Descargando OmeniaClaw"
  L_DOWNLOADED="Descargado"
  L_VERIFYING="Verificando integridad..."
  L_NO_SHA="No se encontró sha256sum/shasum, saltando verificación"
  L_CHECKSUM_FAIL="¡Checksum no coincide!"
  L_EXPECTED="Esperado"
  L_ACTUAL="Actual"
  L_SHA_OK="SHA-256 verificado"
  L_INSTALLING_IN="Instalando en"
  L_BACKUP_ENV="Backup de .env existente"
  L_BACKUP_CONFIG="Backup de config/ existente"
  L_RESTORED_ENV="Restaurado .env previo"
  L_RESTORED_CONFIG="Restaurado config/ previo"
  L_INSTALLING_DEPS="Instalando dependencias core..."
  L_DEPS_INSTALLED="Dependencias core listas"
  L_DEPS_INCLUDED="Dependencias incluidas en el paquete"
  L_DEPS_LAZY="El resto se instala bajo demanda al primer uso"
  L_SUDO_NEEDED="Se necesita sudo para crear /usr/local/bin/omeniaclaw"
  L_CMD_AVAILABLE="Comando 'omeniaclaw' disponible"
  L_ENV_CREATED="Creado .env con defaults de Omenia"
  L_EXT_VERIFIED="Extensiones verificadas"
  L_IMPORT_DETECTED="Instalaciones detectadas que se pueden importar:"
  L_IMPORT_OPENCLAW="Importación legacy de OpenClaw (datos antiguos: sesiones, identidad, personalidad, soul, skills)"
  L_IMPORT_CLAUDE="Claude Code (settings, subagentes, skills, rules, memorias, sesiones, planes, MCP)"
  L_IMPORT_COPILOT="VS Code / GitHub Copilot Chat (memorias, sesiones, agentes)"
  L_IMPORT_ANTIGRAVITY="Antigravity (historial de sesiones)"
  L_IMPORT_ASK="¿Ejecutar el asistente de importación?"
  L_IMPORT_FAILED="El asistente de importación no terminó; se continúa con OmeniaClaw instalado."
  L_COMPLETIONS_OK="Shell completions configuradas"
  L_INSTALLED_OK="instalado OK"
  L_NEXT_STEPS="Próximos pasos:"
  L_NEXT_1="Configuración completa (gateway, modelos, channels, skills):"
  L_NEXT_1A="wizard completo"
  L_NEXT_1B="configuración rápida"
  L_NEXT_2="Inicia el agente:"
  L_NEXT_2A="chat interactivo"
  L_NEXT_2B="gateway local (puerto 19017)"
  L_NEXT_2C="diagnóstico"
  L_NEXT_3="Revisar salud de la instalación:"
  L_NEXT_4="Skills de Claude Code (compatible):"
  L_NEXT_4B="O usa tu API key:"
  L_ONBOARD_ASK="¿Ejecutar 'omeniaclaw onboard' ahora? (configuración completa recomendada)"
  L_ONBOARD_1="Onboarding completo"
  L_ONBOARD_1D="gateway + modelos + channels + skills"
  L_ONBOARD_2="Configuración rápida"
  L_ONBOARD_2D="solo credenciales y gateway"
  L_ONBOARD_3="Saltar"
  L_ONBOARD_3D="configurar después manualmente"
  L_ONBOARD_SKIP="Listo. Ejecuta omeniaclaw onboard cuando quieras configurar."
  L_ONBOARD_FAILED="El onboarding no terminó; la instalación está completa. Ejecuta omeniaclaw onboard para reintentar."
  L_CONFIG_FAILED="La configuración rápida no terminó; la instalación está completa. Ejecuta omeniaclaw configure para reintentar."
  L_CONSENT_TITLE="Antes de continuar, por favor revisa:"
  L_CONSENT_WHAT="Este instalador va a:"
  L_CONSENT_1="Verificar que Node.js v22+ esté instalado"
  L_CONSENT_2="Descargar e instalar OmeniaClaw en ~/.omeniaclaw"
  L_CONSENT_3="Crear un enlace simbólico en /usr/local/bin (puede requerir sudo)"
  L_CONSENT_4="Modificar ~/.bashrc o ~/.zshrc para shell completions"
  L_CONSENT_ASK="¿Deseas continuar?"
  L_CONSENT_NO="Instalación cancelada."
  L_SKILLS_INSTALLING="Instalando pack de skills de ClawHub..."
  L_SKILLS_INSTALLED="Skills de ClawHub instaladas"
  L_SKILLS_ASK="¿Instalar skills recomendadas de ClawHub? (video, frontend, React, animación)"
  L_SKILLS_SKIP="Omitido. Instalar después: omeniaclaw skills install <name>"
  L_SKILLS_SEARCH="Buscar más skills:"
  L_SKILLS_INSTALL="Instalar una skill:"
  L_SKILLS_BROWSE="Ver todas:"
  L_OPTION="Opción"
  L_YES_DEFAULT="S/n"
  L_CONNECT_TITLE="Conectar con omenia.io"
  L_CONNECT_DESC="Vincula tu cuenta Omenia para acceder a 25+ modelos AI (GPT, Claude, DeepSeek, Qwen...) sin API keys individuales."
  L_CONNECT_1="Iniciar sesión (cuenta existente)"
  L_CONNECT_2="Crear cuenta gratuita"
  L_CONNECT_3="Saltar (configurar después)"
  L_CONNECT_EMAIL="Email: "
  L_CONNECT_PASS="Contraseña: "
  L_CONNECT_NAME="Nombre: "
  L_CONNECT_PASS_RULE="(mín 12 caracteres, mayúsculas+minúsculas+números)"
  L_CONNECT_OK="¡Conectado a omenia.io!"
  L_CONNECT_FAIL="Conexión fallida"
  L_CONNECT_SKIP="Omitido. Conectar después: omeniaclaw auth login"
  L_CONNECT_VERIFY="Revisa tu correo para verificar tu cuenta."
  L_CONNECT_PLAN="Plan"
  L_CONNECT_WELCOME="Bienvenido"
}

set_lang_pt() {
  L_OS_UNSUPPORTED="Sistema não suportado"
  L_NODE_NOT_FOUND="Node.js não encontrado. Requer v22+"
  L_NODE_TOO_OLD="detectado. Requer v22+"
  L_DOWNLOADING="Baixando OmeniaClaw"
  L_DOWNLOADED="Baixado"
  L_VERIFYING="Verificando integridade..."
  L_NO_SHA="sha256sum/shasum não encontrado, pulando verificação"
  L_CHECKSUM_FAIL="Checksum não confere!"
  L_EXPECTED="Esperado"
  L_ACTUAL="Atual"
  L_SHA_OK="SHA-256 verificado"
  L_INSTALLING_IN="Instalando em"
  L_BACKUP_ENV="Backup do .env existente"
  L_BACKUP_CONFIG="Backup do config/ existente"
  L_RESTORED_ENV="Restaurado .env anterior"
  L_RESTORED_CONFIG="Restaurado config/ anterior"
  L_INSTALLING_DEPS="Instalando dependências core..."
  L_DEPS_INSTALLED="Dependências core prontas"
  L_DEPS_INCLUDED="Dependências incluídas no pacote"
  L_DEPS_LAZY="As demais são instaladas sob demanda no primeiro uso"
  L_SUDO_NEEDED="sudo necessário para criar /usr/local/bin/omeniaclaw"
  L_CMD_AVAILABLE="Comando 'omeniaclaw' disponível"
  L_ENV_CREATED="Criado .env com padrões Omenia"
  L_EXT_VERIFIED="Extensões verificadas"
  L_IMPORT_DETECTED="Instalações detectadas que podem ser importadas:"
  L_IMPORT_OPENCLAW="Importação legacy do OpenClaw (dados antigos: sessões, identidade, personalidade, soul, skills)"
  L_IMPORT_CLAUDE="Claude Code (settings, subagentes, skills, regras, memórias, sessões, planos, MCP)"
  L_IMPORT_COPILOT="VS Code / GitHub Copilot Chat (memórias, sessões, agentes)"
  L_IMPORT_ANTIGRAVITY="Antigravity (histórico de sessões)"
  L_IMPORT_ASK="Executar assistente de importação?"
  L_IMPORT_FAILED="O assistente de importação não terminou; continuando com o OmeniaClaw instalado."
  L_COMPLETIONS_OK="Shell completions configuradas"
  L_INSTALLED_OK="instalado OK"
  L_NEXT_STEPS="Próximos passos:"
  L_NEXT_1="Configuração completa (gateway, modelos, channels, skills):"
  L_NEXT_1A="wizard completo"
  L_NEXT_1B="configuração rápida"
  L_NEXT_2="Inicie o agente:"
  L_NEXT_2A="chat interativo"
  L_NEXT_2B="gateway local (porta 19017)"
  L_NEXT_2C="diagnóstico"
  L_NEXT_3="Revisar saúde da instalação:"
  L_NEXT_4="Skills do Claude Code (compatível):"
  L_NEXT_4B="Ou use sua API key:"
  L_ONBOARD_ASK="Executar 'omeniaclaw onboard' agora? (configuração completa recomendada)"
  L_ONBOARD_1="Onboarding completo"
  L_ONBOARD_1D="gateway + modelos + channels + skills"
  L_ONBOARD_2="Configuração rápida"
  L_ONBOARD_2D="somente credenciais e gateway"
  L_ONBOARD_3="Pular"
  L_ONBOARD_3D="configurar manualmente depois"
  L_ONBOARD_SKIP="Pronto. Execute omeniaclaw onboard quando quiser configurar."
  L_ONBOARD_FAILED="O onboarding não terminou; a instalação está completa. Execute omeniaclaw onboard para tentar novamente."
  L_CONFIG_FAILED="A configuração rápida não terminou; a instalação está completa. Execute omeniaclaw configure para tentar novamente."
  L_CONSENT_TITLE="Antes de continuar, por favor revise:"
  L_CONSENT_WHAT="Este instalador irá:"
  L_CONSENT_1="Verificar que Node.js v22+ esteja instalado"
  L_CONSENT_2="Baixar e instalar OmeniaClaw em ~/.omeniaclaw"
  L_CONSENT_3="Criar um link simbólico em /usr/local/bin (pode precisar de sudo)"
  L_CONSENT_4="Modificar ~/.bashrc ou ~/.zshrc para shell completions"
  L_CONSENT_ASK="Deseja continuar?"
  L_CONSENT_NO="Instalação cancelada."
  L_SKILLS_INSTALLING="Instalando pack de skills do ClawHub..."
  L_SKILLS_INSTALLED="Skills do ClawHub instaladas"
  L_SKILLS_ASK="Instalar skills recomendadas do ClawHub? (vídeo, frontend, React, animação)"
  L_SKILLS_SKIP="Pulado. Instalar depois: omeniaclaw skills install <name>"
  L_SKILLS_SEARCH="Buscar mais skills:"
  L_SKILLS_INSTALL="Instalar uma skill:"
  L_SKILLS_BROWSE="Ver todas:"
  L_OPTION="Opção"
  L_YES_DEFAULT="S/n"
  L_CONNECT_TITLE="Conectar com omenia.io"
  L_CONNECT_DESC="Vincule sua conta Omenia para acessar 25+ modelos AI (GPT, Claude, DeepSeek, Qwen...) sem API keys individuais."
  L_CONNECT_1="Fazer login (conta existente)"
  L_CONNECT_2="Criar conta gratuita"
  L_CONNECT_3="Pular (configurar depois)"
  L_CONNECT_EMAIL="Email: "
  L_CONNECT_PASS="Senha: "
  L_CONNECT_NAME="Nome: "
  L_CONNECT_PASS_RULE="(mín 12 caracteres, maiúsculas+minúsculas+números)"
  L_CONNECT_OK="Conectado ao omenia.io!"
  L_CONNECT_FAIL="Conexão falhou"
  L_CONNECT_SKIP="Pulado. Conectar depois: omeniaclaw auth login"
  L_CONNECT_VERIFY="Verifique seu email para ativar sua conta."
  L_CONNECT_PLAN="Plano"
  L_CONNECT_WELCOME="Bem-vindo"
}

# ══════════════════════════════════════════════════════════════
# Language selection — FIRST interactive prompt (minimal, pre-banner)
# ══════════════════════════════════════════════════════════════
echo ""
LANG_CHOICE=""
# Update mode: skip language prompt, use saved preference
if [ "$UPDATE_ONLY" = true ] && [ -f "$INSTALL_DIR/.lang" ]; then
  SAVED_LANG=$(cat "$INSTALL_DIR/.lang" 2>/dev/null)
  case "$SAVED_LANG" in
    es) LANG_CHOICE=2 ;;
    pt) LANG_CHOICE=3 ;;
    *)  LANG_CHOICE=1 ;;
  esac
elif [ "$AUTO_YES" != "true" ] && [ "$SKIP_ONBOARD" != "1" ] && [ -t 1 ] && [ -e /dev/tty ]; then
  echo -e "${G3}  Select language / Selecciona idioma / Escolha o idioma${NC}"
  echo -e "  ${G1}1)${NC} ${BOLD}English${NC}   ${G1}2)${NC} ${BOLD}Español${NC}   ${G1}3)${NC} ${BOLD}Português${NC}"
  echo ""
  read -r -p "  [1/2/3]: " LANG_CHOICE < /dev/tty
fi
LANG_CHOICE="${LANG_CHOICE:-1}"
case "$LANG_CHOICE" in
  2) set_lang_es; export OMENIACLAW_LANG="es" ;;
  3) set_lang_pt; export OMENIACLAW_LANG="pt" ;;
  *) set_lang_en; export OMENIACLAW_LANG="en" ;;
esac

# ══════════════════════════════════════════════════════════════
# Banner — Shows RIGHT AFTER language selection
# ══════════════════════════════════════════════════════════════
echo ""
echo -e "${G1}  ⬡ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ⬡${NC}"
echo -e "${G1}  ┃${NC}                                                       ${G1}┃${NC}"
echo -e "${G2}  ┃${NC}   ${BG_HEADER}           ${BOLD}${G1}⬡ ${G2}  O ${G3}M ${G4}E ${G5}N ${G6}I ${G5}A ${G4}C ${G3}L ${G2}A ${G1}W   ⬡${NC}${BG_HEADER}           ${NC}  ${G2} ┃${NC}"
echo -e "${G3}  ┃${NC}                                                       ${G3}┃${NC}"
echo -e "${G4}  ┃${NC}      ${DIM}Core Installer${NC}  ${BOLD}${G5}v${VERSION}${NC}                       ${G4}┃${NC}"
echo -e "${G5}  ┃${NC}      ${DIM}Powered by Omenia${NC}                                ${G5}┃${NC}"
echo -e "${G6}  ┃${NC}                                                       ${G6}┃${NC}"
echo -e "${G6}  ⬡ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ⬡${NC}"
echo ""

# ══════════════════════════════════════════════════════════════
# Begin clack-style unified flow — entire installer in blocks
# ══════════════════════════════════════════════════════════════
echo -e "${BAR_COLOR}┌${NC}  ${BOLD}OmeniaClaw Installer${NC}"
echo -e "${BAR_COLOR}│${NC}"

# ──── Consent — Show what will be installed ────
if [ "$UPDATE_ONLY" = true ]; then
  echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} Update mode — skipping consent"
else
echo -e "${NODE_COLOR}⬡${NC}  ${BOLD}${L_CONSENT_TITLE}${NC}"
echo -e "${BAR_COLOR}│${NC}"
echo -e "${BAR_COLOR}│${NC}  ${L_CONSENT_WHAT}"
echo -e "${BAR_COLOR}│${NC}  ${PURPLE}•${NC} ${L_CONSENT_1}"
echo -e "${BAR_COLOR}│${NC}  ${PURPLE}•${NC} ${L_CONSENT_2}"
echo -e "${BAR_COLOR}│${NC}  ${PURPLE}•${NC} ${L_CONSENT_3}"
echo -e "${BAR_COLOR}│${NC}  ${PURPLE}•${NC} ${L_CONSENT_4}"
echo -e "${BAR_COLOR}│${NC}"
if [ "$AUTO_YES" != "true" ] && [ "$SKIP_ONBOARD" != "1" ] && [ -t 1 ] && [ -e /dev/tty ]; then
  echo -ne "${NODE_COLOR}⬡${NC}  ${L_CONSENT_ASK} [${L_YES_DEFAULT}] "
  read -r CONSENT_ANSWER < /dev/tty
  CONSENT_ANSWER=${CONSENT_ANSWER:-Y}
  if [[ ! "$CONSENT_ANSWER" =~ ^[SsYy]$ ]]; then
    echo -e "${BAR_COLOR}│${NC}"
    echo -e "${BAR_COLOR}└${NC}  ${RED}${L_CONSENT_NO}${NC}"
    exit 0
  fi
fi
echo -e "${BAR_COLOR}│${NC}"

fi  # end UPDATE_ONLY consent bypass
# ──── 0. Detect OS ────
OS="$(uname -s)"
case "$OS" in
  Linux)  OS_NAME="Linux" ;;
  Darwin) OS_NAME="macOS" ;;
  *)
    echo -e "${BAR_COLOR}│${NC}  ${RED}✗ ${L_OS_UNSUPPORTED}: $OS${NC}"
    echo -e "${BAR_COLOR}└${NC}"
    exit 1
    ;;
esac

# ──── 1. Prerequisites ────
echo -e "${NODE_COLOR}⬡${NC}  ${BOLD}Prerequisites${NC}"
if ! command -v node &>/dev/null; then
  echo -e "${BAR_COLOR}│${NC}  ${RED}✗ ${L_NODE_NOT_FOUND}${NC}"
  if [[ "$OS_NAME" == "macOS" ]]; then
    echo -e "${BAR_COLOR}│${NC}    ${DIM}brew install node@22${NC}"
  else
    echo -e "${BAR_COLOR}│${NC}    ${DIM}curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -${NC}"
    echo -e "${BAR_COLOR}│${NC}    ${DIM}sudo apt install -y nodejs${NC}"
  fi
  echo -e "${BAR_COLOR}└${NC}"
  exit 1
fi

NODE_MAJOR=$(node -v | sed 's/v//' | cut -d. -f1)
if [ "$NODE_MAJOR" -lt 22 ]; then
  echo -e "${BAR_COLOR}│${NC}  ${RED}✗ Node.js v${NODE_MAJOR} ${L_NODE_TOO_OLD}${NC}"
  echo -e "${BAR_COLOR}└${NC}"
  exit 1
fi
echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} Node.js $(node -v) ${DIM}($OS_NAME)${NC}"
echo -e "${BAR_COLOR}│${NC}"

# ──── 2. Download ────
echo -e "${NODE_COLOR}⬡${NC}  ${BOLD}${L_DOWNLOADING} ${CYAN}${VERSION}${NC}"
TMPDIR=$(mktemp -d)
trap 'rm -rf "$TMPDIR"' EXIT

curl -fSL --progress-bar "${BASE_URL}/${TARBALL}?v=${VERSION}&r=20260616T200141Z" -o "${TMPDIR}/${TARBALL}"
echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_DOWNLOADED} ($(du -h "${TMPDIR}/${TARBALL}" | cut -f1))"
echo -e "${BAR_COLOR}│${NC}"

# ──── 3. Verify checksum ────
echo -e "${NODE_COLOR}⬡${NC}  ${BOLD}${L_VERIFYING}${NC}"
EXPECTED_SHA=$(curl -fsSL "${BASE_URL}/SHA256SUMS.txt?v=${VERSION}&r=20260616T200141Z" | grep "${TARBALL}" | awk '{print $1}')
if command -v sha256sum &>/dev/null; then
  ACTUAL_SHA=$(sha256sum "${TMPDIR}/${TARBALL}" | awk '{print $1}')
elif command -v shasum &>/dev/null; then
  ACTUAL_SHA=$(shasum -a 256 "${TMPDIR}/${TARBALL}" | awk '{print $1}')
else
  echo -e "${BAR_COLOR}│${NC}  ${YELLOW}⚠ ${L_NO_SHA}${NC}"
  ACTUAL_SHA="$EXPECTED_SHA"
fi
if [ "$EXPECTED_SHA" != "$ACTUAL_SHA" ]; then
  echo -e "${BAR_COLOR}│${NC}  ${RED}✗ ${L_CHECKSUM_FAIL}${NC}"
  echo -e "${BAR_COLOR}│${NC}    ${L_EXPECTED}: $EXPECTED_SHA"
  echo -e "${BAR_COLOR}│${NC}    ${L_ACTUAL}:   $ACTUAL_SHA"
  echo -e "${BAR_COLOR}└${NC}"
  exit 1
fi
echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_SHA_OK}"
echo -e "${BAR_COLOR}│${NC}"

# ──── 4. Install ────
echo -e "${NODE_COLOR}⬡${NC}  ${BOLD}${L_INSTALLING_IN} ${CYAN}${INSTALL_DIR}${NC}"

if [ -f "${STATE_DIR}/.env" ]; then
  cp "${STATE_DIR}/.env" "${TMPDIR}/.env.backup"
  echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_BACKUP_ENV}"
fi
if [ -f "${STATE_DIR}/omeniaclaw.json" ]; then
  cp "${STATE_DIR}/omeniaclaw.json" "${TMPDIR}/omeniaclaw.json.backup"
  [ -f "${STATE_DIR}/omeniaclaw.json.bak" ] && cp "${STATE_DIR}/omeniaclaw.json.bak" "${TMPDIR}/omeniaclaw.json.bak.backup"
  echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_BACKUP_CONFIG}"
fi
if [ -d "${STATE_DIR}/config" ]; then
  cp -r "${STATE_DIR}/config" "${TMPDIR}/config.backup"
  echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_BACKUP_CONFIG}"
fi
if [ -d "${STATE_DIR}/agents" ]; then
  cp -r "${STATE_DIR}/agents" "${TMPDIR}/agents.backup"
fi
if [ -d "${STATE_DIR}/workspace" ]; then
  cp -r "${STATE_DIR}/workspace" "${TMPDIR}/workspace.backup"
fi
STATE_BACKUP_DIR="${TMPDIR}/state.backup"
for state_name in .lang AGENTS.md SOUL.md IDENTITY.md USER.md TOOLS.md HEARTBEAT.md MEMORY.md CLAUDE.md credentials.json completions contexts credentials cron delivery-queue devices flows functions identity logs media memory plugins qqbot sessions skills state subagents tasks telegram tools workspace-state.json workspace-*; do
  for state_path in "${STATE_DIR}/"${state_name}; do
    [ -e "$state_path" ] || [ -L "$state_path" ] || continue
    mkdir -p "$STATE_BACKUP_DIR"
    cp -a "$state_path" "$STATE_BACKUP_DIR/$(basename "$state_path")" 2>/dev/null || true
  done
done

# Stop gateway service before replacing files (stop even if activating/restarting)
GATEWAY_WAS_RUNNING=0
if systemctl --user is-active --quiet omeniaclaw-gateway.service 2>/dev/null; then
  GATEWAY_WAS_RUNNING=1
fi
systemctl --user stop omeniaclaw-gateway.service 2>/dev/null || true
systemctl --user kill omeniaclaw-gateway.service 2>/dev/null || true
# Also kill any stray omeniaclaw processes (SIGKILL to avoid respawn)
pkill -9 -f "omeniaclaw.*gateway" 2>/dev/null || true
pkill -9 -f "node.*\.omeniaclaw" 2>/dev/null || true
:

# Ensure CWD is valid before removing install dir (avoids getcwd errors)
cd /tmp 2>/dev/null || cd /
rm -rf "${INSTALL_DIR}" >/dev/null 2>&1 || true
# If rm failed (locked files), remove contents individually
if [ -d "${INSTALL_DIR}" ]; then
  find "${INSTALL_DIR}" -mindepth 1 -maxdepth 1 ! -name 'agents' ! -name 'workspace' -exec rm -rf {} + 2>/dev/null || true
fi
mkdir -p "${INSTALL_DIR}"
mkdir -p "${STATE_DIR}"
chmod 700 "${STATE_DIR}" 2>/dev/null || true
tar xzf "${TMPDIR}/${TARBALL}" -C "${INSTALL_DIR}" --strip-components=1

if [ -f "${TMPDIR}/.env.backup" ]; then
  cp "${TMPDIR}/.env.backup" "${STATE_DIR}/.env"
  echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_RESTORED_ENV}"
fi
if [ -f "${TMPDIR}/omeniaclaw.json.backup" ]; then
  cp "${TMPDIR}/omeniaclaw.json.backup" "${STATE_DIR}/omeniaclaw.json"
  [ -f "${TMPDIR}/omeniaclaw.json.bak.backup" ] && cp "${TMPDIR}/omeniaclaw.json.bak.backup" "${STATE_DIR}/omeniaclaw.json.bak"
  chmod 600 "${STATE_DIR}/omeniaclaw.json"
  echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_RESTORED_CONFIG}"
fi
if [ -d "${TMPDIR}/config.backup" ]; then
  cp -r "${TMPDIR}/config.backup" "${STATE_DIR}/config"
  echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_RESTORED_CONFIG}"
fi

if [ -d "${TMPDIR}/agents.backup" ]; then
  cp -r "${TMPDIR}/agents.backup" "${STATE_DIR}/agents"
fi
if [ -d "${TMPDIR}/workspace.backup" ]; then
  cp -r "${TMPDIR}/workspace.backup" "${STATE_DIR}/workspace"
fi
if [ -d "${TMPDIR}/state.backup" ]; then
  while IFS= read -r -d "" state_entry; do
    state_name="$(basename "$state_entry")"
    if [ -d "$state_entry" ] && [ ! -L "$state_entry" ]; then
      mkdir -p "${STATE_DIR}/$state_name"
      cp -a "$state_entry"/. "${STATE_DIR}/$state_name"/ 2>/dev/null || true
    elif [ ! -e "${STATE_DIR}/$state_name" ] && [ ! -L "${STATE_DIR}/$state_name" ]; then
      cp -a "$state_entry" "${STATE_DIR}/$state_name" 2>/dev/null || true
    fi
  done < <(find "${TMPDIR}/state.backup" -mindepth 1 -maxdepth 1 -print0)
fi
# Persist language preference for child processes (onboard, banner, etc.)
echo "$OMENIACLAW_LANG" > "${STATE_DIR}/.lang"
echo -e "${BAR_COLOR}│${NC}"

# ──── 5. Verify core dependencies ────
echo -e "${NODE_COLOR}⬡${NC}  ${BOLD}Dependencies${NC}"
if [ ! -d "${INSTALL_DIR}/node_modules" ]; then
  echo -e "${BAR_COLOR}│${NC}  ${DIM}${L_INSTALLING_DEPS}${NC}"
  ( cd "${INSTALL_DIR}" && npm install --omit=dev --ignore-scripts --legacy-peer-deps --fund=false --audit=false --loglevel=error )
  echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_DEPS_INSTALLED}"
else
  echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_DEPS_INCLUDED}"
fi
mkdir -p "${INSTALL_DIR}/node_modules"
rm -rf "${INSTALL_DIR}/node_modules/openclaw"
ln -s .. "${INSTALL_DIR}/node_modules/openclaw"
echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} Internal plugin SDK compatibility ready"
echo -e "${BAR_COLOR}│${NC}"

# ──── 6. Symlink ────
echo -e "${NODE_COLOR}⬡${NC}  ${BOLD}CLI Setup${NC}"
chmod +x "${INSTALL_DIR}/omeniaclaw.mjs"
BIN_LINK_DIR="$(dirname "$BIN_LINK")"
mkdir -p "$BIN_LINK_DIR" 2>/dev/null || true
WRAPPER_INSTALL_TARGET=$(printf '%q' "$INSTALL_DIR/omeniaclaw.mjs")
WRAPPER_STATE_DIR_ESCAPED=$(printf '%q' "$STATE_DIR")
BIN_WRAPPER="${TMPDIR}/omeniaclaw-bin"
cat > "$BIN_WRAPPER" <<WRAPEOF
#!/usr/bin/env bash
export OMENIACLAW_RUNTIME_NAME=omeniaclaw
export OMENIACLAW_STATE_DIR=$WRAPPER_STATE_DIR_ESCAPED
if [ -z "\${OPENCLAW_STATE_DIR:-}" ]; then
  export OPENCLAW_STATE_DIR=$WRAPPER_STATE_DIR_ESCAPED
fi
exec $WRAPPER_INSTALL_TARGET "\$@"
WRAPEOF
chmod +x "$BIN_WRAPPER"
if [ -w "$BIN_LINK_DIR" ]; then
  rm -f "$BIN_LINK"
  cp "$BIN_WRAPPER" "$BIN_LINK"
  chmod 755 "$BIN_LINK"
else
  echo -e "${BAR_COLOR}│${NC}  ${YELLOW}${L_SUDO_NEEDED}${NC}"
  sudo rm -f "$BIN_LINK"
  sudo cp "$BIN_WRAPPER" "$BIN_LINK"
  sudo chmod 755 "$BIN_LINK"
fi
echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_CMD_AVAILABLE}"

# ──── 7. Default .env (fresh install only) ────
if [ ! -f "${STATE_DIR}/.env" ]; then
  cat > "${STATE_DIR}/.env" << 'ENVEOF'
# OmeniaClaw Configuration — Powered by Omenia
# ANTHROPIC_API_KEY=sk-ant-...
# OPENAI_API_KEY=sk-...
# GOOGLE_AI_API_KEY=...
OMENIA_API_URL=https://omenia.io/api/v1
# OMENIA_API_KEY=om_claw_...
# OMENIACLAW_GATEWAY_URL=wss://omeniaclaw.com/ws
# OMENIACLAW_GATEWAY_TOKEN=
ENVEOF
  chmod 600 "${STATE_DIR}/.env"
  echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_ENV_CREATED}"
fi

# ──── 8. Re-enable previously disabled extensions ────
for ext in acpx alibaba arcee fireworks qwen; do
  EXT_DIR="${INSTALL_DIR}/dist-runtime/extensions/${ext}"
  rm -f "$EXT_DIR/.disabled" 2>/dev/null || true
done
echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_EXT_VERIFIED}"

# ──── 8b. Detect import sources ────
IMPORT_SOURCES=""
if [ -d "$HOME/.openclaw" ] || [ -d "$HOME/.clawdbot" ]; then
  IMPORT_SOURCES="${IMPORT_SOURCES}openclaw "
fi
if [ -d "$HOME/.claude" ] || [ -f "$HOME/.claude.json" ]; then
  IMPORT_SOURCES="${IMPORT_SOURCES}claude "
fi
if [ -d "$HOME/.config/Code/User/globalStorage/github.copilot-chat" ] || \
   [ -d "$HOME/.config/Code - Insiders/User/globalStorage/github.copilot-chat" ] || \
   [ -d "$HOME/.config/Code - OSS/User/globalStorage/github.copilot-chat" ] || \
   [ -d "$HOME/.config/VSCodium/User/globalStorage/github.copilot-chat" ] || \
   [ -d "$HOME/.config/Cursor/User/globalStorage/github.copilot-chat" ] || \
   [ -d "$HOME/.vscode-server/data/User/globalStorage/github.copilot-chat" ] || \
   [ -d "$HOME/.vscode-server-insiders/data/User/globalStorage/github.copilot-chat" ] || \
   find "$HOME/.config/Code/User/workspaceStorage" -maxdepth 2 -name "GitHub.copilot-chat" -type d 2>/dev/null | grep -q . || \
   find "$HOME/.vscode-server/data/User/workspaceStorage" -maxdepth 2 -name "GitHub.copilot-chat" -type d 2>/dev/null | grep -q . || \
   [ -d "$HOME/Library/Application Support/Code/User/globalStorage/github.copilot-chat" ] || \
   [ -d "$HOME/Library/Application Support/Code - Insiders/User/globalStorage/github.copilot-chat" ]; then
  IMPORT_SOURCES="${IMPORT_SOURCES}copilot "
fi
if [ -d "$HOME/.antigravity" ] || [ -d "$HOME/.config/antigravity" ]; then
  IMPORT_SOURCES="${IMPORT_SOURCES}antigravity "
fi

# ──── 9. Shell completion ────
COMPLETION_DIR="${STATE_DIR}/completions"
mkdir -p "$COMPLETION_DIR"
"${INSTALL_DIR}/omeniaclaw.mjs" completion --shell bash > "$COMPLETION_DIR/omeniaclaw.bash" 2>/dev/null || true
COMPLETION_LINE="[ -f \"${COMPLETION_DIR}/omeniaclaw.bash\" ] && source \"${COMPLETION_DIR}/omeniaclaw.bash\""
if [ -f "$HOME/.bashrc" ]; then
  sed -i '/omeniaclaw.*.bash/d' "$HOME/.bashrc" 2>/dev/null || true
  sed -i '/openclaw.bash/d' "$HOME/.bashrc" 2>/dev/null || true
  if ! grep -qF "$COMPLETION_LINE" "$HOME/.bashrc" 2>/dev/null; then
    echo "$COMPLETION_LINE" >> "$HOME/.bashrc"
  fi
fi
echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_COMPLETIONS_OK}"
echo -e "${BAR_COLOR}│${NC}"

# ══════════════════════════════════════════════════════════════
# Installation complete — transition to setup
# ══════════════════════════════════════════════════════════════
echo -e "${NODE_COLOR}⬡${NC}  ${GREEN}${BOLD}OmeniaClaw ${CYAN}${VERSION}${NC} ${GREEN}— ${L_INSTALLED_OK}${NC}"
echo -e "${BAR_COLOR}│${NC}"

# ──── Update mode: skip interactive setup ────
if [ "$UPDATE_ONLY" = true ]; then
  # Ensure minimal config exists (may be lost after a failed previous update)
  if [ ! -f "${STATE_DIR}/omeniaclaw.json" ]; then
    echo '{"gateway":{"mode":"local","port":19017,"bind":"loopback"}}' > "${STATE_DIR}/omeniaclaw.json"
    chmod 600 "${STATE_DIR}/omeniaclaw.json"
    echo -e "${BAR_COLOR}│${NC}  ${YELLOW}⚠${NC} Recreated default omeniaclaw.json (gateway.mode=local)"
  fi
  # Restart gateway if it was running before update
  if [ "${GATEWAY_WAS_RUNNING:-0}" = "1" ]; then
    systemctl --user start omeniaclaw-gateway.service 2>/dev/null || true
    echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} Gateway service restarted"
  fi
  echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} Updated to ${CYAN}${VERSION}${NC}"
  echo -e "${BAR_COLOR}│${NC}  ${DIM}Config, .env, and credentials preserved.${NC}"
  echo -e "${BAR_COLOR}└${NC}"
  echo ""
  exit 0
fi

# ──── 10a. Import wizard (inside clack flow) ────
if [ -n "$IMPORT_SOURCES" ] && [ -f "${INSTALL_DIR}/dist/import-omeniaclaw.mjs" ] && [ "$AUTO_YES" != "true" ] && [ "$SKIP_ONBOARD" != "1" ] && [ -t 1 ] && [ -e /dev/tty ]; then
  BOX_W=60
  BAR_LINE=$(printf '─%.0s' $(seq 1 $BOX_W))

  echo -e "${NODE_COLOR}⬡${NC}  ${BOLD}${L_IMPORT_DETECTED}${NC}"
  echo -e "${BAR_COLOR}│${NC}  ${BAR_COLOR}╭${BAR_LINE}╮${NC}"
  if [[ "$IMPORT_SOURCES" == *"openclaw"* ]]; then
    echo -e "${BAR_COLOR}│${NC}  ${BAR_COLOR}│${NC}  ${PURPLE}⬡${NC} ${L_IMPORT_OPENCLAW}$(printf '%*s' $((BOX_W - ${#L_IMPORT_OPENCLAW} - 4)) '')${BAR_COLOR}│${NC}"
  fi
  if [[ "$IMPORT_SOURCES" == *"claude"* ]]; then
    echo -e "${BAR_COLOR}│${NC}  ${BAR_COLOR}│${NC}  ${PURPLE}⬡${NC} ${L_IMPORT_CLAUDE}$(printf '%*s' $((BOX_W - ${#L_IMPORT_CLAUDE} - 4)) '')${BAR_COLOR}│${NC}"
  fi
  if [[ "$IMPORT_SOURCES" == *"copilot"* ]]; then
    echo -e "${BAR_COLOR}│${NC}  ${BAR_COLOR}│${NC}  ${PURPLE}⬡${NC} ${L_IMPORT_COPILOT}$(printf '%*s' $((BOX_W - ${#L_IMPORT_COPILOT} - 4)) '')${BAR_COLOR}│${NC}"
  fi
  if [[ "$IMPORT_SOURCES" == *"antigravity"* ]]; then
    echo -e "${BAR_COLOR}│${NC}  ${BAR_COLOR}│${NC}  ${PURPLE}⬡${NC} ${L_IMPORT_ANTIGRAVITY}$(printf '%*s' $((BOX_W - ${#L_IMPORT_ANTIGRAVITY} - 4)) '')${BAR_COLOR}│${NC}"
  fi
  echo -e "${BAR_COLOR}│${NC}  ${BAR_COLOR}╰${BAR_LINE}╯${NC}"
  echo -e "${BAR_COLOR}│${NC}"
  echo -ne "${NODE_COLOR}⬡${NC}  ${L_IMPORT_ASK} [${L_YES_DEFAULT}] "
  read -r IMPORT_ANSWER < /dev/tty
  IMPORT_ANSWER=${IMPORT_ANSWER:-Y}
  if [[ "$IMPORT_ANSWER" =~ ^[SsYy]$ ]]; then
    echo -e "${BAR_COLOR}│${NC}"
    if OMENIACLAW_LANG="$OMENIACLAW_LANG" node "${INSTALL_DIR}/dist/import-omeniaclaw.mjs" < /dev/tty; then
      OMENIACLAW_DID_IMPORT=1
    else
      echo -e "${BAR_COLOR}│${NC}  ${YELLOW}⚠${NC} ${L_IMPORT_FAILED}"
    fi
  fi
  echo -e "${BAR_COLOR}│${NC}"
fi

# ════════════════════════════════════════════════════════════════
# ──── 10b-bis. Persistent RAG memory (memory-lancedb) ────
# Configures the long-term memory plugin so every agent has
# vector recall across sessions. Embeddings backend is selectable:
#   A) OpenAI text-embedding-3-small  (recommended, requires API key)
#   B) Local llama.cpp + Qwen3-Embedding-0.6B (CPU, ~600 MB RAM)
#   C) Skip
# Idempotent: re-runs will detect existing config and skip.
# ════════════════════════════════════════════════════════════════
OMENIACLAW_CFG="${STATE_DIR}/omeniaclaw.json"
RAG_ALREADY_ENABLED=0
if [ -f "$OMENIACLAW_CFG" ] && grep -q '"memory-lancedb"' "$OMENIACLAW_CFG" 2>/dev/null && \
   grep -q '"enabled": *true' "$OMENIACLAW_CFG" 2>/dev/null; then
  # Heuristic: assume already configured if plugin block exists. User can
  # re-run with OMENIACLAW_FORCE_RAG=1 to redo the wizard.
  RAG_ALREADY_ENABLED=1
fi

if [ "${OMENIACLAW_FORCE_RAG:-0}" = "1" ]; then
  RAG_ALREADY_ENABLED=0
fi

if [ "$RAG_ALREADY_ENABLED" = "0" ] && [ "$AUTO_YES" != "true" ] && [ "$SKIP_ONBOARD" != "1" ] && [ -t 1 ] && [ -e /dev/tty ]; then
  echo -e "${NODE_COLOR}⬡${NC}  ${BOLD}Persistent RAG memory${NC}"
  echo -e "${BAR_COLOR}│${NC}  ${DIM}Enables vector recall of past chats across all agents.${NC}"
  echo -e "${BAR_COLOR}│${NC}  ${PURPLE}A)${NC} OpenAI text-embedding-3-small  ${DIM}(recommended, needs API key)${NC}"
  echo -e "${BAR_COLOR}│${NC}  ${PURPLE}B)${NC} Local llama.cpp + Qwen3-Embedding  ${DIM}(offline, ~600 MB RAM)${NC}"
  echo -e "${BAR_COLOR}│${NC}  ${PURPLE}C)${NC} Skip"
  echo -ne "${NODE_COLOR}⬡${NC}  Choose backend [A/b/c]: "
  read -r RAG_CHOICE < /dev/tty
  RAG_CHOICE=${RAG_CHOICE:-A}
  RAG_BACKEND=""
  RAG_DIM=1536
  RAG_BASE_URL=""
  case "$RAG_CHOICE" in
    [Aa]*)
      RAG_BACKEND="openai"
      echo -ne "${BAR_COLOR}│${NC}  Paste OPENAI_API_KEY (sk-…): "
      read -r -s RAG_OPENAI_KEY < /dev/tty
      echo ""
      if [ -z "${RAG_OPENAI_KEY:-}" ]; then
        echo -e "${BAR_COLOR}│${NC}  ${YELLOW}No key supplied — skipping RAG setup.${NC}"
        RAG_BACKEND=""
      fi
      ;;
    [Bb]*)
      RAG_BACKEND="local"
      RAG_DIM=1024
      RAG_BASE_URL="http://127.0.0.1:8181/v1"
      ;;
    *) RAG_BACKEND="" ;;
  esac

  if [ -n "$RAG_BACKEND" ]; then
    # ── 1. Patch omeniaclaw.json with plugin block (jq if available, else node) ──
    PATCH_SCRIPT=$(cat <<'NODEEOF'
const fs = require('fs');
const path = require('path');
const file = process.argv[1];
const backend = process.argv[2];
const dim = parseInt(process.argv[3], 10);
const baseUrl = process.argv[4] || '';
let cfg = {};
try {
  cfg = JSON.parse(fs.readFileSync(file, 'utf8'));
} catch (err) {
  if (err.code !== 'ENOENT') throw err;
}
fs.mkdirSync(path.dirname(file), { recursive: true });
cfg.plugins = cfg.plugins || {};
cfg.plugins.entries = cfg.plugins.entries || {};
cfg.plugins.slots = cfg.plugins.slots || {};
cfg.plugins.slots.memory = 'memory-lancedb';
cfg.plugins.entries['memory-lancedb'] = {
  enabled: true,
  config: {
    embedding: Object.assign(
      {
        apiKey: '${OPENAI_API_KEY}',
        model: backend === 'local' ? 'qwen3-embedding-0.6b' : 'text-embedding-3-small',
        dimensions: dim,
      },
      baseUrl ? { baseUrl } : {},
    ),
    dbPath: '~/.omeniaclaw/memory/lancedb',
    autoCapture: true,
    autoRecall: true,
    captureMaxChars: 2000,
  },
};
fs.writeFileSync(file, JSON.stringify(cfg, null, 2));
NODEEOF
)
    cp "$OMENIACLAW_CFG" "${OMENIACLAW_CFG}.bak.pre-rag.$(date +%s)" 2>/dev/null || true
    node -e "$PATCH_SCRIPT" "$OMENIACLAW_CFG" "$RAG_BACKEND" "$RAG_DIM" "$RAG_BASE_URL"
    echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} memory-lancedb enabled in omeniaclaw.json"

    if [ "$RAG_BACKEND" = "openai" ]; then
      # ── 2a. ENV trio: systemd drop-in + environment.d + bashrc PREPEND ──
      mkdir -p "$HOME/.config/environment.d"
      ENVD="$HOME/.config/environment.d/omeniaclaw-embeddings.conf"
      printf 'OPENAI_API_KEY=%s\n' "$RAG_OPENAI_KEY" > "$ENVD"
      chmod 600 "$ENVD"

      if command -v systemctl &>/dev/null; then
        SYSD="$HOME/.config/systemd/user/omeniaclaw-gateway.service.d"
        mkdir -p "$SYSD"
        DROPIN="$SYSD/openai-embeddings.conf"
        {
          printf '[Service]\n'
          printf 'Environment="OPENAI_API_KEY=%s"\n' "$RAG_OPENAI_KEY"
        } > "$DROPIN"
        chmod 600 "$DROPIN"
        systemctl --user daemon-reload 2>/dev/null || true
      fi

      # bashrc PREPEND (must run BEFORE the default interactive guard)
      BASHRC="$HOME/.bashrc"
      LOAD_LINE="[ -f ~/.config/environment.d/omeniaclaw-embeddings.conf ] && set -a && . ~/.config/environment.d/omeniaclaw-embeddings.conf && set +a"
      if [ -f "$BASHRC" ] && ! grep -qF "omeniaclaw-embeddings.conf" "$BASHRC"; then
        TMPRC=$(mktemp)
        { printf '%s\n' "$LOAD_LINE"; cat "$BASHRC"; } > "$TMPRC"
        mv "$TMPRC" "$BASHRC"
      fi
      export OPENAI_API_KEY="$RAG_OPENAI_KEY"
      echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} OPENAI_API_KEY persisted (systemd + environment.d + bashrc)"
    fi

    if [ "$RAG_BACKEND" = "local" ]; then
      # ── 2b. Provision llama.cpp + Qwen3-Embedding-0.6B (best effort) ──
      LLAMA_DIR="$HOME/.local/share/llama.cpp"
      MODEL_DIR="$HOME/.local/share/llama-models"
      mkdir -p "$LLAMA_DIR" "$MODEL_DIR"
      MODEL_FILE="$MODEL_DIR/Qwen3-Embedding-0.6B-Q8_0.gguf"
      if [ ! -f "$MODEL_FILE" ]; then
        echo -e "${BAR_COLOR}│${NC}  Downloading Qwen3-Embedding-0.6B (~660 MB)…"
        curl -fL --progress-bar \
          -o "${MODEL_FILE}.tmp" \
          'https://huggingface.co/Qwen/Qwen3-Embedding-0.6B-GGUF/resolve/main/Qwen3-Embedding-0.6B-Q8_0.gguf' \
          && mv "${MODEL_FILE}.tmp" "$MODEL_FILE" \
          || echo -e "${BAR_COLOR}│${NC}  ${YELLOW}⚠ Model download failed — finish manually later.${NC}"
      fi

      if [ ! -x "$LLAMA_DIR/llama-server" ]; then
        echo -e "${BAR_COLOR}│${NC}  Downloading llama-server…"
        _LLAMA_OS=""
        _LLAMA_ARCH=""
        case "$(uname -s)" in Linux) _LLAMA_OS="ubuntu" ;; Darwin) _LLAMA_OS="macos" ;; esac
        case "$(uname -m)" in x86_64) _LLAMA_ARCH="x64" ;; aarch64|arm64) _LLAMA_ARCH="arm64" ;; esac
        if [ -n "$_LLAMA_OS" ] && [ -n "$_LLAMA_ARCH" ]; then
          _LLAMA_TAG=$(curl -sf "https://api.github.com/repos/ggml-org/llama.cpp/releases/latest" | \
            python3 -c "import sys,json; print(json.load(sys.stdin)['tag_name'])" 2>/dev/null || true)
          if [ -n "$_LLAMA_TAG" ]; then
            _LLAMA_ASSET="llama-$_LLAMA_TAG-bin-$_LLAMA_OS-$_LLAMA_ARCH.tar.gz"
            _LLAMA_URL="https://github.com/ggml-org/llama.cpp/releases/download/$_LLAMA_TAG/$_LLAMA_ASSET"
            if curl -fL --progress-bar -o "/tmp/llama-release.tar.gz" "$_LLAMA_URL"; then
              tar -xzf "/tmp/llama-release.tar.gz" -C "$LLAMA_DIR" --strip-components=1
              rm -f "/tmp/llama-release.tar.gz"
              chmod +x "$LLAMA_DIR/llama-server" 2>/dev/null || true
              echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} llama-server installed"
            else
              echo -e "${BAR_COLOR}│${NC}  ${YELLOW}⚠ Download failed — install manually later.${NC}"
            fi
          else
            echo -e "${BAR_COLOR}│${NC}  ${YELLOW}⚠ Could not fetch release info — install llama-server manually.${NC}"
          fi
        else
          echo -e "${BAR_COLOR}│${NC}  ${YELLOW}⚠ Unsupported platform — install llama-server manually.${NC}"
        fi
      fi

      if command -v systemctl &>/dev/null; then
        UNIT_DIR="$HOME/.config/systemd/user"
        mkdir -p "$UNIT_DIR"
        cat > "$UNIT_DIR/llama-embed.service" <<UNITEOF
[Unit]
Description=llama.cpp embeddings server (OmeniaClaw RAG)
After=default.target

[Service]
Type=simple
Environment=LD_LIBRARY_PATH=$LLAMA_DIR
ExecStart=$LLAMA_DIR/llama-server --embedding -m $MODEL_FILE --host 127.0.0.1 --port 8181 -c 8192 --pooling mean
Restart=on-failure
MemoryMax=2G

[Install]
WantedBy=default.target
UNITEOF
        systemctl --user daemon-reload 2>/dev/null || true
        if [ -x "$LLAMA_DIR/llama-server" ] && [ -f "$MODEL_FILE" ]; then
          systemctl --user enable --now llama-embed.service 2>/dev/null || true
          echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} llama-embed.service running on 127.0.0.1:8181"
        else
          echo -e "${BAR_COLOR}│${NC}  ${DIM}llama-embed.service installed (start manually after llama-server is in place).${NC}"
        fi
      fi
      # Plugin uses baseUrl http://127.0.0.1:8181/v1 — no API key required, but OpenAI client needs a non-empty value.
      OPENAI_API_KEY_LOCAL_PLACEHOLDER="local-no-key"
      mkdir -p "$HOME/.config/environment.d"
      printf 'OPENAI_API_KEY=%s\n' "$OPENAI_API_KEY_LOCAL_PLACEHOLDER" > "$HOME/.config/environment.d/omeniaclaw-embeddings.conf"
      chmod 600 "$HOME/.config/environment.d/omeniaclaw-embeddings.conf"
      export OPENAI_API_KEY="$OPENAI_API_KEY_LOCAL_PLACEHOLDER"
    fi

    # ── 3. Backfill: ingest historical chats imported in step 10b ──
    INGESTER="${INSTALL_DIR}/dist/extensions/memory-lancedb/scripts/ingest.mjs"
    if [ -f "$INGESTER" ] && [ "${OMENIACLAW_DID_IMPORT:-0}" = "1" ]; then
      echo -ne "${NODE_COLOR}⬡${NC}  Embed imported historical chats into RAG now? [Y/n] "
      read -r INGEST_ANSWER < /dev/tty
      INGEST_ANSWER=${INGEST_ANSWER:-Y}
      if [[ "$INGEST_ANSWER" =~ ^[SsYy]$ ]]; then
        node "$INGESTER" || echo -e "${BAR_COLOR}│${NC}  ${YELLOW}⚠ Ingester finished with errors (re-run later: omeniaclaw memory ingest).${NC}"
      else
        echo -e "${BAR_COLOR}│${NC}  ${DIM}Skipped — run later: node $INGESTER${NC}"
      fi
    fi

    if command -v systemctl &>/dev/null; then
      systemctl --user restart omeniaclaw-gateway 2>/dev/null || true
    fi
  else
    echo -e "${BAR_COLOR}│${NC}  ${DIM}RAG memory skipped.${NC}"
  fi
fi

# ──── 10b-ter. Defensive auth-profiles.json sanity check ────
# An empty / 0-byte auth-profiles.json caused multi-hour silent hangs
# ("streaming infinito") on agents using cloud providers. Repair now.
for AGENT_DIR in "$INSTALL_DIR"/agents/*/agent; do
  [ -d "$AGENT_DIR" ] || continue
  AP="$AGENT_DIR/auth-profiles.json"
  if [ -f "$AP" ] && [ ! -s "$AP" ]; then
    printf '{"profiles":{},"lastUpdated":%d}\n' "$(date +%s)" > "$AP"
    echo -e "  ${GREEN}✓${NC} Repaired empty auth-profiles.json: $AP"
  fi
done

# ──── 10c. Connect to omenia.io (inside clack flow) ────
CREDS_FILE="${INSTALL_DIR}/credentials.json"
if [ "$AUTO_YES" != "true" ] && [ "$SKIP_ONBOARD" != "1" ] && [ -t 1 ] && [ -e /dev/tty ] && [ ! -f "$CREDS_FILE" ]; then
  BOX_W=60
  BAR_LINE=$(printf '─%.0s' $(seq 1 $BOX_W))

  echo -e "${NODE_COLOR}⬡${NC}  ${BOLD}${L_CONNECT_TITLE}${NC}"
  echo -e "${BAR_COLOR}│${NC}  ${BAR_COLOR}╭${BAR_LINE}╮${NC}"
  echo -e "${BAR_COLOR}│${NC}  ${BAR_COLOR}│${NC}  ${DIM}${L_CONNECT_DESC}${NC}"
  echo -e "${BAR_COLOR}│${NC}  ${BAR_COLOR}╰${BAR_LINE}╯${NC}"
  echo -e "${BAR_COLOR}│${NC}"
  echo -e "${BAR_COLOR}│${NC}  ${PURPLE}1)${NC} ${ACCENT}${L_CONNECT_1}${NC}"
  echo -e "${BAR_COLOR}│${NC}  ${PURPLE}2)${NC} ${ACCENT}${L_CONNECT_2}${NC}"
  echo -e "${BAR_COLOR}│${NC}  ${PURPLE}3)${NC} ${DIM}${L_CONNECT_3}${NC}"
  echo -ne "${NODE_COLOR}⬡${NC}  ${L_OPTION} [1/2/3]: "
  read -r CONN_CHOICE < /dev/tty
  CONN_CHOICE=${CONN_CHOICE:-3}

  _do_omenia_auth() {
    local ACTION="$1"
    local EMAIL="" PASS="" NAME="" RESPONSE=""
    echo -e "${BAR_COLOR}│${NC}"
    echo -ne "${BAR_COLOR}│${NC}  ${L_CONNECT_EMAIL}"
    read -r EMAIL < /dev/tty
    echo -ne "${BAR_COLOR}│${NC}  ${L_CONNECT_PASS}"
    read -r -s PASS < /dev/tty
    echo ""
    if [ "$ACTION" = "register" ]; then
      echo -ne "${BAR_COLOR}│${NC}  ${L_CONNECT_NAME}"
      read -r NAME < /dev/tty
    fi

    # Build JSON safely — use printf pipe (heredocs break in curl|bash)
    local PAYLOAD
    if command -v python3 &>/dev/null; then
      PAYLOAD=$(printf '%s\n' "$EMAIL" "$PASS" "$NAME" | python3 -c "
import json,sys
d={'action':'$ACTION','email':sys.stdin.readline().strip(),'password':sys.stdin.readline().strip(),'device_name':'$(hostname)'}
if '$ACTION'=='register':
  d['name']=sys.stdin.readline().strip()
  d['lang']='${OMENIACLAW_LANG}'
print(json.dumps(d))
")
    elif command -v node &>/dev/null; then
      PAYLOAD=$(node -e "
var d={action:'$ACTION',email:process.argv[1],password:process.argv[2],device_name:'$(hostname)'};
if('$ACTION'==='register'){d.name=process.argv[3];d.lang='${OMENIACLAW_LANG}';}
console.log(JSON.stringify(d));
" "$EMAIL" "$PASS" "$NAME")
    else
      # Fallback: escape special JSON chars manually
      local ESC_PASS=$(printf '%s' "$PASS" | sed 's/\\/\\\\/g; s/"/\\"/g')
      local ESC_EMAIL=$(printf '%s' "$EMAIL" | sed 's/\\/\\\\/g; s/"/\\"/g')
      local ESC_NAME=$(printf '%s' "$NAME" | sed 's/\\/\\\\/g; s/"/\\"/g')
      if [ "$ACTION" = "register" ]; then
        PAYLOAD="{\"action\":\"register\",\"email\":\"${ESC_EMAIL}\",\"password\":\"${ESC_PASS}\",\"name\":\"${ESC_NAME}\",\"device_name\":\"$(hostname)\",\"lang\":\"${OMENIACLAW_LANG}\"}"
      else
        PAYLOAD="{\"action\":\"login\",\"email\":\"${ESC_EMAIL}\",\"password\":\"${ESC_PASS}\",\"device_name\":\"$(hostname)\"}"
      fi
    fi

    echo -e "${BAR_COLOR}│${NC}  ${DIM}(payload: ${#PAYLOAD} bytes)${NC}"

    local RESP_FILE=$(mktemp)
    local HTTP_CODE=""
    RESPONSE=""

    if command -v curl &>/dev/null; then
      HTTP_CODE=$(curl -sS --max-time 20 \
        -w "%{http_code}" -o "$RESP_FILE" \
        -X POST "https://omenia.io/api/v1/claw/auth" \
        -H "Content-Type: application/json" \
        -H "Accept-Encoding: identity" \
        -H "User-Agent: OmeniaClaw/${VERSION}" \
        -d "$PAYLOAD" 2>/dev/null) || true
      RESPONSE=$(cat "$RESP_FILE" 2>/dev/null)

      if [ "$HTTP_CODE" = "200" ] && [ -z "$RESPONSE" ] && command -v wget &>/dev/null; then
        echo -e "${BAR_COLOR}│${NC}  ${DIM}(curl empty, retrying with wget...)${NC}"
        wget -q --timeout=20 -O "$RESP_FILE" --post-data="$PAYLOAD" \
          --header="Content-Type: application/json" \
          --header="Accept-Encoding: identity" \
          --header="User-Agent: OmeniaClaw/${VERSION}" \
          "https://omenia.io/api/v1/claw/auth" 2>/dev/null || true
        RESPONSE=$(cat "$RESP_FILE" 2>/dev/null)
        HTTP_CODE="wget"
      fi

    elif command -v wget &>/dev/null; then
      wget -q --timeout=20 -O "$RESP_FILE" --post-data="$PAYLOAD" \
        --header="Content-Type: application/json" \
        --header="Accept-Encoding: identity" \
        --header="User-Agent: OmeniaClaw/${VERSION}" \
        "https://omenia.io/api/v1/claw/auth" 2>/dev/null || true
      HTTP_CODE="wget"
      RESPONSE=$(cat "$RESP_FILE" 2>/dev/null)
    fi
    rm -f "$RESP_FILE" 2>/dev/null

    echo -e "${BAR_COLOR}│${NC}  ${DIM}(http: ${HTTP_CODE:-?}, response: ${#RESPONSE} bytes)${NC}"

    local OK=$(echo "$RESPONSE" | grep -o '"ok":true' || true)
    if [ -n "$OK" ]; then
      echo "$RESPONSE" > "$CREDS_FILE"
      chmod 600 "$CREDS_FILE"
      local USER_NAME=$(echo "$RESPONSE" | grep -o '"name":"[^"]*"' | head -1 | cut -d'"' -f4)
      local USER_PLAN=$(echo "$RESPONSE" | grep -o '"plan":"[^"]*"' | head -1 | cut -d'"' -f4)
      echo -e "${BAR_COLOR}│${NC}"
      echo -e "${BAR_COLOR}│${NC}  ${GREEN}✓${NC} ${L_CONNECT_OK}"
      echo -e "${BAR_COLOR}│${NC}  ${L_CONNECT_WELCOME}, ${BOLD}${USER_NAME}${NC} (${L_CONNECT_PLAN}: ${ACCENT}${USER_PLAN}${NC})"
      if echo "$RESPONSE" | grep -q '"verify_email":true'; then
        echo -e "${BAR_COLOR}│${NC}  ${YELLOW}→${NC} ${L_CONNECT_VERIFY}"
      fi
    else
      local ERR=$(echo "$RESPONSE" | grep -o '"error":"[^"]*"' | head -1 | cut -d'"' -f4)
      if [ -z "$ERR" ] && [ -z "$RESPONSE" ]; then
        ERR="No response from server (check your internet connection)"
      elif [ -z "$ERR" ]; then
        ERR="Unexpected response: $(echo "$RESPONSE" | head -c 120)"
      fi
      echo -e "${BAR_COLOR}│${NC}  ${RED}✗${NC} ${L_CONNECT_FAIL}: ${ERR}"
    fi
  }

  case "$CONN_CHOICE" in
    1) _do_omenia_auth "login" ;;
    2)
      echo -e "${BAR_COLOR}│${NC}  ${DIM}${L_CONNECT_PASS_RULE}${NC}"
      _do_omenia_auth "register"
      ;;
    *)
      echo -e "${BAR_COLOR}│${NC}  ${DIM}${L_CONNECT_SKIP}${NC}"
      ;;
  esac
  echo -e "${BAR_COLOR}│${NC}"
fi

# ──── 10d. Next steps (inside clack flow) ────
echo -e "${NODE_COLOR}⬡${NC}  ${BOLD}${L_NEXT_STEPS}${NC}"
echo -e "${BAR_COLOR}│${NC}"
echo -e "${BAR_COLOR}│${NC}  ${PURPLE}1.${NC} ${L_NEXT_1}"
echo -e "${BAR_COLOR}│${NC}     ${BOLD}omeniaclaw onboard${NC}        ← ${L_NEXT_1A}"
echo -e "${BAR_COLOR}│${NC}     ${BOLD}omeniaclaw configure${NC}      ← ${L_NEXT_1B}"
echo -e "${BAR_COLOR}│${NC}"
echo -e "${BAR_COLOR}│${NC}  ${PURPLE}2.${NC} ${L_NEXT_2}"
echo -e "${BAR_COLOR}│${NC}     ${BOLD}omeniaclaw tui${NC}            ← ${L_NEXT_2A}"
echo -e "${BAR_COLOR}│${NC}     ${BOLD}omeniaclaw gateway${NC}        ← ${L_NEXT_2B}"
echo -e "${BAR_COLOR}│${NC}     ${BOLD}omeniaclaw doctor${NC}         ← ${L_NEXT_2C}"
echo -e "${BAR_COLOR}│${NC}"
echo -e "${BAR_COLOR}│${NC}  ${PURPLE}3.${NC} ${L_NEXT_3}"
echo -e "${BAR_COLOR}│${NC}     ${BOLD}omeniaclaw doctor${NC}"
echo -e "${BAR_COLOR}│${NC}"
echo -e "${BAR_COLOR}│${NC}  ${PURPLE}4.${NC} ${L_NEXT_4}"
echo -e "${BAR_COLOR}│${NC}     ${BOLD}omeniaclaw onboard --auth-choice claude-cli${NC}"
echo -e "${BAR_COLOR}│${NC}     ${L_NEXT_4B} ${BOLD}omeniaclaw onboard --anthropic-api-key sk-ant-...${NC}"
echo -e "${BAR_COLOR}│${NC}"

# ──── 10e. Offer to run onboard wizard (inside clack flow) ────
if [ "$AUTO_YES" != "true" ] && [ "$SKIP_ONBOARD" != "1" ] && [ -t 1 ] && [ -e /dev/tty ]; then
  echo -e "${NODE_COLOR}⬡${NC}  ${L_ONBOARD_ASK}"
  echo -e "${BAR_COLOR}│${NC}  ${PURPLE}1)${NC} ${ACCENT}${L_ONBOARD_1}${NC} (${L_ONBOARD_1D})"
  echo -e "${BAR_COLOR}│${NC}  ${PURPLE}2)${NC} ${ACCENT}${L_ONBOARD_2}${NC} (${L_ONBOARD_2D})"
  echo -e "${BAR_COLOR}│${NC}  ${PURPLE}3)${NC} ${DIM}${L_ONBOARD_3} (${L_ONBOARD_3D})${NC}"
  echo -ne "${NODE_COLOR}⬡${NC}  ${L_OPTION} [1/2/3]: "
  read -r ONBOARD_CHOICE < /dev/tty
  ONBOARD_CHOICE=${ONBOARD_CHOICE:-1}
  case "$ONBOARD_CHOICE" in
    1)
      echo -e "${BAR_COLOR}│${NC}"
      echo -e "${BAR_COLOR}└${NC}  ${DIM}Launching onboard wizard...${NC}"
      echo ""
      set +e
      trap '' INT
      ( trap - INT; OMENIACLAW_LANG="$OMENIACLAW_LANG" omeniaclaw onboard < /dev/tty )
      ONBOARD_STATUS=$?
      trap - INT
      set -e
      if [ "$ONBOARD_STATUS" -ne 0 ]; then
        echo -e "${BAR_COLOR}│${NC}"
        echo -e "${BAR_COLOR}└${NC}  ${YELLOW}⚠${NC} ${L_ONBOARD_FAILED}"
      fi
      ;;
    2)
      echo -e "${BAR_COLOR}│${NC}"
      echo -e "${BAR_COLOR}└${NC}  ${DIM}Launching quick setup...${NC}"
      echo ""
      set +e
      trap '' INT
      ( trap - INT; OMENIACLAW_LANG="$OMENIACLAW_LANG" omeniaclaw configure < /dev/tty )
      CONFIG_STATUS=$?
      trap - INT
      set -e
      if [ "$CONFIG_STATUS" -ne 0 ]; then
        echo -e "${BAR_COLOR}│${NC}"
        echo -e "${BAR_COLOR}└${NC}  ${YELLOW}⚠${NC} ${L_CONFIG_FAILED}"
      fi
      ;;
    *)
      echo -e "${BAR_COLOR}│${NC}"
      echo -e "${BAR_COLOR}└${NC}  ${GREEN}${L_ONBOARD_SKIP}${NC}"
      echo ""
      ;;
  esac
else
  echo -e "${BAR_COLOR}└${NC}  ${GREEN}${L_ONBOARD_SKIP}${NC}"
  echo ""
fi