#!/usr/bin/env bash
# Rootless Linux/macOS installer: downloads the single-process uglad binary from
# install.ugla.ai (the one runtime origin), verifies publisher-signed SHA-256
# checksums, and installs it into the user-owned ~/.local/share/uglad tree —
# no root, no /opt, no system units. Service lifecycle is a host capability
# (#8160): a reachable user systemd manager runs the daemon as today's
# hardened user unit with linger; a host without one runs the SAME verified
# daemon through the portable backend (bin/uglad-service, plus the host's
# own durable startup mechanism when it exposes one).

set -euo pipefail

# ── Pure helpers ──────────────────────────────────────────────────────
# Pure (no side effects) so the test suite can load them with
# `UGLA_INSTALL_LIB=1 source install.sh` without running the installer.

# Resolve the API_SERVER_KEY to write into ~/.ugla/.env: an explicitly
# supplied valid UGLA_API_KEY (hex, ≥32) wins; else the key already in $env_file
# is preserved verbatim; else a fresh 64-hex key is minted. A re-run must never
# rotate the key — that would reject every already-paired phone.
resolve_api_key() {
    local env_file="$1" supplied="${UGLA_API_KEY:-}" existing=""
    if [[ -n "$supplied" && "$supplied" =~ ^[0-9a-fA-F]+$ && ${#supplied} -ge 32 ]]; then
        printf '%s\n' "$supplied"
        return 0
    fi
    if [[ -f "$env_file" ]]; then
        existing=$(grep -m1 '^API_SERVER_KEY=' "$env_file" | cut -d= -f2- || true)
    fi
    if [[ -n "$existing" ]]; then
        printf '%s\n' "$existing"
        return 0
    fi
    openssl rand -hex 32 2>/dev/null || head -c 32 /dev/urandom | xxd -p | tr -d '\n'
}

# Install an executable over a possibly-running target: stage a sibling temp
# and rename(2) it over the destination — a running binary keeps the old inode
# (ETXTBSY), and the same-directory temp keeps the rename on one filesystem.
atomic_install() {
    local src="$1" dst="$2"
    local tmp="${dst}.new.$$"
    install -m 0755 "$src" "$tmp"
    mv -f "$tmp" "$dst"
}

install_supervised_daemon_candidate() {
    local candidate="$1" daemon_dir="$2" target_home="$3"
    UGLA_DAEMON_DIR="$daemon_dir" "$candidate" memory-check --allow-migration --home "$target_home" || return 1
    if [[ -e "${target_home}/.ugla/ugla-auto-update-armed.json" || -L "${target_home}/.ugla/ugla-auto-update-armed.json" ]]; then
        UGLA_DAEMON_DIR="$daemon_dir" "$candidate" rescue-update --forward-repair --home "$target_home" || return 1
    fi
    mkdir -p "${daemon_dir}/bin" || return 1
    if [[ -e "${daemon_dir}/bin/uglad" || -L "${daemon_dir}/bin/uglad" ]]; then
        [[ -f "${daemon_dir}/bin/uglad" && ! -L "${daemon_dir}/bin/uglad" ]] || return 1
        atomic_install "${daemon_dir}/bin/uglad" "${daemon_dir}/bin/uglad.bak" || return 1
    fi
    atomic_install "$candidate" "${daemon_dir}/bin/uglad"
}

# Rename the `wtf-`-prefixed state files inside an already-moved state dir to
# their `ugla-` names. `mv -n` makes a re-run safe: an already-migrated file is
# left alone rather than clobbered with a stale leftover.
migrate_legacy_state_names() {
    local dir="$1" legacy base
    [[ -d "$dir" ]] || return 0
    for legacy in "$dir"/wtf-*; do
        [[ -e "$legacy" ]] || continue
        base="$(basename -- "$legacy")"
        mv -n -- "$legacy" "${dir}/ugla-${base#wtf-}"
    done
}

# Rewrite `WTF_*` keys in an existing .env to their `UGLA_*` names: only the
# key is rewritten, and a line whose `UGLA_` name already exists is dropped
# rather than duplicated. The rewrite lands through a same-directory temp
# created 0600 before its first byte.
migrate_legacy_env_keys() {
    local file="$1" tmp
    [[ -f "$file" ]] || return 0
    grep -q '^[[:space:]]*WTF_' "$file" || return 0
    tmp="$(mktemp "${file}.XXXXXX")" || return 0
    chmod 600 "$tmp"
    # Two passes: the first learns which UGLA_ keys exist, the second rewrites.
    awk '
        NR == FNR {
            if (match($0, /^[[:space:]]*UGLA_[A-Za-z0-9_]+=/))
                have[substr($0, RSTART, RLENGTH - 1)] = 1
            next
        }
        {
            if (match($0, /^[[:space:]]*WTF_[A-Za-z0-9_]+=/)) {
                renamed = "UGLA_" substr($0, RSTART + 4)
                key = renamed
                sub(/=.*/, "", key)
                if (key in have) next
                print renamed
                next
            }
            print
        }
    ' "$file" "$file" > "$tmp" || { rm -f "$tmp"; return 0; }
    mv -f "$tmp" "$file"
    chmod 600 "$file"
}

# One-time local-state cutover: ~/.wtf → ~/.ugla and ~/WTF → ~/Ugla are moved
# once, and the old names are never read again afterwards. The installer runs
# this BEFORE `uglad service-install`: the daemon's node lock creates the
# state root, so a box still on ~/.wtf must be moved first or its retained
# state is stranded while the new daemon starts on an empty home.
# Args: $1 = user home.
cutover_legacy_home() {
    local home="$1"
    if [[ -d "${home}/.wtf" && ! -e "${home}/.ugla" ]]; then
        mv -- "${home}/.wtf" "${home}/.ugla"
    fi
    if [[ -d "${home}/WTF" && ! -e "${home}/Ugla" ]]; then
        mv -- "${home}/WTF" "${home}/Ugla"
    fi
    # The directory move above is only half the cutover — carry the payload
    # too. Runs unconditionally so a box that moved its directory on an
    # earlier release but never had its files renamed is repaired on the next
    # run.
    migrate_legacy_state_names "${home}/.ugla"
    migrate_legacy_env_keys "${home}/.ugla/.env"
}

# Write one KEY=VALUE pair into the .env, preserving other lines. The file
# holds secrets: it is created 0600 (umask 077 — no world-readable window) and
# repaired to 0600 on every write.
sed_in_place() {
    if [[ "$(uname -s)" == "Darwin" ]]; then
        sed -i '' "$@"
    else
        sed -i "$@"
    fi
}

write_env() {
    local key="$1" val="$2" file="$3"
    if [[ ! -f "$file" ]]; then
        ( umask 077; touch "$file" )
    fi
    if grep -q "^${key}=" "$file"; then
        # Escape the replacement for sed: `&`, `|`, and `\` must land
        # byte-for-byte, not as sed replacement syntax.
        local esc
        esc="$(printf '%s' "$val" | sed -e 's/[\\&|]/\\&/g')"
        sed_in_place "s|^${key}=.*|${key}=${esc}|" "$file"
    else
        echo "${key}=${val}" >> "$file"
    fi
    chmod 600 "$file"
}

# Substitute @@KEY@@ tokens in a file generated from a QUOTED heredoc (<<'EOF')
# so its text is never shell-evaluated; replacements are escaped for sed so
# values insert literally.
render_template() {
    local file="$1"; shift
    local pair key val esc
    for pair in "$@"; do
        key="${pair%%=*}" val="${pair#*=}"
        esc="$(printf '%s' "$val" | sed -e 's/[\\&|]/\\&/g')"
        sed_in_place "s|@@${key}@@|${esc}|g" "$file"
    done
}

# Publish a generated user unit atomically: the text arrives on stdin from a
# QUOTED heredoc, and staging is a mktemp-unique 0600 file inside the
# destination directory — same filesystem for the atomic rename, and private
# from its first byte. No secret travels through the unit text: secrets ride
# the 0600 EnvironmentFile (.env).
publish_user_unit() {
    local target="$1"; shift
    local dir base tmp
    dir="$(dirname -- "$target")"
    base="$(basename -- "$target")"
    mkdir -p "$dir" || return 1
    tmp="$(mktemp "${dir}/.ugla-stage.${base}.XXXXXX")" || return 1
    if ! cat > "$tmp" || ! render_template "$tmp" "$@"; then
        rm -f "$tmp"
        return 1
    fi
    if ! chmod 0644 "$tmp" || ! mv -f "$tmp" "$target"; then
        rm -f "$tmp"
        return 1
    fi
}

# Write the install summary beside the config: version, paths, the manual
# pairing key, service recipes. It holds the API key, so it is created 0600
# from its first byte and repaired to 0600 on every run, like .env.
write_install_summary() {
    local f="$1"
    ( umask 077; : > "$f" )
    chmod 600 "$f"
    {
        printf 'Ugla install summary — %s\n' "$(date)"
        printf 'Version:   %s\n' "${UGLA_VERSION}"
        printf 'Topology:  single process — uglad (%s)\n' "${DAEMON_STATUS}"
        printf 'Neural:    ugla-neurald %s\n' "${NEURAL_STATUS}"
        printf 'Daemon:    %s/bin/uglad  (public app surface :%s)\n' "${DAEMON_DIR}" "${SIDECAR_PORT}"
        printf 'Config:    %s\n' "${ENV_FILE}"
        printf 'Health:    %s\n' "${HEALTH_URL}"
        printf 'Scope:     user install — no root, no /opt, no system units (#6311)\n'
        if [[ "${SERVICE_BACKEND:-systemd}" == "launchd" ]]; then
            printf "Boot:      starts at sign-in; keep this Mac awake and signed in for continuous availability\n"
        elif [[ "${SERVICE_BACKEND:-systemd}" == "portable" ]]; then
            case "${LINGER_RECORD_OUTCOME:-}" in
                ready) printf 'Boot:      starts on boot via this user crontab @reboot entry (portable lifecycle, #8160)\n' ;;
                *)     printf 'Boot:      no durable boot start on this host — %s\n' "${PORTABLE_BOOT_ACTION:-add a startup entry yourself}" ;;
            esac
        else
            case "${LINGER_RECORD_OUTCOME:-}" in
                ready)                 printf 'Boot:      starts automatically with your user service (#6313)\n' ;;
                denied_by_host_policy) printf "Boot:      automatic startup was blocked by this machine's policy — an admin can enable it: loginctl enable-linger %s\n" "$(id -un)" ;;
                *)                     printf 'Boot:      unverified — check loginctl show-user %s --property=Linger\n' "$(id -un)" ;;
            esac
        fi
        case "${SANDBOX_OUTCOME:-}" in
            present)   printf 'Sandbox:   present — the agent runs commands inside it (#7122)\n' ;;
            *)         printf 'Sandbox:   missing — the agent cannot run commands on this box; an admin can run: sudo bash ugla-install.sh --host-op install-sandbox\n' ;;
        esac
        if [[ "${BROWSER_SANDBOX_STATE:-}" == "restricted" ]]; then
            printf 'Browser:   off — this host restricts user namespaces; an admin can run: sudo bash ugla-install.sh --host-op allow-browser-sandbox\n'
        fi
        printf '\nManual pairing from the app (fallback for the claim link):\n'
        printf "  Host: this machine's address   Port: %s\n" "${SIDECAR_PORT}"
        printf '  API key: %s\n' "${API_KEY}"
        if [[ "${SERVICE_BACKEND:-systemd}" == "portable" || "${SERVICE_BACKEND:-systemd}" == "launchd" ]]; then
            printf '\nService commands (portable lifecycle backend):\n'
            printf '  %s/bin/uglad-service status\n' "${DAEMON_DIR}"
            printf '  %s/bin/uglad-service restart\n' "${DAEMON_DIR}"
            printf '  tail -f %s/.ugla/uglad.log\n' "${ACTUAL_HOME}"
        else
            printf "\nService commands (this user's manager):\n"
            printf '  systemctl --user status uglad\n'
            printf '  systemctl --user restart uglad\n'
            printf '  journalctl --user -u uglad -f\n'
        fi
        if [[ "${#INSTALL_TIMING[@]}" -gt 0 ]]; then
            printf '\nTiming (ms since installer entry, #8218):\n'
            local checkpoint
            for checkpoint in "${INSTALL_TIMING[@]}"; do
                printf '  %s\n' "$checkpoint"
            done
        fi
    } >> "$f"
}

# Write the LLM config canonically — `[model]` in ~/.ugla/ugla-agent.toml
# plus the provider key in the encrypted vault — by running `uglad llm-init`
# (the only on-box tool that can open the vault). The key travels on stdin,
# never argv. Any non-zero status is a real failure of the canonical write and
# propagates: a secure-storage failure must not be answered by weakening to
# plaintext state.
# Args: $1 = uglad binary, $2 = user home, $3 = vault keyfile,
#       $4 = base_url, $5 = model, $6 = key ('' = none), $7 = force-model (0/1)
configure_llm() {
    local uglad_bin="$1" user_home="$2" keyfile="$3"
    local base_url="$4" model="$5" key="$6" force="$7"
    local -a extra=()
    if [[ -n "$key" ]]; then extra+=(--key-stdin); fi
    if [[ "$force" == "1" ]]; then extra+=(--force-model); fi
    printf '%s' "$key" | "$uglad_bin" llm-init \
        --home "$user_home" --keyfile "$keyfile" \
        --base-url "$base_url" --model "$model" "${extra[@]}" >/dev/null 2>&1
}

