setup

#!/usr/bin/env bash
# iNiR setup - installer and maintenance entrypoint
# Commands: install, update, status, migrate, doctor, rollback, my-changes, uninstall (or TUI if no args)

resolve_bootstrap_repo_root() {
    local script_dir="$1"

    if [[ -d "${script_dir}/.git" && -f "${script_dir}/setup" && -f "${script_dir}/shell.qml" ]]; then
        printf '%s' "$script_dir"
        return
    fi

    local xdg_config_home="${XDG_CONFIG_HOME:-$HOME/.config}"
    local config_new="${xdg_config_home}/inir"
    local config_legacy="${xdg_config_home}/illogical-impulse"
    local config_dir=""

    if [[ -L "$config_legacy" && -d "$config_new" ]]; then
        config_dir="$config_new"
    elif [[ -d "$config_legacy" ]]; then
        config_dir="$config_legacy"
    elif [[ -d "$config_new" ]]; then
        config_dir="$config_new"
    else
        config_dir="$config_new"
    fi

    local version_file="${config_dir}/version.json"
    local stored_repo=""

    if [[ -f "$version_file" ]]; then
        if command -v jq >/dev/null 2>&1; then
            stored_repo=$(jq -r '.repoPath // .repo_path // empty' "$version_file" 2>/dev/null || true)
        else
            stored_repo=$(sed -n 's/.*"repoPath"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$version_file" | head -1)
            [[ -n "$stored_repo" ]] || stored_repo=$(sed -n 's/.*"repo_path"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$version_file" | head -1)
        fi
    fi

    stored_repo="${stored_repo/#\~/$HOME}"

    if [[ -n "$stored_repo" && -d "${stored_repo}/.git" && -f "${stored_repo}/setup" && -f "${stored_repo}/shell.qml" ]]; then
        printf '%s' "$stored_repo"
        return
    fi

    printf '%s' "$script_dir"
}

SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
REPO_ROOT="$(resolve_bootstrap_repo_root "$SCRIPT_DIR")"

if [[ ! -d "$REPO_ROOT" || ! -f "$REPO_ROOT/shell.qml" ]]; then
    echo "Error: Could not find iNiR repository (resolved to: ${REPO_ROOT:-<empty>})" >&2
    echo "Run this script from the iNiR repo directory, or fix ~/.config/inir/version.json" >&2
    exit 1
fi

cd "$REPO_ROOT"

# Handle Ctrl+C gracefully
cleanup() {
    type _tui_kill_spinner &>/dev/null && _tui_kill_spinner 2>/dev/null || true
    echo ""
    echo -e "\033[33mCancelled.\033[0m"
    rm -rf /tmp/buildyay /tmp/buildparu 2>/dev/null
    exit 130
}

###############################################################################
# Migrate
###############################################################################
run_migrate() {
    echo ""
    tui_title "iNiR Migrations"
    echo ""

    sync_launcher_from_repo

    # Always apply REQUIRED migrations first
    run_migrations_auto

    local pending=$(count_pending_migrations 2>/dev/null || echo "0")
    if [[ "$pending" -gt 0 ]]; then
        tui_warn "$pending pending migration(s)"
        run_migrations_interactive
    else
        tui_success "No pending migrations"
    fi
}
trap cleanup INT
trap 'type _tui_kill_spinner &>/dev/null && _tui_kill_spinner 2>/dev/null || true; rm -rf /tmp/buildyay /tmp/buildparu 2>/dev/null' EXIT TERM

# Load core libraries
source ./sdata/lib/environment-variables.sh
source ./sdata/lib/functions.sh
source ./sdata/lib/tui.sh
source ./sdata/lib/package-installers.sh
source ./sdata/lib/dist-determine.sh
source ./sdata/lib/conflicts.sh
source ./sdata/lib/versioning.sh
source ./sdata/lib/migrations.sh
source ./sdata/lib/robust-update.sh
source ./sdata/lib/extras.sh
source ./sdata/lib/doctor.sh
source ./sdata/lib/snapshots.sh
source ./sdata/lib/uninstall.sh
source ./sdata/lib/user-modifications.sh

prevent_sudo_or_root

# Defaults
ask=true
quiet=false

# Auto-detect non-interactive context (no terminal on stdin).
# Forces non-interactive mode when launched from QML Process, cron, systemd, etc.
# This is defense-in-depth alongside the -y flag.
if ! [ -t 0 ]; then
    ask=false
    quiet=true
fi

# DISABLED: webapps — requires quickshell-webengine rebuild, re-enable when ready
# _build_install_qs_webengine() {
#     local build_script="${REPO_ROOT}/scripts/quickshell-webengine/build-quickshell-webengine.sh"
#     local pkgbuild_dir="${REPO_ROOT}/scripts/quickshell-webengine"
#
#     if pacman -Q quickshell &>/dev/null 2>&1 && ! pacman -Q quickshell-webengine-git &>/dev/null 2>&1; then
#         tui_info "Removing stock quickshell (will be replaced by webengine build)..."
#         pkg_sudo pacman -Rdd --noconfirm quickshell 2>/dev/null || true
#     fi
#
#     if command -v makepkg >/dev/null 2>&1 && [[ -f "${pkgbuild_dir}/PKGBUILD" ]]; then
#         tui_info "Building with PKGBUILD (Arch)..."
#         (cd "$pkgbuild_dir" && makepkg -sif --noconfirm) && tui_success "quickshell-webengine installed!" || tui_warn "Build failed — see errors above"
#     elif [[ -f "$build_script" ]]; then
#         tui_info "Building with generic script..."
#         bash "$build_script" --install && tui_success "quickshell-webengine installed!" || tui_warn "Build failed — see errors above"
#     else
#         tui_warn "No build method available"
#     fi
# }

# Check privilege escalation availability
_check_privilege_prereqs() {
  # Load the package installers to get access to privilege detection
  source ./sdata/lib/package-installers.sh 2>/dev/null
  
  local can_escalate=false
  local method=""
  
  # Check each method
  if command -v sudo &>/dev/null && sudo -n true 2>/dev/null; then
    can_escalate=true
    method="sudo"
  elif command -v pkexec &>/dev/null && ( [[ -n "${DBUS_SESSION_BUS_ADDRESS}" ]] || [[ -n "${DISPLAY}" ]] || [[ -n "${WAYLAND_DISPLAY}" ]] ); then
    can_escalate=true
    method="pkexec"
  elif command -v su &>/dev/null && [[ -z "${DISPLAY}" ]] && [[ -z "${WAYLAND_DISPLAY}" ]]; then
    can_escalate=true
    method="su"
  fi
  
  if ! $can_escalate; then
    echo ""
    tui_warn "No privilege escalation method detected!"
    echo ""
    echo "This may cause installation to fail if sudo credentials are not cached."
    echo ""
    echo "Detected environment:"
    [[ -n "${DISPLAY}" ]] && echo "  - DISPLAY: ${DISPLAY}" || echo "  - DISPLAY: (not set)"
    [[ -n "${WAYLAND_DISPLAY}" ]] && echo "  - WAYLAND: ${WAYLAND_DISPLAY}" || echo "  - WAYLAND: (not set)"
    [[ -n "${DBUS_SESSION_BUS_ADDRESS}" ]] && echo "  - D-Bus: available" || echo "  - D-Bus: (not set)"
    echo "  - sudo: $(command -v sudo &>/dev/null && echo 'available' || echo 'not found')"
    echo "  - pkexec: $(command -v pkexec &>/dev/null && echo 'available' || echo 'not found')"
    echo "  - su: $(command -v su &>/dev/null && echo 'available' || echo 'not found')"
    echo ""
    
    # Only warn in non-interactive mode, otherwise let user decide
    if [[ "$1" == "install" ]] && [[ "$ask" == "false" ]]; then
      tui_warn "Running in non-interactive mode - may fail. Consider:"
      echo "  1. Running interactively: ./setup install"
      echo "  2. Configure sudo first: sudo visudo"
      echo "  3. Or use a graphical terminal with polkit agent"
      echo ""
    fi
  fi
}

sync_launcher_from_repo() {
    local launcher_target="${XDG_BIN_HOME}/inir"
    if [[ -f "${REPO_ROOT}/scripts/inir" ]]; then
        mkdir -p "$XDG_BIN_HOME"
        cp -f "${REPO_ROOT}/scripts/inir" "$launcher_target"
        chmod +x "$launcher_target"
        ensure_launcher_path_in_shells "$XDG_BIN_HOME"
        printf '%s\n' "$launcher_target"
    fi
}

sync_user_inir_service_from_repo_if_present() {
    local service_asset="${REPO_ROOT}/assets/systemd/inir.service"
    local service_target_dir="${XDG_CONFIG_HOME}/systemd/user"
    local service_target="${service_target_dir}/inir.service"
    local launcher_target="${XDG_BIN_HOME}/inir"
    local tmp_file
    local changed=false

    [[ -f "$service_asset" ]] || return 1
    [[ -f "$service_target" ]] || return 1

    mkdir -p "$service_target_dir"
    mkdir -p "${XDG_CACHE_HOME:-$HOME/.cache}"
    tmp_file="${XDG_CACHE_HOME:-$HOME/.cache}/inir.service.$$"

    sed -e "s|^ExecStart=.*|ExecStart=${launcher_target//&/\\&} run --session|" \
        -e "s|^ExecStopPost=-.*|ExecStopPost=-${launcher_target//&/\\&} cleanup-orphans|" \
        "$service_asset" > "$tmp_file"

    if [[ -L "$service_target" ]]; then
        local service_dropin_dir="${service_target_dir}/inir.service.d"
        local service_override="${service_dropin_dir}/override.conf"
        local override_tmp="${XDG_CACHE_HOME:-$HOME/.cache}/inir.service.override.$$"
        mkdir -p "$service_dropin_dir"
        cat > "$override_tmp" <<EOF
# Managed locally: keep the repo unit template portable while running the
# developer launcher path from this machine.
[Service]
ExecStart=
ExecStart=${launcher_target} run --session
ExecStopPost=
ExecStopPost=-${launcher_target} cleanup-orphans
EOF
        if ! cmp -s "$override_tmp" "$service_override"; then
            changed=true
            cp -f "$override_tmp" "$service_override"
        fi
        rm -f "$override_tmp"
    elif ! cmp -s "$tmp_file" "$service_target"; then
        changed=true
        cp -f "$tmp_file" "$service_target"
    fi

    rm -f "$tmp_file"

    if [[ "$changed" == true ]] && command -v systemctl >/dev/null 2>&1; then
        systemctl --user daemon-reload >/dev/null 2>&1 || true
    fi

    if [[ "$changed" == true ]]; then
        return 0
    fi

    return 1
}

ensure_user_inir_service_enabled() {
    if ! command -v systemctl >/dev/null 2>&1; then
        return 1
    fi

    local service_path="${XDG_CONFIG_HOME}/systemd/user/inir.service"
    if [[ ! -f "$service_path" ]]; then
        return 1
    fi

    # Detect the compositor service — never fall back to graphical-session.target
    # because that target is active in KDE/GNOME/etc.
    local target=""
    if systemctl --user cat niri.service &>/dev/null; then
        target="niri.service"
    elif systemctl --user cat 'wayland-wm@Hyprland.service' &>/dev/null; then
        target="wayland-wm@Hyprland.service"
    fi

    if [[ -z "$target" ]]; then
        return 1  # no compositor found — don't enable
    fi

    local wants_dir="${XDG_CONFIG_HOME}/systemd/user/${target}.wants"
    if [[ ! -e "$wants_dir/inir.service" ]]; then
        mkdir -p "$wants_dir"
        ln -sf "$service_path" "$wants_dir/inir.service"
    fi

    systemctl --user daemon-reload >/dev/null 2>&1 || true
    return 0
}

###############################################################################
# Help
###############################################################################
setup_current_branch() {
    git -C "$REPO_ROOT" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown"
}

setup_tracked_branch() {
    get_update_tracking_branch 2>/dev/null || echo "main"
}

setup_service_link_summary() {
    local links=()
    local wants_dir
    for wants_dir in "${XDG_CONFIG_HOME}/systemd/user"/*.wants; do
        [[ -d "$wants_dir" ]] || continue
        [[ -e "$wants_dir/inir.service" || -L "$wants_dir/inir.service" ]] || continue
        links+=("$(basename "${wants_dir%.wants}")")
    done

    if [[ ${#links[@]} -eq 0 ]]; then
        printf '%s' "not enabled"
        return
    fi

    local IFS=', '
    printf '%s' "${links[*]}"
}

setup_remote_state_summary() {
    local installed_strategy
    installed_strategy="$(get_installed_update_strategy)"

    if [[ "$installed_strategy" == "package-manager" ]]; then
        printf '%s' "package-managed"
        return
    fi

    if [[ ! -d "${REPO_ROOT}/.git" ]] || ! declare -F check_remote_updates >/dev/null 2>&1; then
        printf '%s' "unavailable"
        return
    fi

    local rc=0
    check_remote_updates || rc=$?
    case "$rc" in
        0) printf '%s' "update available" ;;
        1) printf '%s' "up to date" ;;
        2) printf '%s' "offline or missing remote" ;;
        3) printf '%s' "ahead of remote" ;;
        4) printf '%s' "diverged" ;;
        *) printf '%s' "unknown" ;;
    esac
}

setup_runtime_change_summary() {
    local installed_mode runtime_dir manifest mod_files add_files mod_count=0 add_count=0
    installed_mode="$(get_installed_install_mode)"
    runtime_dir="$(get_runtime_shell_dir)"

    case "$installed_mode" in
        package-managed)
            printf '%s' "externally managed"
            return
            ;;
        repo-link)
            if [[ -d "${REPO_ROOT}/.git" ]]; then
                local dirty_count
                dirty_count="$(git -C "$REPO_ROOT" status --porcelain 2>/dev/null | wc -l | tr -d ' ')"
                if [[ "${dirty_count:-0}" -eq 0 ]]; then
                    printf '%s' "clean"
                else
                    printf '%s' "${dirty_count} local repo change(s)"
                fi
                return
            fi
            ;;
        repo-copy)
            [[ -n "$runtime_dir" && -d "$runtime_dir" ]] || { printf '%s' "runtime missing"; return; }
            manifest="$(find_runtime_manifest_file "$runtime_dir" 2>/dev/null || true)"
            if [[ -n "$manifest" ]] && manifest_has_checksums "$manifest"; then
                mod_files="$(detect_user_modifications "$runtime_dir" "$manifest")"
                add_files="$(detect_user_additions "$runtime_dir" "$manifest")"
            else
                mod_files="$(detect_user_modifications_by_source_comparison "$runtime_dir" "$REPO_ROOT")"
                add_files=""
            fi
            [[ -n "$mod_files" ]] && mod_count="$(printf '%s\n' "$mod_files" | grep -c . || true)"
            [[ -n "$add_files" ]] && add_count="$(printf '%s\n' "$add_files" | grep -c . || true)"
            if [[ "$mod_count" -eq 0 && "$add_count" -eq 0 ]]; then
                printf '%s' "clean"
            else
                printf '%s' "${mod_count} modified, ${add_count} added"
            fi
            return
            ;;
    esac

    printf '%s' "unknown"
}

setup_preserved_mods_summary() {
    if [[ ! -d "$USER_MODS_DIR" ]]; then
        printf '%s' "0 backups"
        return
    fi

    local count
    count="$(find "$USER_MODS_DIR" -maxdepth 1 -mindepth 1 -type d 2>/dev/null | wc -l | tr -d ' ')"
    printf '%s' "${count:-0} backups"
}

show_setup_context_card() {
    local title="${1:-Current Context}"
    local installed_ver installed_commit installed_mode update_strategy runtime_dir current_branch tracked_branch launcher_path service_links remote_state runtime_state
    installed_ver="$(get_installed_version)"
    installed_commit="$(get_installed_commit)"
    installed_mode="$(get_installed_install_mode)"
    update_strategy="$(get_installed_update_strategy)"
    runtime_dir="$(get_runtime_shell_dir)"
    current_branch="$(setup_current_branch)"
    tracked_branch="$(setup_tracked_branch)"
    launcher_path="$(command -v inir 2>/dev/null || echo "${XDG_BIN_HOME}/inir")"
    service_links="$(setup_service_link_summary)"
    remote_state="$(setup_remote_state_summary)"
    runtime_state="$(setup_runtime_change_summary)"

    local pairs=(
        "Installed:${installed_ver} (${installed_commit})"
        "Mode:${installed_mode}"
        "Updates:${update_strategy}"
        "Remote:${remote_state}"
        "Runtime State:${runtime_state}"
        "Runtime:${runtime_dir:-"(missing)"}"
        "Launcher:${launcher_path}"
        "Service:${service_links}"
    )

    if [[ -d "${REPO_ROOT}/.git" ]]; then
        pairs+=("Branch:${current_branch}")
        [[ "$current_branch" == "HEAD" ]] && pairs+=("Tracks:origin/${tracked_branch}")
    fi

    tui_summary_card "$title" "${pairs[@]}"
}

show_help() {
    echo ""
    tui_hero_card "iNiR setup" \
        "Install, sync, repair, inspect, and unfuck the shell without guessing which entrypoint owns what." \
        "Use inir for daily runtime control. Use ./setup when you want the maintenance brain."

    tui_key_value "Usage:" "./setup [command] [options]"
    show_setup_context_card "Setup Overview"

    tui_section_start "What setup owns"
    tui_list_item "Install flow, runtime sync, migrations, snapshots, and service refresh"
    tui_list_item "Repo-aware updates for repo-link and repo-copy installs"
    tui_list_item "Health diagnostics and safe automatic fixes"
    tui_section_end

    tui_section_start "Everyday maintenance"
    tui_list_item "(none)      Interactive menu"
    tui_list_item "install     Full installation (deps + config + files)"
    tui_list_item "update      Check remote, pull, sync, restart shell"
    tui_list_item "doctor      Diagnose and fix common breakage"
    tui_list_item "status      Show install mode, update strategy, and health"
    tui_list_item "logs        View recent runtime logs"
    tui_list_item "info        System and shell details dashboard"
    tui_section_end

    tui_section_start "Recovery and history"
    tui_list_item "migrate     Review/apply config migrations"
    tui_list_item "backup      Create a manual snapshot"
    tui_list_item "rollback    Restore a previous snapshot"
    tui_list_item "my-changes  View or restore preserved user modifications"
    tui_list_item "reinstall   Re-run install pipeline for current setup"
    tui_list_item "uninstall   Remove iNiR from the system"
    tui_section_end

    tui_section_start "Customization"
    tui_list_item "config      View and edit shell settings"
    tui_list_item "theme       Change wallpaper and color scheme"
    tui_list_item "extras      Install optional extras (iNiR-Walls / SDDM / YAMIS icons)"
    tui_section_end

    tui_section_start "Options"
    tui_list_item "-y, --yes              Skip prompts (auto-yes)"
    tui_list_item "-q, --quiet            Minimal output"
    tui_list_item "--local                Sync local repo to install (skip git pull)"
    tui_list_item "--simulate             Walk the update flow visually without touching files (update only)"
    tui_list_item "--set-default-shell    Set Fish as default shell (uses chsh)"
    tui_list_item "-h, --help             Show this help"
    tui_section_end

    tui_section_start "Good defaults"
    tui_list_item "./setup install      Install iNiR once"
    tui_list_item "./setup update       Pull, sync, and restart"
    tui_list_item "./setup doctor       Diagnose weird runtime breakage"
    tui_list_item "./setup status       See what is installed and what is drifting"
    tui_list_item "inir run             Start the shell"
    tui_list_item "inir logs            Read what the shell is complaining about"
    tui_section_end
    echo ""
}

###############################################################################
# Version Status Display
###############################################################################
show_version_info() {
    local installed_ver=$(get_installed_version)
    local installed_commit=$(get_installed_commit)
    local installed_mode=$(get_installed_install_mode)
    local update_strategy=$(get_installed_update_strategy)
    local installed_repo_path=$(get_installed_repo_path)
    local repo_ver
    local repo_commit
    local runtime_dir
    runtime_dir="$(get_runtime_shell_dir)"
    local runtime_dir_display="${runtime_dir:-"(missing)"}"

    if [[ -n "$installed_repo_path" && -f "${installed_repo_path}/VERSION" ]]; then
        repo_ver="$(head -1 "${installed_repo_path}/VERSION" | tr -d '[:space:]')"
        repo_commit="$(git -C "$installed_repo_path" rev-parse --short HEAD 2>/dev/null || echo "unknown")"
    else
        repo_ver=$(get_repo_version)
        repo_commit=$(get_repo_commit)
    fi

    # Badge row for quick glance
    echo ""
    local badges_args=("Version" "$installed_ver" "accent")
    badges_args+=("Mode" "$installed_mode" "info")
    badges_args+=("Updates" "$update_strategy" "muted")
    tui_badge_row "${badges_args[@]}"

    echo ""
    tui_status_line "Installed:" "$installed_ver ($installed_commit)" "ok"
    tui_status_line "Runtime:" "$runtime_dir_display" ""

    if [[ "$update_strategy" == "package-manager" ]]; then
        local update_hint
        update_hint=$(get_installed_package_update_hint)
        [[ -n "$update_hint" ]] && tui_status_line "Command:" "$update_hint" ""
    elif [[ "$installed_mode" != "repo-link" ]]; then
        # For repo-copy: show what the local repo has vs what's deployed
        tui_status_line "Available:" "$repo_ver ($repo_commit)" ""
    fi

    # Check for pending migrations
    local pending=$(count_pending_migrations 2>/dev/null || echo "0")
    if [[ "$pending" -gt 0 ]]; then
        tui_status_line "Migrations:" "$pending pending" "warn"
    fi

    # Shell running status (resolve symlinks so qs -p matches the running instance)
    if [[ -n "$runtime_dir" && -f "$runtime_dir/shell.qml" ]]; then
        local running_output resolved_runtime_dir
        resolved_runtime_dir="$(readlink -f "$runtime_dir" 2>/dev/null || printf '%s' "$runtime_dir")"
        running_output="$(qs -p "$resolved_runtime_dir" list 2>/dev/null || true)"
        if [[ -n "$running_output" && "$running_output" != No\ running\ instances* ]]; then
            tui_status_line "Shell:" "running" "ok"
        else
            tui_status_line "Shell:" "stopped" "warn"
        fi
    fi

    # Check for updates
    if [[ "$update_strategy" != "package-manager" && "$installed_commit" != "$repo_commit" ]]; then
        echo ""
        tui_alert "info" "Update available" "Run './setup update' or 'inir update' to apply."
    fi
}

###############################################################################
# TUI Menu
###############################################################################
tui_menu() {
    clear
    tui_banner

    # Detect current state
    local is_installed=false
    [[ -f "${FIRSTRUN_FILE}" ]] && is_installed=true

    if $is_installed; then
        show_version_info
        echo ""
        tui_divider
    fi

    echo ""

    # Menu options based on state with rich descriptions
    local choice
    if $is_installed; then
        choice=$(tui_choose_rich "What would you like to do?" \
            "${ICON_ARROW}|Update|Check for updates and apply them" \
            "${ICON_CHECK}|Doctor|Diagnose and fix problems" \
            "${ICON_DOT}|Config|View and edit shell settings" \
            "${ICON_STAR}|Theme|Change wallpaper and color scheme" \
            "${ICON_DOT}|Extras|Install optional extras (iNiR-Walls / SDDM / YAMIS icons)" \
            "${ICON_INFO}|Info|System and shell details dashboard" \
            "${ICON_DOT}|Logs|View recent runtime logs" \
            "${ICON_DOT}|Migrate|Review and apply config migrations" \
            "${ICON_DOT}|Backup|Create a manual snapshot" \
            "${ICON_DOT}|Rollback|Restore a previous snapshot" \
            "${ICON_DOT}|My Changes|View your preserved modifications" \
            "${ICON_DOT}|Reinstall|Full reinstall from scratch" \
            "${ICON_CROSS}|Uninstall|Remove iNiR from the system" \
            "${ICON_CIRCLE}|Help|Show commands and usage" \
            "${ICON_CIRCLE}|Exit|")
    else
        choice=$(tui_choose_rich "What would you like to do?" \
            "${ICON_STAR}|Install|Full installation with dependencies" \
            "${ICON_CIRCLE}|Help|Show commands and usage" \
            "${ICON_CIRCLE}|Exit|")
    fi

    case "$choice" in
        Install) run_install ;;
        Reinstall) IS_UPDATE=true run_install ;;
        Update) run_update ;;
        Theme) run_theme ;;
        Extras) run_extras ;;
        Config) run_config ;;
        Info) show_info; read -rp "Press Enter to continue..." ;;
        Migrate) run_migrate ;;
        Doctor) run_doctor ;;
        Backup) run_backup ;;
        Rollback) run_rollback ;;
        "My Changes") run_my_changes ;;
        Logs) run_logs ;;
        Uninstall) run_uninstall ;;
        Help) show_help; read -rp "Press Enter to continue..." ;;
        Exit|"") return 1 ;;
        *) return 1 ;;
    esac

    return 0
}

###############################################################################
# Status Command
###############################################################################
show_status_boot_timing() {
    local cache_file="${XDG_CACHE_HOME:-$HOME/.cache}/inir/last-boot.json"
    if [[ ! -s "$cache_file" ]]; then
        return 0
    fi

    # Phase timestamps (ms since epoch) — written by shell.qml at deferred phase end.
    local component_ms config_ms entry_ms deferred_ms
    component_ms=$(jq -r '.componentCompletedAt // 0' "$cache_file" 2>/dev/null)
    config_ms=$(jq -r '.configReadyAt // 0' "$cache_file" 2>/dev/null)
    entry_ms=$(jq -r '.shellEntryAt // 0' "$cache_file" 2>/dev/null)
    deferred_ms=$(jq -r '.deferredReadyAt // 0' "$cache_file" 2>/dev/null)
    [[ -z "$component_ms" || "$component_ms" == "0" ]] && return 0

    # Process & service start — these often dominate perceived startup time.
    local service_start_ms=0 qs_start_ms=0
    if command -v systemctl >/dev/null 2>&1; then
        local exec_start
        exec_start=$(systemctl --user show inir.service -p ExecMainStartTimestamp --value 2>/dev/null)
        if [[ -n "$exec_start" && "$exec_start" != "n/a" ]]; then
            # systemctl prints "Tue 2026-05-19 11:38:37 -03"; date -d understands it.
            service_start_ms=$(date -d "$exec_start" +%s%3N 2>/dev/null || echo 0)
        fi
    fi
    # qs process start time (best-effort: read /proc/<pid>/stat starttime if running)
    local qs_pid
    qs_pid=$(pgrep -u "$USER" -fn '/usr/bin/qs.*shell\.qml|/usr/bin/qs -n -p' 2>/dev/null | head -1)
    [[ -z "$qs_pid" ]] && qs_pid=$(pgrep -u "$USER" -fn 'qs -n' 2>/dev/null | head -1)
    if [[ -n "$qs_pid" && -r "/proc/$qs_pid/stat" ]]; then
        # field 22 = starttime in clock ticks since boot
        local starttime_ticks btime hz
        starttime_ticks=$(awk '{print $22}' "/proc/$qs_pid/stat")
        btime=$(awk '/^btime / {print $2}' /proc/stat)
        hz=$(getconf CLK_TCK)
        if [[ -n "$starttime_ticks" && -n "$btime" && -n "$hz" && "$hz" -gt 0 ]]; then
            qs_start_ms=$(( btime * 1000 + (starttime_ticks * 1000 / hz) ))
        fi
    fi

    tui_title "Last Boot Timing"

    # Format helper: render a delta in ms or s.
    _fmt_ms() {
        local ms=$1
        if [[ "$ms" -lt 0 ]]; then printf -- '—'; return; fi
        if [[ "$ms" -ge 1000 ]]; then
            printf '%d.%02ds' "$((ms / 1000))" "$(((ms % 1000) / 10))"
        else
            printf '%dms' "$ms"
        fi
    }

    # Build a single timeline anchored at the earliest known timestamp.
    local origin=$service_start_ms
    if [[ "$origin" == "0" || "$origin" -gt "$qs_start_ms" && "$qs_start_ms" -gt 0 ]]; then
        origin=$qs_start_ms
    fi
    if [[ "$origin" == "0" || "$origin" -gt "$component_ms" ]]; then
        origin=$component_ms
    fi

    tui_table_header "Phase" "Elapsed from start" 22 28
    if [[ "$service_start_ms" -gt 0 ]]; then
        tui_table_row "systemd ExecStart" "$(_fmt_ms 0) (T+0)" 22 28
    fi
    if [[ "$qs_start_ms" -gt 0 && "$service_start_ms" -gt 0 ]]; then
        tui_table_row "qs process started" "$(_fmt_ms $((qs_start_ms - origin)))" 22 28
    fi
    tui_table_row "QML evaluated" "$(_fmt_ms $((component_ms - origin)))" 22 28
    [[ "$config_ms" -gt 0 ]] && tui_table_row "Config ready" "$(_fmt_ms $((config_ms - origin)))" 22 28
    [[ "$entry_ms" -gt 0 ]] && tui_table_row "Bar visible" "$(_fmt_ms $((entry_ms - origin)))" 22 28
    [[ "$deferred_ms" -gt 0 ]] && tui_table_row "Services warm" "$(_fmt_ms $((deferred_ms - origin)))" 22 28
    tui_table_footer 22 28

    # Triage hints based on which phase ate the time. Thresholds chosen empirically:
    # > 5s on cold boot is probably user-data driven (icon cache, network), > 10s is
    # almost certainly something wrong (Qt ABI mismatch, env race, slow disk).
    local total_ms=$((deferred_ms > 0 ? deferred_ms - origin : 0))
    if [[ "$total_ms" -gt 10000 ]]; then
        echo ""
        tui_check_warn "Boot took $(_fmt_ms $total_ms) — unusually slow."
        tui_info "  Common culprits: Qt/Quickshell ABI mismatch, missing WAYLAND_DISPLAY env, slow icon cache, network-bound services on first run."
        tui_info "  Run 'inir doctor' to auto-detect, or share the table above when filing an issue."
    elif [[ "$total_ms" -gt 5000 ]]; then
        echo ""
        tui_check_skip "Boot took $(_fmt_ms $total_ms) — a bit slow on first run; subsequent boots should be faster."
    fi
}

show_status_environment() {
    # Versions and system info — the things we always end up asking users for
    # in support threads. Print once so they can paste their `inir status` output.
    tui_title "System & Quickshell"
    tui_table_header "Property" "Value" 22 42

    # Distro
    local distro="unknown"
    if [[ -r /etc/os-release ]]; then
        # shellcheck disable=SC1091
        local pretty
        pretty=$(. /etc/os-release && printf '%s' "${PRETTY_NAME:-${NAME:-unknown}}")
        [[ -n "$pretty" ]] && distro="$pretty"
    fi
    tui_table_row "Distro" "$distro" 22 42

    # Kernel
    local kernel
    kernel="$(uname -srm 2>/dev/null || echo unknown)"
    tui_table_row "Kernel" "$kernel" 22 42

    # Compositor + version
    local compositor="unknown" comp_ver=""
    if [[ -n "${NIRI_SOCKET:-}" ]] && command -v niri >/dev/null 2>&1; then
        compositor="niri"
        comp_ver="$(niri --version 2>/dev/null | grep -oP '\d+\.\d+(\.\d+)?' | head -1)"
    elif [[ -n "${HYPRLAND_INSTANCE_SIGNATURE:-}" ]] && command -v Hyprland >/dev/null 2>&1; then
        compositor="hyprland"
        comp_ver="$(Hyprland --version 2>/dev/null | grep -oP 'v\d+\.\d+(\.\d+)?' | head -1 | tr -d 'v')"
    elif command -v niri >/dev/null 2>&1 && niri msg --json version >/dev/null 2>&1; then
        compositor="niri (offline)"
    fi
    [[ -n "$comp_ver" ]] && compositor="${compositor} ${comp_ver}"
    tui_table_row "Compositor" "$compositor" 22 42

    # Panel family
    local panel_family="ii"
    local user_cfg="$HOME/.config/illogical-impulse/config.json"
    if [[ -r "$user_cfg" ]] && command -v jq >/dev/null 2>&1; then
        local pf
        pf="$(jq -r '.panelFamily // "ii"' "$user_cfg" 2>/dev/null)"
        [[ -n "$pf" && "$pf" != "null" ]] && panel_family="$pf"
    fi
    tui_table_row "Panel Family" "$panel_family" 22 42

    # Quickshell binary + version + revision + distributor
    local qs_path qs_version_line
    qs_path="$(command -v qs 2>/dev/null || command -v quickshell 2>/dev/null || true)"
    if [[ -n "$qs_path" ]]; then
        qs_version_line="$($qs_path --version 2>&1 | head -1 | tr -d '\r')"
        # Strip ANSI just in case
        qs_version_line="$(printf '%s' "$qs_version_line" | sed 's/\x1b\[[0-9;]*m//g')"
        tui_table_row "Quickshell" "${qs_version_line:-unknown}" 22 42
    else
        tui_table_row "Quickshell" "not installed" 22 42
    fi

    # Quickshell package origin. We want to tell users if their binary came from
    # a repo (in which case the maintainer rebuilds on Qt updates) or from AUR
    # (in which case THEY have to rebuild on Qt updates). Force LANG=C so we don't
    # depend on the user's locale (Spanish pacman prints 'Versión' / 'Nada').
    if command -v pacman >/dev/null 2>&1; then
        local qs_pkg
        for cand in quickshell-git quickshell-bin quickshell; do
            if pacman -Qi "$cand" &>/dev/null; then
                local ver origin=""
                ver="$(LANG=C pacman -Qi "$cand" 2>/dev/null | awk -F': +' '/^Version/ {print $2; exit}')"
                if pacman -Qmq "$cand" &>/dev/null; then
                    origin="AUR / locally built"
                else
                    local repo
                    repo="$(LANG=C pacman -Si "$cand" 2>/dev/null | awk -F': +' '/^Repository/ {print $2; exit}')"
                    if [[ -n "$repo" ]]; then
                        origin="repo: ${repo}"
                    else
                        origin="repo"
                    fi
                fi
                qs_pkg="${cand} ${ver} (${origin})"
                break
            fi
        done
        [[ -n "$qs_pkg" ]] && tui_table_row "QS Package" "$qs_pkg" 22 42
    fi

    # Qt build-time vs runtime (the ABI mismatch witness)
    if [[ -n "$qs_path" ]] && command -v strings >/dev/null 2>&1; then
        local buildtime_qt runtime_qt
        buildtime_qt="$(strings "$qs_path" 2>/dev/null | grep -P '^6\.\d+\.\d+$' | head -1)"
        if [[ -L /usr/lib/libQt6Core.so.6 ]]; then
            runtime_qt="$(readlink -f /usr/lib/libQt6Core.so.6 2>/dev/null | grep -oP '[0-9]+\.[0-9]+\.[0-9]+$')"
        fi
        [[ -z "$runtime_qt" ]] && command -v pkg-config >/dev/null 2>&1 && \
            runtime_qt="$(pkg-config --modversion Qt6Core 2>/dev/null)"
        local qt_display="build=${buildtime_qt:-?}  runtime=${runtime_qt:-?}"
        if [[ -n "$buildtime_qt" && -n "$runtime_qt" && "$buildtime_qt" != "$runtime_qt" ]]; then
            qt_display="${qt_display}  ⚠ ABI mismatch"
        fi
        tui_table_row "Qt" "$qt_display" 22 42
    fi

    # Active session details
    local session_type="${XDG_SESSION_TYPE:-?}"
    local wayland_disp="${WAYLAND_DISPLAY:-(unset)}"
    tui_table_row "Session" "$session_type ($wayland_disp)" 22 42

    # Config namespace location — reminds users where the user config lives
    if [[ -f "$user_cfg" ]]; then
        tui_table_row "User Config" "$user_cfg" 22 42
    else
        tui_table_row "User Config" "(missing) ${user_cfg}" 22 42
    fi

    tui_table_footer 22 42
}

show_status() {
    local installed_ver=$(get_installed_version)
    local installed_commit=$(get_installed_commit)
    local installed_mode=$(get_installed_install_mode)
    local update_strategy=$(get_installed_update_strategy)
    local installed_repo_path=$(get_installed_repo_path)
    local update_hint=$(get_installed_package_update_hint)
    local installed_version_file=$(get_installed_version_file)
    local repo_ver
    local repo_commit
    local runtime_dir=$(get_runtime_shell_dir)
    local runtime_version_file=""
    local running_output
    local runtime_dir_display="${runtime_dir:-"(missing)"}"
    local repo_path_display="$installed_repo_path"
    local branch_display="$(setup_current_branch)"
    local tracked_branch="$(setup_tracked_branch)"
    local remote_state="$(setup_remote_state_summary)"
    local runtime_state="$(setup_runtime_change_summary)"
    local preserved_mods="$(setup_preserved_mods_summary)"

    if [[ -n "$runtime_dir" ]]; then
        runtime_version_file="$(get_runtime_version_file)"
    fi

    if [[ -n "$repo_path_display" ]]; then
        repo_path_display="$(realpath "$repo_path_display" 2>/dev/null || printf '%s' "$repo_path_display")"
    fi

    if [[ -n "$installed_repo_path" && -f "${installed_repo_path}/VERSION" ]]; then
        repo_ver="$(head -1 "${installed_repo_path}/VERSION" | tr -d '[:space:]')"
        repo_commit="$(git -C "$installed_repo_path" rev-parse --short HEAD 2>/dev/null || echo "unknown")"
    else
        repo_ver=$(get_repo_version)
        repo_commit=$(get_repo_commit)
    fi

    tui_hero_card "Status" \
        "What is installed, what is running, and whether this checkout still matches reality." \
        "If any of this looks cursed, run ./setup doctor before you start randomly editing files."

    tui_table_header "Property" "Value" 14 36
    tui_table_row "Version" "$installed_ver" 14 36
    tui_table_row "Commit" "$installed_commit" 14 36
    tui_table_row "Install Mode" "$installed_mode" 14 36
    tui_table_row "Updates" "$update_strategy" 14 36
    tui_table_row "Branch" "$branch_display" 14 36
    tui_table_row "Tracks" "origin/${tracked_branch}" 14 36
    tui_table_row "Remote State" "$remote_state" 14 36
    tui_table_row "Runtime State" "$runtime_state" 14 36
    tui_table_row "Runtime Path" "$runtime_dir_display" 14 36
    tui_table_row "Launcher" "inir run" 14 36
    [[ -n "$repo_path_display" ]] && tui_table_row "Repo Path" "$repo_path_display" 14 36
    if [[ "$update_strategy" == "package-manager" ]]; then
        [[ -n "$update_hint" ]] && tui_table_row "Update Cmd" "$update_hint" 14 36
        tui_table_row "Workspace Ver" "$repo_ver" 14 36
        tui_table_row "Workspace SHA" "$repo_commit" 14 36
    else
        tui_table_row "Repo Version" "$repo_ver" 14 36
        tui_table_row "Repo Commit" "$repo_commit" 14 36
    fi
    tui_table_footer 14 36

    if [[ "$update_strategy" == "package-manager" ]]; then
        echo ""
        tui_info "This installation is externally managed. './setup update' will not sync repo files into the runtime."
    fi

    show_status_environment

    tui_title "Health Checks"

    # Check shell status (resolve symlinks so qs -p matches the running instance)
    if [[ -n "$runtime_dir" && -f "$runtime_dir/shell.qml" ]]; then
        local resolved_runtime_dir
        resolved_runtime_dir="$(readlink -f "$runtime_dir" 2>/dev/null || printf '%s' "$runtime_dir")"
        running_output="$(qs -p "$resolved_runtime_dir" list 2>/dev/null || true)"
        if [[ -n "$running_output" && "$running_output" != No\ running\ instances* ]]; then
            tui_check_ok "Shell is running"
        else
            tui_check_warn "Shell is not running"
        fi
    else
        tui_check_warn "Runtime payload missing"
    fi

    local launcher_path
    launcher_path="$(command -v inir 2>/dev/null || true)"
    if [[ -n "$launcher_path" || -x "${REPO_ROOT}/scripts/inir" ]]; then
        tui_check_ok "Launcher available${launcher_path:+: $launcher_path}"
    else
        tui_check_warn "Launcher not available in PATH"
    fi

    local service_path="${XDG_CONFIG_HOME}/systemd/user/inir.service"
    local service_links
    service_links="$(setup_service_link_summary)"
    if [[ -f "$service_path" ]]; then
        tui_check_ok "User service installed (${service_links})"
    else
        tui_check_warn "User service not installed"
    fi

    case "$remote_state" in
        "up to date") tui_check_ok "Repo remote state: ${remote_state}" ;;
        "update available"|"ahead of remote"|"offline or missing remote") tui_check_warn "Repo remote state: ${remote_state}" ;;
        "diverged") tui_check_fail "Repo remote state: ${remote_state}" ;;
    esac

    if [[ -f "$runtime_version_file" ]]; then
        tui_check_ok "Runtime metadata present"
    elif [[ "$installed_mode" == "repo-link" && -n "$installed_version_file" ]] && version_file_has_core_metadata "$installed_version_file"; then
        tui_check_ok "Repo-link metadata present via config tracking"
    else
        tui_check_warn "Runtime metadata missing"
    fi

    # Check Niri
    if [[ -n "$NIRI_SOCKET" ]]; then
        tui_check_ok "Niri compositor detected"
    else
        tui_check_warn "Not running in Niri session"
    fi

    # Pending migrations
    local pending=$(count_pending_migrations 2>/dev/null || echo "0")
    if [[ "$pending" -gt 0 ]]; then
        tui_check_warn "$pending pending migration(s)"
        tui_info "Run './setup migrate' to review"
    else
        tui_check_ok "No pending migrations"
    fi

    if [[ "$runtime_state" == "clean" || "$runtime_state" == "externally managed" ]]; then
        tui_check_ok "Runtime payload state: ${runtime_state}"
    else
        tui_check_warn "Runtime payload state: ${runtime_state}"
    fi

    # Snapshots
    local snapshot_count=$(list_snapshots 2>/dev/null | wc -l)
    if [[ "$snapshot_count" -gt 0 ]]; then
        tui_check_ok "$snapshot_count snapshot(s) available"
    else
        tui_check_skip "No snapshots"
    fi

    if [[ "$preserved_mods" == "0 backups" ]]; then
        tui_check_skip "Preserved modifications: ${preserved_mods}"
    else
        tui_check_warn "Preserved modifications: ${preserved_mods}"
    fi

    # Last boot timing breakdown — helps users self-triage "my shell takes 15s to start".
    # Pulls T0 from systemd, T1 from `qs list`, T2-T5 from ~/.cache/inir/last-boot.json
    # (written by shell.qml at end of deferred phase).
    show_status_boot_timing
    echo ""
}

###############################################################################
# Info — Rich system & shell details dashboard (Ink StatusMessage-inspired)
###############################################################################
show_info() {
    echo ""
    tui_hero_card "iNiR System Information" \
        "The useful stuff: platform, runtime, launcher, and the shell state that usually matters when something gets weird." \
        "This is the quick dashboard. Doctor is the one that actually gets its hands dirty."

    # System detection
    local distro_name="Unknown"
    local distro_id="unknown"
    if [[ -f /etc/os-release ]]; then
        source /etc/os-release
        distro_name="${PRETTY_NAME:-$NAME}"
        distro_id="${ID}"
    fi

    local current_shell
    current_shell=$(basename "${SHELL:-unknown}")
    local session_type="${XDG_SESSION_TYPE:-unknown}"

    local compositor="Not detected"
    if [[ -n "$NIRI_SOCKET" ]]; then
        compositor="Niri"
    elif [[ -n "$HYPRLAND_INSTANCE_SIGNATURE" ]]; then
        compositor="Hyprland"
    elif [[ -n "$SWAYSOCK" ]]; then
        compositor="Sway"
    elif [[ -n "$XDG_CURRENT_DESKTOP" ]]; then
        compositor="$XDG_CURRENT_DESKTOP"
    fi

    local kernel
    kernel=$(uname -r 2>/dev/null || echo "unknown")

    # iNiR details
    local installed_ver=$(get_installed_version)
    local installed_commit=$(get_installed_commit)
    local installed_mode=$(get_installed_install_mode)
    local runtime_dir
    runtime_dir="$(get_runtime_shell_dir)"
    local config_dir
    config_dir="$(resolve_inir_config_dir)"
    local config_file="${config_dir}/config.json"
    local state_dir="${XDG_STATE_HOME}/quickshell/user/generated"
    local remote_state="$(setup_remote_state_summary)"
    local runtime_state="$(setup_runtime_change_summary)"
    local preserved_mods="$(setup_preserved_mods_summary)"

    # Panel family detection
    local panel_family="unknown"
    if [[ -f "$config_file" ]]; then
        if command -v jq &>/dev/null; then
            panel_family=$(jq -r '.panelFamily // "ii"' "$config_file" 2>/dev/null || echo "ii")
        else
            panel_family=$(sed -n 's/.*"panelFamily"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$config_file" 2>/dev/null | head -1)
            [[ -z "$panel_family" ]] && panel_family="ii"
        fi
    fi

    # Current wallpaper
    local current_wallpaper="none"
    local theme_meta="${state_dir}/theme-meta.json"
    if [[ -f "$theme_meta" ]]; then
        if command -v jq &>/dev/null; then
            current_wallpaper=$(jq -r '.wallpaper // .source_path // "none"' "$theme_meta" 2>/dev/null || echo "none")
        else
            current_wallpaper=$(sed -n 's/.*"wallpaper"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$theme_meta" 2>/dev/null | head -1)
            [[ -n "$current_wallpaper" ]] || current_wallpaper=$(sed -n 's/.*"source_path"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$theme_meta" 2>/dev/null | head -1)
        fi
        [[ -n "$current_wallpaper" && "$current_wallpaper" != "null" ]] && current_wallpaper="$(basename "$current_wallpaper")"
    fi

    show_setup_context_card "Runtime Snapshot"

    local sys_info
    sys_info=$(printf '%s\n%s\n%s\n%s\n%s' \
        "Distro:      $distro_name" \
        "Kernel:      $kernel" \
        "Session:     $session_type" \
        "Compositor:  $compositor" \
        "Shell:       $current_shell")

    local shell_info
    shell_info=$(printf '%s\n%s\n%s\n%s\n%s\n%s' \
        "Version:     $installed_ver ($installed_commit)" \
        "Mode:        $installed_mode" \
        "Family:      $panel_family" \
        "Wallpaper:   $current_wallpaper" \
        "Config:      $config_dir" \
        "Runtime:     ${runtime_dir:-"(missing)"}")

    tui_columns "$sys_info" "$shell_info" 2

    echo ""

    # Paths
    tui_subtitle "Paths"
    tui_key_value "Config:" "$config_file"
    tui_key_value "State:" "$state_dir"
    tui_key_value "Runtime:" "${runtime_dir:-"(not set)"}"
    tui_key_value "Repo:" "$REPO_ROOT"
    tui_key_value "Launcher:" "$(command -v inir 2>/dev/null || echo "${XDG_BIN_HOME}/inir")"
    tui_key_value "Remote:" "$remote_state"
    tui_key_value "Runtime State:" "$runtime_state"
    tui_key_value "Preserved Mods:" "$preserved_mods"

    echo ""

    # Quick health (resolve symlinks so qs -p matches the running instance)
    tui_subtitle "Quick Health"
    if [[ -n "$runtime_dir" && -f "$runtime_dir/shell.qml" ]]; then
        local running_output resolved_runtime_dir
        resolved_runtime_dir="$(readlink -f "$runtime_dir" 2>/dev/null || printf '%s' "$runtime_dir")"
        running_output="$(qs -p "$resolved_runtime_dir" list 2>/dev/null || true)"
        if [[ -n "$running_output" && "$running_output" != No\ running\ instances* ]]; then
            tui_check_ok "Shell is running"
        else
            tui_check_warn "Shell is not running"
        fi
    else
        tui_check_warn "Runtime payload missing"
    fi

    local pending=$(count_pending_migrations 2>/dev/null || echo "0")
    if [[ "$pending" -gt 0 ]]; then
        tui_check_warn "$pending pending migration(s)"
    else
        tui_check_ok "No pending migrations"
    fi

    local snapshot_count=$(list_snapshots 2>/dev/null | wc -l)
    tui_check_ok "$snapshot_count snapshot(s) available"

    local service_path="${XDG_CONFIG_HOME}/systemd/user/inir.service"
    if [[ -f "$service_path" ]]; then
        tui_check_ok "User service file present"
    else
        tui_check_warn "User service file missing"
    fi

    local launcher_path
    launcher_path="$(command -v inir 2>/dev/null || true)"
    if [[ -n "$launcher_path" ]]; then
        tui_check_ok "Launcher resolves to $launcher_path"
    else
        tui_check_warn "Launcher not found in PATH"
    fi

    case "$remote_state" in
        "diverged") tui_check_fail "Repo remote state: ${remote_state}" ;;
        "up to date") tui_check_ok "Repo remote state: ${remote_state}" ;;
        *) tui_check_warn "Repo remote state: ${remote_state}" ;;
    esac

    if [[ "$runtime_state" == "clean" || "$runtime_state" == "externally managed" ]]; then
        tui_check_ok "Runtime payload state: ${runtime_state}"
    else
        tui_check_warn "Runtime payload state: ${runtime_state}"
    fi

    echo ""
}

###############################################################################
# Config — View and edit shell settings (Ink Select-inspired interactive)
###############################################################################
run_config() {
    echo ""
    tui_title "iNiR Configuration"
    echo ""

    local config_dir
    config_dir="$(resolve_inir_config_dir)"
    local config_file="${config_dir}/config.json"

    if [[ ! -f "$config_file" ]]; then
        tui_warn "Config file not found: $config_file"
        tui_info "Run './setup install' first."
        echo ""
        read -rp "Press Enter to continue..."
        return 0
    fi

    # Show current key settings
    local panel_family="ii"
    local bar_position="top"
    local clock_format="12h"
    local search_engine="google"
    local animations="true"
    local blur="true"

    if command -v jq &>/dev/null; then
        panel_family=$(jq -r '.panelFamily // "ii"' "$config_file" 2>/dev/null)
        bar_position=$(jq -r '.bar?.position // "top"' "$config_file" 2>/dev/null)
        clock_format=$(jq -r '.time?.format // "12h"' "$config_file" 2>/dev/null)
        search_engine=$(jq -r '.search?.engine // "google"' "$config_file" 2>/dev/null)
        animations=$(jq -r '.animations?.enabled // true' "$config_file" 2>/dev/null)
        blur=$(jq -r '.appearance?.blur // true' "$config_file" 2>/dev/null)
    fi

    tui_summary_card "Current Settings" \
        "Panel Family:$panel_family" \
        "Bar Position:$bar_position" \
        "Clock Format:$clock_format" \
        "Search Engine:$search_engine" \
        "Animations:$animations" \
        "Blur:$blur"

    echo ""

    local action
    action=$(tui_choose_rich "Configuration" \
        "${ICON_ARROW}|Edit in Editor|Open config.json in your editor" \
        "${ICON_DOT}|Panel Family|Switch between ii and waffle" \
        "${ICON_DOT}|Open Config Dir|Open the config directory" \
        "${ICON_DOT}|Reset to Defaults|Restore default configuration" \
        "${ICON_CIRCLE}|Back|Return to main menu")

    case "$action" in
        "Edit in Editor")
            local editor="${EDITOR:-${VISUAL:-nano}}"
            tui_info "Opening $config_file with $editor..."
            "$editor" "$config_file"
            tui_success "Config saved"
            tui_info "Run 'inir restart' to apply changes"
            ;;
        "Panel Family")
            echo ""
            local new_family
            new_family=$(tui_choose "Select panel family:" "ii" "waffle")
            if [[ -n "$new_family" && "$new_family" != "$panel_family" ]]; then
                if command -v jq &>/dev/null; then
                    local tmp_file
                    tmp_file=$(mktemp)
                    jq --arg f "$new_family" '.panelFamily = $f' "$config_file" > "$tmp_file" && mv "$tmp_file" "$config_file"
                    tui_success "Panel family set to: $new_family"
                    tui_info "Run 'inir restart' to apply"
                else
                    tui_warn "jq required to edit config programmatically"
                    tui_info "Edit $config_file manually"
                fi
            else
                tui_info "No change"
            fi
            ;;
        "Open Config Dir")
            if command -v xdg-open &>/dev/null; then
                xdg-open "$config_dir" &>/dev/null &
                tui_success "Opened in file manager"
            else
                tui_info "Path: $config_dir"
            fi
            ;;
        "Reset to Defaults")
            tui_warn "This will replace your config with defaults."
            if tui_confirm "Are you sure?" "no"; then
                if [[ -f "${REPO_ROOT}/defaults/config.json" ]]; then
                    cp "$config_file" "${config_file}.backup.$(date +%Y%m%d%H%M%S)"
                    cp "${REPO_ROOT}/defaults/config.json" "$config_file"
                    tui_success "Config reset to defaults (backup created)"
                    tui_info "Run 'inir restart' to apply"
                else
                    tui_error "Default config not found"
                fi
            fi
            ;;
        *)
            return 0
            ;;
    esac

    echo ""
    read -rp "Press Enter to continue..."
}

###############################################################################
# Theme — Quick wallpaper and color scheme operations
###############################################################################
run_theme() {
    echo ""
    tui_title "Theme & Wallpaper"
    echo ""

    local state_dir="${XDG_STATE_HOME}/quickshell/user/generated"
    local theme_meta="${state_dir}/theme-meta.json"
    local colors_file="${state_dir}/colors.json"
    local wallpaper_state_path="${state_dir}/wallpaper/path.txt"

    resolve_switchwall_script() {
        local candidate="${REPO_ROOT}/scripts/colors/switchwall.sh"
        if [[ -x "$candidate" ]]; then
            printf '%s' "$candidate"
            return 0
        fi

        if command -v inir &>/dev/null; then
            local runtime_dir
            runtime_dir="$(inir path 2>/dev/null || true)"
            candidate="${runtime_dir}/scripts/colors/switchwall.sh"
            if [[ -x "$candidate" ]]; then
                printf '%s' "$candidate"
                return 0
            fi
        fi

        return 1
    }

    # Show current theme info
    local current_wallpaper="none"
    local current_scheme="unknown"
    if [[ -f "$theme_meta" ]]; then
        if command -v jq &>/dev/null; then
            current_wallpaper=$(jq -r '.wallpaper // .source_path // "none"' "$theme_meta" 2>/dev/null)
            current_scheme=$(jq -r '.scheme // .variant // "unknown"' "$theme_meta" 2>/dev/null)
        else
            current_wallpaper=$(sed -n 's/.*"wallpaper"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$theme_meta" 2>/dev/null | head -1)
            [[ -n "$current_wallpaper" ]] || current_wallpaper=$(sed -n 's/.*"source_path"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$theme_meta" 2>/dev/null | head -1)
            current_scheme=$(sed -n 's/.*"scheme"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$theme_meta" 2>/dev/null | head -1)
            [[ -n "$current_scheme" ]] || current_scheme="unknown"
        fi
    fi

    local display_wallpaper="$current_wallpaper"
    [[ "$current_wallpaper" != "none" && -n "$current_wallpaper" && "$current_wallpaper" != "null" ]] && display_wallpaper="$(basename "$current_wallpaper")"

    tui_summary_card "Current Theme" \
        "Wallpaper:${display_wallpaper}" \
        "Scheme:${current_scheme}"

    echo ""

    local action
    action=$(tui_choose_rich "Theme Options" \
        "${ICON_STAR}|Browse Defaults|Pick from default wallpapers" \
        "${ICON_DOT}|Regenerate|Rebuild colors from current wallpaper" \
        "${ICON_CIRCLE}|Back|Return to main menu")

    case "$action" in
        "Regenerate")
            echo ""
            tui_info "Regenerating theme from current wallpaper..."
            local switchwall
            switchwall="$(resolve_switchwall_script || true)"
            local regen_wallpaper="$current_wallpaper"
            if [[ ( -z "$regen_wallpaper" || "$regen_wallpaper" == "none" || ! -f "$regen_wallpaper" ) && -f "$wallpaper_state_path" ]]; then
                regen_wallpaper="$(<"$wallpaper_state_path")"
            fi

            if [[ -n "$switchwall" && -n "$regen_wallpaper" && -f "$regen_wallpaper" ]]; then
                bash "$switchwall" "$regen_wallpaper" 2>/dev/null &
                disown
                tui_success "Color regeneration started"
            else
                tui_warn "Cannot regenerate — wallpaper path unknown or switchwall.sh missing"
            fi
            ;;
        "Browse Defaults")
            echo ""
            local defaults_dir="${REPO_ROOT}/defaults/wallpapers"
            if [[ ! -d "$defaults_dir" ]]; then
                # Try alternate paths
                for try_dir in \
                    "${REPO_ROOT}/assets/wallpapers" \
                    "${REPO_ROOT}/defaults/backgrounds" \
                    "${DOTS_CORE_CONFDIR}/wallpapers"; do
                    [[ -d "$try_dir" ]] && defaults_dir="$try_dir" && break
                done
            fi

            if [[ -d "$defaults_dir" ]]; then
                local wallpapers=()
                while IFS= read -r f; do
                    wallpapers+=("$(basename "$f")")
                done < <(find "$defaults_dir" -maxdepth 1 -type f \( -name "*.jpg" -o -name "*.jpeg" -o -name "*.png" -o -name "*.webp" \) | sort)

                if [[ ${#wallpapers[@]} -eq 0 ]]; then
                    tui_info "No wallpapers found in $defaults_dir"
                else
                    local chosen_wall
                    chosen_wall=$(printf '%s\n' "${wallpapers[@]}" | tui_filter "Search wallpapers...")
                    if [[ -n "$chosen_wall" ]]; then
                        local full_path="${defaults_dir}/${chosen_wall}"
                        tui_info "Applying: $chosen_wall"
                        local switchwall
                        switchwall="$(resolve_switchwall_script || true)"
                        if [[ -n "$switchwall" ]]; then
                            bash "$switchwall" "$full_path" 2>/dev/null &
                            disown
                            tui_success "Wallpaper pipeline started"
                        else
                            tui_error "switchwall.sh not found or not executable"
                        fi
                    fi
                fi
            else
                tui_info "No default wallpapers directory found"
            fi
            ;;
        *)
            return 0
            ;;
    esac

    echo ""
    read -rp "Press Enter to continue..."
}

###############################################################################
# Extras — Optional post-install components
###############################################################################
run_extras() {
    echo ""
    tui_title "Optional Extras"
    echo ""

    local action
    action=$(tui_choose_rich "Extras" \
        "${ICON_DOT}|Install iNiR-Walls|Download optional wallpaper pack and copy image files" \
        "${ICON_DOT}|Install ii-pixel-sddm|Install/apply iNiR SDDM login theme" \
        "${ICON_DOT}|Install YAMIS icons|Install/update yet-another-monochrome-icon-set (GPL-3, ~23 MiB)" \
        "${ICON_DOT}|Install all|Run all optional installers" \
        "${ICON_CIRCLE}|Back|Return to main menu")

    case "$action" in
        "Install iNiR-Walls")
            echo ""
            extras_install_inir_walls
            ;;
        "Install ii-pixel-sddm")
            echo ""
            extras_install_sddm_theme "ask"
            ;;
        "Install YAMIS icons")
            echo ""
            extras_install_yamis_icons
            ;;
        "Install all")
            echo ""
            extras_install_inir_walls
            echo ""
            extras_install_sddm_theme "ask"
            echo ""
            extras_install_yamis_icons
            ;;
        *)
            return 0
            ;;
    esac

    echo ""
    read -rp "Press Enter to continue..."
}

###############################################################################
# Backup — Create a manual snapshot
###############################################################################
run_backup() {
    echo ""
    tui_title "Manual Backup"
    echo ""

    # Show existing snapshots
    local snapshot_count=$(list_snapshots 2>/dev/null | wc -l)
    tui_info "$snapshot_count existing snapshot(s)"
    echo ""

    if tui_confirm "Create a new snapshot of the current state?"; then
        echo ""
        tui_info "Creating snapshot..."

        local current_ver=$(get_installed_version)
        local current_commit=$(get_installed_commit)
        local snapshot_id
        snapshot_id=$(create_snapshot "manual" "Manual backup via setup TUI" "$current_commit")

        if [[ -n "$snapshot_id" ]]; then
            tui_alert "success" "Snapshot created" "ID: $snapshot_id\nVersion: $current_ver ($current_commit)\nRestore with: ./setup rollback"
        else
            tui_error "Failed to create snapshot"
        fi
    else
        tui_info "Cancelled"
    fi

    echo ""
    read -rp "Press Enter to continue..."
}

###############################################################################
# Logs — View recent runtime logs via pager
###############################################################################
run_logs() {
    echo ""
    tui_title "Runtime Logs"
    echo ""

    local log_sources=()
    local log_labels=()

    # Quickshell logs
    local qs_log="${XDG_STATE_HOME}/quickshell/log"
    local qs_log_alt="${XDG_CACHE_HOME}/quickshell/log"
    local journal_available=false
    command -v journalctl &>/dev/null && journal_available=true

    [[ -f "$qs_log" ]] && log_sources+=("$qs_log") && log_labels+=("Quickshell log (state)")
    [[ -f "$qs_log_alt" ]] && log_sources+=("$qs_log_alt") && log_labels+=("Quickshell log (cache)")

    if $journal_available; then
        log_sources+=("__journal_qs__")
        log_labels+=("Journal: quickshell (last 200 lines)")
        log_sources+=("__journal_niri__")
        log_labels+=("Journal: niri (last 100 lines)")
    fi

    if [[ ${#log_sources[@]} -eq 0 ]]; then
        tui_warn "No log sources found"
        tui_info "Start iNiR first: inir run"
        echo ""
        read -rp "Press Enter to continue..."
        return 0
    fi

    log_labels+=("Back")
    local choice
    choice=$(tui_choose "Select log source:" "${log_labels[@]}")

    [[ "$choice" == "Back" ]] && return 0

    # Find matching source
    local source_idx=0
    for i in "${!log_labels[@]}"; do
        if [[ "${log_labels[$i]}" == "$choice" ]]; then
            source_idx=$i
            break
        fi
    done

    local source="${log_sources[$source_idx]}"

    echo ""
    case "$source" in
        __journal_qs__)
            tui_info "Showing last 200 lines from journalctl..."
            if $HAS_GUM; then
                journalctl --user -u quickshell --no-pager -n 200 2>/dev/null | gum pager
            else
                journalctl --user -u quickshell --no-pager -n 200 2>/dev/null | less
            fi
            ;;
        __journal_niri__)
            tui_info "Showing last 100 lines from niri journal..."
            if $HAS_GUM; then
                journalctl --user -u niri --no-pager -n 100 2>/dev/null | gum pager
            else
                journalctl --user -u niri --no-pager -n 100 2>/dev/null | less
            fi
            ;;
        *)
            tui_info "Viewing: $source"
            if $HAS_GUM; then
                gum pager < "$source"
            else
                less "$source"
            fi
            ;;
    esac
}

###############################################################################
# Install
###############################################################################
run_install() {
    detect_distro

    # Greeting & system info
    source ./sdata/subcmd-install/0.greeting.sh

    # Check conflicts
    check_conflicts

    # Show tasuku-style task overview before starting
    echo ""
    tui_subtitle "Installation progress"
    echo ""
    tui_task_init \
        "Install dependencies" \
        "System configuration" \
        "Install config files" \
        "Version tracking"

    # 1. Dependencies
    if [[ "${SKIP_ALLDEPS}" != "true" ]]; then
        tui_task_run 0 "packages, runtime, compositor"
        tui_task_finalize
        tui_step 1 3 "Installing dependencies" "Package managers, shell runtime pieces, and compositor requirements."
        source ./sdata/subcmd-install/1.deps-router.sh
        # Reinit after step output to show updated state
        echo ""
        tui_task_init \
            "Install dependencies" \
            "System configuration" \
            "Install config files" \
            "Version tracking"
        _TUI_TASK_STATES[0]="done"
        _TUI_TASK_DETAILS[0]="complete"
        tui_task_render
    else
        tui_task_skip 0 "skipped"
    fi

    # 2. System setup (groups, services)
    if [[ "${SKIP_ALLSETUPS}" != "true" ]]; then
        tui_task_run 1 "groups, services, permissions"
        tui_task_finalize
        tui_step 2 3 "System configuration" "Groups, services, permissions, and machine-level integration."
        source ./sdata/subcmd-install/2.setups.sh
        echo ""
        tui_task_init \
            "Install dependencies" \
            "System configuration" \
            "Install config files" \
            "Version tracking"
        _TUI_TASK_STATES[0]="done"
        _TUI_TASK_DETAILS[0]="complete"
        _TUI_TASK_STATES[1]="done"
        _TUI_TASK_DETAILS[1]="complete"
        tui_task_render
    else
        tui_task_skip 1 "skipped"
    fi

    # 3. Config files
    if [[ "${SKIP_ALLFILES}" != "true" ]]; then
        tui_task_run 2 "configs, backups, theming"
        tui_task_finalize
        tui_step 3 3 "Installing config files" "User configs, backups, wallpaper defaults, and generated theme inputs."
        source ./sdata/subcmd-install/3.files.sh
        echo ""
        tui_task_init \
            "Install dependencies" \
            "System configuration" \
            "Install config files" \
            "Version tracking"
        _TUI_TASK_STATES[0]="done"
        _TUI_TASK_DETAILS[0]="complete"
        _TUI_TASK_STATES[1]="done"
        _TUI_TASK_DETAILS[1]="complete"
        _TUI_TASK_STATES[2]="done"
        _TUI_TASK_DETAILS[2]="complete"
        tui_task_render
    else
        tui_task_skip 2 "skipped"
    fi

    # DISABLED: webapps — requires quickshell-webengine rebuild, re-enable when ready
    # # WebApp Plugins: check if quickshell has WebEngine support
    # if [[ -d "${REPO_ROOT}/defaults/plugins" ]]; then
    #     echo ""
    #     tui_title "WebApp Plugins"
    #     echo ""
    #
    #     local has_webengine=false
    #     if pacman -Q qt6-webengine &>/dev/null 2>&1; then
    #         has_webengine=true
    #     elif dpkg -s qt6-webengine-dev &>/dev/null 2>&1; then
    #         has_webengine=true
    #     elif rpm -q qt6-qtwebengine-devel &>/dev/null 2>&1; then
    #         has_webengine=true
    #     fi
    #
    #     # Check if quickshell was compiled with our WebEngine patch
    #     local qs_has_patch=false
    #     if strings "$(which qs 2>/dev/null || echo /usr/bin/quickshell)" 2>/dev/null | grep -q "EnableQtWebEngineQuick" 2>/dev/null; then
    #         qs_has_patch=true
    #     fi
    #
    #     if $qs_has_patch; then
    #         tui_success "Quickshell has WebEngine support"
    #         tui_info "Enable Web Apps in Settings → Interface → Sidebars"
    #     elif $has_webengine; then
    #         tui_info "qt6-webengine is installed but quickshell needs to be recompiled"
    #         tui_info "Web Apps (Discord, YouTube Music, etc.) require a patched quickshell"
    #         if $ask; then
    #             if tui_confirm "Build and install quickshell with WebEngine support?"; then
    #                 echo ""
    #                 _build_install_qs_webengine
    #             fi
    #         else
    #             tui_info "Run: cd ${REPO_ROOT}/scripts/quickshell-webengine && makepkg -si"
    #         fi
    #     else
    #         tui_info "WebApp plugins available (Discord, YouTube Music with adblock)"
    #         tui_info "Requires: qt6-webengine + patched quickshell"
    #         if $ask; then
    #             if tui_confirm "Install qt6-webengine and build patched quickshell?"; then
    #                 echo ""
    #                 if command -v pacman >/dev/null 2>&1; then
    #                     tui_info "Installing qt6-webengine..."
    #                     pkg_sudo pacman -S --needed --noconfirm qt6-webengine || true
    #                 fi
    #                 _build_install_qs_webengine
    #             fi
    #         else
    #             tui_info "To enable: pacman -S qt6-webengine"
    #             tui_info "Then: cd ${REPO_ROOT}/scripts/quickshell-webengine && makepkg -si"
    #         fi
    #     fi
    # fi

    # Set version tracking
    tui_task_run 3 "recording version"
    set_installed_version "$(get_repo_version)" "$(get_repo_commit)" "setup"
    tui_task_done 3 "$(get_repo_version)"
    tui_task_finalize

    echo ""
    tui_alert "success" "Installation complete" "Version $(get_repo_version) is ready.\nRun 'inir run' to start the shell, or log out and back in."
}

###############################################################################
# My Changes - View and restore preserved user modifications
###############################################################################
run_my_changes() {
    echo ""
    tui_title "Your Preserved Modifications"
    echo ""

    # Check if any preserved modifications exist
    if [[ ! -d "$USER_MODS_DIR" ]] || [[ -z "$(ls -A "$USER_MODS_DIR" 2>/dev/null)" ]]; then
        tui_info "No preserved modifications found."
        echo ""
        tui_dim "When you update and have local changes, they are saved here."
        tui_dim "You can then restore them after the update completes."
        echo ""
        read -rp "Press Enter to continue..."
        return 0
    fi

    # List available preserved modifications
    local mods_list=($(ls -1t "$USER_MODS_DIR" 2>/dev/null))

    if [[ ${#mods_list[@]} -eq 0 ]]; then
        tui_info "No preserved modifications found."
        read -rp "Press Enter to continue..."
        return 0
    fi

    # Build options with details
    local options=()
    for mod_dir in "${mods_list[@]}"; do
        local meta="${USER_MODS_DIR}/${mod_dir}/metadata.json"
        if [[ -f "$meta" ]]; then
            local mod_count=$(grep -o '"modified_count": [0-9]*' "$meta" 2>/dev/null | grep -o '[0-9]*' || echo 0)
            local add_count=$(grep -o '"additions_count": [0-9]*' "$meta" 2>/dev/null | grep -o '[0-9]*' || echo 0)
            local date_formatted=$(echo "$mod_dir" | sed 's/\([0-9]\{4\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)-\([0-9]\{2\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)/\1-\2-\3 \4:\5/')
            options+=("$date_formatted (${mod_count} modified, ${add_count} added)")
        else
            options+=("$mod_dir")
        fi
    done
    options+=("Back")

    local choice
    choice=$(tui_choose "Select a backup to view/restore:" "${options[@]}")

    [[ "$choice" == "Back" ]] && return 0

    # Find which backup was selected
    local selected_idx=0
    for i in "${!options[@]}"; do
        if [[ "${options[$i]}" == "$choice" ]]; then
            selected_idx=$i
            break
        fi
    done

    local selected_dir="${mods_list[$selected_idx]}"
    local selected_path="${USER_MODS_DIR}/${selected_dir}"

    # Show contents of selected backup
    echo ""
    tui_subtitle "Contents of $selected_dir"
    echo ""

    # List modified files
    if [[ -d "$selected_path" ]]; then
        local files_found=false

        # Show modified files (excluding _additions and metadata)
        while IFS= read -r file; do
            [[ "$file" == *"metadata.json" ]] && continue
            [[ "$file" == *"_additions"* ]] && continue
            files_found=true
            local rel_path="${file#$selected_path/}"
            echo "    [modified] $rel_path"
        done < <(find "$selected_path" -type f 2>/dev/null)

        # Show additions
        if [[ -d "$selected_path/_additions" ]]; then
            while IFS= read -r file; do
                files_found=true
                local rel_path="${file#$selected_path/_additions/}"
                echo "    [added]    $rel_path"
            done < <(find "$selected_path/_additions" -type f 2>/dev/null)
        fi

        if ! $files_found; then
            tui_dim "    (no files found)"
        fi
    fi

    echo ""

    # Action menu
    local action
    action=$(tui_choose "What would you like to do?" \
        "Restore All" \
        "Restore Single File" \
        "Open in File Manager" \
        "Delete This Backup" \
        "Back")

    case "$action" in
        "Restore All")
            echo ""
            tui_warn "This will copy all preserved files back to your installation."
            tui_info "Existing files will be overwritten."
            if tui_confirm "Continue?" "no"; then
                restore_all_user_mods "$selected_path"
            fi
            ;;
        "Restore Single File")
            restore_single_user_mod "$selected_path"
            ;;
        "Open in File Manager")
            if command -v xdg-open &>/dev/null; then
                xdg-open "$selected_path" &>/dev/null &
                tui_success "Opened in file manager"
            else
                tui_info "Path: $selected_path"
            fi
            ;;
        "Delete This Backup")
            if tui_confirm "Delete this backup permanently?" "no"; then
                rm -rf "$selected_path"
                tui_success "Backup deleted"
            fi
            ;;
        *)
            return 0
            ;;
    esac

    echo ""
    read -rp "Press Enter to continue..."
}

# Helper: Restore all files from a user-mods backup
restore_all_user_mods() {
    local backup_path="$1"
    local target
    target="$(get_runtime_shell_dir)"
    local restored=0

    # Restore modified files
    while IFS= read -r file; do
        [[ "$file" == *"metadata.json" ]] && continue
        [[ "$file" == *"_additions"* ]] && continue

        local rel_path="${file#$backup_path/}"
        local dest="${target}/${rel_path}"

        mkdir -p "$(dirname "$dest")"
        cp "$file" "$dest"
        ((restored++))
        tui_dim "  Restored: $rel_path"
    done < <(find "$backup_path" -type f 2>/dev/null)

    # Restore additions
    if [[ -d "$backup_path/_additions" ]]; then
        while IFS= read -r file; do
            local rel_path="${file#$backup_path/_additions/}"
            local dest="${target}/${rel_path}"

            mkdir -p "$(dirname "$dest")"
            cp "$file" "$dest"
            ((restored++))
            tui_dim "  Restored: $rel_path"
        done < <(find "$backup_path/_additions" -type f 2>/dev/null)
    fi

    echo ""
    tui_success "Restored $restored file(s)"
    tui_info "Restart the shell to apply changes: inir restart"
}

# Helper: Restore a single file from user-mods backup
restore_single_user_mod() {
    local backup_path="$1"
    local target
    target="$(get_runtime_shell_dir)"

    # Build list of files
    local files=()
    while IFS= read -r file; do
        [[ "$file" == *"metadata.json" ]] && continue
        [[ "$file" == *"_additions"* ]] && continue
        local rel_path="${file#$backup_path/}"
        files+=("$rel_path")
    done < <(find "$backup_path" -type f 2>/dev/null)

    # Add files from _additions
    if [[ -d "$backup_path/_additions" ]]; then
        while IFS= read -r file; do
            local rel_path="${file#$backup_path/_additions/}"
            files+=("[added] $rel_path")
        done < <(find "$backup_path/_additions" -type f 2>/dev/null)
    fi

    if [[ ${#files[@]} -eq 0 ]]; then
        tui_warn "No files to restore"
        return 1
    fi

    files+=("Cancel")

    local choice
    choice=$(tui_choose "Select file to restore:" "${files[@]}")

    [[ "$choice" == "Cancel" ]] && return 0

    # Handle [added] prefix
    local src_file dest_file
    if [[ "$choice" == "[added] "* ]]; then
        local rel_path="${choice#\[added\] }"
        src_file="$backup_path/_additions/$rel_path"
        dest_file="$target/$rel_path"
    else
        src_file="$backup_path/$choice"
        dest_file="$target/$choice"
    fi

    mkdir -p "$(dirname "$dest_file")"
    cp "$src_file" "$dest_file"
    tui_success "Restored: $choice"
    tui_info "Restart the shell to apply changes: inir restart"
}

###############################################################################
# Update
###############################################################################

# Progress reporting for shell UI — writes structured markers to the update
# status file so ShellUpdates.qml can show live progress in the bar indicator.
# Format: progress:STEP:TOTAL:MESSAGE
# Called only during automated updates (setup -y -q update from ShellUpdates).
_update_status_file="${XDG_STATE_HOME:-$HOME/.local/state}/quickshell/user/update-status"
_update_total_steps=7

_report_progress() {
    local step="$1" msg="$2"
    echo "progress:${step}:${_update_total_steps}:${msg}" > "$_update_status_file" 2>/dev/null || true
}

# Composed helpers: write the status marker AND start the animated visual line.
# Use these in run_update for any phase that should show as one of the 7 steps;
# fall back to bare _report_progress if you want the marker without the spinner
# (rare — almost everything user-facing should use these).
_step_phase_start() {
    local step="$1" msg="$2"
    _report_progress "$step" "$msg"
    tui_step_start "$step" "$_update_total_steps" "$msg"
}

_step_phase_done() { tui_step_done "${1:-}"; }
_step_phase_fail() { tui_step_fail "${1:-}"; }
_step_phase_warn() { tui_step_warn "${1:-}"; }
_step_phase_skip() { tui_step_skip "${1:-}"; }

# Header-only variant: writes the status marker AND prints the dot indicator +
# step counter, but no spinner. Use for phases where verbose output (per-file
# rsync, per-dependency check, per-package install) would compete with the
# spinner animation. Each verbose line still uses the existing tui_* primitives.
_step_phase_header() {
    local step="$1" msg="$2"
    _report_progress "$step" "$msg"
    local dots
    dots="$(_tui_step_dots "$step" "$_update_total_steps")"
    printf '\n  %b %b[%d/%d]%b %b%s%b\n\n' \
        "$dots" \
        "$STY_FAINT" "$step" "$_update_total_steps" "$STY_RST" \
        "$STY_PURPLE" "$msg" "$STY_RST"
}

# Simulated update: same step pacing and visuals as the real flow, but with
# sleeps in place of git pull / rsync / migrations / makepkg. Writes the same
# progress markers so ShellUpdates resume logic can be exercised end-to-end
# without touching the user's installation. Triggered by `setup update --simulate`.
run_update_simulated() {
    local started=$SECONDS

    tui_hero_card "Simulated Update" \
        "Walks the seven update phases with the real visuals — no files touched, no git pull, no shell restart." \
        "Status markers are still written to update-status so the bar indicator and resume logic can be exercised."

    tui_warn "Simulation mode — the installation will not change."

    # Step 1 — fast atomic op: animated spinner
    _step_phase_start 1 "Pulling changes"
    sleep 2
    _step_phase_done "Pulled 4 commits from origin/prerelease"

    # Step 2 — verbose op: header + simulated per-file lines
    _step_phase_header 2 "Syncing files"
    tui_info "Syncing iNiR..."
    sleep 1
    tui_check_ok "scripts/inir         (current)"
    tui_check_ok "modules/bar          (3 files updated)"
    tui_check_ok "services/Audio.qml   (current)"
    tui_check_ok "translations/es.json (current)"
    sleep 1
    tui_success "Synced 1247 files (12 modified, 3 added)"

    # Step 3 — fast atomic op: animated spinner
    _step_phase_start 3 "Running migrations"
    sleep 1
    _step_phase_done "All migrations up to date (0 pending)"

    # Step 4 — verbose op: header + simulated service-refresh lines
    _step_phase_header 4 "Finalizing"
    tui_info "Refreshing systemd unit..."
    sleep 1
    tui_check_ok "inir.service reloaded"
    tui_check_ok "Launcher path verified"
    tui_success "Service file refreshed"

    # Step 5 — verbose op: header + simulated dependency-check lines
    _step_phase_header 5 "Checking dependencies"
    sleep 1
    tui_check_ok "pipewire             (installed)"
    tui_check_ok "niri                 (installed)"
    tui_check_ok "matugen              (installed)"
    tui_check_ok "millennium           (installed)"
    tui_check_ok "fish                 (installed)"
    sleep 1
    tui_success "All 48 runtime dependencies satisfied"

    # Step 6 — verbose op: header + simulated python-pkg lines
    _step_phase_header 6 "Python packages"
    sleep 1
    tui_check_ok "matugen              (current)"
    tui_check_ok "mutagen              (current)"
    tui_check_ok "requests             (current)"
    sleep 1
    tui_success "Python venv up to date"

    # Mirror the real flow's order: write success BEFORE the final "Restarting" marker.
    echo "success" > "$_update_status_file" 2>/dev/null || true

    # Step 7 — fast atomic op: animated spinner
    _step_phase_start 7 "Restarting shell"
    sleep 1
    _step_phase_done "Shell restart skipped in simulation"

    echo ""
    tui_alert "success" "Simulation complete" \
        "Total elapsed: $(tui_elapsed "$started"). Run './setup update' (without --simulate) for the real thing."
}

refresh_sddm_theme_on_update() {
    local ask_mode="${1:-true}"

    if ! command -v sddm >/dev/null 2>&1; then
        return 0
    fi

    # Always refresh on update — settings like InputMethod may have changed
    local auto_apply_mode="yes"
    if [[ "$ask_mode" == "true" ]]; then
        # Interactive: let installer ask if switching from another theme
        auto_apply_mode="ask"
    fi

    echo ""
    tui_info "Refreshing ii-pixel SDDM theme..."

    if ! extras_install_sddm_theme "$auto_apply_mode"; then
        tui_warn "SDDM theme refresh failed — you may need to run manually:"
        tui_dim "  sudo bash ${REPO_ROOT}/scripts/sddm/install-pixel-sddm.sh"
    fi
}

run_update() {
    # Short-circuit to the simulated walkthrough — no git pull, no rsync,
    # no migrations, no shell restart. Useful for previewing the new TUI
    # visuals or exercising the resume-from-status-file logic.
    if [[ "${INIR_SIMULATE_UPDATE:-}" == "1" ]]; then
        run_update_simulated
        return $?
    fi

    echo ""
    tui_title "Checking for updates..."
    echo ""

    # Show current branch for awareness
    local current_branch
    local tracked_branch
    current_branch="$(git -C "$REPO_ROOT" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")"
    tracked_branch="$(get_update_tracking_branch 2>/dev/null || echo "main")"
    if [[ "$current_branch" == "HEAD" ]]; then
        tui_warn "Detached HEAD checkout. Updates will track origin/${tracked_branch}."
    elif [[ "$current_branch" != "main" && "$current_branch" != "master" && "$current_branch" != "unknown" ]]; then
        tui_warn "On branch '$current_branch' (non-release). Updates will track this branch."
    else
        tui_info "Branch: $tracked_branch"
    fi

    local installed_mode=$(get_installed_install_mode)
    local installed_strategy=$(get_installed_update_strategy)
    local package_name=$(get_installed_package_name)
    local update_hint=$(get_installed_package_update_hint)

    if [[ "$installed_strategy" == "package-manager" ]]; then
        tui_warn "This iNiR installation is package-managed"
        tui_status_line "Install Mode:" "$installed_mode" ""
        [[ -n "$package_name" ]] && tui_status_line "Package:" "$package_name" ""
        if [[ -n "$update_hint" ]]; then
            tui_info "Update the shell payload with: $update_hint"
        else
            tui_info "Update the shell payload with your package manager."
        fi

        local pending=$(count_pending_migrations 2>/dev/null || echo "0")
        if [[ "$pending" -gt 0 ]]; then
            echo ""
            run_migrations_auto
            pending=$(count_pending_migrations 2>/dev/null || echo "0")
            if [[ "$pending" -gt 0 ]]; then
                tui_warn "$pending optional migration(s) available"
                if $ask && tui_confirm "Review and apply now?"; then
                    run_migrations_interactive
                fi
            fi
        fi

        ensure_user_inir_service_enabled >/dev/null 2>&1 || true
        # Only start inir if we're running under a supported compositor.
        # WAYLAND_DISPLAY alone is not enough — KDE/GNOME set it too.
        if [[ -n "${NIRI_SOCKET:-}" ]] || pgrep -x niri &>/dev/null || pgrep -x Hyprland &>/dev/null; then
            systemctl --user reset-failed inir.service >/dev/null 2>&1 || true
            systemctl --user start inir.service >/dev/null 2>&1 || true
        fi

        # Even on package-managed installs, refresh the shipped ii-pixel theme from
        # the current checkout so SDDM import/theme fixes are not stranded behind
        # the separate extras flow.
        refresh_sddm_theme_on_update "$ask"
        extras_refresh_yamis_icons_on_update

        echo ""
        tui_success "Package-managed installation left unchanged"
        echo "success" > "$_update_status_file" 2>/dev/null || true
        return 0
    fi

    # After a git pull, the setup script re-execs itself so that updated library
    # code (doctor, migrations, etc.) is loaded fresh. _II_POST_PULL signals that
    # we already pulled and should skip straight to the sync phase.
    # Values: "1" = re-exec after pull, "local" = --local flag (skip pull entirely)
    if [[ "${_II_POST_PULL:-}" == "1" ]]; then
        unset _II_POST_PULL
        tui_success "Libraries reloaded after pull"
    elif [[ "${_II_POST_PULL:-}" == "local" ]]; then
        unset _II_POST_PULL
        tui_info "Syncing from local repo (git pull skipped)"
        # Still create a snapshot before sync
        local repo_commit=$(get_repo_commit)
        local snapshot_id=$(create_snapshot "update" "Before local sync to ${repo_commit}" "$repo_commit")
        tui_success "Snapshot: $snapshot_id"
    else
        local update_rc=0
        check_remote_updates || update_rc=$?

        if [[ "$update_rc" -eq 0 ]]; then
            # Updates available
            show_pending_commits

            if [[ "$current_branch" == "HEAD" ]]; then
                tui_error "Detached HEAD checkout cannot pull updates automatically."
                tui_info "Check out a branch first, then run ./setup update again."
                return 1
            fi

            if $ask; then
                if ! tui_confirm "Pull and apply these updates?"; then
                    echo "Cancelled."
                    return 0
                fi
            fi

            # Create snapshot BEFORE pulling
            tui_info "Creating snapshot..."
            local remote_commit=$(get_remote_commit)
            local snapshot_id=$(create_snapshot "update" "Before update to ${remote_commit}" "$remote_commit")
            tui_success "Snapshot: $snapshot_id"

            # Pull changes
            _step_phase_start 1 "Pulling changes"
            if ! git -C "$REPO_ROOT" pull --ff-only origin "$tracked_branch" 2>/dev/null; then
                _step_phase_fail "Git pull failed"
                tui_error "Git pull from origin/${tracked_branch} failed. You may have local changes."
                tui_info "Try: git stash && ./setup update"
                return 1
            fi
            _step_phase_done "Pulled changes from origin/${tracked_branch}"

            # Re-exec to pick up updated library code from the pull.
            # Without this, functions sourced at startup (doctor, migrations, etc.)
            # would still be the OLD versions in memory.
            local reexec_args=()
            $ask || reexec_args+=("-y")
            $quiet && reexec_args+=("-q")
            reexec_args+=("update")
            export _II_POST_PULL=1
            exec "$REPO_ROOT/setup" "${reexec_args[@]}"
        elif [[ "$update_rc" -eq 3 ]]; then
            tui_warn "Local checkout is ahead of origin/${tracked_branch}. Skipping git pull."
            show_local_ahead_commits
            tui_info "Syncing from the current local repo state..."
        elif [[ "$update_rc" -eq 4 ]]; then
            show_diverged_commits
            if [[ "$tracked_branch" == "main" || "$tracked_branch" == "master" ]]; then
                tui_error "Remote branch '${tracked_branch}' diverged from this checkout."
                tui_info "Release branch history should not be rewritten. Refusing automatic update."
            else
                tui_error "Branch '${current_branch}' diverged from origin/${tracked_branch}."
                tui_info "Non-release branches may be rewritten during testing. Refusing to auto-reset this checkout."
                tui_info "If the rewrite was intentional, realign manually: git fetch origin && git reset --hard origin/${tracked_branch}"
            fi
            return 1
        elif [[ "$update_rc" -eq 2 ]]; then
            # Could not check remote (offline/no git/missing tracked branch)
            tui_warn "Could not check for remote updates (offline, not a git repo, or missing tracked branch)"
            tui_info "Checking local repo vs installed version..."
        fi
        # Fall through: rc=1 (no updates) or rc=2 (error) — check local repo vs installed

        # Check if local repo is ahead of installed
        local installed_ver=$(get_installed_version)
        local installed_commit=$(get_installed_commit)
        local repo_ver=$(get_repo_version)
        local repo_commit=$(get_repo_commit)

        if [[ "$installed_ver" == "0.0.0" ]] && [[ -f "${FIRSTRUN_FILE}" ]]; then
            tui_info "Detected existing installation without version tracking"
        elif [[ "$installed_commit" == "$repo_commit" ]]; then
            tui_success "Already up to date ($installed_ver)"
            echo "success" > "$_update_status_file" 2>/dev/null || true

            local pending=$(count_pending_migrations)
            if [[ "$pending" -gt 0 ]]; then
                echo ""
                tui_warn "$pending pending migration(s) available"
                if $ask && tui_confirm "Apply migrations now?"; then
                    run_migrations_interactive
                fi
            fi
            return 0
        else
            # Local repo ahead of installed - create snapshot
            tui_info "Creating snapshot..."
            local snapshot_id=$(create_snapshot "update" "Before sync to ${repo_commit}" "$repo_commit")
            tui_success "Snapshot: $snapshot_id"
        fi
    fi

    # Sync files
    local repo_ver=$(get_repo_version)
    local repo_commit=$(get_repo_commit)

    _step_phase_header 2 "Syncing files"
    tui_info "Syncing iNiR..."

    II_SOURCE="${REPO_ROOT}"
    II_TARGET="${XDG_CONFIG_HOME}/quickshell/inir"
    local legacy_runtime_dir="${XDG_CONFIG_HOME}/quickshell/ii"

    for dir in "$XDG_BIN_HOME" "$XDG_CACHE_HOME" "$XDG_CONFIG_HOME" "$XDG_DATA_HOME" "$XDG_STATE_HOME" "$II_TARGET"; do
        [[ -n "$dir" ]] && mkdir -p "$dir"
    done

    # Check if source and target are the same (dev setup)
    local src_real=$(realpath "$II_SOURCE" 2>/dev/null || echo "$II_SOURCE")
    local tgt_real=$(realpath "$II_TARGET" 2>/dev/null || echo "$II_TARGET")

    if [[ "$src_real" != "$tgt_real" ]]; then
        local runtime_compare_dir="$II_TARGET"
        local runtime_manifest=""
        local legacy_transition=false

        if [[ ! -f "${II_TARGET}/shell.qml" ]] && [[ -f "${legacy_runtime_dir}/shell.qml" ]]; then
            runtime_compare_dir="$legacy_runtime_dir"
            legacy_transition=true
            tui_info "Detected legacy quickshell/ii runtime"
        fi

        PRESERVED_MODS_DIR=""
        runtime_manifest=$(find_runtime_manifest_file "$runtime_compare_dir" 2>/dev/null || true)
        if [[ -n "$runtime_manifest" ]] && manifest_has_checksums "$runtime_manifest"; then
            echo ""
            tui_info "Checking for local modifications..."

            local modified_files_str
            local added_files_str
            modified_files_str=$(detect_user_modifications "$runtime_compare_dir" "$runtime_manifest")
            added_files_str=$(detect_user_additions "$runtime_compare_dir" "$runtime_manifest")

            local mod_count=0
            local add_count=0
            [[ -n "$modified_files_str" ]] && mod_count=$(echo "$modified_files_str" | grep -c . || echo 0)
            [[ -n "$added_files_str" ]] && add_count=$(echo "$added_files_str" | grep -c . || echo 0)
            local total_mods=$((mod_count + add_count))

            if [[ $total_mods -gt 0 ]]; then
                if ! handle_user_modifications "$modified_files_str" "$added_files_str" "$runtime_compare_dir"; then
                    return 1  # User cancelled
                fi
            else
                tui_success "No local modifications detected"
            fi
        elif [[ "$legacy_transition" == "true" ]]; then
            echo ""
            tui_info "Preserving legacy quickshell/ii runtime..."
            PRESERVED_MODS_DIR=$(preserve_runtime_tree "$runtime_compare_dir" "legacy-runtime")
            tui_success "Legacy runtime preserved"
        elif [[ -f "${runtime_compare_dir}/shell.qml" ]]; then
            # No checksum manifest (v1 or missing) — compare installed files
            # directly against repo to catch user modifications before first v2 update
            echo ""
            tui_info "No checksum manifest — comparing installed files against repo..."

            local modified_files_str
            modified_files_str=$(detect_user_modifications_by_source_comparison "$runtime_compare_dir" "$REPO_ROOT")

            local mod_count=0
            [[ -n "$modified_files_str" ]] && mod_count=$(echo "$modified_files_str" | grep -c . || echo 0)

            if [[ $mod_count -gt 0 ]]; then
                if ! handle_user_modifications "$modified_files_str" "" "$runtime_compare_dir"; then
                    return 1  # User cancelled
                fi
            else
                tui_success "No local modifications detected"
            fi
        fi

        echo ""
        tui_info "Syncing files..."

        # Sync root QML files
        for qml in "${II_SOURCE}"/*.qml; do
            [[ -f "$qml" ]] && cp -f "$qml" "${II_TARGET}/$(basename "$qml")"
        done

        local runtime_root_manifest="${II_SOURCE}/sdata/runtime-root-files.txt"
        local runtime_dirs_manifest="${II_SOURCE}/sdata/runtime-payload-dirs.txt"

        if [[ -f "$runtime_root_manifest" ]]; then
            while IFS= read -r runtime_file; do
                [[ -n "$runtime_file" ]] || continue
                [[ -f "${II_SOURCE}/${runtime_file}" ]] && cp -f "${II_SOURCE}/${runtime_file}" "${II_TARGET}/${runtime_file}"
            done < "$runtime_root_manifest"
        fi

        if [[ -f "$runtime_dirs_manifest" ]]; then
            while IFS= read -r dir; do
                [[ -n "$dir" ]] || continue
                [[ -d "${II_SOURCE}/${dir}" ]] && mkdir -p "${II_TARGET}/${dir}" && rsync -a --delete --exclude='AGENTS.md' "${II_SOURCE}/${dir}/" "${II_TARGET}/${dir}/"
            done < "$runtime_dirs_manifest"
        fi

        # Cleanup deprecated files
        [[ -f "${II_TARGET}/requirements.txt" ]] && rm -f "${II_TARGET}/requirements.txt"

        # Show preservation reminder after sync
        if [[ -n "$PRESERVED_MODS_DIR" ]]; then
            echo ""
            tui_info "Reminder: Your modifications were saved to:"
            tui_dim "    $PRESERVED_MODS_DIR"
        fi
    fi

    # Generate manifest
    generate_manifest "$II_SOURCE" "${II_TARGET}/.inir-manifest"

    # Remove orphan files left from previous versions
    cleanup_orphans "$II_TARGET" "${II_TARGET}/.inir-manifest"

    # Fix permissions
    find "$II_TARGET/scripts" \( -name "*.sh" -o -name "*.fish" -o -name "*.py" \) -exec chmod +x {} \; 2>/dev/null || true
    [[ -f "${II_TARGET}/setup" ]] && chmod +x "${II_TARGET}/setup"

    local launcher_target="${XDG_BIN_HOME}/inir"
    if [[ -f "${REPO_ROOT}/scripts/inir" ]]; then
        mkdir -p "$XDG_BIN_HOME"
        cp -f "${REPO_ROOT}/scripts/inir" "$launcher_target"
        chmod +x "$launcher_target"
        ensure_launcher_path_in_shells "$XDG_BIN_HOME"
        if ! command -v inir &>/dev/null && [[ ":$PATH:" != *":${XDG_BIN_HOME}:"* ]]; then
            tui_warn "Launcher installed to ${launcher_target}, but ${XDG_BIN_HOME} is not in PATH for this shell"
        fi
    fi

    local _service_refresh_status=1

    if [[ -f "${REPO_ROOT}/assets/icons/desktop-symbolic.svg" ]]; then
        local icon_target_dir="${XDG_DATA_HOME}/icons/hicolor/scalable/apps"
        mkdir -p "$icon_target_dir"
        cp -f "${REPO_ROOT}/assets/icons/desktop-symbolic.svg" "${icon_target_dir}/inir.svg"
    fi

    local applications_dir="${XDG_DATA_HOME}/applications"
    mkdir -p "$applications_dir"
    if [[ -f "${REPO_ROOT}/assets/applications/inir.desktop" ]]; then
        cp -f "${REPO_ROOT}/assets/applications/inir.desktop" "${applications_dir}/inir.desktop"
    fi
    if [[ -f "${REPO_ROOT}/assets/applications/inir-settings.desktop" ]]; then
        local settings_tmp="${XDG_CACHE_HOME}/inir-settings.desktop.$$"
        sed "s|^Exec=.*|Exec=${launcher_target//&/\\&} settings|" "${REPO_ROOT}/assets/applications/inir-settings.desktop" > "$settings_tmp"
        cp -f "$settings_tmp" "${applications_dir}/inir-settings.desktop"
        rm -f "$settings_tmp"
    fi

    # Update version
    set_installed_version "$repo_ver" "$repo_commit" "update"

    # Write runtime version.json only for repo-copy (separate target dir).
    # For repo-link (src==tgt) this would pollute the repo root — skip it;
    # the canonical tracking is already in the config dir via set_installed_version.
    if [[ -d "$II_TARGET" && "$src_real" != "$tgt_real" ]]; then
        write_version_info_json "${II_TARGET}/version.json" "$repo_ver" "$repo_commit" "setup-update"
    fi

    tui_success "Files synced"

    # Refresh ii-pixel SDDM theme on update (keeps shipped theme in sync with fixes)
    # Interactive mode can prompt before switching Current theme; non-interactive
    # mode only refreshes the installed theme files.
    refresh_sddm_theme_on_update "$ask"
    extras_refresh_yamis_icons_on_update

    # Update Vesktop themes (themes live outside quickshell/ii tree)
    if [[ -d "${REPO_ROOT}/dots/.config/vesktop/themes" ]]; then
        echo ""
        tui_info "Updating Vesktop themes..."

        mkdir -p "${XDG_CONFIG_HOME}/vesktop/themes"
        mkdir -p "${XDG_CONFIG_HOME}/Vesktop/themes"

        OLD_VESKTOP_THEMES=(
            "midnight-ii.theme.css"
            "dms-midnight.theme.css"
            "system24-ii.theme.css"
            "system24-palette.css"
            "ii-palette.css"
            "ii-system24.theme.css"
        )
        for old_theme in "${OLD_VESKTOP_THEMES[@]}"; do
            [[ -f "${XDG_CONFIG_HOME}/vesktop/themes/${old_theme}" ]] && rm -f "${XDG_CONFIG_HOME}/vesktop/themes/${old_theme}"
            [[ -f "${XDG_CONFIG_HOME}/Vesktop/themes/${old_theme}" ]] && rm -f "${XDG_CONFIG_HOME}/Vesktop/themes/${old_theme}"
        done

        install_dir "${REPO_ROOT}/dots/.config/vesktop/themes" "${XDG_CONFIG_HOME}/vesktop/themes"
        install_dir "${REPO_ROOT}/dots/.config/vesktop/themes" "${XDG_CONFIG_HOME}/Vesktop/themes"

        tui_success "Vesktop themes updated"
    fi

    # Migrations
    _step_phase_header 3 "Running migrations"
    local pending=$(count_pending_migrations)
    if [[ "$pending" -gt 0 ]]; then
        echo ""
        # Always apply REQUIRED migrations automatically, then offer optional migrations.
        run_migrations_auto
        pending=$(count_pending_migrations)
        if [[ "$pending" -gt 0 ]]; then
            tui_warn "$pending optional migration(s) available"
            if $ask && tui_confirm "Review and apply?"; then
                run_migrations_interactive
            fi
        fi
    fi

    _step_phase_header 4 "Finalizing"
    _service_refresh_status=1
    if sync_user_inir_service_from_repo_if_present; then
        _service_refresh_status=0
    else
        _service_refresh_status=$?
    fi
    if [[ $_service_refresh_status -eq 0 ]]; then
        tui_success "Updated existing user inir.service"
    fi

    ensure_user_inir_service_enabled >/dev/null 2>&1 || true

    local niri_config="${XDG_CONFIG_HOME}/niri/config.kdl"
    local niri_startup_cfg="${XDG_CONFIG_HOME}/niri/config.d/50-startup.kdl"
    local niri_binds_cfg="${XDG_CONFIG_HOME}/niri/config.d/70-binds.kdl"
    if [[ -f "$niri_config" && -x "${XDG_BIN_HOME}/inir" ]]; then
        local launcher_target_escaped="${XDG_BIN_HOME}/inir"
        launcher_target_escaped="${launcher_target_escaped//&/\\&}"
        if [[ -f "$niri_binds_cfg" ]]; then
            sed -i \
                -e 's|spawn "bash" "-lc" "exec \"\$(inir path)/scripts/launch-terminal.sh\""|spawn "'"${launcher_target_escaped}"'" "terminal"|' \
                -e 's|spawn "bash" "-lc" "exec \"\$(inir path)/scripts/close-window.sh\""|spawn "'"${launcher_target_escaped}"'" "close-window"|' \
                -e 's|spawn "inir" "|spawn "'"${launcher_target_escaped}"'" "|g' \
                "$niri_binds_cfg"
        else
            sed -i \
                -e 's|spawn "bash" "-lc" "exec \"\$(inir path)/scripts/launch-terminal.sh\""|spawn "'"${launcher_target_escaped}"'" "terminal"|' \
                -e 's|spawn "bash" "-lc" "exec \"\$(inir path)/scripts/close-window.sh\""|spawn "'"${launcher_target_escaped}"'" "close-window"|' \
                -e 's|spawn "inir" "|spawn "'"${launcher_target_escaped}"'" "|g' \
                "$niri_config"
        fi
    fi

    # DISABLED: webapps — requires quickshell-webengine rebuild, re-enable when ready
    # # Install default WebApp plugins for existing users
    # if [[ -d "${REPO_ROOT}/defaults/plugins" ]]; then
    #     local plugins_dir="${XDG_CONFIG_HOME}/illogical-impulse/plugins"
    #     mkdir -p "$plugins_dir"
    #     local new_plugins=0
    #     for plugin_src in "${REPO_ROOT}/defaults/plugins"/*/; do
    #         local pname=$(basename "$plugin_src")
    #         local pdest="${plugins_dir}/${pname}"
    #         if [[ ! -d "$pdest" ]]; then
    #             cp -r "$plugin_src" "$pdest"
    #             ((new_plugins++))
    #         else
    #             # Update userscripts only (don't overwrite user manifest/icon)
    #             if [[ -d "${plugin_src}scripts" ]]; then
    #                 mkdir -p "${pdest}/scripts"
    #                 cp -r "${plugin_src}scripts/"* "${pdest}/scripts/" 2>/dev/null || true
    #             fi
    #         fi
    #     done
    #     [[ $new_plugins -gt 0 ]] && tui_success "Installed $new_plugins default WebApp plugin(s)"
    # fi

    # Post-update: check for missing dependencies and offer to install them
    _step_phase_header 5 "Checking dependencies"
    check_dependencies
    if [[ ${#doctor_missing_deps[@]} -gt 0 ]]; then
        tui_warn "Missing packages detected: ${doctor_missing_deps[*]}"
        if $ask; then
            # Interactive mode: offer to install
            if tui_confirm "Install missing packages now?"; then
                detect_distro
                SKIP_SYSUPDATE=true
                ONLY_MISSING_DEPS="${doctor_missing_deps[*]}"
                source ./sdata/subcmd-install/1.deps-router.sh
                tui_success "Dependencies installed"
            else
                tui_info "Skipped dependency installation"
            fi
        elif can_elevate; then
            # Non-interactive mode but can elevate (pkexec available) — install via graphical auth
            tui_info "Installing missing packages via graphical authentication..."
            detect_distro
            SKIP_SYSUPDATE=true
            ONLY_MISSING_DEPS="${doctor_missing_deps[*]}"
            USE_ELEVATE=true  # Signal deps-router to use elevate() instead of sudo
            source ./sdata/subcmd-install/1.deps-router.sh
            tui_success "Dependencies installed"
        else
            # No way to elevate — just inform
            tui_info "Run './setup doctor' to install missing packages"
        fi
    else
        tui_success "All required commands available"
    fi

    # DISABLED: webapps — requires quickshell-webengine rebuild, re-enable when ready
    # # WebApp plugins: check if quickshell has WebEngine support
    # if [[ -d "${REPO_ROOT}/defaults/plugins" ]]; then
    #     echo ""
    #     tui_title "WebApp Plugins"
    #     echo ""
    #
    #     local has_webengine=false
    #     if pacman -Q qt6-webengine &>/dev/null 2>&1; then
    #         has_webengine=true
    #     elif dpkg -s qt6-webengine-dev &>/dev/null 2>&1; then
    #         has_webengine=true
    #     elif rpm -q qt6-qtwebengine-devel &>/dev/null 2>&1; then
    #         has_webengine=true
    #     fi
    #
    #     # Check if quickshell was compiled with our WebEngine patch
    #     local qs_has_patch=false
    #     if strings "$(which qs 2>/dev/null || echo /usr/bin/quickshell)" 2>/dev/null | grep -q "EnableQtWebEngineQuick" 2>/dev/null; then
    #         qs_has_patch=true
    #     fi
    #
    #     if $qs_has_patch; then
    #         tui_success "Quickshell has WebEngine support"
    #         tui_info "Enable Web Apps in Settings → Interface → Sidebars"
    #     elif $has_webengine; then
    #         tui_info "qt6-webengine is installed but quickshell needs to be recompiled"
    #         tui_info "Web Apps (Discord, YouTube Music, etc.) require a patched quickshell"
    #         if $ask; then
    #             if tui_confirm "Build and install quickshell with WebEngine support?"; then
    #                 echo ""
    #                 _build_install_qs_webengine
    #             fi
    #         else
    #             tui_info "Run: cd ${REPO_ROOT}/scripts/quickshell-webengine && makepkg -si"
    #         fi
    #     else
    #         tui_info "WebApp plugins available (Discord, YouTube Music with adblock)"
    #         tui_info "Requires: qt6-webengine + patched quickshell"
    #         if $ask; then
    #             if tui_confirm "Install qt6-webengine and build patched quickshell?"; then
    #                 echo ""
    #                 if command -v pacman >/dev/null 2>&1; then
    #                     tui_info "Installing qt6-webengine..."
    #                     pkg_sudo pacman -S --needed --noconfirm qt6-webengine || true
    #                 fi
    #                 _build_install_qs_webengine
    #             fi
    #         else
    #             tui_info "To enable: pacman -S qt6-webengine"
    #             tui_info "Then: cd ${REPO_ROOT}/scripts/quickshell-webengine && makepkg -si"
    #         fi
    #     fi
    # fi

    # Update Python venv packages
    _step_phase_header 6 "Python packages"
    local venv_dir="${XDG_STATE_HOME}/quickshell/.venv"
    local req_file="${REPO_ROOT}/sdata/uv/requirements.txt"

    if [[ -f "$req_file" ]] && command -v uv &>/dev/null; then
        if [[ ! -d "$venv_dir/bin" ]]; then
            tui_info "Creating Python venv..."
            uv venv --prompt ii-venv "$venv_dir" -p 3.12 2>/dev/null || uv venv --prompt ii-venv "$venv_dir" 2>/dev/null
        fi

        if [[ -d "$venv_dir/bin" ]]; then
            tui_info "Updating Python packages..."
            source "$venv_dir/bin/activate"
            uv pip install -q -r "$req_file" 2>/dev/null
            deactivate
            tui_success "Python packages updated"
        fi
    else
        tui_success "Python packages (skipped - uv not available)"
    fi

    # Signal success to the shell UI before restart
    echo "success" > "$_update_status_file" 2>/dev/null || true

    # Restart shell (only if we have access to the session)
    if [[ -n "$NIRI_SOCKET" ]] || [[ -n "$WAYLAND_DISPLAY" ]]; then
        _step_phase_start 7 "Restarting shell"
        if command -v systemctl >/dev/null 2>&1 && systemctl --user cat inir.service >/dev/null 2>&1; then
            nohup systemctl --user restart inir.service >/dev/null 2>&1 &
            disown
        elif [[ -x "${II_TARGET}/scripts/inir" ]]; then
            nohup bash "${II_TARGET}/scripts/inir" restart -c "${II_TARGET}" >/dev/null 2>&1 &
            disown
        else
            qs -p "${II_TARGET}" kill 2>/dev/null || true
            sleep 1
            nohup qs -p "${II_TARGET}" >/dev/null 2>&1 &
            disown
        fi
        _step_phase_done "Shell restart triggered"
    else
        _step_phase_header 7 "Restarting shell"
        tui_warn "Not in graphical session - shell restart skipped"
        tui_info "The shell will use new files on next restart"
        tui_info "Or run: inir restart"
    fi

    echo ""
    tui_alert "success" "Update complete" "Version $repo_ver ($repo_commit) synced.\nRun './setup rollback' if something breaks."
}

###############################################################################
# Doctor
###############################################################################
run_doctor() {
    echo ""
    tui_hero_card "iNiR Doctor" \
        "Diagnosing and auto-fixing your shell setup."
    show_setup_context_card "Doctor Context"
    run_doctor_with_fixes
}

###############################################################################
# Parse args
###############################################################################
COMMAND=""
SUBCMD_ARGS=()
while [[ $# -gt 0 ]]; do
    case $1 in
        install|reinstall|update|migrate|doctor|rollback|my-changes|uninstall|status|config|theme|info|backup|logs|extras)
            COMMAND="$1"; shift
            SUBCMD_ARGS=("$@")
            break
            ;;
        -y|--yes) ask=false; shift ;;
        -q|--quiet) quiet=true; shift ;;
        --local) export _II_POST_PULL=local; shift ;;
        --set-default-shell) export INIR_SET_DEFAULT_SHELL=true; shift ;;
        -h|--help) show_help; exit 0 ;;
        *) echo "Unknown: $1"; show_help; exit 1 ;;
    esac
