jishushell 0.5.15 → 0.6.5

package/install/jishu-install.sh

@@ -166,7 +166,8 @@ JISHU_SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd 2>/dev/null |
 NODE_VERSION="${JISHU_NODE_VERSION:-22}"
 NVM_VERSION="${JISHU_NVM_VERSION:-0.40.4}"
 NOMAD_VERSION="${JISHU_NOMAD_VERSION:-1.6.5}"
-JISHUSHELL_PORT="${JISHUSHELL_PORT:-8090}"
+JISHUSHELL_PORT="${JISHUSHELL_PORT:-8091}"
+JISHUSHELL_PANEL_PORT="${JISHUSHELL_PANEL_PORT:-8090}"
 
 # ──── NPM Registry Configuration ────
 # Pass --registry <url> to override the npm registry for all installs.
@@ -206,6 +207,37 @@ JISHUSHELL_BIN_DIR="${JISHUSHELL_BIN_DIR:-$JISHUSHELL_HOME/bin}"
 # Pick tagline
 TAGLINE=""
 pick_tagline
+JISHUSHELL_PANEL_SERVICE_STARTED=0
+JISHUSHELL_INSTALLED_PACKAGE_DIR="${JISHUSHELL_INSTALLED_PACKAGE_DIR:-}"
+
+jishushell_panel_bundled() {
+    local _pkg_root
+    if [[ -n "${JISHUSHELL_INSTALLED_PACKAGE_DIR:-}" ]]; then
+        [[ -f "${JISHUSHELL_INSTALLED_PACKAGE_DIR}/node_modules/jishushell-panel/package.json" ]] && return 0
+        [[ -f "${JISHUSHELL_INSTALLED_PACKAGE_DIR}/node_modules/jishushell-panel/output/dist/server.js" ]] && return 0
+    fi
+    _pkg_root="$(cd "${JISHU_SCRIPT_DIR}/.." 2>/dev/null && pwd || true)"
+    [[ -n "$_pkg_root" ]] || return 1
+    [[ -f "${_pkg_root}/node_modules/jishushell-panel/package.json" ]] && return 0
+    [[ -f "${_pkg_root}/node_modules/jishushell-panel/output/dist/server.js" ]] && return 0
+    return 1
+}
+
+jishushell_panel_server_path() {
+    local _pkg_root
+    if [[ -n "${JISHUSHELL_INSTALLED_PACKAGE_DIR:-}" ]]; then
+        local _installed_server="${JISHUSHELL_INSTALLED_PACKAGE_DIR}/node_modules/jishushell-panel/output/dist/server.js"
+        if [[ -f "$_installed_server" ]]; then
+            printf '%s\n' "$_installed_server"
+            return 0
+        fi
+    fi
+    _pkg_root="$(cd "${JISHU_SCRIPT_DIR}/.." 2>/dev/null && pwd || true)"
+    [[ -n "$_pkg_root" ]] || return 1
+    local _server="${_pkg_root}/node_modules/jishushell-panel/output/dist/server.js"
+    [[ -f "$_server" ]] || return 1
+    printf '%s\n' "$_server"
+}
 
 # Colors
 BOLD='\033[1m'
@@ -239,6 +271,9 @@ AUTO_YES="${AUTO_YES:-0}"
 DOCKER_CMD_PREFIX=""          # Set to "sg docker -c" when group activated via sg
 DOCKER_GROUP_JUST_ADDED=0     # 1 if usermod was called this run
 DOCKER_USE_SUDO=0             # 1 if sudo docker should be used as fallback
+ENABLE_AUTOLOGIN="${ENABLE_AUTOLOGIN:-0}"   # opt-in: writes /etc/kcpassword
+NO_AUTOLOGIN=0                              # explicit --no-autologin override
+AUTOLOGIN_PASSWORD="${AUTOLOGIN_PASSWORD:-}"  # env-overridable; or --autologin-password
 
 PKG_UPDATED=0
 
@@ -250,17 +285,6 @@ _JISHU_TEE_PID=""
 _JISHU_LOG_FIFO=""
 _JISHU_DETAIL_LOG=""
 