# True iff $1 is an IPv4 address a LAN peer could plausibly dial: excludes
# loopback, unspecified, link-local, the RFC6598 CGNAT range, and
# multicast/reserved space.
lan_addr_usable() {
    local a="$1"
    [[ "$a" =~ ^([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$ ]] || return 1
    local o1 o2
    o1=$((10#${BASH_REMATCH[1]})); o2=$((10#${BASH_REMATCH[2]}))
    (( 10#${BASH_REMATCH[3]} <= 255 && 10#${BASH_REMATCH[4]} <= 255 )) || return 1
    (( o1 <= 255 && o2 <= 255 )) || return 1
    (( o1 == 0 || o1 == 127 )) && return 1
    [[ "$a" == 169.254.* ]] && return 1
    (( o1 == 100 && o2 >= 64 && o2 <= 127 )) && return 1
    (( o1 >= 224 )) && return 1
    return 0
}

# True iff $1 names an interface that can carry the LAN origin. Container
# bridges, veths, overlays, and tunnels cannot; plain `br0`-style bridges are
# KEPT — on boxes that bridge the physical uplink they are the real LAN
# interface (only docker's `br-<id>` user bridges are excluded).
lan_iface_usable() {
    local i="$1"
    [[ -n "$i" ]] || return 1
    case "$i" in
        lo|docker*|br-*|veth*|virbr*|podman*|cni*|flannel*|calico*|cilium*|\
        tailscale*|tun*|tap*|utun*|wg*|zt*|ppp*|ipip*|gre*|sit*|ip6tnl*|ip6gre*)
            return 1
            ;;
    esac
    return 0
}

# Derive the LAN address a phone is expected to reach this box on — never
# simply the first token of `hostname -I`, whose order follows interface
# registration. Preference order:
#   1. the source address of the default IPv4 route, when both the address
#      and the route's interface pass the filters;
#   2. any other global address on a usable interface;
#   3. without iproute2, `hostname -I` filtered by address class alone.
# Echoes the chosen address; returns 1 when nothing usable exists, so the
# caller falls back to the manual key path instead of minting an invite bound
# to an address the phone cannot reach.
lan_origin_address() {
    local line addr iface
    if [[ "$(uname -s)" == "Darwin" ]]; then
        iface="$(/sbin/route -n get default 2>/dev/null | awk '/interface:/ {print $2; exit}')"
        if lan_iface_usable "$iface"; then
            addr="$(/usr/sbin/ipconfig getifaddr "$iface" 2>/dev/null || true)"
            if lan_addr_usable "$addr"; then printf '%s\n' "$addr"; return 0; fi
        fi
        return 1
    fi
    if exists ip; then
        line="$(ip -4 route get 1.1.1.1 2>/dev/null | head -1)"
        addr="$(printf '%s\n' "$line" | awk '{for (i=1; i<=NF; i++) if ($i=="src") print $(i+1)}')"
        iface="$(printf '%s\n' "$line" | awk '{for (i=1; i<=NF; i++) if ($i=="dev") print $(i+1)}')"
        if lan_addr_usable "$addr" && lan_iface_usable "$iface"; then
            printf '%s\n' "$addr"
            return 0
        fi
        while read -r addr iface; do
            [[ -n "$addr" ]] || continue
            if lan_addr_usable "$addr" && lan_iface_usable "$iface"; then
                printf '%s\n' "$addr"
                return 0
            fi
        done < <(ip -4 -o addr show scope global 2>/dev/null \
                    | awk '{split($4, a, "/"); print a[1], $2}')
        # With iproute2 the empty usable set is authoritative — falling
        # through to hostname -I could resurrect a Docker/VPN address.
        return 1
    fi
    for addr in $(hostname -I 2>/dev/null); do
        if lan_addr_usable "$addr"; then
            printf '%s\n' "$addr"
            return 0
        fi
    done
    return 1
}

# Mint this box's one-time claim proof through `uglad claim-invite` and print
# the invite the phone opens. Version skew or an unusable LAN origin means no
# invite is minted; the manual key path remains the fallback.
# Args: $1 = uglad binary, $2 = user home. Sets CLAIM_INVITE/CLAIM_ORIGIN.
mint_claim_invite() {
    local uglad_bin="$1" user_home="$2"
    local origin="" lan_ip=""
    if lan_ip="$(lan_origin_address)"; then
        origin="http://${lan_ip}:${SIDECAR_PORT}"
    fi
    [[ -z "$origin" ]] && return 1
    local output="" payload="" qr_supported=false
    if "$uglad_bin" --help 2>&1 | grep -q 'claim-invite.*--qr'; then
        qr_supported=true
    fi
    local -a claim_args=(claim-invite --home "$user_home" --origin "$origin")
    if $qr_supported; then
        claim_args+=(--qr)
    fi
    output="$("$uglad_bin" "${claim_args[@]}" 2>/dev/null)" || return 1
    payload="$(printf '%s\n' "$output" | sed -n 's/^claim-invite: //p' | head -1)"
    if [[ -z "$payload" ]]; then
        return 1
    fi
    CLAIM_INVITE="$payload"
    CLAIM_ORIGIN="$origin"
    CLAIM_QR="$(printf '%s\n' "$output" | sed -n '/^claim-invite-qr:/,/^claim-invite-qr-end$/ { /^claim-invite-qr:/d; /^claim-invite-qr-end$/d; p; }')"
    CLAIM_QR_COLS="$(printf '%s\n' "$output" | sed -n 's/^claim-invite-qr: //p' | head -1)"
    [[ "$CLAIM_QR_COLS" =~ ^[0-9]+$ ]] || CLAIM_QR_COLS=""
}

# The QR block is half-block glyphs: a non-UTF-8 terminal would draw mojibake
# where the code should be.
terminal_is_utf8() {
    case "${LC_ALL:-${LC_CTYPE:-${LANG:-}}}" in
        *[Uu][Tt][Ff]*) return 0 ;;
    esac
    [[ "$(locale charmap 2>/dev/null)" == *UTF-8* ]]
}

# Pure width half of the QR gate: $1 = measured terminal columns (non-numeric
# or 0 = unknown). Uses the daemon's own column count — counting multibyte
# glyphs with awk in a C locale overestimates threefold.
claim_qr_fits_width() {
    local columns="$1"
    [[ -n "${CLAIM_QR:-}" ]] || return 1
    [[ "${CLAIM_QR_COLS:-}" =~ ^[0-9]+$ ]] || return 1
    [[ "$columns" =~ ^[0-9]+$ ]] || return 1
    (( columns >= CLAIM_QR_COLS + 2 ))
}

claim_qr_fits_terminal() {
    [[ "${NON_INTERACTIVE:-false}" != true ]] || return 1
    [[ -t 1 || -t 3 ]] || return 1
    terminal_is_utf8 || return 1
    local columns="${COLUMNS:-}"
    if ! [[ "$columns" =~ ^[0-9]+$ ]] || (( columns == 0 )); then
        columns="$(stty size </dev/tty 2>/dev/null | awk '{print $2}')"
    fi
    claim_qr_fits_width "${columns:-0}"
}

show_claim_invite_qr() {
    claim_qr_fits_terminal || return 1
    printf '\n%s  Scan this QR code with your phone to open Ugla:%s\n' "${BOLD}" "$NC" >/dev/tty
    printf '%s\n' "$CLAIM_QR" >/dev/tty
    printf '\n' >/dev/tty
}

# Health URL for the one public app-facing listener; internal listeners never
# participate in install success.
# Args: $1 = public companion/server port.
uglad_public_health_url() {
    printf 'http://127.0.0.1:%s/healthz\n' "$1"
}

# Linger state for a named user — the migration runs as root and must observe
# the TARGET user's linger, not root's.
# Args: $1 = user name.
user_linger_state_of() {
    command -v loginctl >/dev/null 2>&1 || { printf 'unknown\n'; return 0; }
    local v
    v="$(loginctl show-user "$1" --property=Linger 2>/dev/null | sed -n 's/^Linger=//p' | head -1)"
    case "$v" in
        yes) printf 'enabled\n' ;;
        no)  printf 'disabled\n' ;;
        *)   printf 'unknown\n' ;;
    esac
}

# The token stays on curl's stdin: never in argv, files, App options or logs.
home_assistant_request() {
    local method="$1" endpoint="$2"
    printf 'header = "Authorization: Bearer %s"\n' "$SUPERVISOR_TOKEN" |
        curl --config - --silent --show-error --fail --max-time 600 \
            --request "$method" "http://supervisor${endpoint}"
}

home_assistant_config_is_safe() {
    jq -se '
        .[0] as $config
        | length == 1 and ($config |
        keys == (["name", "version", "slug", "description", "arch", "image", "startup", "boot", "init", "host_network", "hassio_api", "homeassistant_api", "docker_api", "host_pid", "full_access", "privileged", "map", "options", "schema"] | sort)
        and .name == "Ugla"
        and (.version | type == "string" and test("^[0-9]+\\.[0-9]+\\.[0-9]+$"))
        and .slug == "ugla"
        and .description == "Your personal Ugla box"
        and .arch == ["amd64", "aarch64"]
        and .image == "ghcr.io/lixxxor/ugla-home-assistant"
        and .startup == "application"
        and .boot == "auto"
        and .init == false
        and .host_network == true
        and .hassio_api == false
        and .homeassistant_api == false
        and .docker_api == false
        and .host_pid == false
        and .full_access == false
        and .privileged == []
        and .map == []
        and .options == {}
        and .schema == {})
    ' >/dev/null
}

install_home_assistant_app() {
    # A Supervisor shell is a candidate, not proof of HAOS. Failure inside
    # that shell must never install a native daemon into the terminal App.
    [[ -n "${SUPERVISOR_TOKEN:-}" ]] || {
        if [[ -e /run/s6/container_environment/SUPERVISOR_TOKEN || ( -f /run/cid && ( -d /local_apps || -d /addons ) ) ]]; then
            die "Home Assistant Supervisor authentication is unavailable in this terminal."
        fi
        return 1
    }
    command -v jq >/dev/null || die "Home Assistant bootstrap requires jq in Terminal & SSH."
    [[ "$SUPERVISOR_TOKEN" =~ ^[A-Za-z0-9._-]+$ ]] || die "Invalid Supervisor authentication token."
    local info os arch config app local_apps
    info="$(home_assistant_request GET /supervisor/info)" || die "Cannot authenticate to Home Assistant Supervisor."
    os="$(home_assistant_request GET /os/info)" || die "Cannot verify Home Assistant OS through Supervisor /os/info."
    printf '%s' "$info" | jq -e '.result == "ok"' >/dev/null || die "Supervisor refused its information endpoint."
    printf '%s' "$os" | jq -e '.result == "ok" and (.data.version | type == "string" and length > 0) and (.data.board | type == "string" and length > 0)' >/dev/null \
        || die "Supervisor does not verify Home Assistant OS on this machine; refusing to install inside a terminal App."
    arch="$(printf '%s' "$info" | jq -r '.data.arch')"
    case "$arch" in amd64|aarch64) ;; *) die "Unsupported Home Assistant OS architecture: ${arch}." ;; esac
    local_apps=/local_apps
    [[ -d "$local_apps" ]] || local_apps=/addons
    [[ -d "$local_apps" && -w "$local_apps" && ! -L "$local_apps" ]] \
        || die "Terminal & SSH needs its writable Local Apps mount to install Ugla."
    app="$(home_assistant_request GET /addons)" || die "Supervisor App information is unavailable."
    printf '%s' "$app" | jq -e '.result == "ok" and (.data.addons | type == "array")' >/dev/null \
        || die "Supervisor returned no usable installed-App inventory."
    local installed=false temporary
    if printf '%s' "$app" | jq -e 'any(.data.addons[]; .slug == "local_ugla")' >/dev/null; then
        installed=true
    fi
    config="$(curl -fsSL --max-time 30 https://install.ugla.ai/home-assistant/config.json)" \
        || die "Cannot fetch the Ugla App definition from install.ugla.ai."
    printf '%s' "$config" | home_assistant_config_is_safe \
        || die "The Ugla App definition has an unexpected privilege or image contract."
    if [[ -e ${local_apps}/ugla ]]; then
        [[ -d ${local_apps}/ugla && ! -L ${local_apps}/ugla && -f ${local_apps}/ugla/config.json && ! -L ${local_apps}/ugla/config.json ]] \
            || die "Existing Local App directory ${local_apps}/ugla is not a regular Ugla definition."
        jq -e '.slug == "ugla" and .image == "ghcr.io/lixxxor/ugla-home-assistant"' "${local_apps}/ugla/config.json" >/dev/null \
            || die "Existing Local App definition belongs to another image; refusing to overwrite it."
    else
        mkdir "${local_apps}/ugla" || die "Cannot create the Ugla Local App directory."
    fi
    temporary="$(mktemp "${local_apps}/ugla/config.json.XXXXXX")" || die "Cannot stage the Ugla App definition."
    printf '%s\n' "$config" > "$temporary" && mv -f "$temporary" "${local_apps}/ugla/config.json" \
        || die "Cannot publish the Ugla Local App definition."
    home_assistant_request POST /store/reload | jq -e '.result == "ok"' >/dev/null \
        || die "Supervisor refused Local App reload; verify Terminal & SSH manager authority."
    if ! $installed; then
        home_assistant_request POST /addons/local_ugla/install | jq -e '.result == "ok"' >/dev/null \
            || die "Supervisor could not install the Ugla App; inspect its store/image error and retry."
    fi
    app="$(home_assistant_request GET /addons/local_ugla/info)" || die "Cannot inspect the installed Ugla App."
    if [[ "$(printf '%s' "$app" | jq -r '.data.update_available')" == true ]]; then
        home_assistant_request POST /addons/local_ugla/update | jq -e '.result == "ok"' >/dev/null \
            || die "Supervisor could not update the Ugla wrapper image."
        app="$(home_assistant_request GET /addons/local_ugla/info)" || die "Cannot inspect the updated Ugla App."
    fi
    if [[ "$(printf '%s' "$app" | jq -r '.data.state')" != started ]]; then
        home_assistant_request POST /addons/local_ugla/start | jq -e '.result == "ok"' >/dev/null \
            || die "Supervisor could not start the Ugla App."
    fi
    local attempt
    for attempt in $(seq 1 150); do
        if curl -fsS --max-time 2 http://homeassistant:8643/healthz >/dev/null 2>&1; then
            unset SUPERVISOR_TOKEN
            result "Ugla is healthy. Open Ugla on the same network to claim your box."
            return 0
        fi
        sleep 2
    done
    unset SUPERVISOR_TOKEN
    die "Supervisor started the Ugla App, but its companion listener did not become healthy. Inspect the Ugla App logs in Home Assistant."
}

# ── Legacy system-scope → user-scope migration (pure halves) ──────────

# Fixture redirection for the migration's absolute system paths: the
# acceptance test sets UGLA_TEST_FIXTURE_ROOT so /opt and /etc/systemd/system
# become seeded fixture trees.
# Args: $1 = absolute path to redirect.
mig_root() {
    printf '%s%s' "${UGLA_TEST_FIXTURE_ROOT:-}" "$1"
}

# Classify this box's install topology for the migration as one typed word:
#   uglad | wtfd | user | none.
# Args: $1 = the target user's home dir.
legacy_system_scope_kind() {
    local home="$1" units version scope=""
    units="$(mig_root /etc/systemd/system)"
    if [[ -d "$(mig_root /opt/uglad)" || -e "${units}/uglad.service" ]]; then
        printf 'uglad\n'
        return 0
    fi
    if [[ -d "$(mig_root /opt/wtfd)" || -e "${units}/wtfd.service" ]]; then
        printf 'wtfd\n'
        return 0
    fi
    version="${home}/.local/share/uglad/version"
    if [[ -f "$version" ]]; then
        scope="$(sed -n 's/^scope=//p' "$version" | head -1)"
        [[ "$scope" == "user" ]] && { printf 'user\n'; return 0; }
    fi
    printf 'none\n'
}

# Rewrite a version file's content for the user-owned tree: every line is
# preserved byte-for-byte and the one topology input the updater reads —
# `scope=` — is forced to `user`. The stamp is supplied when absent, not just
# replaced: absence itself means system scope to the updater.
# Args: $1 = legacy version-file content.
migrate_version_file_content() {
    local line seen_scope=0
    while IFS= read -r line; do
        if [[ "$line" == scope=* ]]; then
            [[ "$seen_scope" -eq 0 ]] && { printf 'scope=user\n'; seen_scope=1; }
        else
            printf '%s\n' "$line"
        fi
    done <<< "$1"
    # A legacy file has no scope line at all — absence itself means
    # system scope to the updater.
    [[ "$seen_scope" -eq 0 ]] && printf 'scope=user\n'
    return 0
}

# The system unit files successful migration removes; `rm -f` makes each a
# no-op where the box never had it.
retire_system_unit_files() {
    local unit
    for unit in uglad.service uglad-rescue.service \
                wtfd.service wtfd-rescue.service \
                wtf-gateway.service wtf-sidecar.service; do
        printf '%s/%s\n' "$(mig_root /etc/systemd/system)" "$unit"
    done
}

# Run one `systemctl --user` command as the target user from the migration's
# root seat: sudo drops the invoking environment, so XDG_RUNTIME_DIR is
# restored explicitly.
# Args: $1 = user, $2 = uid, rest = systemctl --user operands.
run_user_systemctl() {
    local user="$1" uid="$2"; shift 2
    sudo -u "$user" env "XDG_RUNTIME_DIR=/run/user/${uid}" systemctl --user "$@"
}

# Poll a URL until it answers or the attempt budget is spent.
# Args: $1 = URL, $2 = attempts (default 300), $3 = seconds between (default 1).
wait_for_url() {
    local url="$1" attempts="${2:-300}" delay="${3:-1}" i
    for ((i = 1; i <= attempts; i++)); do
        curl -fsS --max-time 5 "$url" >/dev/null 2>&1 && return 0
        sleep "$delay"
    done
    return 1
}

# Prove authenticated access with a preserved credential: one authorized GET
# must succeed within the attempt budget. The bearer rides a header, never a
# URL or log line.
# Args: $1 = URL, $2 = bearer token, $3 = attempts (default 30).
auth_probe_ok() {
    local url="$1" bearer="$2" attempts="${3:-30}" i
    for ((i = 1; i <= attempts; i++)); do
        curl -fsS --max-time 10 -H "Authorization: Bearer ${bearer}" "$url" >/dev/null 2>&1 \
            && return 0
        sleep 1
    done
    return 1
}

# The sudoers drops successful migration removes; `rm -f` no-ops when absent.
retire_system_sudoers_files() {
    local name
    for name in uglad wtfd wtf-gateway wtf-gateway-restart wtf-sidecar; do
        printf '%s/%s/%s\n' "$(mig_root /etc)" sudoers.d "$name"
    done
}

# ── Output vocabulary ─────────────────────────────────────────
# The [ugla] prefix marks headings and lines that need attention — not
# details, not tables, not blank lines.
# ANSI-C quoted so the variables hold real escape bytes: they are passed as
# printf ARGUMENTS (%s), where \033 would otherwise print literally.
RED=$'\033[0;31m'
GREEN=$'\033[0;32m'
YELLOW=$'\033[0;33m'
CYAN=$'\033[0;36m'
BOLD=$'\033[1m'
NC=$'\033[0m'

# Every phase prints its heading in order (skipped work says so inside the
# phase), so the numbering never gaps and never claims work it did not do.
PHASE_N=0
PHASE_TOTAL=6
phase() { # $1 = title
    PHASE_N=$((PHASE_N + 1))
    printf '\n%s[ugla] [%d/%d] %s%s\n' "${GREEN}${BOLD}" "$PHASE_N" "$PHASE_TOTAL" "$1" "$NC"
}
detail() { printf '  %s\n' "$1"; }
result() { printf '%s✅ %s%s\n' "${GREEN}" "$1" "$NC"; }
warn()   { printf '%s[ugla] %s%s\n' "${YELLOW}" "$1" "$NC" >&2; }