done

# Check prerequisites for install command (after parsing flags)
if [[ "$COMMAND" == "install" ]]; then
  # Source install-specific option parser if there are subcommand args
  if [[ ${#SUBCMD_ARGS[@]} -gt 0 ]]; then
    source ./sdata/subcmd-install/options.sh "${SUBCMD_ARGS[@]}"
  fi
  _check_privilege_prereqs "install"
fi

###############################################################################
# Run
###############################################################################
case "$COMMAND" in
    install) run_install ;;
    reinstall)
        for _arg in "${SUBCMD_ARGS[@]}"; do
            case "$_arg" in
                -y|--yes) ask=false ;;
                -q|--quiet) quiet=true ;;
            esac
        done
        IS_UPDATE=true
        run_install
        ;;
    update)
        for _arg in "${SUBCMD_ARGS[@]}"; do
            case "$_arg" in
                -y|--yes) ask=false ;;
                -q|--quiet) quiet=true ;;
                --local) export _II_POST_PULL=local ;;
                --simulate|--dry-run) export INIR_SIMULATE_UPDATE=1 ;;
            esac
        done
        run_update
        ;;
    migrate) run_migrate ;;
    doctor) run_doctor ;;
    rollback) run_rollback ;;
    my-changes) run_my_changes ;;
    uninstall) run_uninstall ;;
    status) show_status ;;
    config) run_config ;;
    theme) run_theme ;;
    info) show_info ;;
    backup) run_backup ;;
    logs) run_logs ;;
    extras) run_extras ;;
    "") while tui_menu; do :; done ;;
esac