-# Legacy environment variable mapping
-map_legacy_env() {
-    local key="$1"
-    local legacy="$2"
-    if [[ -z "${!key:-}" && -n "${!legacy:-}" ]]; then
-        printf -v "$key" '%s' "${!legacy}"
-    fi
-}
-
-# (legacy env var mappings reserved for future renames)
-
 # ─── UI helpers ───────────────────────────────────────────────────────────────
 ui_info() {
     echo -e "${MUTED}·${NC} $*"
@@ -294,6 +318,12 @@ ui_kv() {
     printf "${MUTED}%-18s${NC} %s\n" "$key:" "$value"
 }
 
+ui_clear_tty_line() {
+    if ( : > /dev/tty ) 2>/dev/null; then
+        printf '\r\033[K' >/dev/tty
+    fi
+}
+
 # ─── Detail-log helpers ───────────────────────────────────────────────────────
 # Appends one line directly to the detail log file (bypasses the terminal pipe).
 log_detail() {
@@ -452,12 +482,16 @@ check_sudo() {
     fi
 
     if ! sudo -n true 2>/dev/null; then
+        ui_clear_tty_line
         ui_info "Some steps require sudo — you may be prompted for your password."
+        if ( : > /dev/tty ) 2>/dev/null; then
+            printf '\r\033[K%s\n' "· Waiting for sudo password; npm progress is paused for this prompt." >/dev/tty
+        fi
         if ! is_promptable; then
             ui_error "Failed to obtain sudo privileges (no interactive TTY available)"
             exit 1
         fi
-        if ! sudo -p "Password: " -v </dev/tty; then
+        if ! sudo -p "Password: " -v </dev/tty >/dev/tty 2>&1; then
             ui_error "Failed to obtain sudo privileges"
             exit 1
         fi
@@ -1088,7 +1122,7 @@ install_docker() {
         local need_brew=0
         local need_profile=0
 
-        if ! command -v docker &>/dev/null || ! command -v colima &>/dev/null; then
+        if [[ "$DOCKER_BIN_FOUND" != "1" || "$COLIMA_BIN_FOUND" != "1" ]]; then
             need_brew=1
             need_profile=1
         elif ! _colima list 2>/dev/null | grep -q "${_COLIMA_PROFILE}"; then
@@ -1104,8 +1138,8 @@ install_docker() {
             ui_info "Starting Colima VM (profile: ${_COLIMA_PROFILE})..."
             mkdir -p "${_COLIMA_HOME}"
             _colima start "${_COLIMA_PROFILE}" \
-                --vm-type vz --mount-type virtiofs \
-                --network-host-addresses --arch aarch64 \
+                --vm-type "${COLIMA_VM_TYPE}" --mount-type virtiofs \
+                --network-host-addresses --arch "${COLIMA_ARCH}" \
                 --activate=false --cpu 2 --memory 4 --disk 60 >/dev/null \
                 || { ui_warn "colima start failed — run 'COLIMA_HOME=${_COLIMA_HOME} colima start ${_COLIMA_PROFILE}' manually"; return 1; }
             export DOCKER_HOST="unix://${_COLIMA_SOCKET}"
@@ -1179,7 +1213,11 @@ install_docker() {
 
 _do_install_docker() {
     if [[ "$DRY_RUN" == "1" ]]; then
-        ui_info "[dry-run] Would install Docker via get.docker.com"
+        if [[ "$OS" == "macos" ]]; then
+            ui_info "[dry-run] Would install docker and colima via Homebrew"
+        else
+            ui_info "[dry-run] Would install Docker via get.docker.com"
+        fi
         return 0
     fi
 
@@ -1194,8 +1232,8 @@ _do_install_docker() {
         mkdir -p "${_COLIMA_HOME}"
         ui_info "Starting Colima VM (profile: ${_COLIMA_PROFILE})..."
         _colima start "${_COLIMA_PROFILE}" \
-            --vm-type vz --mount-type virtiofs \
-            --network-host-addresses --arch aarch64 \
+            --vm-type "${COLIMA_VM_TYPE}" --mount-type virtiofs \
+            --network-host-addresses --arch "${COLIMA_ARCH}" \
             --activate=false --cpu 2 --memory 4 --disk 60 >/dev/null \
             || { ui_warn "colima start failed — run 'COLIMA_HOME=${_COLIMA_HOME} colima start ${_COLIMA_PROFILE}' manually"; return 1; }
         ui_success "Colima is running"
@@ -1357,12 +1395,12 @@ _ensure_docker_running() {
 
     if [[ "$OS" == "macos" ]]; then
         export DOCKER_HOST="unix://${_COLIMA_SOCKET}"
-        if ! docker info &>/dev/null 2>&1; then
+        if ! _docker info &>/dev/null 2>&1; then
             ui_info "Starting Colima VM..."
             mkdir -p "${_COLIMA_HOME}"
             if ! _colima start "${_COLIMA_PROFILE}" \
-                --vm-type vz --mount-type virtiofs \
-                --network-host-addresses --arch aarch64 \
+                --vm-type "${COLIMA_VM_TYPE}" --mount-type virtiofs \
+                --network-host-addresses --arch "${COLIMA_ARCH}" \
                 --activate=false --cpu 2 --memory 4 --disk 60 >/dev/null; then
                 ui_warn "colima start failed"
                 ui_info "Run manually: COLIMA_HOME=${_COLIMA_HOME} colima start ${_COLIMA_PROFILE}"
@@ -1371,7 +1409,7 @@ _ensure_docker_running() {
         fi
         local waited=0
         local timeout=120
-        while ! docker info &>/dev/null 2>&1; do
+        while ! _docker info &>/dev/null 2>&1; do
             if [[ $waited -ge $timeout ]]; then
                 ui_warn "Docker daemon did not become ready within ${timeout} seconds"
                 ui_info "Run: COLIMA_HOME=${_COLIMA_HOME} colima status ${_COLIMA_PROFILE}"
@@ -1526,9 +1564,47 @@ docker_exec() {
 _COLIMA_HOME="${JISHUSHELL_HOME}/colima"
 _COLIMA_PROFILE="jishushell"
 _COLIMA_SOCKET="${_COLIMA_HOME}/${_COLIMA_PROFILE}/docker.sock"
+# jishushell on macOS supports Apple Silicon (arm64) ONLY. Fail fast on
+# Intel/other so third-party users get a clear message instead of an
+# obscure colima failure. NOTE: $OS is not set yet at script-load time
+# (detect_os runs later), so gate on `uname -s` directly, not $OS.
+if [[ "$(uname -s)" == "Darwin" ]]; then
+    case "$(uname -m)" in
+        arm64|aarch64) : ;;
+        *)
+            ui_error "jishushell on macOS supports Apple Silicon (arm64) only — detected $(uname -m). Installation aborted."
+            exit 1
+            ;;
+    esac
+fi
+COLIMA_ARCH="aarch64"
+COLIMA_VM_TYPE="vz"
+# colima binary: prefer PATH, fall back to both Homebrew prefixes.
+COLIMA_BIN="$(command -v colima 2>/dev/null || true)"
+[[ -z "$COLIMA_BIN" && -x /opt/homebrew/bin/colima ]] && COLIMA_BIN="/opt/homebrew/bin/colima"
+[[ -z "$COLIMA_BIN" && -x /usr/local/bin/colima ]] && COLIMA_BIN="/usr/local/bin/colima"
+COLIMA_BIN_FOUND=1
+[[ -z "$COLIMA_BIN" ]] && COLIMA_BIN_FOUND=0 && COLIMA_BIN="colima"
+DOCKER_BIN="$(PATH="/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin${PATH:+:${PATH}}" command -v docker 2>/dev/null || true)"
+[[ -z "$DOCKER_BIN" && -x /opt/homebrew/bin/docker ]] && DOCKER_BIN="/opt/homebrew/bin/docker"
+[[ -z "$DOCKER_BIN" && -x /usr/local/bin/docker ]] && DOCKER_BIN="/usr/local/bin/docker"
+DOCKER_BIN_FOUND=1
+[[ -z "$DOCKER_BIN" ]] && DOCKER_BIN_FOUND=0 && DOCKER_BIN="docker"
+COLIMA_STD_PATH="/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin"
 
 _colima() {
-    COLIMA_HOME="${_COLIMA_HOME}" command colima "$@"
+    # Use the resolved COLIMA_BIN path — non-interactive shells (launchd
+    # wrappers, sshd) routinely lack /opt/homebrew/bin in PATH, so a bare
+    # `command colima` falls back to "not found" even when colima is fully
+    # installed at /opt/homebrew/bin/colima.
+    PATH="${COLIMA_STD_PATH}${PATH:+:${PATH}}" \
+        COLIMA_HOME="${_COLIMA_HOME}" \
+        "${COLIMA_BIN:-colima}" "$@"
+}
+
+_docker() {
+    PATH="${COLIMA_STD_PATH}${PATH:+:${PATH}}" \
+        "${DOCKER_BIN:-docker}" "$@"
 }
 
 # ─── 3. Nomad ────────────────────────────────────────────────────────────────
@@ -1999,6 +2075,20 @@ _port_is_listening() {
     fi
 }
 
+_wait_for_port() {
+    local port="$1"
+    local timeout="${2:-15}"
+    local waited=0
+    while (( waited < timeout )); do
+        if _port_is_listening "$port"; then
+            return 0
+        fi
+        sleep 1
+        waited=$(( waited + 1 ))
+    done
+    return 1
+}
+
 # Write nomad.hcl if it does not already exist.
 # Safe to call multiple times — never overwrites an existing config.
 _ensure_nomad_hcl() {
@@ -2073,6 +2163,9 @@ ${external_host_network_block}
 plugin "docker" {
   config {
     disable_log_collection = true
+        gc {
+            image = false
+        }
     volumes {
       enabled = true
     }
@@ -2236,6 +2329,8 @@ WantedBy=multi-user.target"
         ${SUDO} mv /tmp/nomad.service.$$ "$svc_path"
         need_reload=1
     fi
+    ${SUDO} chown root:root "$svc_path" 2>/dev/null || true
+    ${SUDO} chmod 644 "$svc_path" 2>/dev/null || true
 
     # Keep the real user owning ~/.jishushell except for Nomad's own state,
     # which must be root-owned because the agent runs as root for driver fingerprinting.
@@ -2260,12 +2355,86 @@ WantedBy=multi-user.target"
 # Without this, after every Mac reboot the user has to run `colima start
 # jishushell` manually, and Nomad (started earlier by launchd) caches
 # docker.Healthy=False because docker is not yet reachable.
+# Wrapper invoked by the colima launchd plist. Serializes concurrent
+# starts, waits for the network, clears unclean-shutdown residue WITHOUT
+# deleting the VM, then retries `colima start` until the managed docker
+# socket answers. Mirrors _install_nomad_wait_docker_wrapper's style.
+_install_colima_wait_start_wrapper() {
+    local wrapper="${JISHUSHELL_BIN_DIR}/colima-launchd-wrapper.sh"
+    mkdir -p "${JISHUSHELL_BIN_DIR}"
+    cat > "$wrapper" << WRAPPER
+#!/bin/bash
+# Auto-generated by jishu-install.sh — do not edit by hand.
+set -u
+export COLIMA_HOME="${_COLIMA_HOME}"
+export PATH="/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
+COLIMA_BIN="${COLIMA_BIN}"
+PROFILE="${_COLIMA_PROFILE}"
+SOCK="${_COLIMA_SOCKET}"
+LOCKDIR="${_COLIMA_HOME}/.colima-launchd.lock.d"
+
+# Ensure the colima home exists (launchd runs us at boot, independently).
+mkdir -p "\$COLIMA_HOME"
+
+# Reclaim a stale lock orphaned by SIGKILL/power-cut (mkdir-lock has no
+# owner; rmdir only removes it if still empty — safe).
+[ -d "\$LOCKDIR" ] && find "\$LOCKDIR" -maxdepth 0 -type d -mmin +10 -exec rmdir {} \\; 2>/dev/null || true
+
+# Single-flight via atomic mkdir (POSIX-atomic, dependency-free, stock macOS
+# compatible). If the lock dir already exists, another start is in progress —
+# exit 0.
+if ! mkdir "\$LOCKDIR" 2>/dev/null; then
+  echo "[colima-wrapper] another start in progress; exiting" >&2
+  exit 0
+fi
+trap 'rmdir "\$LOCKDIR" 2>/dev/null || true' EXIT
+
+docker_ok() { DOCKER_HOST="unix://\$SOCK" /usr/bin/env docker info >/dev/null 2>&1; }
+
+# Already up → idempotent no-op.
+if docker_ok; then echo "[colima-wrapper] docker already reachable" >&2; exit 0; fi
+
+# Wait up to 60s for the network (--network-host-addresses needs en0 up).
+net_deadline=\$(( \$(date +%s) + 60 ))
+while ! /sbin/ifconfig en0 2>/dev/null | grep -q "inet "; do
+  [ \$(date +%s) -ge \$net_deadline ] && break
+  sleep 2
+done
+
+# Unclean-shutdown residue: stop a half-broken VM, but NEVER delete it
+# (delete destroys the openclaw image and all VM data).
+status="\$("\$COLIMA_BIN" status "\$PROFILE" 2>&1 || true)"
+if echo "\$status" | grep -qiE 'broken|cannot|error'; then
+  echo "[colima-wrapper] stale state detected; stopping (never deleting)" >&2
+  "\$COLIMA_BIN" stop "\$PROFILE" >/dev/null 2>&1 || true
+fi
+
+# Retry start with backoff until docker answers (~5 attempts).
+attempt=0
+while [ \$attempt -lt 5 ]; do
+  # Refresh our own lock mtime each attempt so a long (>budget) legit
+  # start is never reclaimed as stale by a concurrent launchd fire.
+  touch "\$LOCKDIR" 2>/dev/null || true
+  attempt=\$(( attempt + 1 ))
+  echo "[colima-wrapper] colima start attempt \$attempt" >&2
+  "\$COLIMA_BIN" start "\$PROFILE" \\
+    --vm-type ${COLIMA_VM_TYPE} --mount-type virtiofs \\
+    --network-host-addresses --arch ${COLIMA_ARCH} --activate=false \\
+    --cpu 2 --memory 4 --disk 60 >/dev/null 2>&1 || true
+  docker_ok && { echo "[colima-wrapper] docker reachable" >&2; exit 0; }
+  sleep \$(( attempt * 10 ))
+done
+echo "[colima-wrapper] exhausted retries; docker still unreachable" >&2
+exit 1
+WRAPPER
+    chmod 755 "$wrapper"
+    echo "$wrapper"
+}
+
 _install_colima_launchd() {
     local plist_label="com.jishushell.colima"
     local plist_path="${HOME}/Library/LaunchAgents/${plist_label}.plist"
     local log_path="${JISHUSHELL_HOME}/colima/colima-launchd.log"
-    local colima_bin
-    colima_bin="$(command -v colima 2>/dev/null || echo /opt/homebrew/bin/colima)"
 
     if [[ "$DRY_RUN" == "1" ]]; then
         ui_info "[dry-run] Would install launchd agent: ${plist_path}"
@@ -2274,12 +2443,9 @@ _install_colima_launchd() {
 
     mkdir -p "${HOME}/Library/LaunchAgents" "${JISHUSHELL_HOME}/colima"
 
-    # `colima start` exits cleanly once the VM is up, so KeepAlive must be
-    # false — otherwise launchd restarts colima start in an infinite loop.
-    # The flags here mirror the ones jishushell itself uses on first install
-    # (network-host-addresses + arch aarch64), so a relaunched VM gets the
-    # same network config; --activate=false keeps the user's docker context
-    # selection in ~/.docker/config.json untouched.
+    local colima_wrapper
+    colima_wrapper="$(_install_colima_wait_start_wrapper)"
+
     cat > "$plist_path" << PLIST
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -2289,17 +2455,7 @@ _install_colima_launchd() {
     <string>${plist_label}</string>
     <key>ProgramArguments</key>
     <array>
-        <string>${colima_bin}</string>
-        <string>start</string>
-        <string>${_COLIMA_PROFILE}</string>
-        <string>--vm-type</string><string>vz</string>
-        <string>--mount-type</string><string>virtiofs</string>
-        <string>--network-host-addresses</string>
-        <string>--arch</string><string>aarch64</string>
-        <string>--activate=false</string>
-        <string>--cpu</string><string>2</string>
-        <string>--memory</string><string>4</string>
-        <string>--disk</string><string>60</string>
+        <string>${colima_wrapper}</string>
     </array>
     <key>EnvironmentVariables</key>
     <dict>
@@ -2311,7 +2467,12 @@ _install_colima_launchd() {
     <key>RunAtLoad</key>
     <true/>
     <key>KeepAlive</key>
-    <false/>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+    </dict>
+    <key>ThrottleInterval</key>
+    <integer>30</integer>
     <key>StandardOutPath</key>
     <string>${log_path}</string>
     <key>StandardErrorPath</key>
@@ -2322,7 +2483,7 @@ PLIST
 
     launchctl unload "$plist_path" 2>/dev/null || true
     if launchctl load -w "$plist_path" 2>/dev/null; then
-        ui_success "Colima launchd agent installed (auto-start at login)"
+        ui_success "Colima launchd agent installed (self-retrying, auto-start at login)"
     else
         ui_warn "Could not load colima launchd agent"
     fi
@@ -2435,7 +2596,7 @@ PLIST
 
 _save_openclaw_image_to_panel() {
     local image="$1"
-    local panel_file="${JISHUSHELL_HOME}/panel.json"
+    local panel_file="${JISHUSHELL_HOME}/core.json"
     node -e "
 const fs = require('fs');
 const p = '${panel_file}';
@@ -2448,7 +2609,7 @@ fs.writeFileSync(p, JSON.stringify(cfg, null, 2));
 }
 
 _read_openclaw_image_from_panel() {
-    local panel_file="${JISHUSHELL_HOME}/panel.json"
+    local panel_file="${JISHUSHELL_HOME}/core.json"
     node -e "
 const fs = require('fs');
 const p = '${panel_file}';
@@ -2575,7 +2736,7 @@ install_openclaw() {
 
     # ── Step 2: Reuse the currently configured pinned image if it already
     # exists locally. This avoids re-pulling :latest on machines where the
-    # running JishuShell service has already migrated panel.json from a mutable
+    # running JishuShell service has already migrated core.json from a mutable
     # tag (e.g. :latest) to an immutable version tag (e.g. :2026.4.9).
     configured_tag="$(_read_openclaw_image_from_panel)"
     if [[ -n "${configured_tag}" ]] && docker_exec image inspect "${configured_tag}" &>/dev/null 2>&1; then
@@ -2692,6 +2853,27 @@ jishushell_package_spec() {
     printf 'jishushell'
 }
 
+find_local_jishushell_tgz() {
+    [[ "${JISHUSHELL_VERSION_OVERRIDE}" != "1" && "${JISHUSHELL_NPM_VERSION}" == "latest" ]] || return 1
+
+    local _candidate
+    for _candidate in "${JISHU_SCRIPT_DIR}"/jishushell-gui-*.tgz "${JISHU_SCRIPT_DIR}"/jishushell-cli-*.tgz "${JISHU_SCRIPT_DIR}"/jishushell-*.tgz; do
+        [[ -f "$_candidate" ]] || continue
+        printf '%s\n' "$_candidate"
+        return 0
+    done
+    return 1
+}
+
+jishushell_package_name_from_spec() {
+    local _spec="${1:-}"
+    case "$_spec" in
+        jishushell-gui|jishushell-gui@*|*/jishushell-gui-*.tgz) printf 'jishushell-gui' ;;
+        jishushell|jishushell@*|*/jishushell-*.tgz) printf 'jishushell' ;;
+        *) printf 'jishushell' ;;
+    esac
+}
+
 # show_install_plan [--with-jishushell]
 show_install_plan() {
     local with_jishushell=0
@@ -2717,11 +2899,8 @@ show_install_plan() {
             _plan_jishu="skip"
         else
             local _plan_tgz=""
-            if [[ "${JISHUSHELL_VERSION_OVERRIDE}" != "1" && "${JISHUSHELL_NPM_VERSION}" == "latest" ]]; then
-                for _c in "${JISHU_SCRIPT_DIR}"/jishushell-*.tgz; do
-                    [[ -f "$_c" ]] && { _plan_tgz="$(basename "$_c")"; break; }
-                done
-            fi
+            _plan_tgz="$(find_local_jishushell_tgz 2>/dev/null || true)"
+            [[ -n "$_plan_tgz" ]] && _plan_tgz="$(basename "$_plan_tgz")"
             _plan_jishu="${_plan_tgz:+npm install -g ${_plan_tgz} (local)}${_plan_tgz:-npm install -g $(jishushell_package_spec)}"
         fi
         ui_kv "JishuShell"         "$_plan_jishu"
@@ -2802,7 +2981,7 @@ show_summary() {
     fi
 
     if [[ $with_jishushell -eq 1 && $SKIP_JISHUSHELL -eq 0 ]]; then
-        local _wrapper="${JISHUSHELL_BIN_DIR}/jishushell-panel-start"
+        local _wrapper="${JISHUSHELL_BIN_DIR}/jishushell-core-start"
         if [[ -x "$_wrapper" ]]; then
             ui_kv "JishuShell" "✓ ${_wrapper}"
         elif command -v jishushell &>/dev/null; then
@@ -2834,6 +3013,10 @@ show_summary() {
         echo ""
         ui_kv "Log file" "${JISHU_LOG_FILE}"
     fi
+    if [[ $with_jishushell -eq 1 && $SKIP_JISHUSHELL -eq 0 ]] && jishushell_panel_bundled; then
+        echo ""
+        echo -e "${WARN}${BOLD}If JishuShell is already open in a browser, refresh the page to load the updated web UI.${NC}"
+    fi
     echo ""
     if [[ $all_ok -eq 1 && $with_jishushell -eq 1 && $SKIP_JISHUSHELL -eq 0 ]]; then
         # Detect the primary non-loopback LAN IP address.
@@ -2859,15 +3042,47 @@ show_summary() {
             fi
         fi
 
-        echo -e "${SUCCESS}${BOLD}  ╔══════════════════════════════════════════════════════╗${NC}"
-        echo -e "${SUCCESS}${BOLD}  ║  Installation complete!                              ║${NC}"
-        echo -e "${SUCCESS}${BOLD}  ║                                                      ║${NC}"
-        echo -e "${SUCCESS}${BOLD}  ║  Open your browser and navigate to:                  ║${NC}"
-        echo -e "${SUCCESS}${BOLD}  ║    http://localhost:${JISHUSHELL_PORT}/$(printf '%*s' $((32 - ${#JISHUSHELL_PORT})) '')║${NC}"
+        local _box_width=54
+        local _box_lines=(
+            "  Installation complete!"
+            ""
+            "  Core server is available at:"
+            "    http://localhost:${JISHUSHELL_PORT}/"
+        )
         if [[ -n "$_local_ip" ]]; then
-        echo -e "${SUCCESS}${BOLD}  ║    http://${_local_ip}:${JISHUSHELL_PORT}/$(printf '%*s' $((28 - ${#_local_ip} - ${#JISHUSHELL_PORT})) '')║${NC}"
+            _box_lines+=("    http://${_local_ip}:${JISHUSHELL_PORT}/")
         fi
-        echo -e "${SUCCESS}${BOLD}  ╚══════════════════════════════════════════════════════╝${NC}"
+        if jishushell_panel_bundled; then
+            local _panel_label="  Panel web UI service:"
+            if [[ "$JISHUSHELL_PANEL_SERVICE_STARTED" != "1" ]]; then
+                _panel_label="  Panel web UI (run jishushell-gui):"
+            fi
+            _box_lines+=(
+                ""
+                "$_panel_label"
+                "    http://localhost:${JISHUSHELL_PANEL_PORT}/"
+            )
+            if [[ -n "$_local_ip" ]]; then
+                _box_lines+=("    http://${_local_ip}:${JISHUSHELL_PANEL_PORT}/")
+            fi
+        fi
+
+        local _box_line
+        for _box_line in "${_box_lines[@]}"; do
+            if (( ${#_box_line} > _box_width )); then
+                _box_width=${#_box_line}
+            fi
+        done
+
+        local _box_border
+        printf -v _box_border '%*s' "$_box_width" ''
+        _box_border="${_box_border// /═}"
+
+        printf '%b  ╔%s╗%b\n' "${SUCCESS}${BOLD}" "$_box_border" "${NC}"
+        for _box_line in "${_box_lines[@]}"; do
+            printf "%b  ║%-${_box_width}s║%b\n" "${SUCCESS}${BOLD}" "$_box_line" "${NC}"
+        done
+        printf '%b  ╚%s╝%b\n' "${SUCCESS}${BOLD}" "$_box_border" "${NC}"
         echo ""
     fi
 }
@@ -2876,7 +3091,7 @@ show_summary() {
 # Core install orchestration
 # ═══════════════════════════════════════════════════════════════════════════════
 
-# ─── 6. JishuShell backend (npm install -g jishushell) ───────────────────────
+# ─── 6. JishuShell core package (CLI-only or Core+Panel GUI) ──────────────────
 
 install_jishushell() {
     ui_stage "JishuShell"
@@ -2892,17 +3107,16 @@ install_jishushell() {
         local _dry_reg=""
         [[ -n "${NPM_REGISTRY:-}" ]] && _dry_reg=" --registry ${NPM_REGISTRY}"
         local _dry_tgz=""
-        if [[ "${JISHUSHELL_VERSION_OVERRIDE}" != "1" && "${JISHUSHELL_NPM_VERSION}" == "latest" ]]; then
-            for _c in "${JISHU_SCRIPT_DIR}"/jishushell-*.tgz; do
-                [[ -f "$_c" ]] && { _dry_tgz="$_c"; break; }
-            done
-        fi
+        _dry_tgz="$(find_local_jishushell_tgz 2>/dev/null || true)"
         if [[ -n "$_dry_tgz" ]]; then
             ui_info "[dry-run] Would: npm install -g ${_dry_tgz}  (local package)"
         else
             ui_info "[dry-run] Would: npm install -g ${jishushell_pkg_spec}${_dry_reg}"
         fi
-        ui_info "[dry-run] Would write wrapper: ${JISHUSHELL_BIN_DIR}/jishushell-panel-start"
+        ui_info "[dry-run] Would write wrapper: ${JISHUSHELL_BIN_DIR}/jishushell-core-start"
+        if jishushell_panel_bundled || [[ "$(basename "${_dry_tgz:-}")" == jishushell-gui-*.tgz ]]; then
+            ui_info "[dry-run] Would write wrapper: ${JISHUSHELL_BIN_DIR}/jishushell-panel-start"
+        fi
         return 0
     fi
 
@@ -2947,22 +3161,17 @@ install_jishushell() {
 
     # When jishushell is already installed (e.g. running as npm postinstall hook),
     # skip the npm install step and only write the wrapper + service.
+    local tgz_path=""
+    local expected_pkg_name
     if [[ "${JISHUSHELL_SKIP_NPM_INSTALL:-0}" != "1" ]]; then
         # Prefer a local .tgz package in the same directory as this script.
-        local tgz_path=""
-        local _tgz_candidate
-        if [[ "${JISHUSHELL_VERSION_OVERRIDE}" != "1" && "${JISHUSHELL_NPM_VERSION}" == "latest" ]]; then
-            for _tgz_candidate in "${JISHU_SCRIPT_DIR}"/jishushell-*.tgz; do
-                if [[ -f "$_tgz_candidate" ]]; then
-                    tgz_path="$_tgz_candidate"
-                    break
-                fi
-            done
-        fi
+        tgz_path="$(find_local_jishushell_tgz 2>/dev/null || true)"
+        expected_pkg_name="$(jishushell_package_name_from_spec "${tgz_path:-$jishushell_pkg_spec}")"
 
         # Export a sentinel so post-install.sh (triggered by npm's postinstall
-        # lifecycle hook) knows it was launched from inside jishu-install.sh and
-        # must not re-run Docker/Nomad/OpenClaw installation steps again.
+        # lifecycle hook) knows it was launched from inside jishu-install.sh.
+        # The parent installer resumes after npm returns and owns wrapper/service
+        # setup, which keeps core and panel startup ordering in one place.
         export JISHU_RUNNING_IN_INSTALLER=1
 
         if [[ -n "$tgz_path" ]]; then
@@ -2990,6 +3199,10 @@ install_jishushell() {
         unset JISHU_RUNNING_IN_INSTALLER
     else
         ui_info "Skipping npm install (already installed by caller)"
+        local current_pkg_root current_pkg_name
+        current_pkg_root="$(cd "${JISHU_SCRIPT_DIR}/.." 2>/dev/null && pwd || true)"
+        current_pkg_name="$("$node_bin" -p "require('${current_pkg_root}/package.json').name" 2>/dev/null || true)"
+        expected_pkg_name="$(jishushell_package_name_from_spec "${current_pkg_name:-$jishushell_pkg_spec}")"
     fi
 
     # Resolve the installed cli.js path via the npm that did the install
@@ -2999,9 +3212,27 @@ install_jishushell() {
         ui_error "Cannot locate npm root — wrapper cannot be written"
         return 1
     fi
-    local jishushell_bin="${npm_root}/jishushell/dist/cli.js"
-    ui_success "JishuShell installed ($(${node_bin} -p "require('${npm_root}/jishushell/package.json').version" 2>/dev/null || echo 'version unknown'))"
-    local wrapper="${JISHUSHELL_BIN_DIR}/jishushell-panel-start"
+    local jishushell_pkg_dir="${npm_root}/${expected_pkg_name:-jishushell}"
+    if [[ ! -f "${jishushell_pkg_dir}/dist/cli.js" ]]; then
+        if [[ -f "${npm_root}/jishushell/dist/cli.js" ]]; then
+            jishushell_pkg_dir="${npm_root}/jishushell"
+        elif [[ -f "${npm_root}/jishushell-cli/dist/cli.js" ]]; then
+            # Legacy package name from the brief 'jishushell-cli' split-era
+            jishushell_pkg_dir="${npm_root}/jishushell-cli"
+        elif [[ -f "${npm_root}/jishushell-gui/dist/cli.js" ]]; then
+            # Legacy GUI package name from before the 'jishushell' rename
+            jishushell_pkg_dir="${npm_root}/jishushell-gui"
+        fi
+    fi
+    local jishushell_bin="${jishushell_pkg_dir}/dist/cli.js"
+    if [[ ! -f "$jishushell_bin" ]]; then
+        ui_error "Cannot locate installed JishuShell CLI entrypoint in ${npm_root}"
+        return 1
+    fi
+    JISHUSHELL_INSTALLED_PACKAGE_DIR="$jishushell_pkg_dir"
+    ui_success "JishuShell CLI installed ($(${node_bin} -p "require('${jishushell_pkg_dir}/package.json').version" 2>/dev/null || echo 'version unknown'))"
+    local wrapper="${JISHUSHELL_BIN_DIR}/jishushell-core-start"
+    local cli_wrapper="${JISHUSHELL_BIN_DIR}/jishushell"
     mkdir -p "${JISHUSHELL_BIN_DIR}"
 
     # The wrapper resolves node at runtime — it does NOT hardcode the path so
@@ -3010,6 +3241,28 @@ install_jishushell() {
 #!/usr/bin/env bash
 set -euo pipefail
 
+_WRAPPER_PATH="\${BASH_SOURCE[0]:-\$0}"
+_WRAPPER_DIR="\$(cd "\$(dirname "\$_WRAPPER_PATH")" && pwd)"
+_DEFAULT_JISHUSHELL_HOME="\$(cd "\${_WRAPPER_DIR}/.." && pwd)"
+JISHUSHELL_HOME="\${JISHUSHELL_HOME:-\$_DEFAULT_JISHUSHELL_HOME}"
+
+_resolve_home() {
+    if [ -n "\${SUDO_UID:-}" ] && command -v getent >/dev/null 2>&1; then
+        local _entry
+        _entry="\$(getent passwd "\$SUDO_UID" 2>/dev/null || true)"
+        if [ -n "\$_entry" ]; then
+            printf '%s\n' "\$_entry" | cut -d: -f6
+            return
+        fi
+    fi
+    case "\$JISHUSHELL_HOME" in
+        */.jishushell) printf '%s\n' "\${JISHUSHELL_HOME%/.jishushell}" ;;
+        *) printf '%s\n' "\${HOME:-\$PWD}" ;;
+    esac
+}
+HOME="\$(_resolve_home)"
+export HOME JISHUSHELL_HOME
+
 _find_node() {
     command -v node 2>/dev/null && return
     local nvm_dir="\${NVM_DIR:-\${HOME}/.nvm}"
@@ -3023,48 +3276,343 @@ if [ -z "\$NODE_BIN" ]; then
     NODE_BIN="/opt/homebrew/bin/node"
 fi
 if [ ! -x "\$NODE_BIN" ]; then
-    echo "[jishushell-panel-start] ERROR: cannot locate node binary" >&2
+    echo "[jishushell-core-start] ERROR: cannot locate node binary" >&2
     exit 1
 fi
 
-# Data directory: honour explicit env override, otherwise use the real
-# user home embedded at install time (avoids /root when run as root).
-JISHUSHELL_HOME="\${JISHUSHELL_HOME:-${REAL_HOME}/.jishushell}"
 NOMAD_ENV="\${JISHUSHELL_HOME}/nomad.env"
 
 [ -f "\$NOMAD_ENV" ] && source "\$NOMAD_ENV"
 
 if [ ! -f "${jishushell_bin}" ]; then
-    echo "[jishushell-panel-start] ERROR: could not find jishushell at ${jishushell_bin}" >&2
+    echo "[jishushell-core-start] ERROR: could not find jishushell at ${jishushell_bin}" >&2
     exit 1
 fi
 
-exec "\$NODE_BIN" "${jishushell_bin}" "\$@"
+export JISHUSHELL_CORE_BIN="${jishushell_bin}"
+export JISHUSHELL_CORE_PORT=${JISHUSHELL_PORT}
+export NODE_ENV="\${NODE_ENV:-production}"
+if command -v ss >/dev/null 2>&1 && ss -tln 2>/dev/null | grep -Eq '(^|[[:space:]])[^[:space:]]*:${JISHUSHELL_PORT}[[:space:]]'; then
+    echo "JishuShell core port ${JISHUSHELL_PORT} is already listening; not starting another core."
+    exit 0
+fi
+exec "\$NODE_BIN" "${jishushell_bin}" serve --core-only --port ${JISHUSHELL_PORT}
 WRAPPER
     chmod +x "$wrapper"
-    ui_success "JishuShell installed — wrapper: ${wrapper}"
+    rm -f "$cli_wrapper"
+    cat > "$cli_wrapper" << CLIWRAPPER
+#!/usr/bin/env bash
+set -euo pipefail
+
+_WRAPPER_PATH="\${BASH_SOURCE[0]:-\$0}"
+_WRAPPER_DIR="\$(cd "\$(dirname "\$_WRAPPER_PATH")" && pwd)"
+_DEFAULT_JISHUSHELL_HOME="\$(cd "\${_WRAPPER_DIR}/.." && pwd)"
+JISHUSHELL_HOME="\${JISHUSHELL_HOME:-\$_DEFAULT_JISHUSHELL_HOME}"
+
+_resolve_home() {
+    if [ -n "\${SUDO_UID:-}" ] && command -v getent >/dev/null 2>&1; then
+        local _entry
+        _entry="\$(getent passwd "\$SUDO_UID" 2>/dev/null || true)"
+        if [ -n "\$_entry" ]; then
+            printf '%s\n' "\$_entry" | cut -d: -f6
+            return
+        fi
+    fi
+    case "\$JISHUSHELL_HOME" in
+        */.jishushell) printf '%s\n' "\${JISHUSHELL_HOME%/.jishushell}" ;;
+        *) printf '%s\n' "\${HOME:-\$PWD}" ;;
+    esac
+}
+HOME="\$(_resolve_home)"
+export HOME JISHUSHELL_HOME
+
+_find_node() {
+    command -v node 2>/dev/null && return
+    local nvm_dir="\${NVM_DIR:-\${HOME}/.nvm}"
+    [ -s "\$nvm_dir/nvm.sh" ] && . "\$nvm_dir/nvm.sh" --no-use 2>/dev/null || true
+    command -v node 2>/dev/null && return
+    local ndir="\${HOME}/.nvm/versions/node"
+    [ -d "\$ndir" ] && find "\$ndir" -name node -type f 2>/dev/null | sort -V | tail -1 || true
+}
+NODE_BIN="\$(_find_node || true)"
+if [ -z "\$NODE_BIN" ]; then
+    NODE_BIN="/opt/homebrew/bin/node"
+fi
+if [ ! -x "\$NODE_BIN" ]; then
+    echo "[jishushell] ERROR: cannot locate node binary" >&2
+    exit 1
+fi
+
+NOMAD_ENV="\${JISHUSHELL_HOME}/nomad.env"
+
+[ -f "\$NOMAD_ENV" ] && source "\$NOMAD_ENV"
+
+if [ ! -f "${jishushell_bin}" ]; then
+    echo "[jishushell] ERROR: could not find jishushell at ${jishushell_bin}" >&2
+    exit 1
+fi
+
+export JISHUSHELL_CORE_BIN="${jishushell_bin}"
+export JISHUSHELL_CORE_PORT=${JISHUSHELL_PORT}
+export NODE_ENV="\${NODE_ENV:-production}"
+exec "\$NODE_BIN" "${jishushell_bin}" "\$@"
+CLIWRAPPER
+    chmod +x "$cli_wrapper"
+ui_success "JishuShell installed — wrapper: ${wrapper}"
+
+if jishushell_panel_bundled; then
+        local panel_server
+        if ! panel_server="$(jishushell_panel_server_path)"; then
+            ui_warn "Panel package detected, but server entrypoint was not found"
+            return 0
+        fi
+        local panel_manage_core_default="${JISHUSHELL_PANEL_MANAGE_CORE_DEFAULT:-0}"
+        if [[ "$panel_manage_core_default" != "1" ]]; then
+            panel_manage_core_default="0"
+        fi
+        local panel_wrapper="${JISHUSHELL_BIN_DIR}/jishushell-panel-start"
+        cat > "$panel_wrapper" << PANELWRAPPER
+#!/usr/bin/env bash
+set -euo pipefail
+
+_WRAPPER_PATH="\${BASH_SOURCE[0]:-\$0}"
+_WRAPPER_DIR="\$(cd "\$(dirname "\$_WRAPPER_PATH")" && pwd)"
+_DEFAULT_JISHUSHELL_HOME="\$(cd "\${_WRAPPER_DIR}/.." && pwd)"
+JISHUSHELL_HOME="\${JISHUSHELL_HOME:-\$_DEFAULT_JISHUSHELL_HOME}"
+
+_resolve_home() {
+    if [ -n "\${SUDO_UID:-}" ] && command -v getent >/dev/null 2>&1; then
+        local _entry
+        _entry="\$(getent passwd "\$SUDO_UID" 2>/dev/null || true)"
+        if [ -n "\$_entry" ]; then
+            printf '%s\n' "\$_entry" | cut -d: -f6
+            return
+        fi
+    fi
+    case "\$JISHUSHELL_HOME" in
+        */.jishushell) printf '%s\n' "\${JISHUSHELL_HOME%/.jishushell}" ;;
+        *) printf '%s\n' "\${HOME:-\$PWD}" ;;
+    esac
+}
+HOME="\$(_resolve_home)"
+export HOME JISHUSHELL_HOME
+
+_find_node() {
+    command -v node 2>/dev/null && return
+    local nvm_dir="\${NVM_DIR:-\${HOME}/.nvm}"
+    [ -s "\$nvm_dir/nvm.sh" ] && . "\$nvm_dir/nvm.sh" --no-use 2>/dev/null || true
+    command -v node 2>/dev/null && return
+    local ndir="\${HOME}/.nvm/versions/node"
+    [ -d "\$ndir" ] && find "\$ndir" -name node -type f 2>/dev/null | sort -V | tail -1 || true
+}
+NODE_BIN="\$(_find_node || true)"
+if [ -z "\$NODE_BIN" ]; then
+    NODE_BIN="/opt/homebrew/bin/node"
+fi
+if [ ! -x "\$NODE_BIN" ]; then
+    echo "[jishushell-panel-start] ERROR: cannot locate node binary" >&2
+    exit 1
+fi
+
+export NODE_ENV="\${NODE_ENV:-production}"
+export JISHUSHELL_CORE_BASE_URL="\${JISHUSHELL_CORE_BASE_URL:-http://127.0.0.1:${JISHUSHELL_PORT}}"
+export JISHUSHELL_PANEL_PORT="\${JISHUSHELL_PANEL_PORT:-${JISHUSHELL_PANEL_PORT}}"
+export JISHUSHELL_PANEL_MANAGE_CORE="\${JISHUSHELL_PANEL_MANAGE_CORE:-${panel_manage_core_default}}"
+
+if [ ! -f "${panel_server}" ]; then
+    echo "[jishushell-panel-start] ERROR: could not find jishushell-panel at ${panel_server}" >&2
+    exit 1
+fi
+
+exec "\$NODE_BIN" "${panel_server}" "\$@"
+PANELWRAPPER
+        chmod +x "$panel_wrapper"
+        ui_success "JishuShell Panel installed — wrapper: ${panel_wrapper}"
+    fi
+}
+
+install_jishushell_panel_service() {
+    jishushell_panel_bundled || return 0
+
+    local panel_wrapper="${JISHUSHELL_BIN_DIR}/jishushell-panel-start"
+    local log_path="${JISHUSHELL_HOME}/jishushell-panel.log"
+    if [[ ! -x "$panel_wrapper" ]]; then
+        ui_warn "JishuShell Panel wrapper not found — run jishushell-gui manually or reinstall the Panel package"
+        return 0
+    fi
+
+    if [[ "$OS" == "macos" ]]; then
+        local plist_label="com.jishushell.panel"
+        local plist_path="${HOME}/Library/LaunchAgents/${plist_label}.plist"
+
+        mkdir -p "${HOME}/Library/LaunchAgents"
+        cat > "$plist_path" << PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${plist_label}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${panel_wrapper}</string>
+    </array>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>HOME</key>
+        <string>${REAL_HOME}</string>
+        <key>JISHUSHELL_HOME</key>
+        <string>${JISHUSHELL_HOME}</string>
+        <key>JISHUSHELL_CORE_BASE_URL</key>
+        <string>http://127.0.0.1:${JISHUSHELL_PORT}</string>
+        <key>JISHUSHELL_PANEL_PORT</key>
+        <string>${JISHUSHELL_PANEL_PORT}</string>
+        <key>JISHUSHELL_PANEL_MANAGE_CORE</key>
+        <string>0</string>
+        <key>NODE_ENV</key>
+        <string>production</string>
+    </dict>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${log_path}</string>
+    <key>StandardErrorPath</key>
+    <string>${log_path}</string>
+</dict>
+</plist>
+PLIST
+
+        if ! _wait_for_port "$JISHUSHELL_PORT" 30; then
+            ui_warn "Core server is not ready on port ${JISHUSHELL_PORT}; Panel launchd agent was written but not started"
+            return 0
+        fi
+
+        launchctl unload "$plist_path" 2>/dev/null || true
+        if launchctl load -w "$plist_path" 2>/dev/null; then
+            if _wait_for_port "$JISHUSHELL_PANEL_PORT" 15; then
+                JISHUSHELL_PANEL_SERVICE_STARTED=1
+                ui_success "JishuShell Panel launchd agent installed and started"
+            else
+                ui_warn "JishuShell Panel launchd agent installed, but port ${JISHUSHELL_PANEL_PORT} is not listening yet"
+            fi
+        else
+            ui_warn "Could not load JishuShell Panel launchd agent"
+        fi
+        return 0
+    fi
+
+    if [[ "$(uname -s)" != "Linux" ]]; then
+        return 0
+    fi
+
+    local service_content="[Unit]
+Description=JishuShell Panel
+After=network-online.target jishushell.service
+Wants=network-online.target jishushell.service
+
+[Service]
+Type=simple
+User=${REAL_USER}
+Environment=HOME=${REAL_HOME}
+Environment=JISHUSHELL_HOME=${JISHUSHELL_HOME}
+Environment=JISHUSHELL_CORE_BASE_URL=http://127.0.0.1:${JISHUSHELL_PORT}
+Environment=JISHUSHELL_PANEL_PORT=${JISHUSHELL_PANEL_PORT}
+Environment=JISHUSHELL_PANEL_MANAGE_CORE=0
+Environment=NODE_ENV=production
+ExecStart=${panel_wrapper}
+Restart=on-failure
+RestartSec=3
+ProtectSystem=strict
+PrivateTmp=true
+ReadWritePaths=${JISHUSHELL_HOME}
+
+[Install]
+WantedBy=multi-user.target"
+
+    local svc_path="/etc/systemd/system/jishushell-panel.service"
+    local need_reload=0
+    if [[ ! -f "$svc_path" ]] || ! echo "$service_content" | diff -q - "$svc_path" &>/dev/null; then
+        echo "$service_content" > /tmp/jishushell-panel.service.$$
+        ${SUDO} mv /tmp/jishushell-panel.service.$$ "$svc_path"
+        need_reload=1
+    fi
+    ${SUDO} chown root:root "$svc_path" 2>/dev/null || true
+    ${SUDO} chmod 644 "$svc_path" 2>/dev/null || true
+
+    if [[ $need_reload -eq 1 ]]; then
+        ${SUDO} systemctl daemon-reload
+    fi
+
+    if ! ${SUDO} systemctl enable jishushell-panel 2>/dev/null; then
+        ui_warn "Could not enable jishushell-panel systemd service"
+        return 0
+    fi
+
+    if ! _wait_for_port "$JISHUSHELL_PORT" 30; then
+        ui_warn "Core server is not ready on port ${JISHUSHELL_PORT}; Panel systemd service was enabled but not started"
+        return 0
+    fi
+
+    if ${SUDO} systemctl restart jishushell-panel 2>/dev/null; then
+        if _wait_for_port "$JISHUSHELL_PANEL_PORT" 15; then
+            JISHUSHELL_PANEL_SERVICE_STARTED=1
+            ui_success "JishuShell Panel systemd service installed and started"
+        else
+            ui_warn "JishuShell Panel systemd service installed, but port ${JISHUSHELL_PANEL_PORT} is not listening yet"
+        fi
+    else
+        ui_warn "Could not start jishushell-panel systemd service"
+    fi
 }
 
 install_jishushell_service() {
-    ui_stage "JishuShell service"
+    if jishushell_panel_bundled; then
+        ui_stage "JishuShell services"
+    else
+        ui_stage "JishuShell service"
+    fi
 
     if [[ $SKIP_JISHUSHELL_SERVICE -eq 1 ]]; then
         ui_info "Skipped (--skip-jishushell-service)"
         return 0
     fi
 
-    local wrapper="${JISHUSHELL_BIN_DIR}/jishushell-panel-start"
-    local log_path="${JISHUSHELL_HOME}/jishushell.log"
+    local wrapper="${JISHUSHELL_BIN_DIR}/jishushell-core-start"
+    local log_path="${JISHUSHELL_HOME}/jishushell-core.log"
 
     if [[ "$DRY_RUN" == "1" ]]; then
         ui_info "[dry-run] Would register jishushell as a system service"
+        if jishushell_panel_bundled; then
+            ui_info "[dry-run] Would register jishushell-panel as a system service"
+        fi
         return 0
     fi
 
     if [[ "$OS" == "macos" ]]; then
-        local plist_label="com.jishushell.panel"
+        local plist_label="com.jishushell.core"
         local plist_path="${HOME}/Library/LaunchAgents/${plist_label}.plist"
 
+        local core_gate="${JISHUSHELL_BIN_DIR}/core-launchd-wrapper.sh"
+        mkdir -p "${JISHUSHELL_BIN_DIR}"
+        cat > "$core_gate" << COREGATE
+#!/bin/bash
+set -u
+# Auto-generated by jishu-install.sh — do not edit by hand.
+# Lightweight 60s docker-readiness gate before starting core. Core self-heals
+# afterward, so on timeout we start anyway.
+CORE_DOCKER_WAIT_DEADLINE=60
+export PATH="/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
+deadline=\$(( \$(date +%s) + \$CORE_DOCKER_WAIT_DEADLINE ))
+while ! DOCKER_HOST="unix://${_COLIMA_SOCKET}" /usr/bin/env docker info >/dev/null 2>&1; do
+  [ \$(date +%s) -ge \$deadline ] && { echo "[core-gate] docker not ready after 60s; starting anyway" >&2; break; }
+  sleep 2
+done
+exec "${wrapper}"
+COREGATE
+        chmod 755 "$core_gate"
+
         mkdir -p "${HOME}/Library/LaunchAgents"
         cat > "$plist_path" << PLIST
 <?xml version="1.0" encoding="UTF-8"?>
@@ -3075,8 +3623,7 @@ install_jishushell_service() {
     <string>${plist_label}</string>
     <key>ProgramArguments</key>
     <array>
-        <string>${wrapper}</string>
-        <string>serve</string>
+        <string>${core_gate}</string>
     </array>
     <key>RunAtLoad</key>
     <true/>
@@ -3092,10 +3639,16 @@ PLIST
 
         launchctl unload "$plist_path" 2>/dev/null || true
         if launchctl load -w "$plist_path" 2>/dev/null; then
-            ui_success "JishuShell backend service installed and started"
+            if _wait_for_port "$JISHUSHELL_PORT" 30; then
+                ui_success "JishuShell core launchd agent installed and started"
+            else
+                ui_warn "JishuShell core launchd agent installed, but port ${JISHUSHELL_PORT} is not listening yet"
+            fi
         else
             ui_warn "Could not load jishushell launchd agent"
         fi
+        install_jishushell_panel_service || true
+        _enable_autologin
         return 0
     fi
 
@@ -3104,7 +3657,7 @@ PLIST
     fi
 
     local service_content="[Unit]
-Description=JishuShell Backend
+Description=JishuShell Core
 After=network-online.target nomad.service
 Wants=network-online.target
 
@@ -3113,14 +3666,18 @@ Type=simple
 User=${REAL_USER}
 SupplementaryGroups=docker
 EnvironmentFile=-/etc/jishushell/nomad.env
-ExecStart=${wrapper} serve
+ExecStart=${wrapper}
 Restart=on-failure
 RestartSec=3
 Environment=HOME=${REAL_HOME}
 Environment=JISHUSHELL_HOME=${JISHUSHELL_HOME}
 ProtectSystem=strict
 PrivateTmp=true
-ReadWritePaths=${JISHUSHELL_HOME} /etc/jishushell
+# /usr/local is whitelisted so app lifecycle scripts (e.g. ollama install.sh,
+# which writes /usr/local/bin/ollama and /usr/local/lib/ollama/) can succeed
+# even when the core runs under ProtectSystem=strict. The rest of /usr stays
+# read-only.
+ReadWritePaths=${JISHUSHELL_HOME} /etc/jishushell /usr/local
 
 [Install]
 WantedBy=multi-user.target"
@@ -3133,29 +3690,44 @@ WantedBy=multi-user.target"
         ${SUDO} mv /tmp/jishushell.service.$$ "$svc_path"
         need_reload=1
     fi
+    ${SUDO} chown root:root "$svc_path" 2>/dev/null || true
+    ${SUDO} chmod 644 "$svc_path" 2>/dev/null || true
 
     if [[ $need_reload -eq 1 ]]; then
         ${SUDO} systemctl daemon-reload
     fi
 
-    # Enable the service (auto-start on boot).
-    # Use 'enable --now' to also start it immediately — jishushell is the final
-    # component so there is no double-wait concern unlike Nomad.
+    # Enable and start the core service first. The panel service, when bundled,
+    # is handled after the core port is reachable.
     if ! systemctl is-enabled jishushell &>/dev/null 2>&1; then
         if ${SUDO} systemctl enable --now jishushell 2>/dev/null; then
-            ui_success "JishuShell systemd service installed and started"
+            if _wait_for_port "$JISHUSHELL_PORT" 30; then
+                ui_success "JishuShell core systemd service installed and started"
+            else
+                ui_warn "JishuShell core systemd service installed, but port ${JISHUSHELL_PORT} is not listening yet"
+            fi
         else
             ui_warn "Could not enable jishushell systemd service"
         fi
     elif [[ $need_reload -eq 1 ]]; then
         # Service file changed — restart to pick up new config
         ${SUDO} systemctl restart jishushell 2>/dev/null || true
-        ui_success "JishuShell systemd service updated and restarted"
+        if _wait_for_port "$JISHUSHELL_PORT" 30; then
+            ui_success "JishuShell core systemd service updated and restarted"
+        else
+            ui_warn "JishuShell core systemd service updated, but port ${JISHUSHELL_PORT} is not listening yet"
+        fi
     else
         # Package may have been upgraded — always restart to pick up new code
         ${SUDO} systemctl restart jishushell 2>/dev/null || true
-        ui_success "JishuShell systemd service restarted"
+        if _wait_for_port "$JISHUSHELL_PORT" 30; then
+            ui_success "JishuShell core systemd service restarted"
+        else
+            ui_warn "JishuShell core systemd service restarted, but port ${JISHUSHELL_PORT} is not listening yet"
+        fi
     fi
+
+    install_jishushell_panel_service || true
 }
 
 # ─── run_install_components ───────────────────────────────────────────────────
@@ -3278,17 +3850,20 @@ run_install_components() {
         # OpenSSH refuses any key with group/world-readable perms ("bad
         # permissions"), so a 644 key file makes lima hostagent unable to
         # provision the VM (host-addresses + docker context never come up),
-        # docker containers ship empty Ports{}, and the panel proxy 502s.
-        for f in auth.json jwt-secret panel.json nomad.env encryption-key \
+        # docker containers ship empty Ports{}, and the core proxy 502s.
+        for f in auth.json jwt-secret core.json nomad.env encryption-key \
                  colima/_lima/_config/user; do
             local fp="${JISHUSHELL_HOME}/${f}"
             [[ -f "$fp" ]] && ${SUDO} chmod 600 "$fp" 2>/dev/null || true
         done
         # Sync nomad.env from /etc/jishushell if missing in JISHUSHELL_HOME
         if [[ ! -f "${JISHUSHELL_HOME}/nomad.env" && -f /etc/jishushell/nomad.env ]]; then
-            ${SUDO} cp /etc/jishushell/nomad.env "${JISHUSHELL_HOME}/nomad.env"
-            ${SUDO} chown "${REAL_USER}:${REAL_GID:-${REAL_USER}}" "${JISHUSHELL_HOME}/nomad.env"
-            ${SUDO} chmod 600 "${JISHUSHELL_HOME}/nomad.env"
+            if [[ -n "${SUDO}" || -r /etc/jishushell/nomad.env ]]; then
+                if ${SUDO} cp /etc/jishushell/nomad.env "${JISHUSHELL_HOME}/nomad.env"; then
+                    ${SUDO} chown "${REAL_USER}:${REAL_GID:-${REAL_USER}}" "${JISHUSHELL_HOME}/nomad.env"
+                    ${SUDO} chmod 600 "${JISHUSHELL_HOME}/nomad.env"
+                fi
+            fi
         fi
         ui_success "Permissions set: ${REAL_USER}:${REAL_USER} on ${JISHUSHELL_HOME}"
     fi
@@ -3296,6 +3871,69 @@ run_install_components() {
     return $has_error
 }
 
+# Opt-in macOS auto-login so headless boxes get a GUI (Aqua) session that
+# fires the colima/nomad/panel LaunchAgents after a reboot. Writes the
+# user's login password (kcpassword-obfuscated) to /etc/kcpassword — a
+# security-sensitive, explicitly-gated action. Skipped if FileVault is on
+# (mutually exclusive) and never run without consent.
+_enable_autologin() {
+    [[ "$OS" != "macos" ]] && return 0
+    if [[ "$NO_AUTOLOGIN" == "1" ]]; then
+        ui_info "Auto-login skipped (--no-autologin)"
+        return 0
+    fi
+    if [[ "$ENABLE_AUTOLOGIN" != "1" ]]; then
+        ui_warn "Auto-login NOT enabled. On a headless Mac the LaunchAgents only"
+        ui_warn "fire after a GUI login. Enable later with:"
+        ui_warn "  bash jishu-install.sh --run 6 --enable-autologin"
+        return 0
+    fi
+    if fdesetup status 2>/dev/null | grep -q "FileVault is On"; then
+        ui_warn "FileVault is ON — auto-login is incompatible and will be skipped."
+        ui_warn "Disable FileVault or log in at the GUI after each reboot."
+        return 0
+    fi
+
+    local pw="$AUTOLOGIN_PASSWORD"
+    if [[ -z "$pw" ]]; then
+        if [[ "$AUTO_YES" == "1" ]]; then
+            ui_warn "Auto-login requested but no password (use --autologin-password); skipping"
+            return 0
+        fi
+        read -r -s -p "Login password for ${REAL_USER} (for auto-login, not stored in logs): " pw
+        echo ""
+    fi
+    [[ -z "$pw" ]] && { ui_warn "Empty password; auto-login skipped"; return 0; }
+
+    if [[ "$DRY_RUN" == "1" ]]; then
+        ui_info "[dry-run] Would set autoLoginUser=${REAL_USER} and write /etc/kcpassword"
+        return 0
+    fi
+
+    ${SUDO} defaults write /Library/Preferences/com.apple.loginwindow autoLoginUser "${REAL_USER}"
+
+    # kcpassword cipher (classic 11-byte key, repeated). Password is XOR'd
+    # byte-wise; the buffer is padded with cipher bytes to a multiple of 12,
+    # adding a full 12-byte block when the length is already a multiple.
+    local cipher=(0x7D 0x89 0x52 0x23 0xD2 0xBC 0xDD 0xEA 0xA3 0xB9 0x1F)
+    local out="" i ch ck
+    local len=${#pw}
+    local total=$(( (len / 12 + 1) * 12 ))
+    for (( i=0; i<total; i++ )); do
+        ck=$(( cipher[i % 11] ))
+        if (( i < len )); then
+            printf -v ch '%d' "'${pw:i:1}"
+        else
+            ch=0
+        fi
+        out+=$(printf '\\x%02x' $(( ch ^ ck )))
+    done
+    ( umask 077; printf "%b" "$out" | ${SUDO} tee /etc/kcpassword >/dev/null )
+    ${SUDO} chmod 600 /etc/kcpassword
+    unset pw
+    ui_success "Auto-login enabled for ${REAL_USER} (headless reboot will fire LaunchAgents)"
+}
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # Installer entry point — argument parsing, banner, main
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -3366,6 +4004,12 @@ parse_args() {
                     exit 1
                 fi
                 ;;
+            --enable-autologin)        ENABLE_AUTOLOGIN=1 ;;
+            --no-autologin)            NO_AUTOLOGIN=1 ;;
+            --autologin-password)
+                shift
+                AUTOLOGIN_PASSWORD="${1:?--autologin-password requires a value}"
+                ;;
             --yes|-y)                  AUTO_YES=1 ;;
             --help|-h)        usage; exit 0 ;;
             *)                ui_warn "Unknown argument: $1" ;;
@@ -3399,6 +4043,11 @@ Options:
                                                          (e.g. --jishushell-version 0.4.9)
   --registry <url>           Use a custom npm registry for all installs
                              (e.g. --registry http://127.0.0.1:4873/)
+  --enable-autologin         Enable macOS auto-login (headless reboot support;
+                             writes /etc/kcpassword — security-sensitive, opt-in)
+  --no-autologin             Never configure auto-login (overrides --enable-autologin)
+  --autologin-password <pw>  Password for non-interactive auto-login setup
+                             (visible in 'ps'; prefer AUTOLOGIN_PASSWORD env var)
   --yes, -y                  Skip all confirmation prompts
   --help, -h                 Show this help message