# ── Fresh-install timing (#8218) ───────────────────────────────────────
# Named checkpoints from installer entry, in milliseconds. `date +%s%N` is
# GNU/coreutils; a `date` without %N prints it literally, so fall back to
# whole-second resolution rather than recording garbage. `INSTALL_T0_NS` is
# set by the first `mark()` call (installer entry) rather than eagerly here,
# so sourcing this file for its pure helpers never shells out to `date`.
INSTALL_TIMING=()
install_now_ns() {
    local now
    now="$(date +%s%N 2>/dev/null)"
    [[ "$now" =~ ^[0-9]+$ ]] && { printf '%s\n' "$now"; return; }
    printf '%s\n' "$(($(date +%s) * 1000000000))"
}
mark() { # $1 = checkpoint name
    if [[ -z "${INSTALL_T0_NS:-}" ]]; then
        INSTALL_T0_NS="$(install_now_ns)"
    fi
    INSTALL_TIMING+=("$1=$((($(install_now_ns) - INSTALL_T0_NS) / 1000000))ms")
}

# Prompts write to /dev/tty: under `curl | bash`, stdin is the script pipe.
ask() { # $1 = question, $2 = one-line explanation ('' = none), $3 = input prompt
    printf '\n%s? %s%s\n' "${CYAN}${BOLD}" "$1" "$NC" >/dev/tty
    [[ -n "${2:-}" ]] && printf '  %s\n' "$2" >/dev/tty
    printf '  %s' "$3" >/dev/tty
}

die() { # $1 = what stopped, $2 = optional: the one thing to try
    printf '%s[ugla] ✘ %s%s\n' "$RED" "$1" "$NC" >&2
    [[ -n "${2:-}" ]] && printf '  Try: %s\n' "$2" >&2
    printf '  After addressing the error above, you can safely run this installer again.\n' >&2
    printf '  It repeats the installation steps; it does not resume from this point.\n' >&2
    exit 1
}

# curl's progress meter draws only on stderr and -s mutes it even there, so
# interactive downloads run without -s with stderr pinned to the controlling
# terminal; with no terminal (cloud-init, setsid) they stay silent.
has_controlling_tty() {
    ( : >/dev/tty ) 2>/dev/null
}

fetch() {
    local label="$1" dest="$2" max_time="$3" url="$4" rc=0
    detail "$label"
    if has_controlling_tty; then
        curl -fL --max-time "$max_time" -o "$dest" "$url" 2>/dev/tty || rc=$?
    else
        curl -fsSL --max-time "$max_time" -o "$dest" "$url" || rc=$?
    fi
    return "$rc"
}

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

# Default download key — scoped to only request short-lived download tokens;
# safe to embed in the script. The serve-time rewrite pairs the served script
# with the deployment's key, and the deploy gates fail on drift.
UGLA_DOWNLOAD_KEY="${UGLA_DOWNLOAD_KEY:-dc6a08f3b75d4b427a1299099989385b941e91dbbfc83f3e7d75fade777092df}"

# The Ugla Cloud this deployment's boxes trust, written to ~/.ugla/.env so
# the daemon fetches its managed-AI grant from the control plane the app
# enabled it on. The baked default is production; set UGLA_CLOUD_ORIGIN to
# point one install elsewhere.
UGLA_CLOUD_ORIGIN="${UGLA_CLOUD_ORIGIN:-https://staging.ugla.ai}"

# ── Publisher authority ───────────────────────────────────────────────
# The install service supplies the bytes AND the digest they are checked
# against, so neither authenticates the publisher: every executable carries a
# separate Ed25519 authorization chained to these baked-in root keys — a root
# fetched from the same response cannot authenticate it. ugla-release-auth's
# PUBLISHER_ROOT_KEYS holds the identical list, pinned by a test; while the
# list is empty this script installs nothing.
UGLA_PUBLISHER_ROOT_KEYS="c89809fb17031d672d97147b3e42d9ff1ebbbdc8d36d8a2bcf7cfcbc123f4cd2"
UGLA_PUBLISHER_ROOT_THRESHOLD=1
# Longest lifetime a roster may claim, matching MAX_ROSTER_VALIDITY_SECS.
UGLA_PUBLISHER_ROSTER_MAX_VALIDITY=7776000

# Write hex to a file as raw bytes. Command substitution cannot carry NUL, so
# only the escaped text passes through it.
hex_to_file() {
    local escaped
    escaped=$(printf '%s' "$1" | sed 's/../\\x&/g')
    printf %b "$escaped" > "$2"
}

macos_verifier_payload() {
    case "$1" in
        arm64) cat <<'UGLA_ARM64_PAYLOAD'
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
UGLA_ARM64_PAYLOAD
        ;;
        *) return 1 ;;
    esac
}

prepare_macos_verifier() {
    local directory="$1" architecture="$2" payload
    payload="$(macos_verifier_payload "$architecture")" || return 1
    [[ -n "$payload" && "$payload" != *'@@'* ]] || return 1
    MACOS_VERIFIER="${directory}/ugla-verify-signature"
    printf '%s' "$payload" | /usr/bin/base64 -D | /usr/bin/gzip -dc > "$MACOS_VERIFIER" || return 1
    chmod 0700 "$MACOS_VERIFIER"
}

# Verify a raw Ed25519 signature. $1 hex public key, $2 hex signature,
# $3 the file holding the signed preimage.
ed25519_verify() {
    [[ "$1" =~ ^[0-9a-f]{64}$ && "$2" =~ ^[0-9a-f]{128}$ ]] || return 1
    if [[ "$(uname -s)" == "Darwin" ]]; then
        [[ -x "${MACOS_VERIFIER:-}" ]] || return 1
        "$MACOS_VERIFIER" "$1" "$2" "$3" >/dev/null 2>&1
        return $?
    fi
    local dir rc
    dir="$(mktemp -d "${TMPDIR:-/tmp}/ugla-verify-XXXXXXXX")" || return 1
    # SubjectPublicKeyInfo prefix for a raw Ed25519 public key.
    hex_to_file "302a300506032b6570032100$1" "${dir}/key.der"
    hex_to_file "$2" "${dir}/sig.bin"
    openssl pkeyutl -verify -pubin -inkey "${dir}/key.der" -keyform DER \
        -rawin -sigfile "${dir}/sig.bin" -in "$3" >/dev/null 2>&1
    rc=$?
    rm -rf "$dir"
    return "$rc"
}

# The signed preimage of a roster or an authorization: every line above the
# signatures, joined by newlines with no trailing newline.
signed_preimage() {
    awk '/^sig=/ { exit } { printf "%s%s", sep, $0; sep = "\n" }' "$1"
}

# True when $1 is signed and carries nothing but signature lines after the
# first `sig=`: any later line is outside what the signature covers and must
# never reach a field parser.
signed_body_is_closed() {
    awk '
        /^sig=/ { signed = 1; next }
        signed  { trailing = 1; exit }
        END     { exit (signed && !trailing) ? 0 : 1 }
    ' "$1"
}

PUBLISHER_RELEASE_KEYS=""
PUBLISHER_REVOKED_KEYS=""
PUBLISHER_ROSTER_VERSION=""

# Verify a publisher roster held in $1 against the baked root keys, refusing a
# version older than $2. On success the roster's release/revoked key sets and
# version land in the PUBLISHER_* variables.
verify_publisher_roster() {
    local roster="$1" accepted="${2:-0}" preimage now verified seen line rest root sig key
    local version issued expires
    [[ -n "${UGLA_PUBLISHER_ROOT_KEYS// /}" ]] \
        || die "This installer carries no publisher root, so it cannot authenticate any release." \
               "the publisher root is provisioned by the Ugla owner; use an installer that carries it"
    exists openssl || die "Need openssl to verify publisher signatures. The rootless installer does not install packages (#6311) — install openssl yourself and re-run."
    [[ "$(head -1 "$roster")" == "ugla-publisher-roster-v1" ]] \
        || die "The publisher roster is not in the expected format; refusing unverifiable bytes."
    signed_body_is_closed "$roster" \
        || die "The publisher roster is unsigned or carries lines its signatures do not cover; refusing unverifiable bytes."
    preimage="$(mktemp "${TMPDIR:-/tmp}/ugla-roster-preimage-XXXXXXXX")"
    signed_preimage "$roster" > "$preimage"

    # Every field below is read from the preimage, never from the served file:
    # a line the root signature does not cover authorizes nothing.
    version=$(sed -n 's/^version=//p' "$preimage" | head -1)
    issued=$(sed -n 's/^issued_at=//p' "$preimage" | head -1)
    expires=$(sed -n 's/^expires_at=//p' "$preimage" | head -1)
    [[ "$version" =~ ^[0-9]+$ && "$issued" =~ ^[0-9]+$ && "$expires" =~ ^[0-9]+$ ]] \
        || die "The publisher roster is malformed; refusing unverifiable bytes."
    [[ "$version" -ge "$accepted" ]] \
        || die "The publisher roster served is version ${version}, older than the version ${accepted} this box already accepted; refusing a replayed key set."
    now=$(date -u +%s)
    [[ "$expires" -gt "$now" ]] \
        || die "The publisher roster expired; refusing to install against stale release metadata." \
               "try again once the rail publishes a current roster"
    [[ "$issued" -le $((now + 60)) ]] \
        || die "The publisher roster is dated in the future; refusing unverifiable bytes."
    [[ $((expires - issued)) -le "$UGLA_PUBLISHER_ROSTER_MAX_VALIDITY" ]] \
        || die "The publisher roster claims an unbounded lifetime; refusing unverifiable bytes."

    verified=0
    seen=""
    while IFS= read -r line; do
        case "$line" in sig=*) ;; *) continue ;; esac
        rest="${line#sig=}"
        root="${rest%%:*}"
        sig="${rest#*:}"
        case " ${UGLA_PUBLISHER_ROOT_KEYS} " in *" ${root} "*) ;; *) continue ;; esac
        case " ${seen} " in *" ${root} "*) continue ;; esac
        if ed25519_verify "$root" "$sig" "$preimage"; then
            seen="${seen} ${root}"
            verified=$((verified + 1))
        fi
    done < "$roster"
    [[ "$verified" -ge "$UGLA_PUBLISHER_ROOT_THRESHOLD" ]] \
        || die "The publisher roster is not signed by ${UGLA_PUBLISHER_ROOT_THRESHOLD} trusted publisher root key(s); refusing unverifiable bytes."

    PUBLISHER_RELEASE_KEYS="$(sed -n 's/^key=//p' "$preimage" | tr '\n' ' ')"
    PUBLISHER_REVOKED_KEYS="$(sed -n 's/^revoked=//p' "$preimage" | tr '\n' ' ')"
    PUBLISHER_ROSTER_VERSION="$version"
    rm -f "$preimage"
    [[ -n "${PUBLISHER_RELEASE_KEYS// /}" ]] \
        || die "The publisher roster authorizes no release key; refusing unverifiable bytes."
    for key in $PUBLISHER_RELEASE_KEYS; do
        case " ${PUBLISHER_REVOKED_KEYS} " in
            *" ${key} "*) die "The publisher roster lists a key as both authorized and revoked; refusing unverifiable bytes." ;;
        esac
    done
}

# Fetch the publisher roster and verify it; $1 is the highest roster version
# this box has already accepted (0 for a fresh install).
load_publisher_roster() {
    local work roster
    work="$(mktemp -d "${TMPDIR:-/tmp}/ugla-roster-XXXXXXXX")"
    roster="${work}/roster.txt"
    curl -fsSL --max-time 15 --max-filesize 8192 \
        "${UGLA_INSTALL_SERVER}/publisher-roster" -o "$roster" \
        || die "The canonical install service did not serve a publisher roster; refusing unverifiable bytes." \
               "check this machine's network/DNS for ${UGLA_INSTALL_SERVER}, then re-run"
    verify_publisher_roster "$roster" "${1:-0}"
    rm -rf "$work"
}

# Verify the release authorization held in $1 against the loaded roster and the
# release coordinates ($2 component, $3 version, $4 target, $5 channel),
# printing the one digest those bytes may have.
verify_release_authorization() {
    local doc="$1" component="$2" version="$3" target="$4" channel="$5"
    local preimage key sig field digest
    [[ "$(head -1 "$doc")" == "ugla-release-authorization-v1" ]] \
        || die "The publisher authorization for ${component} is not in the expected format."
    signed_body_is_closed "$doc" \
        || die "The publisher authorization for ${component} is unsigned or carries lines its signature does not cover; refusing it."
    for field in component:"$component" version:"${version#v}" target:"$target" channel:"$channel"; do
        [[ "$(sed -n "s/^${field%%:*}=//p" "$doc" | head -1)" == "${field#*:}" ]] \
            || die "The publisher authorization names a different ${field%%:*} than the one being installed; refusing it."
    done
    key=$(sed -n 's/^key=//p' "$doc" | head -1)
    sig=$(sed -n 's/^sig=//p' "$doc" | head -1)
    digest=$(sed -n 's/^sha256=//p' "$doc" | head -1)
    [[ "$digest" =~ ^[0-9a-f]{64}$ ]] \
        || die "The publisher authorization for ${component} carries no usable digest."
    case " ${PUBLISHER_REVOKED_KEYS} " in
        *" ${key} "*) die "The publisher authorization for ${component} was signed by a revoked release key; refusing it." ;;
    esac
    case " ${PUBLISHER_RELEASE_KEYS} " in
        *" ${key} "*) ;;
        *) die "The publisher authorization for ${component} was signed by a key the publisher roster does not list; refusing it." ;;
    esac
    preimage="$(mktemp "${TMPDIR:-/tmp}/ugla-authz-preimage-XXXXXXXX")"
    signed_preimage "$doc" > "$preimage"
    if ! ed25519_verify "$key" "$sig" "$preimage"; then
        rm -f "$preimage"
        die "The publisher authorization for ${component} does not verify; refusing to install unauthorized bytes."
    fi
    rm -f "$preimage"
    printf '%s\n' "$digest"
}

# Fetch and verify one release authorization, printing the authorized SHA-256.
# $1 component, $2 version, $3 target, $4 channel.
authorized_release_sha256() {
    local work doc digest
    work="$(mktemp -d "${TMPDIR:-/tmp}/ugla-authz-XXXXXXXX")"
    doc="${work}/authorization.txt"
    curl -fsSL --max-time 15 --max-filesize 8192 \
        "${UGLA_INSTALL_SERVER}/release/$1/$2/$3?channel=$4" -o "$doc" \
        || die "No publisher authorization is served for $1 $2 ($3, $4); refusing unverifiable bytes."
    digest="$(verify_release_authorization "$doc" "$1" "$2" "$3" "$4")"
    rm -rf "$work"
    printf '%s\n' "$digest"
}

# ── Typed persistence/host-op records ─────────────────────────────────
# Pure argv → JSON builders for the records the daemon's typed status blocks
# read back.

# Read one string field from the daemon's activation result. The result is
# the boot record on its last line; the install-timing lines above it never
# match. Empty when the field is absent or empty.
# Args: $1 = JSON field name; the activation result on stdin.
activation_result_field() {
    sed -n "s/.*\"$1\":\"\([^\"]*\)\".*/\1/p"
}

# Args: $1 = outcome (ready | denied_by_host_policy | unknown | unsupported),
#       $2 = the installing user's name, $3 = epoch seconds,
#       $4 = service backend (systemd | portable; empty = omit — the
#            systemd-era shape the daemon's older readers parse),
#       $5 = bounded action line for a non-ready portable outcome (empty =
#            omit). Quote characters and backslashes are stripped: the
#            action is prose for the record, never JSON structure.
boot_persistence_record_json() {
    local outcome="$1" user="$2" at="${3:-0}" backend="${4:-}" action="${5:-}" extra=""
    [[ -n "$backend" ]] && extra="${extra},\"backend\":\"${backend}\""
    if [[ -n "$action" ]]; then
        action="$(printf '%s' "$action" | tr -d "\"'\\\\")"
        extra="${extra},\"action\":\"${action}\""
    fi
    printf '{"outcome":"%s","user":"%s","checked_at":%s%s}\n' "$outcome" "$user" "$at" "$extra"
}

# Read one KEY=VALUE line from an .env file (no interpolation, first match
# wins); empty when the file or the key is absent.
host_op_env_value() {
    local v=""
    if [[ -f "$1" ]]; then
        v="$(grep -m1 "^${2}=" "$1" | cut -d= -f2- || true)"
    fi
    printf '%s' "$v"
}

# The public port the installed daemon listens on, read from the stamped
# install's .env; 8643 when absent.
host_op_daemon_port() {
    local port
    port="$(host_op_env_value "${1}/.ugla/.env" UGLA_COMPANION_PORT)"
    printf '%s' "${port:-8643}"
}

# Detect the host's package manager binary; empty when none of the supported
# managers exists.
host_op_package_manager() {
    local m
    for m in apt-get dnf yum pacman zypper; do
        command -v "$m" >/dev/null 2>&1 && { printf '%s\n' "$m"; return 0; }
    done
    return 0
}

# The install plan for the Bubblewrap prerequisite: already present → nothing
# to do; a supported manager → exactly one fixed package transaction;
# otherwise a typed unsupported outcome — never a script download.
# Args: $1 = package manager ("" = none), $2 = bwrap present ("1" | "0").
host_op_install_sandbox_plan() {
    if [[ "$2" == "1" ]]; then
        printf 'present\n'
    else
        case "$1" in
            apt-get) printf 'apt-get install -y bubblewrap\n' ;;
            dnf)     printf 'dnf install -y bubblewrap\n' ;;
            yum)     printf 'yum install -y bubblewrap\n' ;;
            pacman)  printf 'pacman --noconfirm -S --needed bubblewrap\n' ;;
            zypper)  printf 'zypper --non-interactive install bubblewrap\n' ;;
            *)       printf 'unsupported\n' ;;
        esac
    fi
    return 0
}

# The ordinary install's sandbox half: detect whether Bubblewrap is already on
# this box, so the daemon's first boot can compose the local execution
# capability. Detection only — the ordinary installer never elevates or runs a
# package manager; a missing sandbox is reported as the explicit
# `--host-op install-sandbox` recovery action instead of an attempted
# transaction.
# Echoes one typed word: present | missing.
provision_sandbox() {
    if [[ "$(uname -s)" == "Darwin" ]]; then
        if [[ -x /usr/bin/sandbox-exec ]]; then printf 'present\n'; else printf 'missing\n'; fi
        return 0
    fi
    if exists bwrap; then
        printf 'present\n'
    else
        printf 'missing\n'
    fi
    return 0
}

# Ubuntu 23.10+ lets AppArmor deny unprivileged user namespaces, which the
# browser engine needs for its native sandbox; the engine then refuses to
# start (sandbox_unavailable) and is never run without that sandbox.
# `--host-op allow-browser-sandbox` grants the namespace to the engine alone.
# Detection only, from world-readable files. Granted means both halves hold:
# the kernel has a profile of that name loaded (its policy directory's `name`
# is readable by anyone, unlike the root-only profile list) and the installed
# file is exactly the profile for this daemon dir, so a stale, unloaded or
# moved grant still reports the host action.
# Args: $1 = the installing user's name, $2 = daemon dir (or a CI runner's
# browser install dir), $3 = grant kind (box, the default, | ci).
# Echoes one typed word: unrestricted | granted | restricted.
browser_sandbox_state() {
    local user="$1" daemon_dir="$2" kind="${3:-box}" restrict="" name rendered name_file
    restrict="$(cat "$(mig_root /proc/sys/kernel/apparmor_restrict_unprivileged_userns)" 2>/dev/null || true)"
    if [[ "$restrict" != "1" ]]; then
        printf 'unrestricted\n'
        return 0
    fi
    if name="$(browser_profile_name "$user" "$kind")" \
        && rendered="$(browser_apparmor_profile "$user" "$daemon_dir" "$kind" 2>/dev/null)" \
        && [[ "$(cat "$(mig_root "/etc/apparmor.d/${name}")" 2>/dev/null)" == "$rendered" ]]; then
        for name_file in "$(mig_root /sys/kernel/security/apparmor/policy/profiles)"/*/name; do
            if [[ "$(cat "$name_file" 2>/dev/null)" == "$name" ]]; then
                printf 'granted\n'
                return 0
            fi
        done
    fi
    printf 'restricted\n'
    return 0
}

# The profile name of one user's browser grant. A box grant covers the
# user's daemon dir; a ci grant covers a CI runner's fixed browser install
# under the same account, so loading one never replaces the other. The
# prefixes differ before the user name, so no user name makes them collide.
# Args: $1 = user name, $2 = grant kind (box | ci).
browser_profile_name() {
    case "$2" in
        box) printf 'ugla-browser-%s\n' "$1" ;;
        ci)  printf 'ugla-ci-browser-%s\n' "$1" ;;
        *)   return 1 ;;
    esac
}

# The AppArmor profile granting user namespaces to one user's browser engine.
# It attaches to every updater generation under the daemon dir, so a browser
# update keeps the grant, and mirrors the profiles Ubuntu ships for Chrome:
# unconfined apart from the name, with `userns` the one added permission.
# The daemon dir comes from the user-writable .env and is rendered into
# profile syntax by a root host op, so both operands must be plain: a quote,
# comma, glob, comment or whitespace could attach the grant elsewhere.
# Args: $1 = user name, $2 = daemon dir (or a CI runner's browser install
# dir), $3 = grant kind (box, the default, | ci). Returns 1, printing
# nothing, when any operand is outside that grammar.
browser_apparmor_profile() {
    local user="$1" daemon_dir="$2" name
    [[ "$user" =~ ^[a-z_][a-z0-9_.-]*$ ]] || return 1
    [[ "$daemon_dir" =~ ^(/[A-Za-z0-9_.-]+)+$ ]] || return 1
    [[ "/${daemon_dir}/" != *"/../"* && "/${daemon_dir}/" != *"/./"* ]] || return 1
    name="$(browser_profile_name "$user" "${3:-box}")" || return 1
    cat <<PROFILE
# Written by: sudo bash ugla-install.sh --host-op allow-browser-sandbox
abi <abi/4.0>,
include <tunables/global>

profile ${name} "${daemon_dir}/browser/*/generation-*/chrome-headless-shell" flags=(unconfined) {
  userns,
}
PROFILE
}

# The home directory of $1 from the passwd database; empty when unresolvable.
home_of_user() {
    local home=""
    if command -v getent >/dev/null 2>&1; then
        home="$(getent passwd "$1" 2>/dev/null | cut -d: -f6)"
    fi
    if [[ -z "$home" ]]; then
        home="$(awk -F: -v u="$1" '$1 == u {print $6; exit}' /etc/passwd 2>/dev/null || true)"
    fi
    printf '%s' "$home"
}

# Assemble the JSON report body from a scrubbed transcript file: jq when
# available, else a pure-awk escape (the transcript is already ANSI/control
# stripped, so only backslash, ", tab and newline need escaping). No Python —
# the report path must never depend on it.
# Args: $1 = scrubbed transcript path, $2 = failed line number (0 if unknown).
diag_build_payload() {
    local tfile="$1" line="${2:-0}"
    local ver="${UGLA_VERSION:-unknown}" os arch
    os="$(uname -s 2>/dev/null || echo unknown)"
    arch="$(uname -m 2>/dev/null || echo unknown)"
    [[ "$line" =~ ^[0-9]+$ ]] || line=0
    if command -v jq >/dev/null 2>&1; then
        jq -n --arg version "$ver" --arg os "$os" --arg arch "$arch" \
              --argjson failed_line "$line" \
              --rawfile transcript "$tfile" \
              '{version:$version,os:$os,arch:$arch,failed_line:$failed_line,transcript:$transcript}'
    else
        local esc nl=""
        esc="$(awk 'BEGIN{ORS=""} {gsub(/\\/,"\\\\");gsub(/"/,"\\\"");gsub(/\t/,"\\t");print (NR>1?"\\n":"") $0}' "$tfile")"
        # awk strips the per-record newline; re-append it as a JSON \n when
        # the file ends in one. The last byte is read via od because command
        # substitution strips a trailing newline.
        if [[ -s "$tfile" ]] && [[ "$(tail -c1 "$tfile" 2>/dev/null | od -An -tx1 | tr -d ' ')" == "0a" ]]; then
            nl='\n'
        fi
        printf '{"version":"%s","os":"%s","arch":"%s","failed_line":%s,"transcript":"%s%s"}\n' \
            "$ver" "$os" "$arch" "$line" "$esc" "$nl"
    fi
}

# Redact secrets from a captured transcript, in place: the exact values this
# installer holds are struck first, then defence-in-depth shape scrubs; ANSI
# and control bytes are stripped so the result is valid inside a JSON string.
diag_scrub_file() {
    local f="$1"
    sed_in_place -E 's/\x1b\[[0-9;]*[a-zA-Z]//g' "$f" 2>/dev/null || true
    tr -d '\000-\010\013-\037' < "$f" > "${f}.t" 2>/dev/null && mv "${f}.t" "$f"
    [[ -n "${API_KEY:-}" ]] && sed_in_place "s|${API_KEY}|<redacted:api-key>|g" "$f" 2>/dev/null || true
    if [[ -n "${API_KEY:-}" && ${#API_KEY} -ge 16 ]]; then
        sed_in_place "s|${API_KEY:0:8}...${API_KEY: -8}|<redacted:api-key>|g" "$f" 2>/dev/null || true
    fi
    [[ -n "${UGLA_DOWNLOAD_KEY:-}" ]] && sed_in_place "s|${UGLA_DOWNLOAD_KEY}|<redacted:download-key>|g" "$f" 2>/dev/null || true
    [[ -n "${TS_AUTHKEY:-}" ]] && sed_in_place "s|${TS_AUTHKEY}|<redacted:ts-authkey>|g" "$f" 2>/dev/null || true
    # The claim invite is not plain hex, so its ERE metacharacters are escaped
    # before use as a pattern (API_KEY above is always hex and needs none).
    if [[ -n "${CLAIM_INVITE:-}" ]]; then
        local invite_escaped
        invite_escaped="$(printf '%s' "$CLAIM_INVITE" | sed 's/[^[:alnum:]]/\\&/g')"
        sed_in_place -E "s|${invite_escaped}|<redacted:claim-invite>|g" "$f" 2>/dev/null || true
    fi
    sed_in_place -E \
        -e 's/(Bearer )[A-Za-z0-9._~+/=-]+/\1<redacted>/g' \
        -e 's,(wtf|ugla)://claim\?[^[:space:]]*,<redacted:claim-invite>,g' \
        -e 's/rav_[A-Za-z0-9_-]{8,}/<redacted:rav-key>/g' \
        -e 's/sk-[A-Za-z0-9_-]{8,}/<redacted:sk-key>/g' \
        -e 's/tskey-[A-Za-z0-9_-]{6,}/<redacted:tskey>/g' \
        -e 's/^([A-Za-z0-9_]*(KEY|TOKEN|SECRET|PASSWORD|AUTHKEY))=.*/\1=<redacted>/' \
        "$f" 2>/dev/null || true
}

# Write $2 as $1, owned by the invoking user: an op runs as root, and files it
# leaves in the target user's state root must not become root-owned.
host_op_write_user_file() {
    local dest="$1" dir tmp
    dir="$(dirname "$dest")"
    mkdir -p "$dir"
    tmp="${dest}.ugla-new.$$"
    printf '%s\n' "$2" > "$tmp"
    if [[ -n "${SUDO_USER:-}" ]]; then
        chown "${SUDO_USER}" "$tmp" 2>/dev/null || true
    fi
    chmod 644 "$tmp"
    mv -f "$tmp" "$dest"
}

# `--host-op install-sandbox` — the Bubblewrap prerequisite as one fixed
# package transaction, for a box whose install-time attempt could not run.
# Args: $1 = the target user's home dir.
host_op_install_sandbox() {
    local home="$1" mgr plan
    if exists bwrap; then
        result "Bubblewrap is already present ($(bwrap --version 2>/dev/null || echo version unknown)) — nothing to do."
        return 0
    fi
    mgr="$(host_op_package_manager)"
    plan="$(host_op_install_sandbox_plan "$mgr" 0)"
    if [[ "$plan" == "unsupported" ]]; then
        die "No supported package manager for Bubblewrap (looked for apt-get, dnf, yum, pacman, zypper). Install the 'bubblewrap' package yourself, then restart the box's uglad service."
    fi
    detail "Installing the sandbox package (${plan})..."
    if ! $plan; then
        die "The package transaction failed — nothing else was changed. Install the 'bubblewrap' package yourself, then restart the box's uglad service."
    fi
    exists bwrap || die "The package transaction reported success but no bwrap executable appeared — install the 'bubblewrap' package yourself."
    result "Sandbox present ($(bwrap --version)). Restart the box's uglad service and the daemon composes the capability after verifying the boundary itself (#6316)."
}

# Open the configured companion TCP port only when explicitly requested.
# An existing allow rule is left unchanged.
# Args: $1 = the target user's home dir.
host_op_open_firewall_port() {
    local home="$1" port status
    exists ufw || { result "No ufw firewall present on this box — nothing to do."; return 0; }
    status="$(ufw status 2>&1)" || die "Could not read ufw status: ${status}"
    if ! grep -q '^Status: active' <<<"$status"; then
        result "ufw is inactive — nothing to open."
        return 0
    fi
    port="$(host_op_daemon_port "$home")"
    if grep -Eq "^${port}(/tcp)?[[:space:]]+ALLOW" <<<"$status"; then
        result "Port ${port}/tcp is already open — nothing to do."
        return 0
    fi
    ufw allow "${port}/tcp" comment 'ugla: the phone dials this port' >/dev/null \
        || die "Could not add the ufw rule for port ${port}/tcp."
    result "Firewall opened for the phone on port ${port}/tcp."
}

# `--host-op allow-browser-sandbox` — installs and loads the one profile
# browser_apparmor_profile renders, for a box whose ordinary install detected
# the user-namespace restriction, or with `--ci <dir>` for a CI runner's fixed
# browser install under the same account, as its own ci profile. The profile
# is loaded from a staged file before it replaces the installed one, so a
# parser refusal changes nothing. Idempotent: an identical, loaded profile is
# reported, never reloaded.
# Args: $1 = the target user's home dir, $2 = the target user's name,
#       $3 = the CI browser install dir (empty = the box's daemon dir).
host_op_allow_browser_sandbox() {
    local home="$1" user="$2" daemon_dir="${3:-}" kind=ci name profile rendered staged
    if [[ -z "$daemon_dir" ]]; then
        kind=box
        daemon_dir="$(host_op_env_value "${home}/.ugla/.env" UGLA_DAEMON_DIR)"
        daemon_dir="${daemon_dir:-${home}/.local/share/uglad}"
    fi
    name="$(browser_profile_name "$user" "$kind")"
    case "$(browser_sandbox_state "$user" "$daemon_dir" "$kind")" in
        unrestricted)
            result "This host does not restrict user namespaces — the browser sandbox needs nothing."
            return 0
            ;;
        granted)
            result "The browser sandbox grant ${name} is already loaded — nothing to do."
            return 0
            ;;
    esac
    rendered="$(browser_apparmor_profile "$user" "$daemon_dir" "$kind")" \
        || die "Refusing to grant: the user name or install dir (${daemon_dir}) is not a plain absolute path this profile can name safely."
    exists apparmor_parser || die "This host restricts user namespaces but has no apparmor_parser to load a profile with."
    profile="$(mig_root "/etc/apparmor.d/${name}")"
    staged="$(mktemp "${profile}.XXXXXX")" || die "Could not stage the AppArmor profile next to ${profile}."
    printf '%s\n' "$rendered" > "$staged" && chmod 644 "$staged" \
        || { rm -f "$staged"; die "Could not write the staged AppArmor profile."; }
    if ! apparmor_parser -r "$staged"; then
        rm -f "$staged"
        die "apparmor_parser refused the browser profile — nothing was changed."
    fi
    mv -f "$staged" "$profile" || { rm -f "$staged"; die "Loaded the profile but could not install ${profile}; it will not survive a reboot."; }
    if [[ "$kind" == ci ]]; then
        result "The browser engine installed under ${daemon_dir} may now build its sandbox (${name})."
    else
        result "The browser engine may now build its sandbox. Restart the box's uglad service so it proves the browser again."
    fi
}

# Generate the user-scope daemon + rescue units. One writer serves the fresh
# install and the migration so the unit contract cannot drift between them.
# QUOTED heredocs + @@tokens@@: generated files are never shell-evaluated and
# carry no secret — the bearer reaches the daemon through the 0600
# EnvironmentFile (.env).
# Args: $1 = destination unit dir, $2 = home, $3 = daemon dir, $4 = port,
#       $5 = env file.
write_user_unit_files() {
    local dest="$1" home="$2" daemon_dir="$3" port="$4" env_file="$5"
    publish_user_unit "${dest}/uglad.service" \
        "PORT=${port}" \
        "DAEMON_DIR=${daemon_dir}" \
        "HOME=${home}" \
        "ENV_FILE=${env_file}" <<'EOF'
[Unit]
Description=Ugla Daemon — one process, public app surface :@@PORT@@
After=network-online.target
Wants=network-online.target
# The out-of-process rollback guard: the start limit turns a crash loop into
# a failed unit, and OnFailure hands the failure to uglad-rescue.service,
# which restores the proven backup when an unattended update is armed.
StartLimitIntervalSec=30min
StartLimitBurst=4
OnFailure=uglad-rescue.service

[Service]
Type=notify
# READY=1 is sent only once BOTH listeners are bound; optional runtimes stay
# outside serving readiness.
TimeoutStartSec=300
ExecStart=@@DAEMON_DIR@@/bin/uglad
Restart=always
RestartSec=5

# The daemon needs write ownership of this unit's own cgroup for its
# per-source process ceiling; only the pids controller is used, so only it is
# relinquished.
Delegate=pids

# Rootless: nothing may elevate — the self-update swap runs as this same user
# inside the user-owned tree.
NoNewPrivileges=true
ProtectSystem=strict
# Every daemon-owned mutable artifact lives under one of these three roots —
# the state root, the workspace, and the self-update tree. No broader write
# grant.
ReadWritePaths=@@HOME@@/.ugla @@HOME@@/Ugla @@DAEMON_DIR@@
PrivateTmp=true

# The neural worker's model cache defaults to ~/.cache/huggingface, which
# ProtectSystem=strict keeps read-only; park it under the writable state root.
Environment=HF_HOME=@@HOME@@/.ugla/cache
Environment=HOME=@@HOME@@
EnvironmentFile=@@ENV_FILE@@
WorkingDirectory=@@HOME@@

StandardOutput=journal
StandardError=journal
SyslogIdentifier=uglad

[Install]
WantedBy=default.target
EOF

    # Current recovery policy must validate every retained store before an
    # older executable can regain its writer role. A candidate that executes
    # runs its own validated rescue; one that cannot be executed at all
    # (126/127 — exec and loader failure, never a signal: a candidate that
    # ran and died by panic or OOM may have touched state) never opened a
    # writer, so the proven backup may run the same rescue — the armed
    # marker's digest still names the only restorable binary.
    publish_user_unit "${dest}/uglad-rescue.service" \
        "HOME=${home}" \
        "DAEMON_DIR=${daemon_dir}" <<'EOF'
[Unit]
Description=Ugla auto-update rescue — restore the proven uglad when a new build cannot start (#5801)
# There is no recovery entry point until a build has been installed; without
# the condition systemd logs an exec-spawn failure on top of whatever actually
# went wrong. The key must sit in [Unit]: systemd ignores an unknown key in
# [Service] with only a journal warning.
ConditionPathExists=@@DAEMON_DIR@@/bin/uglad

[Service]
Type=oneshot
Environment=HOME=@@HOME@@
ExecStart=/bin/sh -c '@@DAEMON_DIR@@/bin/uglad rescue-update; rc=$?; if [ "$rc" -eq 126 ] || [ "$rc" -eq 127 ]; then exec @@DAEMON_DIR@@/bin/uglad.bak rescue-update; fi; exit "$rc"'

StandardOutput=journal
StandardError=journal
SyslogIdentifier=uglad-rescue
EOF
}

# `--host-op migrate-system-scope` — the one-way migration from the legacy
# root-owned topology (/opt/uglad + system units + /etc/sudoers.d/uglad) to
# the user-owned rootless layout, for the SUDO_USER whose state root the box
# has been running on. The narrow root seat is migration cleanup only —
# stopping/disabling/removing the system artifacts — never standing runtime
# privilege. A re-run is idempotent and resumes from wherever it stopped:
# staging is overwrite-in-place and identity is never re-keyed.
# Args: $1 = the target user's home dir.
host_op_migrate_system_scope() {
    local home="$1"
    local user="${SUDO_USER:-$(id -un)}" uid
    local state="${home}/.ugla"
    local env_file="${state}/.env"
    local user_dir="${home}/.local/share/uglad"
    local unit_dir="${home}/.config/systemd/user"
    local legacy_dir; legacy_dir="$(mig_root /opt/uglad)"

    local kind
    kind="$(legacy_system_scope_kind "$home")"
    case "$kind" in
        user)
            result "This box already runs the user-owned rootless layout — nothing to migrate."
            return 0
            ;;
        wtfd)
            die "This system install predates the ugla rename (/opt/wtfd, wtfd units) — the migration will not guess at it. Update it once with its own self-updater so it converges onto /opt/uglad, then re-run this operation."
            ;;
        none)
            die "No legacy system-scope Ugla install found (no /opt/uglad, no system uglad units) — nothing to migrate."
            ;;
    esac

    # The identity this box must keep: a system install always has ~/.ugla and
    # an API key every paired phone authenticates with. Without both the
    # migration refuses rather than mint a new identity.
    [[ -f "$env_file" ]] || die "No ${env_file} — a system-scope install's state root is missing. Refusing to migrate an identity that cannot be preserved."
    local api_key port
    api_key="$(host_op_env_value "$env_file" API_SERVER_KEY)"
    [[ -n "$api_key" ]] || die "API_SERVER_KEY is absent from ${env_file} — paired devices authenticate with it. Refusing to migrate without it."
    port="$(host_op_daemon_port "$home")"
    uid="$(id -u "$user")" || die "Could not resolve the uid of ${user}."

    detail "Migrating the system-scope install to the user-owned layout for ${user} (port ${port})..."

    # ── Stage (no service impact; a failure here leaves the system install
    #    exactly as it was). The /opt tree moves as-is — binaries, the proven
    #    rescue backup, and version/channel metadata keep their exact bytes.
    [[ -f "${legacy_dir}/version" ]] || die "${legacy_dir}/version is missing — its update identity cannot be carried across. Update the system install once with its own updater, then re-run."
    mkdir -p "$user_dir" || die "Could not create ${user_dir}."
    cp -a "${legacy_dir}/." "${user_dir}/" || die "Staging ${legacy_dir} into ${user_dir} failed — the running system install is untouched."
    migrate_version_file_content "$(cat "${user_dir}/version")" > "${user_dir}/version.ugla-new.$$" \
        && mv -f "${user_dir}/version.ugla-new.$$" "${user_dir}/version" \
        || die "Could not restamp the staged version file — nothing was cutover."
    # Ownership converges with the topology: a legacy box can carry root-owned
    # drift inside ~/.ugla from its sudo-era updater.
    chown -R "$user" "$state" "${home}/Ugla" "$user_dir" 2>/dev/null || true
    # Point the self-updater at the user tree. write_env touches only the
    # named key — the API key line is never rewritten, so it cannot rotate.
    # The op runs as root, and sed_in_place rewrites the file through a fresh
    # inode: re-own it so .env stays the user's.
    write_env "UGLA_DAEMON_DIR" "$user_dir" "$env_file"
    # The generated user unit carries no secret — the download bearer rides
    # the 0600 .env. Harvest it from the old system unit before that unit is
    # retired, so a migrated box keeps authenticated downloads; an empty
    # harvest writes nothing.
    local legacy_key
    legacy_key="$(grep -m1 '^Environment=UGLA_DOWNLOAD_KEY=' "$(mig_root /etc/systemd/system)/uglad.service" 2>/dev/null \
        | sed -e 's|^Environment=UGLA_DOWNLOAD_KEY=||' -e 's|^"||' -e 's|"$||' || true)"
    if [[ -n "$legacy_key" ]]; then
        write_env "UGLA_DOWNLOAD_KEY" "$legacy_key" "$env_file"
    fi
    chown "$user" "$env_file" 2>/dev/null || true

    # ── Prepare the user unit without starting a competing listener.
    write_user_unit_files "$unit_dir" "$home" "$user_dir" "$port" "$env_file"
    chown -R "$user" "$unit_dir" 2>/dev/null || true

    # Boot persistence for the user manager: root may enable linger for the
    # target user directly. The typed record is what the daemon's
    # boot_persistence status block reads back.
    local linger_outcome="unknown"
    if [[ "$(user_linger_state_of "$user")" == "enabled" ]]; then
        linger_outcome="ready"
        detail "Boot persistence already on (linger enabled for ${user})."
    elif loginctl enable-linger "$user" 2>/dev/null \
         && [[ "$(user_linger_state_of "$user")" == "enabled" ]]; then
        linger_outcome="ready"
        result "Boot persistence enabled — ${user}'s services now survive logout/reboot (linger)."
    else
        linger_outcome="denied_by_host_policy"
        warn "Could not enable linger for ${user} (denied_by_host_policy)."
        warn "The box runs now, but stops when ${user} logs out. An admin can run:"
        warn "    loginctl enable-linger ${user}"
    fi
    host_op_write_user_file "${state}/ugla-boot-persistence.json" \
        "$(boot_persistence_record_json "$linger_outcome" "$user" "$(date +%s)")"
    # The user manager must be up for the unit commands below.
    systemctl start "user@${uid}.service" >/dev/null 2>&1 || true

    # ── Cutover: exactly one live daemon at every moment — the system unit
    #    stops BEFORE the user unit starts; if the user side cannot prove
    #    itself, the system unit comes back.
    local health_url auth_url
    health_url="$(uglad_public_health_url "$port")"
    auth_url="http://127.0.0.1:${port}/v1/devices"
    detail "Stopping the system uglad unit..."
    systemctl stop uglad || migrate_restore_system_unit "$user" "$uid" "$port" "systemctl stop uglad failed"

    detail "Starting the user uglad unit..."
    if ! run_user_systemctl "$user" "$uid" daemon-reload \
        || ! run_user_systemctl "$user" "$uid" enable --now uglad; then
        migrate_restore_system_unit "$user" "$uid" "$port" "the user unit could not be started"
    fi
    detail "Waiting for the migrated uglad to answer (${health_url})..."
    if ! wait_for_url "$health_url" "${UGLA_MIGRATION_HEALTH_ATTEMPTS:-300}"; then
        migrate_restore_system_unit "$user" "$uid" "$port" "the migrated daemon did not answer ${health_url}"
    fi
    detail "Verifying authenticated access with the preserved API_SERVER_KEY..."
    if ! auth_probe_ok "$auth_url" "$api_key" "${UGLA_MIGRATION_AUTH_ATTEMPTS:-30}"; then
        migrate_restore_system_unit "$user" "$uid" "$port" "the preserved API_SERVER_KEY did not authenticate against ${auth_url}"
    fi

    # ── Commit: legacy artifacts go away only after the user side proved
    #    itself. From here the box IS a rootless install.
    detail "Cutover verified — retiring the system-scope install..."
    systemctl disable uglad >/dev/null 2>&1 || true
    local artifact
    while IFS= read -r artifact; do rm -f "$artifact"; done < <(retire_system_unit_files)
    systemctl daemon-reload >/dev/null 2>&1 || true
    while IFS= read -r artifact; do rm -f "$artifact"; done < <(retire_system_sudoers_files)
    rm -rf "$legacy_dir"
    # A legacy box's model cache lives in the default ~/.cache/huggingface;
    # move it under the state root so the first user-scope boot reuses it.
    # `mv -n` keeps a cache the daemon already placed at the target.
    if [[ -d "${home}/.cache/huggingface" && ! -e "${state}/cache/huggingface" ]]; then
        mkdir -p "${state}/cache"
        mv -n "${home}/.cache/huggingface" "${state}/cache/huggingface" 2>/dev/null || true
        chown -R "$user" "${state}/cache" 2>/dev/null || true
    fi
    result "Migration complete for ${user}:"
    detail "Install:  ${user_dir} (user unit, port ${port})"
    detail "Identity: ${state} preserved — paired devices keep working, no re-pairing"
    detail "Retired:  /opt/uglad, system units, and the sudoers grant are gone"
    detail "Updates:  self-update now runs in user scope (#6312)"
}

# The cutover failure path: give the system unit back the port as the one
# known-good service owner, leave every legacy artifact in place, and fail
# loudly. The staged user tree stays — it is inert without an enabled user
# unit, and a re-run resumes from it.
# Args: $1 = user, $2 = uid, $3 = port, $4 = the reason cutover failed.
migrate_restore_system_unit() {
    local user="$1" uid="$2" port="$3" because="$4"
    warn "Cutover failed: ${because}."
    warn "Restoring the system unit as the one service owner..."
    run_user_systemctl "$user" "$uid" disable --now uglad >/dev/null 2>&1 || true
    systemctl start uglad >/dev/null 2>&1 || true
    die "Migration rolled back — the system install owns port ${port} again and /opt is untouched. Re-run this operation once the cause is fixed; the staged user tree resumes."
}

# Dispatch one host operation: guards, then the bounded op bodies above.
# Args: $1 = op name, rest = the op's operands (already shifted past --host-op).
host_op_dispatch() {
    local op="${1:-}"; shift || true
    # Never a piped script: the operator must have been able to inspect the
    # bytes root is about to run. A `curl | sudo bash` invocation has no
    # BASH_SOURCE file; a downloaded, inspected file does.
    if [[ -z "${BASH_SOURCE[0]:-}" || ! -f "${BASH_SOURCE[0]}" ]]; then
        die "--host-op runs from a downloaded, inspected file — never a pipe. Download the script first (curl -fsSL https://install.ugla.ai/install.sh -o ugla-install.sh), read it, then: sudo bash ugla-install.sh --host-op …"
    fi
    if [[ $EUID -ne 0 ]]; then
        die "--host-op needs root for this one feature — run it with sudo, as yourself."
    fi
    if [[ -z "${SUDO_USER:-}" ]]; then
        die "--host-op must run as yourself with sudo (SUDO_USER is not set) — not from a root shell."
    fi
    local target_home
    target_home="$(home_of_user "${SUDO_USER}")"
    if [[ -z "$target_home" ]]; then
        die "Could not resolve the home directory of ${SUDO_USER}."
    fi
    # Host ops maintain an installed box, never install one; the migration is
    # the one exception and carries its own stricter preflight.
    if [[ "$op" != "migrate-system-scope" ]]; then
        local daemon_dir
        daemon_dir="$(host_op_env_value "${target_home}/.ugla/.env" UGLA_DAEMON_DIR)"
        daemon_dir="${daemon_dir:-${target_home}/.local/share/uglad}"
        if [[ ! -f "${daemon_dir}/version" ]]; then
            die "No stamped rootless Ugla install for ${SUDO_USER} (${daemon_dir}). The host operations maintain an installed box; they never install one."
        fi
    fi
    case "$op" in
        install-sandbox)
            [[ $# -eq 0 ]] || die "Usage: sudo bash <install.sh> --host-op install-sandbox"
            host_op_install_sandbox "$target_home"
            ;;
        migrate-system-scope)
            [[ $# -eq 0 ]] || die "Usage: sudo bash <install.sh> --host-op migrate-system-scope"
            host_op_migrate_system_scope "$target_home"
            ;;
        open-firewall-port)
            [[ $# -eq 0 ]] || die "Usage: sudo bash <install.sh> --host-op open-firewall-port"
            host_op_open_firewall_port "$target_home"
            ;;
        allow-browser-sandbox)
            if [[ $# -eq 0 ]]; then
                host_op_allow_browser_sandbox "$target_home" "${SUDO_USER}"
            elif [[ $# -eq 2 && "$1" == "--ci" && -n "$2" ]]; then
                host_op_allow_browser_sandbox "$target_home" "${SUDO_USER}" "$2"
            else
                die "Usage: sudo bash <install.sh> --host-op allow-browser-sandbox [--ci <CI runner browser install dir>]"
            fi
            ;;
        "")
            die "Missing operation. Usage: sudo bash <install.sh> --host-op <install-sandbox|migrate-system-scope|open-firewall-port|allow-browser-sandbox>"
            ;;
        *)
            die "Unknown host operation: '${op}'. Available: install-sandbox, migrate-system-scope, open-firewall-port, allow-browser-sandbox."
            ;;
    esac
    exit 0
}

# Clear this run's raw diagnostic capture and download scratch on EVERY exit
# (wired to the EXIT trap below; defined above the lib hook so the test can
# call it). Ends `return 0` — a trap that failed would rewrite the script's
# own exit status.
clear_scratch() {
    local rc="$?"
    if [[ "$rc" != 0 && "${NATIVE_ACTIVATION_STARTED:-0}" == 1 \
          && -x "${DAEMON_BINARY:-}" && -f "${DAEMON_DIR:-}/service-activation.json" ]]; then
        "$DAEMON_BINARY" service-abort "${SERVICE_ARGS[@]}" >&2 \
            || warn "Native activation recovery requires attention; its verified inputs are retained."
    fi
    rm -f "${DIAG_TRANSCRIPT:-}" 2>/dev/null || true
    [[ -n "${DOWNLOAD_DIR:-}" ]] && rm -rf "${DOWNLOAD_DIR}" 2>/dev/null
    return 0
}

# Testing hook: `UGLA_INSTALL_LIB=1 source install.sh` loads the helpers above
# and stops here — no downloads, no systemd, no filesystem writes.
[[ -n "${UGLA_INSTALL_LIB:-}" ]] && return 0 2>/dev/null

mark "installer_entry"

# ── Host-operation entry ──────────────────────────────────────
# Parsed before everything else so it cannot combine with install flags, and
# before the rootless preflight — the ops are the one place root is expected.
if [[ "${1:-}" == "--host-op" ]]; then
    host_op_dispatch "${2:-}" "${@:3}"
fi

# ── Status sentinel ──────────────────────────────────────────────────
# Per-user, not a fixed name in shared /tmp. `$XDG_RUNTIME_DIR` is the user's
# own runtime directory when systemd gives us one; the /tmp fallback carries
# the uid so two users on one machine cannot collide either.
if [[ -n "${XDG_RUNTIME_DIR:-}" && -w "${XDG_RUNTIME_DIR}" ]]; then
    STATUS_FILE="${XDG_RUNTIME_DIR}/ugla-install-status"
else
    STATUS_FILE="/tmp/ugla-install-status.$(id -u)"
fi
# A stale sentinel we cannot write is not ours to keep; refusing to start
# over one is worse than replacing it.
if [[ -e "$STATUS_FILE" && ! -w "$STATUS_FILE" ]]; then
    rm -f "$STATUS_FILE" 2>/dev/null || true
fi
echo "running" > "$STATUS_FILE"
cleanup_status() { rm -f "$STATUS_FILE"; }
trap 'echo "failed:line $LINENO" > "$STATUS_FILE"' ERR

# ── Parse flags ──────────────────────────────────────────────────────
NON_INTERACTIVE=false
HOME_ASSISTANT_RUNTIME=false
for arg in "$@"; do
    case "$arg" in
        --home-assistant-runtime)
            [[ -f /usr/share/ugla/home-assistant ]] || { echo "This flag belongs to the Ugla Home Assistant App." >&2; exit 1; }
            HOME_ASSISTANT_RUNTIME=true
            ;;
        --non-interactive|-y)
            NON_INTERACTIVE=true
            ;;
        --help|-h)
            cat <<'HELP' >&2
Usage: bash install.sh [OPTIONS]

Options:
  --non-interactive, -y   Unattended mode for cloud-init / CI.
                          Requires UGLA_API_KEY env var (hex, ≥32 chars).
  --host-op <op> [args]   One narrow privileged maintenance operation for
                          an already-installed box, run deliberately with
                          sudo from a downloaded, inspected copy of this
                          script (#6313). Ops: install-sandbox (the
                          Bubblewrap sandbox the ordinary install only
                          detects, never provisions itself),
                          open-firewall-port (the ufw allow rule the
                          ordinary install only detects, never mutates
                          itself),
                          allow-browser-sandbox [--ci <dir>] (the AppArmor
                          profile that lets the browser engine keep its
                          sandbox on hosts restricting user namespaces;
                          --ci grants a CI runner's browser install dir
                          as its own profile),
                          migrate-system-scope (one-way #6314 conversion of
                          a legacy /opt + system-unit install to the
                          user-owned rootless layout).
                          Never installs Ugla; never combines with install.
  --help, -h              Show this help and exit.

Environment:
  UGLA_VERSION          Pin a release tag (default: latest)
  UGLA_CHANNEL          Release channel: canary (default — the newest nightly)
                        or stable (only moves when a release is promoted)
  UGLA_API_KEY          Pre-supplied API key (required in non-interactive mode)
  UGLA_INSTALL_SERVER   Binary download server (default: https://install.ugla.ai)
  UGLA_DOWNLOAD_KEY     Bearer token for authenticated downloads
  UGLA_INSTALL_REPORT=1 Pre-consent to send a REDACTED failure report to the Ugla
                       team if the install crashes (for non-interactive / CI;
                       interactive runs are asked y/N instead — default No)
  UGLA_TAILSCALE=1      REFUSED on the rootless path: tailscaled is a
                        privileged host integration. Install Tailscale
                        yourself if you want it; Ugla orchestrates no
                        root install of it.
  TS_AUTHKEY           (unused on the rootless path — see UGLA_TAILSCALE)
  SIDECAR_PORT         Public uglad/app listener port (default: 8643)
  UGLA_IMPORT_FROM=user@host  Carry your agent's mind (memory, identity,
                         jobs, agent.toml) from another box. A stopped
                         source is copied directly; a RUNNING source is
                         copied from WAL-safe SQLite snapshots (#2429 —
                         needs the sqlite3 CLI on the source). Secrets,
                         vault material, and embeddings are NOT copied —
                         keys re-enter on the new box, embeddings recompute.
                         Interactive installs at a terminal are offered
                         this as a prompt when the variable is unset.
  UGLA_IMPORT_FORCE=1   With UGLA_IMPORT_FROM, overwrite existing stores on
                         the new box (default: existing files are kept).
HELP
            exit 0
            ;;
        *)
            echo "Unknown flag: $arg" >&2
            echo "Usage: bash install.sh [--non-interactive|-y]" >&2
            exit 1
            ;;
    esac
done

# ── Field diagnostics: opt-in scrubbed failure report ─────────────────
# Output is mirrored to a 0600 temp file so a field failure can be reported
# home — strictly opt-in, redacted, and consented. The RAW capture (which may
# hold the generated API key or a download token) is deleted on EVERY exit;
# only an *unhandled* crash produces a SCRUBBED report and offers to send it.
DIAG_TRANSCRIPT=""
DIAG_TEE_PID=""
if DIAG_TRANSCRIPT="$(mktemp "${TMPDIR:-/tmp}/wtf-install-log.XXXXXX" 2>/dev/null)"; then
    chmod 600 "$DIAG_TRANSCRIPT" 2>/dev/null || true
    # Keep the original terminal fds so the failure handler can restore direct
    # output and prompt a human after capture.
    exec 3>&1 4>&2
    exec > >(tee -a "$DIAG_TRANSCRIPT") 2>&1
    DIAG_TEE_PID=$!
else
    DIAG_TRANSCRIPT=""   # capture unavailable — install proceeds, just no report
fi

# ERR handler: preserve the status sentinel, then (if a transcript was
# captured) scrub it, ask consent, and either POST it or hand back a
# manual-submit one-liner. Never blocks a non-interactive / no-tty run.
on_err() {
    local ec=$?
    local failed_line="${1:-0}"
    set +e
    trap - ERR
    echo "failed:line ${failed_line}" > "$STATUS_FILE" 2>/dev/null || true

    if [[ -n "${DIAG_TEE_PID:-}" ]]; then
        exec 1>&3 2>&4                       # direct output; closes the tee pipe
        wait "$DIAG_TEE_PID" 2>/dev/null || true   # let tee flush the last lines
    fi
    if [[ -z "${DIAG_TRANSCRIPT:-}" || ! -s "${DIAG_TRANSCRIPT:-/nonexistent}" ]]; then
        exit "$ec"
    fi

    local server="${UGLA_INSTALL_SERVER:-https://install.ugla.ai}"
    local report_url="${server}/api/v1/install-report"

    local payload
    payload="$(mktemp "${TMPDIR:-/tmp}/wtf-install-report.XXXXXX" 2>/dev/null)" || exit "$ec"
    chmod 600 "$payload" 2>/dev/null || true
    # Cap the transcript (tail wins — the failure is at the end), then scrub.
    tail -c 200000 "$DIAG_TRANSCRIPT" > "$payload" 2>/dev/null || cp "$DIAG_TRANSCRIPT" "$payload"
    diag_scrub_file "$payload"
    # Turn the scrubbed transcript into the final JSON report body, in place.
    local body
    body="$(diag_build_payload "$payload" "$failed_line")" && printf '%s\n' "$body" > "$payload"

    local send=false
    if [[ "${UGLA_INSTALL_REPORT:-}" == "1" ]]; then
        send=true
    elif ! $NON_INTERACTIVE && ( : </dev/tty ) 2>/dev/null; then
        printf '\n%s[ugla] Installation failed at line %s.%s\n' "$RED" "$failed_line" "$NC" >/dev/tty
        ask "Send a REDACTED diagnostic report to the Ugla team so we can fix it?" \
            "No secrets are included; the report is the scrubbed transcript above." \
            "[y/N] "
        local reply=""
        IFS= read -r reply </dev/tty || reply=""
        case "$reply" in [yY]|[yY][eE][sS]) send=true ;; *) send=false ;; esac
    fi

    if $send; then
        if curl -fsS --max-time 15 -X POST "$report_url" \
                -H 'Content-Type: application/json' \
                --data-binary @"$payload" >/dev/null 2>&1; then
            printf "[ugla] Thank you — a redacted report was sent. No secrets were included.\n"
            rm -f "$payload" 2>/dev/null || true
        else
            printf "[ugla] Could not reach the report server. Your redacted report is saved at:\n    %s\n" "$payload"
            printf "[ugla] Send it later with:\n    curl -sS -X POST %s -H 'Content-Type: application/json' --data-binary @%s\n" "$report_url" "$payload"
        fi
    else
        printf "\n[ugla] Installation failed at line %s. A redacted report (no secrets) was saved to:\n    %s\n" "$failed_line" "$payload"
        printf "[ugla] To let the Ugla team help fix this, review it and send it with:\n    curl -sS -X POST %s -H 'Content-Type: application/json' --data-binary @%s\n" "$report_url" "$payload"
    fi
    exit "$ec"
}

# Supersede the simple ERR sentinel with the reporting handler, and destroy
# the RAW (unscrubbed) capture on any exit. Only the scrubbed report file may
# ever survive.
trap 'on_err $LINENO' ERR
trap clear_scratch EXIT

# ── Configurable via environment ──────────────────────────────────────
UGLA_VERSION="${UGLA_VERSION:-}"
# The default is the channel that MOVES: `canary` advances per artifact every
# night; `stable` only advances when a release is promoted.
UGLA_CHANNEL="${UGLA_CHANNEL:-canary}"
SIDECAR_HOST="${SIDECAR_HOST:-0.0.0.0}"
SIDECAR_PORT="${SIDECAR_PORT:-8643}"
UGLA_TAILSCALE="${UGLA_TAILSCALE:-0}"
TS_AUTHKEY="${TS_AUTHKEY:-}"
UGLA_INSTALL_SERVER="${UGLA_INSTALL_SERVER:-https://install.ugla.ai}"

# ── Single-process daemon topology ────────────────────────────────────
# `uglad` is THE topology: one binary, one service registration — a user
# unit under systemd, the ugla-service helper under the portable backend.
# The install root is defined once here and reused by both registrations and
# .env (UGLA_DAEMON_DIR, so the self-updater never guesses /opt);
# DAEMON_DIR stays overridable for nonstandard homes.
DAEMON_DIR="${DAEMON_DIR:-${HOME}/.local/share/uglad}"
USER_UNIT_DIR="${XDG_CONFIG_HOME:-${HOME}/.config}/systemd/user"

# ── Helpers ───────────────────────────────────────────────────────────
# phase/detail/result/warn/die/exists live with the pure helpers above the
# lib hook.

# Best-effort remote→local copy for the agent import (rsync when available —
# it preserves the SQLite dir shape for the memory stores — else scp -r).
# Quiet on failure: callers decide what's worth warning about.
import_copy_one() {
    local src="$1" remote_path="$2" target="$3"
    if exists rsync; then
        rsync -a --timeout=30 -e "ssh -o BatchMode=yes" \
            "${src}:${remote_path}" "$target" 2>/dev/null
    elif exists scp; then
        scp -rq -o BatchMode=yes "${src}:${remote_path}" "$target" 2>/dev/null
    else
        return 1
    fi
}

# Carry an agent's mind (memory, jobs, agent.toml) from a source box into a
# fresh ~/.ugla over SSH. A STOPPED source is copied directly; a RUNNING
# source is copied from per-store snapshots taken with the SQLite
# online-backup API via the `sqlite3` CLI (which the source must have) — a
# raw copy could catch a store mid-write. Best-effort: a failure warns and
# the install continues with a blank agent, never aborts.
#
# Args: $1 = destination ~/.ugla (already created, owned), $2 = user@host[:port],
# $3 = "1" to overwrite existing stores (UGLA_IMPORT_FORCE), else keep existing.
import_agent_from() {
    local dest="$1" src="$2" force="${3:-0}"
    # The data stores that ARE the agent's mind, copied one at a time so a
    # missing one on the source is just skipped. `memory.db` is the legacy
    # memory dir a source box may still carry; it travels under the canonical
    # `mem/` name below.
    local -a stores=(
        "mem"
        "memory.db"
        "world.db"
        "ugla-jobs.db"
        "ugla-agent.toml"
    )
    # Explicitly NEVER copy — secrets/vault are box-local (keys re-enter
    # through the normal key flow), embeddings are derived (recompute on the
    # new box), and .env is box-local.
    local -a skip=(
        "vault.key"
        ".env"
    )

    if ! exists ssh; then
        warn "UGLA_IMPORT_FROM set but 'ssh' not found — skipping agent import."
        return 0
    fi
    if ! exists rsync && ! exists scp; then
        warn "UGLA_IMPORT_FROM set but neither 'rsync' nor 'scp' found — skipping agent import."
        return 0
    fi

    # Probe whether the source daemon is live: a stopped source is copied
    # directly, a running one from WAL-safe snapshots.
    local live=0
    if ssh -o BatchMode=yes -o ConnectTimeout=5 "$src" \
        'curl -fsS --max-time 3 http://127.0.0.1:8643/healthz >/dev/null 2>&1' 2>/dev/null; then
        live=1
    fi
    # A healthz timeout is the expected "source is stopped" signal; only a
    # real SSH failure is worth surfacing.
    if ! ssh -o BatchMode=yes -o ConnectTimeout=5 "$src" 'true' 2>/dev/null; then
        warn "UGLA_IMPORT_FROM: could not reach '$src' over SSH — skipping agent import."
        warn "  The new box boots with a blank agent. Re-run with UGLA_IMPORT_FROM once reachable."
        return 0
    fi

    detail "Importing agent from '$src' into ${dest}..."
    local src_home
    src_home=$(ssh -o BatchMode=yes "$src" 'printf %s "$HOME"' 2>/dev/null) || src_home=""
    if [[ -z "$src_home" ]]; then
        warn "UGLA_IMPORT_FROM: could not resolve HOME on '$src' — skipping agent import."
        return 0
    fi
    # The source box may pre- or post-date the ~/.wtf → ~/.ugla cutover;
    # prefer its new home.
    local src_wtf
    if ssh -o BatchMode=yes "$src" '[[ -d "$HOME/.ugla" ]]' 2>/dev/null; then
        src_wtf="${src_home}/.ugla"
    else
        src_wtf="${src_home}/.wtf"
    fi

    # Copy FROM the source's data home directly, or from the snapshot
    # directory prepared on the source when it's live.
    local copy_root="$src_wtf" snap_dir=""
    if [[ "$live" == "1" ]]; then
        if ! ssh -o BatchMode=yes "$src" \
            'command -v sqlite3 >/dev/null 2>&1' 2>/dev/null; then
            warn "UGLA_IMPORT_FROM: source gateway on '$src' is running, and 'sqlite3'"
            warn "  is not installed there — a consistent live copy isn't possible."
            warn "  Install the sqlite3 CLI on the source, or stop the gateway first"
            warn "  ('ssh $src sudo systemctl stop wtf-gateway wtf-sidecar'). Skipping import."
            return 0
        fi
        detail "Source gateway is running — snapshotting its stores (WAL-safe live import)..."
        snap_dir=$(ssh -o BatchMode=yes "$src" \
            'mktemp -d "${TMPDIR:-/tmp}/wtf-import.XXXXXX"' 2>/dev/null) || snap_dir=""
        if [[ -z "$snap_dir" ]]; then
            warn "UGLA_IMPORT_FROM: could not create a snapshot dir on '$src' — skipping agent import."
            return 0
        fi
        # Snapshot every store ON THE SOURCE: SQLite files (identified by
        # header, not name) go through the online-backup API, everything else
        # is a plain cp; -wal/-shm sidecars are skipped (backup output is
        # self-contained). The heredoc is single-quoted — nothing expands
        # locally; $UGLA_SNAP/$UGLA_STORES arrive via the env prefix.
        if ! ssh -o BatchMode=yes "$src" \
            "UGLA_SNAP=$(printf %q "$snap_dir") UGLA_STORES=$(printf %q "${stores[*]}") bash -s" \
            <<'UGLA_SNAPSHOT' 2>/dev/null
set -u
cd "$HOME/.ugla" 2>/dev/null || cd "$HOME/.wtf" || exit 1
is_sqlite() { head -c 15 "$1" 2>/dev/null | grep -q 'SQLite format 3'; }
snap_db() {
    sqlite3 -cmd '.timeout 5000' "$1" ".backup '$2'"
}
for store in $UGLA_STORES; do
    [ -e "$store" ] || continue
    if [ -d "$store" ]; then
        find "$store" -type f | while IFS= read -r f; do
            case "$f" in *-wal|*-shm|*-journal) continue ;; esac
            mkdir -p "$UGLA_SNAP/$(dirname "$f")" || exit 1
            if is_sqlite "$f"; then
                snap_db "$f" "$UGLA_SNAP/$f" || exit 1
            else
                cp -p "$f" "$UGLA_SNAP/$f" || exit 1
            fi
        done || exit 1
    elif is_sqlite "$store"; then
        snap_db "$store" "$UGLA_SNAP/$store" || exit 1
    else
        cp -p "$store" "$UGLA_SNAP/$store" || exit 1
    fi
done
UGLA_SNAPSHOT
        then
            warn "UGLA_IMPORT_FROM: snapshotting the running source's stores failed — skipping import."
            warn "  (Stop the gateway on '$src' and re-run for the direct copy path.)"
            ssh -o BatchMode=yes "$src" "rm -rf $(printf %q "$snap_dir")" 2>/dev/null || true
            return 0
        fi
        copy_root="$snap_dir"
    fi

    # Which stores (and, on a stopped source, which -wal/-shm sidecars) exist
    # at the copy root? Absence is normal, not a copy failure.
    local -a candidates=()
    local store
    for store in "${stores[@]}"; do
        candidates+=("$store" "${store}-wal" "${store}-shm")
    done
    local present
    present=$(ssh -o BatchMode=yes "$src" \
        "cd $(printf %q "$copy_root") 2>/dev/null && for s in ${candidates[*]}; do [ -e \"\$s\" ] && printf '%s\\n' \"\$s\"; done; true" \
        2>/dev/null)

    local copied=0 skipped=0
    for store in "${stores[@]}"; do
        printf '%s\n' "$present" | grep -qxF "$store" || continue
        local dest_name="$store"
        if [[ "$store" == "memory.db" ]]; then
            dest_name="mem"
            # Never land a legacy copy over a live `mem/` — the stale legacy
            # dir stays behind, even under UGLA_IMPORT_FORCE.
            if [[ -e "${dest}/mem" ]]; then
                skipped=$((skipped + 1))
                continue
            fi
        fi
        # Don't clobber an existing mind unless forced (idempotent re-run).
        if [[ -e "${dest}/${dest_name}" && "$force" != "1" ]]; then
            skipped=$((skipped + 1))
            continue
        fi
        local copy_target="${dest}/"
        if [[ "$store" == "memory.db" ]]; then
            copy_target="${dest}/mem"
        fi
        if import_copy_one "$src" "${copy_root}/${store}" "$copy_target"; then
            copied=$((copied + 1))
            # A fresh store copy must never pair with sidecars from an earlier
            # import — a mismatched -wal next to a db risks confusing SQLite.
            rm -f "${dest}/${dest_name}-wal" "${dest}/${dest_name}-shm" 2>/dev/null || true
            # Sidecars from an uncleanly-stopped gateway hold committed
            # transactions; carry them so SQLite replays them on first open.
            # Snapshots are self-contained (no sidecars ever).
            local side
            for side in "${store}-wal" "${store}-shm"; do
                printf '%s\n' "$present" | grep -qxF "$side" || continue
                import_copy_one "$src" "${copy_root}/${side}" "${dest}/" ||
                    warn "  could not copy ${side} from source (skipping)"
            done
        else
            warn "  could not copy ${store} from source (skipping)"
        fi
    done

    # Clean the snapshot directory off the source (best-effort).
    if [[ -n "$snap_dir" ]]; then
        ssh -o BatchMode=yes "$src" "rm -rf $(printf %q "$snap_dir")" 2>/dev/null || true
    fi

    # Strip box-specific bits from the imported agent.toml so it boots cleanly:
    # tunnel_host is the old box's address. Temp-file rewrite so the edit is
    # atomic and GNU/BSD sed-portable.
    if [[ -f "${dest}/ugla-agent.toml" ]]; then
        cp -p "${dest}/ugla-agent.toml" "${dest}/ugla-agent.toml.imported" 2>/dev/null || true
        local _at="${dest}/ugla-agent.toml"
        grep -vE '^[[:space:]]*tunnel_host[[:space:]]*=' "$_at" > "${_at}.tmp" \
            && mv "${_at}.tmp" "$_at" || rm -f "${_at}.tmp"
    fi

    # (No re-own needed: a rootless import lands as the invoking user.)
    result "Agent import: ${copied} store(s) copied, ${skipped} kept (already present)."
    warn "  Secrets/vault/embeddings were NOT copied — keys re-enter on the new box,"
    warn "  embeddings recompute."
    if [[ "$live" == "1" ]]; then
        warn "  The source gateway was RUNNING: stores came from point-in-time WAL-safe"
        warn "  snapshots. Anything the old agent learns after this moment stays on the"
        warn "  old box — stop it when you're ready to switch over."
    else
        warn "  (The source gateway was stopped for a safe copy.)"
    fi
}

# ── Preflight ─────────────────────────────────────────────────────────
printf '%s[ugla] Ugla installer — one background service%s\n' "${BOLD}" "$NC"
detail "Six steps: check this machine → fetch Ugla → fetch the model runtimes"
detail "→ install → start the service → open the door for your phone."

phase "Checking this machine"

INSTALL_OS="$(uname -s)"
case "$INSTALL_OS" in Linux|Darwin) ;; *) die "Ugla supports Linux and macOS." ;; esac

if ! $HOME_ASSISTANT_RUNTIME && install_home_assistant_app; then
    cleanup_status
    exit 0
fi

# The installer never elevates: no sudo, no package managers, no /opt or /etc
# writes. Root is refused outright — a root-owned "user" install is a
# contradiction. The one root-seated action is the explicit migration host-op.
if [[ $EUID -eq 0 ]]; then
    die "Run as your normal user — the installer no longer uses root (#6311). To migrate an existing /opt system-scope install, run: sudo bash <this-script> --host-op migrate-system-scope"
fi

# One topology per box: a system-scope install must not gain a second,
# user-scoped one beside it. Fail before touching anything.
if [[ -d /opt/uglad || -d /opt/wtfd || -e /etc/systemd/system/uglad.service || -e /etc/systemd/system/wtfd.service ]]; then
    die "This box already carries a system-scope Ugla install (/opt + system units), and neither this installer nor the daemon's self-updater operates it. Migrate it in place — download this script, inspect it, then: sudo bash ugla-install.sh --host-op migrate-system-scope. A fresh user-scope install belongs on another machine or user."
fi

# The service lifecycle backend is a host capability (#8160), selected up
# front so the rest of the install runs through exactly one of them. A
# reachable user systemd manager keeps the rootless user-unit behavior; a
# host without one installs and runs the SAME verified daemon through the
# portable backend instead of being refused. `curl | bash` over SSH
# normally inherits XDG_RUNTIME_DIR from the PAM session; repair the one
# common gap before the manager probe.
if [[ -z "${XDG_RUNTIME_DIR:-}" && -d "/run/user/$(id -u)" ]]; then
    export XDG_RUNTIME_DIR="/run/user/$(id -u)"
fi
# ── Non-interactive: fail fast on missing required config ─────────────
if $NON_INTERACTIVE; then
    detail "Non-interactive mode — validating configuration..."
    if [[ -z "${UGLA_API_KEY:-}" ]]; then
        die "Non-interactive mode requires UGLA_API_KEY (hex, ≥32 chars). Set it in your cloud-init user-data." \
            "add UGLA_API_KEY=<64-hex-chars> to the user-data and re-run"
    fi
    if ! [[ "${UGLA_API_KEY}" =~ ^[0-9a-fA-F]+$ ]] || [[ ${#UGLA_API_KEY} -lt 32 ]]; then
        die "UGLA_API_KEY must be hex and ≥32 chars. Got: ${#UGLA_API_KEY} chars." \
            "generate one with: openssl rand -hex 32"
    fi
    detail "Configuration valid (UGLA_VERSION=${UGLA_VERSION:-latest}, UGLA_API_KEY=present)."
fi

# The caddy/TLS "public HTTPS" mode is retired: remote access is first-party,
# turned on from the app. Requesting the retired env fails fast, before
# anything is touched.
if [[ -n "${UGLA_HTTPS_HOST:-}" ]]; then
    die "UGLA_HTTPS_HOST is retired: remote access is first-party now — turn it on from the app (Remote access on the box page). For a deliberate manual proxy, run and configure one yourself; this installer never manages TLS."
fi


# ── "Moving from another box?" ─────────────────────────────────────────
# Only /dev/tty can make this call: the canonical install is `curl … | bash`,
# where stdin is the script pipe, and detached installs run with no
# controlling terminal — the env var is the only channel there.
UGLA_IMPORT_FROM="${UGLA_IMPORT_FROM:-}"
if ! $NON_INTERACTIVE && [[ -z "$UGLA_IMPORT_FROM" ]] && ( : </dev/tty ) 2>/dev/null; then
    import_prompt="Import from user@host (Enter = fresh agent): "
    ask "Moving from another box?" \
        "Carries your agent's memory, identity, and scheduled jobs over SSH from the old box — secrets never travel. Leave blank to start fresh." \
        "$import_prompt"
    while true; do
        IFS= read -r UGLA_IMPORT_FROM </dev/tty || { UGLA_IMPORT_FROM=""; break; }
        [[ -z "$UGLA_IMPORT_FROM" ]] && break
        # The value lands verbatim on ssh/rsync command lines — accept only a
        # plain user@host; anything fancier goes through the env var.
        if [[ "$UGLA_IMPORT_FROM" =~ ^[A-Za-z0-9._-]+@[A-Za-z0-9._-]+$ ]]; then
            break
        fi
        warn "That doesn't look like user@host — try again, or leave blank to skip."
        UGLA_IMPORT_FROM=""
        printf '  %s' "$import_prompt" >/dev/tty
    done
    if [[ -n "$UGLA_IMPORT_FROM" ]]; then
        detail "Will carry the agent over from '$UGLA_IMPORT_FROM' after install."
    fi
fi

# ── Detect architecture ──────────────────────────────────────────────
phase "Fetching Ugla"
ARCH="$(uname -m)"
case "$INSTALL_OS/$ARCH" in
    Darwin/arm64) BINARY_ARCH="mac-arm64"; RUST_TARGET="aarch64-apple-darwin" ;;
    Darwin/x86_64) die "Ugla needs a Mac with Apple silicon; Intel Macs are not supported." "install Ugla on a Linux machine instead." ;;
    Linux/x86_64) BINARY_ARCH="linux-amd64"; RUST_TARGET="x86_64-unknown-linux-gnu" ;;
    Linux/aarch64|Linux/armv7l) BINARY_ARCH="linux-arm64"; RUST_TARGET="aarch64-unknown-linux-gnu" ;;
    *) die "Unsupported architecture: ${ARCH}. Prebuilt Ugla releases cover Apple silicon Macs, x86_64 Linux and aarch64 Linux." ;;
esac

detail "Architecture: ${ARCH} → ${BINARY_ARCH} (${RUST_TARGET})"

# ── Resolve version ──────────────────────────────────────────────────
if [[ -z "$UGLA_VERSION" ]]; then
    detail "Finding latest release..."

    case "$UGLA_CHANNEL" in
        stable|canary) ;;
        *) die "UGLA_CHANNEL must be stable or canary, got: $UGLA_CHANNEL" ;;
    esac
    LATEST_URL="${UGLA_INSTALL_SERVER}/latest?artifact=uglad&target=${RUST_TARGET}&channel=${UGLA_CHANNEL}"
    LATEST_RESP=$(curl -fsSL --max-time 15 "$LATEST_URL") \
        || die "The canonical install service is unavailable at ${UGLA_INSTALL_SERVER}; refusing to switch distribution origin." \
               "check this machine's network/DNS for ${UGLA_INSTALL_SERVER}, then re-run"
    UGLA_VERSION=$(printf '%s' "$LATEST_RESP" | sed -n 's/.*"version"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -1)
    [[ -n "$UGLA_VERSION" ]] \
        || die "The canonical install service returned no release for uglad/${RUST_TARGET}/${UGLA_CHANNEL}."
fi

detail "Target: ${UGLA_VERSION}"
mark "release_resolved"

# ── Install runtime dependencies ──────────────────────────────────────
detail "Checking runtime dependencies..."

# Local terminal/process execution is boundary-driven: the installer
# provisions the Bubblewrap sandbox below (best effort — never a failed
# install); uglad fails closed until that boundary verifies. Everything else
# needs no package at all.

# curl is needed for download; we're already running so it exists.
# sha256sum or shasum for checksum verification.
if exists sha256sum; then
    CHECKSUM_CMD="sha256sum"
elif exists shasum; then
    CHECKSUM_CMD="shasum -a 256"
else
    die "Need sha256sum or shasum for checksum verification. The rootless installer does not install packages (#6311) — install coreutils yourself and re-run."
fi

# ── Scratch dir for downloads (uglad binary) ──────────────────────────
DOWNLOAD_DIR="$(mktemp -d "${TMPDIR:-/tmp}/ugla-download-XXXXXXXX")"

# Publisher authority before any executable is fetched. A re-run carries its
# recorded roster version forward so a replayed older key set is refused; a
# fresh box has no version file yet, so this read must tolerate its absence
# under `pipefail`.
ACCEPTED_ROSTER_VERSION="$(sed -n 's/^publisher_roster=//p' "${DAEMON_DIR}/version" 2>/dev/null | head -1 || true)"
[[ "$ACCEPTED_ROSTER_VERSION" =~ ^[0-9]+$ ]] || ACCEPTED_ROSTER_VERSION=0
if [[ "$INSTALL_OS" == "Darwin" ]]; then
    prepare_macos_verifier "$DOWNLOAD_DIR" "$ARCH" \
        || die "This installer build has no valid Mac signature verifier. The installation service must publish a complete Mac bootstrap."
fi
load_publisher_roster "$ACCEPTED_ROSTER_VERSION"

# ── Download uglad binary from the canonical service ─────────────────
# No alternate runtime origin exists: if discovery, token mint, signed
# download, or integrity verification fails, the install fails clearly.
DAEMON_BINARY="${DOWNLOAD_DIR}/uglad"
UGLAD_DL_HEADERS=(-H "X-Artifact: uglad" -H "X-Target: ${RUST_TARGET}" -H "X-Version: ${UGLA_VERSION}")
UGLAD_TOKEN_RESP=$(curl -fsSL --max-time 15 -X POST "${UGLA_INSTALL_SERVER}/api/v1/installer/download-token" \
    -H "Authorization: Bearer ${UGLA_DOWNLOAD_KEY}" \
    "${UGLAD_DL_HEADERS[@]}") \
    || die "The canonical install service could not mint a download for uglad/${UGLA_VERSION}/${RUST_TARGET}." \
           "check this machine's network/DNS for ${UGLA_INSTALL_SERVER}, then re-run"
UGLAD_SIGNED_URL=$(printf '%s' "$UGLAD_TOKEN_RESP" | sed -n 's/.*"url"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -1)
[[ -n "$UGLAD_SIGNED_URL" ]] || die "The canonical install service returned a malformed signed-download response (missing url)."
# The digest comes from the publisher, never from the service that serves the
# bytes it describes.
UGLAD_EXPECTED_SHA=$(authorized_release_sha256 uglad "${UGLA_VERSION#v}" "$RUST_TARGET" "$UGLA_CHANNEL")
fetch "uglad ${UGLA_VERSION} (${RUST_TARGET}) from ${UGLA_INSTALL_SERVER}" \
    "$DAEMON_BINARY" 120 "$UGLAD_SIGNED_URL" \
    || die "The canonical signed download failed; refusing to switch distribution origin." \
           "check the network path from this machine, then re-run"
[[ -s "$DAEMON_BINARY" ]] || die "The canonical signed download returned an empty uglad binary." \
    "re-run — the download starts fresh each time"
UGLAD_ACTUAL_SHA=$($CHECKSUM_CMD "$DAEMON_BINARY" | awk '{print $1}')
[[ "$(printf %s "$UGLAD_EXPECTED_SHA" | tr A-F a-f)" == "$(printf %s "$UGLAD_ACTUAL_SHA" | tr A-F a-f)" ]] \
    || die "uglad SHA-256 mismatch from the canonical install service; refusing to install it." \
           "re-run for a fresh download; if it repeats, the rail may be serving wrong bytes — report it"
mark "essential_bytes_verified"
chmod +x "$DAEMON_BINARY"

# The one-time ~/.wtf → ~/.ugla cutover runs BEFORE any daemon invocation:
# `service-install` takes the node lock on the state root and creates it, so
# a box still on ~/.wtf must be moved first or its retained state is stranded
# while the new daemon starts on an empty home.
ACTUAL_HOME="${HOME}"
cutover_legacy_home "${ACTUAL_HOME}"
if $HOME_ASSISTANT_RUNTIME; then
    "$DAEMON_BINARY" service-backend-check supervisor >/dev/null \
        || die "The selected signed Ugla release does not yet support Home Assistant App updates. Wait for a compatible daemon release and restart the App."
fi
if $HOME_ASSISTANT_RUNTIME; then
    SERVICE_BACKEND="supervisor"
    install_supervised_daemon_candidate "$DAEMON_BINARY" "$DAEMON_DIR" "$HOME" \
        || die "The candidate cannot safely replace this Home Assistant installation."
else
    SERVICE_BACKEND="$("$DAEMON_BINARY" service-backend --install-dir "$DAEMON_DIR")" \
        || die "The verified release cannot activate a rootless service on this host. Existing service files are unchanged." \
               "use a release with native service activation and resolve the reported host capability"
    SERVICE_ARGS=(--home "$HOME" --install-dir "$DAEMON_DIR" --backend "$SERVICE_BACKEND" \
        --env-file "$HOME/.ugla/.env" --unit-dir "$USER_UNIT_DIR" --port "$SIDECAR_PORT")
    "$DAEMON_BINARY" service-install --sha256 "$UGLAD_ACTUAL_SHA" "${SERVICE_ARGS[@]}" \
        || die "The candidate could not safely prepare this installation." \
               "resolve the reported activation or retained-format error, then re-run"
    NATIVE_ACTIVATION_STARTED=1
fi
result "uglad ${UGLA_VERSION} verified and installed ($(du -h "${DAEMON_DIR}/bin/uglad" | cut -f1))"

# Optional runtimes are resolved only after the daemon serves. Their updater
# owns signed resolution, disk admission, probing, swaps and recovery; a slow
# or unavailable component never turns a working Ugla install into a failure.
NEURAL_STATUS="preparing in the background (FTS5 remains available)"

# `scope=user` is the updater's one privilege-topology input; `backend` is
# the lifecycle line the updater's restart goes through (#8160). `channel`
# records the channel this install actually resolved its version FROM — the
# app's updater reads it back to decide what to offer, so a fallback here
# would record a channel the box never used.
cat > "${DAEMON_DIR}/version" <<EOF
version=${UGLA_VERSION}
installed=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
channel=${UGLA_CHANNEL}
target=${RUST_TARGET}
scope=user
backend=${SERVICE_BACKEND}
publisher_roster=${PUBLISHER_ROSTER_VERSION}
EOF


# ── Generate API key and write config ─────────────────────────────────
phase "Installing"
detail "Writing this box's identity and config..."

UGLA_HOME_DIR="${ACTUAL_HOME}/.ugla"
AGENT_WORKSPACE_DIR="${ACTUAL_HOME}/Ugla"
ENV_FILE="${UGLA_HOME_DIR}/.env"
# The high-entropy keyfile that unlocks the credential vault at boot; lives
# beside .env under ~/.ugla.
VAULT_KEYFILE="${UGLA_HOME_DIR}/vault.key"

mkdir -p "$UGLA_HOME_DIR" "$AGENT_WORKSPACE_DIR"
chmod 700 "$UGLA_HOME_DIR"

# Resolve the key BEFORE touching .env, so a re-run (which already has a key)
# preserves it instead of rotating it. The pre-read only logs honestly which
# branch resolve_api_key took.
EXISTING_KEY=""
if [[ -f "$ENV_FILE" ]]; then
    EXISTING_KEY=$(grep -m1 '^API_SERVER_KEY=' "$ENV_FILE" | cut -d= -f2- || true)
fi
API_KEY=$(resolve_api_key "$ENV_FILE")
if [[ -n "${UGLA_API_KEY:-}" && "${UGLA_API_KEY}" =~ ^[0-9a-fA-F]+$ && ${#UGLA_API_KEY} -ge 32 ]]; then
    detail "Using pre-supplied UGLA_API_KEY"
elif [[ -n "$EXISTING_KEY" ]]; then
    detail "Preserving existing API_SERVER_KEY — paired devices stay connected"
else
    detail "Minted a fresh API_SERVER_KEY"
    if [[ -n "${UGLA_API_KEY:-}" ]]; then
        warn "UGLA_API_KEY set but invalid (must be hex, ≥32 chars). Minted a new key instead."
    fi
fi

# (`write_env`, defined with the pure helpers above the lib hook, creates .env
# 0600 and repairs the mode on every run. The explicit touch+chmod here
# repairs a pre-existing 0644 from an older install even before the first
# write.)
( umask 077; touch "$ENV_FILE" )
chmod 600 "$ENV_FILE"
write_env "API_SERVER_KEY" "$API_KEY" "$ENV_FILE"
write_env "UGLA_COMPANION_HOST" "$SIDECAR_HOST" "$ENV_FILE"
write_env "UGLA_COMPANION_PORT" "$SIDECAR_PORT" "$ENV_FILE"
write_env "UGLA_SIDECAR_URL" "http://127.0.0.1:${SIDECAR_PORT}" "$ENV_FILE"

# Vault keyfile: mint a high-entropy keyfile so the credential vault boots
# unlocked with zero manual steps. The vault store loads exactly 32 raw bytes
# (wtf-vault KekSource::load_keyfile), so write raw bytes — NOT hex.
# Idempotent: never overwrite an existing keyfile — it may unlock an existing
# vault, and replacing it would orphan the stored secrets. `umask 077` in the
# subshell makes the file 0600 from creation.
if [[ ! -f "$VAULT_KEYFILE" ]]; then
    ( umask 077; openssl rand 32 > "$VAULT_KEYFILE" 2>/dev/null \
        || head -c 32 /dev/urandom > "$VAULT_KEYFILE" )
    chmod 600 "$VAULT_KEYFILE"
    detail "Vault keyfile generated at ${VAULT_KEYFILE}"
else
    detail "Vault keyfile already present — keeping it"
fi
# The daemon reads this from EnvironmentFile=.env.
write_env "UGLA_VAULT_KEYFILE" "$VAULT_KEYFILE" "$ENV_FILE"
# Point the daemon's self-updater at THIS install's user-owned tree — without
# it the updater falls back to its /opt/uglad default, which no rootless box
# has.
write_env "UGLA_DAEMON_DIR" "$DAEMON_DIR" "$ENV_FILE"
write_env "UGLA_INSTALL_URL" "$UGLA_INSTALL_SERVER" "$ENV_FILE"
# The download bearer rides the same 0600 EnvironmentFile as every other
# secret: the generated uglad.service carries no literal key.
write_env "UGLA_DOWNLOAD_KEY" "$UGLA_DOWNLOAD_KEY" "$ENV_FILE"
# Written explicitly so a box installed from a staging rail reaches staging —
# the daemon would otherwise default to production.
write_env "UGLA_CLOUD_ORIGIN" "$UGLA_CLOUD_ORIGIN" "$ENV_FILE"

result "Config written to ${ENV_FILE}"

# ── Optional: carry your agent's mind from another box ────────────────
# After ~/.ugla exists and is owned, before any service starts.
if [[ -n "${UGLA_IMPORT_FROM:-}" ]]; then
    import_agent_from "$UGLA_HOME_DIR" "$UGLA_IMPORT_FROM" "${UGLA_IMPORT_FORCE:-0}"
fi

if [[ "$SERVICE_BACKEND" == "supervisor" ]]; then
    if ! UGLA_DAEMON_DIR="$DAEMON_DIR" "${DAEMON_DIR}/bin/uglad" state-check --home "$ACTUAL_HOME"; then
        UGLA_DAEMON_DIR="$DAEMON_DIR" "${DAEMON_DIR}/bin/uglad" memory-migrate --home "$ACTUAL_HOME" \
            && UGLA_DAEMON_DIR="$DAEMON_DIR" "${DAEMON_DIR}/bin/uglad" state-check --home "$ACTUAL_HOME" \
            || die "Home Assistant retained memory could not be activated."
    fi
fi


# ── Single-process daemon ─────────────────────────────────────────────
DAEMON_STATUS="not installed"
detail "Installing the uglad single-process daemon (WTFD-3)..."

    # The LLM config lands canonically — `[model]` in ugla-agent.toml + the
    # key (if supplied) in the encrypted vault. Placed after the optional
    # brain import above so an imported ugla-agent.toml keeps its [model]
    # (configure_llm only forces the update when the user explicitly set
    # UGLA_LLM_BASE_URL / UGLA_LLM_MODEL).
    LLM_FORCE=0
    if [[ -n "${UGLA_LLM_BASE_URL:-}${UGLA_LLM_MODEL:-}" ]]; then LLM_FORCE=1; fi
    # Only configure a provider we can actually reach: no key and no explicit
    # override leaves the provider unset for the app to fill in.
    if [[ -z "${UGLA_LLM_KEY:-}" && "$LLM_FORCE" -eq 0 ]]; then
        detail "No model key supplied — leaving the provider unset for the app to fill in"
    else
        LLM_RC=0
        configure_llm "${DAEMON_DIR}/bin/uglad" "$ACTUAL_HOME" "$VAULT_KEYFILE" \
            "${UGLA_LLM_BASE_URL:-https://api.z.ai/api/paas/v4}" \
            "${UGLA_LLM_MODEL:-glm-4.6}" "${UGLA_LLM_KEY:-}" "$LLM_FORCE" || LLM_RC=$?
        case "$LLM_RC" in
            0)
                detail "LLM config written canonically (ugla-agent.toml + vault)"
                ;;
            *)
                die "uglad llm-init failed (exit ${LLM_RC}) without writing any config: the vault write itself failed. Check the keyfile/config state with 'uglad llm-init --help' and re-run; a plaintext .env fallback is not taken (#6562)."
                ;;
        esac
    fi
    if [[ -z "${UGLA_LLM_KEY:-}" ]]; then
        detail "No UGLA_LLM_KEY supplied — add a provider key in the app (or re-run the installer with UGLA_LLM_KEY) to enable agent runs."
    fi

    # The staged self-update file lives under the state dir.
    if [[ -n "${ACTUAL_HOME:-}" ]]; then
        mv -f "${ACTUAL_HOME}/.ugla/wtfd.staged" "${ACTUAL_HOME}/.ugla/uglad.staged" 2>/dev/null || true
    fi

    # ── The agent's sandbox: detected before the first boot ──
    # The daemon composes its tools once at boot, so the prerequisite is
    # checked before the service starts. Detection only — the ordinary
    # installer never elevates or runs a package manager to provision it, so a
    # missing sandbox always leaves a healthy box with the capability
    # unavailable until the explicit host op runs.
    SANDBOX_OUTCOME="$(provision_sandbox)"
    case "$SANDBOX_OUTCOME" in
        present)
            detail "Sandbox already present — the agent has hands on this box."
            ;;
        missing)
            warn "Bubblewrap is not installed, so the agent cannot run commands on this box."
            warn "The box is healthy; an admin can add the capability without a reinstall:"
            warn "    sudo bash ugla-install.sh --host-op install-sandbox"
            ;;
    esac
    BROWSER_SANDBOX_STATE="$(browser_sandbox_state "$(id -un)" "$DAEMON_DIR")"
    if [[ "$BROWSER_SANDBOX_STATE" == "restricted" ]]; then
        warn "This host restricts user namespaces, so the browser engine cannot build its sandbox and stays off."
        warn "The box is healthy; an admin can allow it for the browser alone:"
        warn "    sudo bash ugla-install.sh --host-op allow-browser-sandbox"
    fi

    if [[ "$SERVICE_BACKEND" == "supervisor" ]]; then
        printf '%s\n' "$(boot_persistence_record_json ready "$(id -un)" "$(date +%s)" supervisor "Home Assistant owns App startup and shutdown.")" \
            > "${UGLA_HOME_DIR}/ugla-boot-persistence.json"
        cleanup_status
        exit 0
    fi

    phase "Starting the service"
    HEALTH_URL="$(uglad_public_health_url "$SIDECAR_PORT")"
    NATIVE_ACTIVATION_STARTED=0
    ACTIVATION_RESULT="$("$DAEMON_BINARY" service-activate "${SERVICE_ARGS[@]}")" \
        || die "The installed Ugla service could not be activated." \
               "resolve the reported recovery or startup error, then re-run"
    while read -r prefix checkpoint at; do
        if [[ "$prefix" == "install-timing" && "$at" =~ ^[0-9]+$ ]]; then
            INSTALL_TIMING+=("${checkpoint}=$((at - INSTALL_T0_NS / 1000000))ms")
        fi
    done <<< "$ACTIVATION_RESULT"
    LINGER_RECORD_OUTCOME="$(printf '%s\n' "$ACTIVATION_RESULT" | activation_result_field outcome)"
    # The daemon's bounded host action rides the same record; the summary
    # prints it for an unsupported portable boot instead of a dead variable.
    PORTABLE_BOOT_ACTION="$(printf '%s\n' "$ACTIVATION_RESULT" | activation_result_field action)"
    D_OK=true
    DAEMON_STATUS="running"
    result "The installed Ugla release is answering — ${HEALTH_URL}"

# ── Optional: Tailscale ───────────────────────────────────────────────
# Refused: tailscaled is a privileged host integration the rootless installer
# never performs, and remote access is first-party. The request fails fast
# instead of half-installing.
if [[ "$UGLA_TAILSCALE" == "1" ]]; then
    die "UGLA_TAILSCALE installs and starts the system tailscaled — a privileged host integration the rootless installer (#6311) never performs. Remote access is first-party (turn it on from the app); install Tailscale yourself only if you want it for your own reasons."
fi

# ── Search backend ────────────────────────────────────────────────────
# web_search ships with NO provisioned backend (no Python, no containers,
# one binary); UGLA_SEARXNG_URL in ~/.ugla/.env remains a bring-your-own
# override for operators running their own instance.

# ── First-claim invite ────────────────────────────────────────
# Minted only once the daemon is answering, so the proof's clock starts when
# the box is actually claimable. Best-effort: without it the summary keeps the
# manual key path.
phase "Preparing your phone's invitation"
CLAIM_INVITE=""
CLAIM_ORIGIN=""
CLAIM_QR=""
CLAIM_QR_COLS=""
if $D_OK; then
    if mint_claim_invite "${DAEMON_DIR}/bin/uglad" "${ACTUAL_HOME}"; then
        detail "Scan the invitation in Ugla. Its encrypted link needs no inbound firewall port."
        mark "claim_ready"
    else
        warn "Could not mint a first-claim invite — pair manually with the API key."
    fi
fi
mark "installer_exit"

# ── The ending ────────────────────────────────────────────────
# The claim link is the one big thing; everything else (paths, manual pairing
# key, service recipes) is reference material in install-summary.txt, 0600
# because it holds the API key.
SUMMARY_FILE="${UGLA_HOME_DIR}/install-summary.txt"
write_install_summary "$SUMMARY_FILE"
printf '\n'
if [[ -n "$CLAIM_INVITE" ]]; then
    result "Ugla is running — one thing left:"
    printf '\n'
    show_claim_invite_qr || true
    printf '%s  Claim this box from your phone — open this text link there if you cannot scan:%s\n' "${BOLD}" "$NC"
    printf '%s  %s%s\n' "${BOLD}" "$CLAIM_INVITE" "$NC"
    detail "expires in 30 minutes; a fresh one: ${DAEMON_DIR}/bin/uglad claim-invite --home ${ACTUAL_HOME} --origin ${CLAIM_ORIGIN}"
    printf '\n'
    detail "Paths, the manual pairing key, and service commands are in ${SUMMARY_FILE}"
elif [[ "$DAEMON_STATUS" == "running" ]]; then
    result "Ugla is running"
    printf '\n'
    printf '%s  Pair it from the app — the key it asks for:%s\n' "${BOLD}" "$NC"
    printf '%s  %s%s\n' "${BOLD}" "$API_KEY" "$NC"
    detail "Host: <this machine's address>   Port: ${SIDECAR_PORT}"
    detail "Also in ${SUMMARY_FILE}"
else
    warn "Ugla is installed but not answering yet. Pairing details are in ${SUMMARY_FILE}"
    # The service never became healthy: end unsuccessfully instead of a
    # green summary a rerun cannot make true.
    echo "failed" > "$STATUS_FILE"
    exit 1
fi

# ── Cleanup ───────────────────────────────────────────────────────────
# Silent on purpose: housekeeping never speaks last; the scratch this run
# minted is cleared by the EXIT trap.
echo "done" > "$STATUS_FILE"