From 7b54ea583f980abf6762376b1e335372911441dd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=82=B9=E6=B0=B8=E8=B5=AB?= <1259085392@qq.com>
Date: Thu, 19 Mar 2026 19:32:55 +0900
Subject: [PATCH 1/3] feat(startup): add compact startup diagnostics panel

Show backend launch stages and recent logs in a collapsible startup panel so desktop users can track startup progress on top of upstream main without the loading window growing too tall.
---
 .../startup-shell-copy.test.mjs               | 297 +++++++++-
 src-tauri/src/app_runtime.rs                  |   1 +
 src-tauri/src/app_types.rs                    |  56 +-
 src-tauri/src/backend/launch.rs               |   5 +
 src-tauri/src/backend/readiness.rs            | 107 +++-
 src-tauri/src/bridge/commands.rs              |   8 +
 src-tauri/src/startup_task.rs                 |  85 ++-
 src-tauri/src/window/mod.rs                   |   1 +
 src-tauri/src/window/startup_panel.rs         | 549 ++++++++++++++++++
 ui/index.html                                 | 431 +++++++++++++-
 ui/startup-copy.js                            |  54 ++
 11 files changed, 1583 insertions(+), 11 deletions(-)
 create mode 100644 src-tauri/src/window/startup_panel.rs

diff --git a/scripts/prepare-resources/startup-shell-copy.test.mjs b/scripts/prepare-resources/startup-shell-copy.test.mjs
index 1939aeee..cab53836 100644
--- a/scripts/prepare-resources/startup-shell-copy.test.mjs
+++ b/scripts/prepare-resources/startup-shell-copy.test.mjs
@@ -1,9 +1,145 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
+import vm from 'node:vm';
 
 const startupShellPath = new URL('../../ui/index.html', import.meta.url);
 const startupCopyConfigPath = new URL('../../ui/startup-copy.js', import.meta.url);
+const startupTaskPath = new URL('../../src-tauri/src/startup_task.rs', import.meta.url);
+
+const STARTUP_ELEMENT_IDS = [
+  'startup-title',
+  'startup-desc',
+  'startup-status',
+  'startup-summary-label',
+  'startup-summary-text',
+  'startup-diagnostics-toggle',
+  'startup-diagnostics-toggle-text',
+  'startup-diagnostics',
+  'startup-stage-list',
+  'startup-desktop-log-label',
+  'startup-desktop-log-lines',
+  'startup-backend-log-label',
+  'startup-backend-log-lines',
+];
+
+class FakeElement {
+  constructor(id) {
+    this.id = id;
+    this.textContent = '';
+    this.title = '';
+    this.hidden = false;
+    this.className = '';
+    this.dataset = {};
+    this.children = [];
+    this.attributes = new Map();
+    this.listeners = new Map();
+  }
+
+  append(child) {
+    this.children.push(child);
+  }
+
+  replaceChildren(...children) {
+    this.children = children;
+  }
+
+  setAttribute(name, value) {
+    this.attributes.set(name, String(value));
+  }
+
+  getAttribute(name) {
+    return this.attributes.get(name);
+  }
+
+  addEventListener(type, listener) {
+    const listeners = this.listeners.get(type) || [];
+    listeners.push(listener);
+    this.listeners.set(type, listeners);
+  }
+}
+
+class FakeDocument {
+  constructor(ids) {
+    this.elements = new Map(ids.map((id) => [id, new FakeElement(id)]));
+  }
+
+  getElementById(id) {
+    return this.elements.get(id) || null;
+  }
+
+  createElement(tagName) {
+    return new FakeElement(tagName);
+  }
+}
+
+const extractInlineStartupScript = (source) => {
+  const match = source.match(/<script>\s*([\s\S]*?)\s*<\/script>\s*<\/body>/);
+  assert.ok(match, 'expected startup shell to include an inline bootstrap script');
+  return match[1];
+};
+
+const flushMicrotasks = async () => {
+  await new Promise((resolve) => setImmediate(resolve));
+  await new Promise((resolve) => setImmediate(resolve));
+};
+
+const renderStartupShell = async ({ locale = 'zh-CN', snapshot } = {}) => {
+  const [source, configSource] = await Promise.all([
+    readFile(startupShellPath, 'utf8'),
+    readFile(startupCopyConfigPath, 'utf8'),
+  ]);
+  const inlineScript = extractInlineStartupScript(source);
+  const document = new FakeDocument(STARTUP_ELEMENT_IDS);
+  const windowListeners = [];
+  const intervalCalls = [];
+  const invokeCalls = [];
+  const window = {
+    astrbot: {},
+    __TAURI_INTERNALS__: {
+      invoke: async (command) => {
+        invokeCalls.push(command);
+        return snapshot ?? null;
+      },
+    },
+    setInterval: (handler, delay) => {
+      intervalCalls.push({ handler, delay });
+      return intervalCalls.length;
+    },
+    clearInterval: () => {},
+    addEventListener: (type, listener, options) => {
+      windowListeners.push({ type, listener, options });
+    },
+  };
+
+  const context = vm.createContext({
+    window,
+    document,
+    navigator: { language: locale },
+    console,
+    Promise,
+    Object,
+    Array,
+    Number,
+    String,
+    Boolean,
+    JSON,
+    Map,
+    Set,
+  });
+
+  vm.runInContext(configSource, context, { filename: 'startup-copy.js' });
+  vm.runInContext(inlineScript, context, { filename: 'startup-shell-inline.js' });
+  await flushMicrotasks();
+
+  return {
+    window,
+    document,
+    windowListeners,
+    intervalCalls,
+    invokeCalls,
+  };
+};
 
 test('startup shell loads shared copy config, reuses applyStartupMode, and exposes a focused live region', async () => {
   const source = await readFile(startupShellPath, 'utf8');
@@ -69,8 +205,8 @@ test('startup shell loads shared copy config, reuses applyStartupMode, and expos
   );
   assert.match(
     source,
-    /if\s*\(status\.textContent\s*===\s*next\.status\)\s*return;/,
-    'expected startup shell to skip duplicate status announcements',
+    /setStatusText\(next\.status\);/,
+    'expected startup shell to route startup-mode status changes through the shared duplicate-announcement guard',
   );
 
   assert.match(
@@ -109,3 +245,160 @@ test('startup shell loads shared copy config, reuses applyStartupMode, and expos
     'expected shared startup copy config to include Chinese startup copy',
   );
 });
+
+test('startup diagnostics keeps localized stage summaries in frontend copy and stacks logs on narrow widths', async () => {
+  const source = await readFile(startupShellPath, 'utf8');
+  const configSource = await readFile(startupCopyConfigPath, 'utf8').catch(() => '');
+
+  assert.match(
+    configSource,
+    /en:\s*\{[\s\S]*stageSummaries:\s*\{[\s\S]*resolveLaunchPlan:\s*'Resolving launch plan'/,
+    'expected English stage summaries to stay in the shared frontend copy config',
+  );
+  assert.match(
+    configSource,
+    /zh:\s*\{[\s\S]*stageSummaries:\s*\{[\s\S]*resolveLaunchPlan:\s*'正在解析启动计划'/,
+    'expected Chinese stage summaries to stay in the shared frontend copy config',
+  );
+  assert.match(
+    source,
+    /const\s+resolveSnapshotSummary\s*=\s*\(snapshot\)\s*=>/,
+    'expected startup shell to resolve diagnostics summaries through a dedicated helper',
+  );
+  assert.match(
+    source,
+    /snapshot\?\.stage\s*===\s*"failed"/,
+    'expected startup shell to surface failure details from snapshot data only for failed startup states',
+  );
+  assert.doesNotMatch(
+    source,
+    /setSummaryText\(snapshot\.summary\)/,
+    'expected startup shell not to blindly reuse backend summary text for every stage',
+  );
+  assert.match(
+    source,
+    /setSummaryText\(resolveSnapshotSummary\(snapshot\)\)/,
+    'expected snapshot rendering to localize non-failure summaries before updating the compact row',
+  );
+  assert.match(
+    source,
+    /@media\s*\(max-width:\s*\d+px\)\s*\{[\s\S]*?\.startup-log-grid\s*\{[\s\S]*?grid-template-columns:\s*1fr;/,
+    'expected diagnostics log cards to collapse to one column at narrow widths',
+  );
+  assert.match(
+    source,
+    /\.startup-diagnostics\s*\{[\s\S]*overflow-y:\s*auto;[\s\S]*overflow-x:\s*hidden;/,
+    'expected the capped diagnostics panel to scroll vertically so stacked log cards remain reachable on narrow widths',
+  );
+});
+
+test('startup diagnostics keeps the live status row in sync with localized snapshot summaries', async () => {
+  const source = await readFile(startupShellPath, 'utf8');
+
+  assert.match(
+    source,
+    /const\s+setStatusText\s*=\s*\(value\)\s*=>/,
+    'expected startup shell to centralize live status updates through a helper',
+  );
+  assert.match(
+    source,
+    /if\s*\(status\.textContent\s*===\s*nextValue\)\s*return;/,
+    'expected live status updates to preserve duplicate-announcement restraint',
+  );
+  assert.match(
+    source,
+    /setStatusText\(resolveSnapshotSummary\(snapshot\)\)/,
+    'expected polled startup snapshots to keep the live status row aligned with the compact summary',
+  );
+});
+
+test('startup mode updates keep snapshot-controlled status and summary text aligned after polling starts', async () => {
+  const { document, window } = await renderStartupShell({
+    locale: 'zh-CN',
+    snapshot: {
+      stage: 'tcpReachable',
+      summary: 'TCP ready, waiting for HTTP',
+      items: [],
+      desktopLog: [],
+      backendLog: [],
+    },
+  });
+
+  const status = document.getElementById('startup-status');
+  const summaryText = document.getElementById('startup-summary-text');
+  const desc = document.getElementById('startup-desc');
+
+  assert.equal(status.textContent, 'TCP 已就绪，正在等待 HTTP');
+  assert.equal(summaryText.textContent, 'TCP 已就绪，正在等待 HTTP');
+
+  window.__astrbotSetStartupMode('panel-update');
+
+  assert.equal(
+    desc.textContent,
+    '检测到新面板版本，正在下载并应用。',
+    'expected startup mode changes to keep updating the descriptive copy',
+  );
+  assert.equal(
+    status.textContent,
+    'TCP 已就绪，正在等待 HTTP',
+    'expected startup mode changes to stop overriding the live status after snapshot polling takes over',
+  );
+  assert.equal(
+    summaryText.textContent,
+    'TCP 已就绪，正在等待 HTTP',
+    'expected startup mode changes to keep the compact summary synchronized with the live status after snapshot polling takes over',
+  );
+});
+
+test('failed snapshot prefers localized frontend failure copy when backend summary is empty or generic', async () => {
+  for (const summary of ['', 'Startup failed']) {
+    const { document } = await renderStartupShell({
+      locale: 'zh-CN',
+      snapshot: {
+        stage: 'failed',
+        summary,
+        items: [],
+        desktopLog: [],
+        backendLog: [],
+      },
+    });
+
+    assert.equal(
+      document.getElementById('startup-status').textContent,
+      '启动失败',
+      'expected failed snapshots with empty or generic backend summaries to fall back to localized frontend copy for the live status',
+    );
+    assert.equal(
+      document.getElementById('startup-summary-text').textContent,
+      '启动失败',
+      'expected failed snapshots with empty or generic backend summaries to fall back to localized frontend copy for the compact summary',
+    );
+  }
+});
+
+test('startup task records the desktop log offset before async startup work is spawned', async () => {
+  const source = await readFile(startupTaskPath, 'utf8');
+  const taskStartIndex = source.indexOf('pub fn spawn_startup_task');
+  const testsStartIndex = source.indexOf('#[cfg(test)]');
+  const taskSource = source.slice(
+    taskStartIndex,
+    testsStartIndex === -1 ? source.length : testsStartIndex,
+  );
+  const prepareCallIndex = taskSource.lastIndexOf('prepare_startup_panel_for_attempt(');
+  const spawnAsyncIndex = taskSource.indexOf('tauri::async_runtime::spawn(async move {');
+
+  assert.notEqual(
+    prepareCallIndex,
+    -1,
+    'expected startup task to record the desktop log start offset for the startup panel',
+  );
+  assert.notEqual(
+    spawnAsyncIndex,
+    -1,
+    'expected startup task to spawn its async startup work',
+  );
+  assert.ok(
+    prepareCallIndex < spawnAsyncIndex,
+    'expected startup task to capture the desktop log offset before the async startup work begins',
+  );
+});
diff --git a/src-tauri/src/app_runtime.rs b/src-tauri/src/app_runtime.rs
index f9ff9ad6..d9c4c896 100644
--- a/src-tauri/src/app_runtime.rs
+++ b/src-tauri/src/app_runtime.rs
@@ -158,6 +158,7 @@ pub(crate) fn run() {
         .invoke_handler(tauri::generate_handler![
             crate::bridge::commands::desktop_bridge_is_desktop_runtime,
             crate::bridge::commands::desktop_bridge_get_backend_state,
+            crate::bridge::commands::desktop_bridge_get_startup_panel_snapshot,
             crate::bridge::commands::desktop_bridge_set_auth_token,
             crate::bridge::commands::desktop_bridge_set_shell_locale,
             crate::bridge::commands::desktop_bridge_get_app_update_channel,
diff --git a/src-tauri/src/app_types.rs b/src-tauri/src/app_types.rs
index 53e0bbf7..a919365e 100644
--- a/src-tauri/src/app_types.rs
+++ b/src-tauri/src/app_types.rs
@@ -1,4 +1,4 @@
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::{
     env,
     path::PathBuf,
@@ -41,6 +41,7 @@ pub(crate) struct BackendState {
     pub(crate) child: Mutex<Option<Child>>,
     pub(crate) backend_url: String,
     pub(crate) restart_auth_token: Mutex<Option<String>>,
+    pub(crate) startup_panel: Mutex<StartupPanelState>,
     pub(crate) startup_loading_mode: Mutex<Option<&'static str>>,
     pub(crate) log_rotator_stop: Mutex<Option<Arc<AtomicBool>>>,
     pub(crate) exit_state: Mutex<exit_state::ExitStateMachine>,
@@ -48,6 +49,45 @@ pub(crate) struct BackendState {
     pub(crate) is_restarting: AtomicBool,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) enum StartupPanelStage {
+    ResolveLaunchPlan,
+    SpawnBackend,
+    TcpReachable,
+    HttpReady,
+    Failed,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct StartupPanelState {
+    pub(crate) stage: StartupPanelStage,
+    pub(crate) last_non_failed_stage: StartupPanelStage,
+    pub(crate) failure: Option<String>,
+    pub(crate) desktop_log_start_offset: u64,
+    pub(crate) backend_log_path: Option<PathBuf>,
+    pub(crate) backend_log_start_offset: u64,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct StartupPanelStageItem {
+    pub(crate) key: &'static str,
+    pub(crate) label: &'static str,
+    pub(crate) done: bool,
+    pub(crate) active: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct StartupPanelSnapshot {
+    pub(crate) stage: StartupPanelStage,
+    pub(crate) summary: String,
+    pub(crate) items: Vec<StartupPanelStageItem>,
+    pub(crate) desktop_log: Vec<String>,
+    pub(crate) backend_log: Vec<String>,
+}
+
 #[derive(Debug, serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct BackendBridgeState {
@@ -96,6 +136,7 @@ impl Default for BackendState {
                 DEFAULT_BACKEND_URL,
             ),
             restart_auth_token: Mutex::new(None),
+            startup_panel: Mutex::new(StartupPanelState::default()),
             startup_loading_mode: Mutex::new(None),
             log_rotator_stop: Mutex::new(None),
             exit_state: Mutex::new(exit_state::ExitStateMachine::default()),
@@ -105,6 +146,19 @@ impl Default for BackendState {
     }
 }
 
+impl Default for StartupPanelState {
+    fn default() -> Self {
+        Self {
+            stage: StartupPanelStage::ResolveLaunchPlan,
+            last_non_failed_stage: StartupPanelStage::ResolveLaunchPlan,
+            failure: None,
+            desktop_log_start_offset: 0,
+            backend_log_path: None,
+            backend_log_start_offset: 0,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::sync::atomic::{AtomicBool, Ordering};
diff --git a/src-tauri/src/backend/launch.rs b/src-tauri/src/backend/launch.rs
index ac91d7af..b1857a2b 100644
--- a/src-tauri/src/backend/launch.rs
+++ b/src-tauri/src/backend/launch.rs
@@ -150,6 +150,7 @@ impl BackendState {
                 "backend",
                 false,
             );
+            crate::window::startup_panel::remember_backend_log_path(self, log_path.clone());
             let stdout_file = OpenOptions::new()
                 .create(true)
                 .append(true)
@@ -185,6 +186,10 @@ impl BackendState {
             build_debug_command(plan),
             plan.cwd.display()
         ));
+        crate::window::startup_panel::set_stage(
+            self,
+            crate::app_types::StartupPanelStage::SpawnBackend,
+        );
         *self
             .child
             .lock()
diff --git a/src-tauri/src/backend/readiness.rs b/src-tauri/src/backend/readiness.rs
index 7eb3793d..ac5e8fc6 100644
--- a/src-tauri/src/backend/readiness.rs
+++ b/src-tauri/src/backend/readiness.rs
@@ -11,11 +11,27 @@ use crate::{
 };
 
 impl BackendState {
+    fn existing_backend_is_ready_for_startup(&self) -> bool {
+        let readiness = backend::runtime::backend_readiness_config(append_desktop_log);
+        matches!(
+            self.request_backend_status_code(
+                "GET",
+                &readiness.path,
+                readiness.probe_timeout_ms,
+                None,
+                None,
+            ),
+            Some(status_code) if (200..400).contains(&status_code)
+        )
+    }
+
     pub(crate) fn ensure_backend_ready(&self, app: &AppHandle) -> Result<(), String> {
-        if self.ping_backend(backend::runtime::backend_ping_timeout_ms(
-            append_desktop_log,
-        )) {
-            append_desktop_log("backend already reachable, skip spawn");
+        if self.existing_backend_is_ready_for_startup() {
+            crate::window::startup_panel::set_stage(
+                self,
+                crate::app_types::StartupPanelStage::HttpReady,
+            );
+            append_desktop_log("backend already HTTP ready, skip spawn");
             return Ok(());
         }
 
@@ -28,6 +44,10 @@ impl BackendState {
 
         let _spawn_guard = AtomicFlagGuard::try_set(&self.is_spawning)
             .ok_or_else(|| "Backend action already in progress.".to_string())?;
+        crate::window::startup_panel::set_stage(
+            self,
+            crate::app_types::StartupPanelStage::ResolveLaunchPlan,
+        );
         let plan = self.resolve_launch_plan(app)?;
         self.start_backend_process(app, &plan)?;
         self.wait_for_backend(&plan)
@@ -49,12 +69,20 @@ impl BackendState {
             let (http_status, tcp_reachable) =
                 self.probe_backend_readiness(&readiness.path, readiness.probe_timeout_ms);
             if matches!(http_status, Some(status_code) if (200..400).contains(&status_code)) {
+                crate::window::startup_panel::set_stage(
+                    self,
+                    crate::app_types::StartupPanelStage::HttpReady,
+                );
                 return Ok(());
             }
 
             if tcp_reachable {
                 ever_tcp_reachable = true;
                 if !tcp_ready_logged {
+                    crate::window::startup_panel::set_stage(
+                        self,
+                        crate::app_types::StartupPanelStage::TcpReachable,
+                    );
                     append_desktop_log(
                         "backend TCP port is reachable but HTTP dashboard is not ready yet; waiting",
                     );
@@ -139,3 +167,74 @@ impl BackendState {
         ));
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        io::ErrorKind,
+        net::TcpListener,
+        sync::{
+            atomic::{AtomicBool, Ordering},
+            Arc,
+        },
+        thread,
+        time::Duration,
+    };
+
+    use super::BackendState;
+
+    struct TcpOnlyServer {
+        url: String,
+        stop: Arc<AtomicBool>,
+        handle: Option<thread::JoinHandle<()>>,
+    }
+
+    impl TcpOnlyServer {
+        fn start() -> Self {
+            let listener = TcpListener::bind("127.0.0.1:0").expect("bind tcp-only listener");
+            listener
+                .set_nonblocking(true)
+                .expect("set nonblocking listener");
+            let address = listener.local_addr().expect("listener local addr");
+            let stop = Arc::new(AtomicBool::new(false));
+            let stop_for_thread = Arc::clone(&stop);
+            let handle = thread::spawn(move || {
+                while !stop_for_thread.load(Ordering::Relaxed) {
+                    match listener.accept() {
+                        Ok((stream, _)) => drop(stream),
+                        Err(error) if error.kind() == ErrorKind::WouldBlock => {
+                            thread::sleep(Duration::from_millis(10));
+                        }
+                        Err(_) => break,
+                    }
+                }
+            });
+
+            Self {
+                url: format!("http://{address}"),
+                stop,
+                handle: Some(handle),
+            }
+        }
+    }
+
+    impl Drop for TcpOnlyServer {
+        fn drop(&mut self) {
+            self.stop.store(true, Ordering::Relaxed);
+            if let Some(handle) = self.handle.take() {
+                handle.join().expect("join tcp-only listener thread");
+            }
+        }
+    }
+
+    #[test]
+    fn existing_backend_startup_skip_requires_http_readiness() {
+        let server = TcpOnlyServer::start();
+        let state = BackendState {
+            backend_url: server.url.clone(),
+            ..BackendState::default()
+        };
+
+        assert!(!state.existing_backend_is_ready_for_startup());
+    }
+}
diff --git a/src-tauri/src/bridge/commands.rs b/src-tauri/src/bridge/commands.rs
index ddf848f4..dceed94f 100644
--- a/src-tauri/src/bridge/commands.rs
+++ b/src-tauri/src/bridge/commands.rs
@@ -212,6 +212,14 @@ pub(crate) fn desktop_bridge_get_backend_state(app_handle: AppHandle) -> Backend
     state.bridge_state(&app_handle)
 }
 
+#[tauri::command]
+pub(crate) fn desktop_bridge_get_startup_panel_snapshot(
+    app_handle: AppHandle,
+) -> crate::app_types::StartupPanelSnapshot {
+    let state = app_handle.state::<BackendState>();
+    crate::window::startup_panel::snapshot(state.inner())
+}
+
 #[tauri::command]
 pub(crate) fn desktop_bridge_set_auth_token(
     app_handle: AppHandle,
diff --git a/src-tauri/src/startup_task.rs b/src-tauri/src/startup_task.rs
index 1b13626a..8fc455ea 100644
--- a/src-tauri/src/startup_task.rs
+++ b/src-tauri/src/startup_task.rs
@@ -1,11 +1,29 @@
+use std::path::Path;
+
 use tauri::{AppHandle, Manager};
 
-use crate::{navigate_main_window_to_backend, ui_dispatch, BackendState};
+use crate::{
+    logging, navigate_main_window_to_backend, runtime_paths, ui_dispatch, BackendState,
+    DESKTOP_LOG_FILE,
+};
+
+fn prepare_startup_panel_for_attempt(state: &BackendState, desktop_log_path: &Path) {
+    crate::window::startup_panel::remember_desktop_log_start(state, desktop_log_path);
+}
 
 pub fn spawn_startup_task<F>(app_handle: AppHandle, log: F)
 where
     F: Fn(&str) + Copy + Send + 'static,
 {
+    let desktop_log_path = logging::resolve_desktop_log_path(
+        runtime_paths::default_packaged_root_dir(),
+        DESKTOP_LOG_FILE,
+    );
+    prepare_startup_panel_for_attempt(
+        app_handle.state::<BackendState>().inner(),
+        &desktop_log_path,
+    );
+
     let startup_app_handle = app_handle.clone();
     tauri::async_runtime::spawn(async move {
         let startup_worker_handle = startup_app_handle.clone();
@@ -25,10 +43,18 @@ where
                     move |main_app| match navigate_main_window_to_backend(main_app) {
                         Ok(()) => {}
                         Err(navigate_error) => {
+                            crate::window::startup_panel::set_failed(
+                                main_app.state::<BackendState>().inner(),
+                                &navigate_error,
+                            );
                             ui_dispatch::show_startup_error(main_app, &navigate_error, log);
                         }
                     },
                 ) {
+                    crate::window::startup_panel::set_failed(
+                        startup_app_handle.state::<BackendState>().inner(),
+                        &error,
+                    );
                     ui_dispatch::show_startup_error_on_main_thread(
                         &startup_app_handle,
                         &error,
@@ -37,8 +63,65 @@ where
                 }
             }
             Err(error) => {
+                crate::window::startup_panel::set_failed(
+                    startup_app_handle.state::<BackendState>().inner(),
+                    &error,
+                );
                 ui_dispatch::show_startup_error_on_main_thread(&startup_app_handle, &error, log);
             }
         }
     });
 }
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        fs,
+        path::PathBuf,
+        time::{SystemTime, UNIX_EPOCH},
+    };
+
+    use super::prepare_startup_panel_for_attempt;
+    use crate::BackendState;
+
+    fn create_temp_case_dir(name: &str) -> PathBuf {
+        let ts = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time before unix epoch")
+            .as_nanos();
+        let dir = std::env::temp_dir().join(format!(
+            "astrbot-desktop-startup-task-test-{}-{}-{}",
+            std::process::id(),
+            ts,
+            name
+        ));
+        fs::create_dir_all(&dir).expect("create temp case dir");
+        dir
+    }
+
+    #[test]
+    fn prepare_startup_panel_for_attempt_records_current_desktop_log_end() {
+        let state = BackendState::default();
+        let root = create_temp_case_dir("desktop-log-start-offset");
+        let desktop_log_path = root.join(crate::DESKTOP_LOG_FILE);
+
+        fs::write(
+            &desktop_log_path,
+            "previous launch line\nold readiness note\n",
+        )
+        .expect("write existing desktop log");
+        let expected_offset = fs::metadata(&desktop_log_path)
+            .expect("read desktop log metadata")
+            .len();
+
+        prepare_startup_panel_for_attempt(&state, &desktop_log_path);
+
+        let panel = match state.startup_panel.lock() {
+            Ok(guard) => guard.clone(),
+            Err(error) => error.into_inner().clone(),
+        };
+        assert_eq!(panel.desktop_log_start_offset, expected_offset);
+
+        fs::remove_dir_all(&root).expect("cleanup temp case dir");
+    }
+}
diff --git a/src-tauri/src/window/mod.rs b/src-tauri/src/window/mod.rs
index bf143683..a7afbf65 100644
--- a/src-tauri/src/window/mod.rs
+++ b/src-tauri/src/window/mod.rs
@@ -1,3 +1,4 @@
 pub(crate) mod actions;
 pub(crate) mod main_window;
 pub(crate) mod startup_loading;
+pub(crate) mod startup_panel;
diff --git a/src-tauri/src/window/startup_panel.rs b/src-tauri/src/window/startup_panel.rs
new file mode 100644
index 00000000..16d59484
--- /dev/null
+++ b/src-tauri/src/window/startup_panel.rs
@@ -0,0 +1,549 @@
+use std::{
+    fs::{self, File},
+    io::{self, Read, Seek, SeekFrom},
+    path::{Path, PathBuf},
+};
+
+use crate::{
+    app_types::{
+        StartupPanelSnapshot, StartupPanelStage, StartupPanelStageItem, StartupPanelState,
+    },
+    logging, runtime_paths, BackendState, DESKTOP_LOG_FILE,
+};
+
+const SNAPSHOT_LOG_READ_BYTES: usize = 8 * 1024;
+const SNAPSHOT_LOG_LINES: usize = 8;
+
+struct CompactStageDefinition {
+    stage: StartupPanelStage,
+    key: &'static str,
+    label: &'static str,
+}
+
+const COMPACT_STAGE_DEFINITIONS: [CompactStageDefinition; 4] = [
+    CompactStageDefinition {
+        stage: StartupPanelStage::ResolveLaunchPlan,
+        key: "plan",
+        label: "Plan",
+    },
+    CompactStageDefinition {
+        stage: StartupPanelStage::SpawnBackend,
+        key: "spawn",
+        label: "Spawn",
+    },
+    CompactStageDefinition {
+        stage: StartupPanelStage::TcpReachable,
+        key: "tcp",
+        label: "TCP",
+    },
+    CompactStageDefinition {
+        stage: StartupPanelStage::HttpReady,
+        key: "http",
+        label: "HTTP",
+    },
+];
+
+fn with_startup_panel_state<R, F>(state: &BackendState, update: F) -> R
+where
+    F: FnOnce(&mut StartupPanelState) -> R,
+{
+    match state.startup_panel.lock() {
+        Ok(mut guard) => update(&mut guard),
+        Err(error) => {
+            let mut guard = error.into_inner();
+            update(&mut guard)
+        }
+    }
+}
+
+fn current_startup_panel_state(state: &BackendState) -> StartupPanelState {
+    match state.startup_panel.lock() {
+        Ok(guard) => guard.clone(),
+        Err(error) => error.into_inner().clone(),
+    }
+}
+
+pub(crate) fn set_stage(state: &BackendState, stage: StartupPanelStage) {
+    with_startup_panel_state(state, |panel| {
+        panel.stage = stage;
+        panel.last_non_failed_stage = stage;
+        panel.failure = None;
+    });
+}
+
+pub(crate) fn set_failed(state: &BackendState, reason: &str) {
+    let failure = reason.trim();
+    with_startup_panel_state(state, |panel| {
+        panel.stage = StartupPanelStage::Failed;
+        panel.failure = if failure.is_empty() {
+            None
+        } else {
+            Some(failure.to_string())
+        };
+    });
+}
+
+pub(crate) fn remember_backend_log_path(state: &BackendState, path: PathBuf) {
+    let start_offset = current_log_end(&path);
+    with_startup_panel_state(state, |panel| {
+        panel.backend_log_path = Some(path);
+        panel.backend_log_start_offset = start_offset;
+    });
+}
+
+pub(crate) fn remember_desktop_log_start(state: &BackendState, path: &Path) {
+    let start_offset = current_log_end(path);
+    with_startup_panel_state(state, |panel| {
+        panel.desktop_log_start_offset = start_offset;
+    });
+}
+
+pub(crate) fn snapshot(state: &BackendState) -> StartupPanelSnapshot {
+    let panel = current_startup_panel_state(state);
+    let desktop_log_path = logging::resolve_desktop_log_path(
+        runtime_paths::default_packaged_root_dir(),
+        DESKTOP_LOG_FILE,
+    );
+
+    snapshot_for_panel_state(&panel, &desktop_log_path)
+}
+
+fn snapshot_for_panel_state(
+    panel: &StartupPanelState,
+    desktop_log_path: &Path,
+) -> StartupPanelSnapshot {
+    let desktop_log_tail = read_recent_log_tail_after(
+        desktop_log_path,
+        panel.desktop_log_start_offset,
+        SNAPSHOT_LOG_READ_BYTES,
+    );
+    let backend_log_tail = panel
+        .backend_log_path
+        .as_deref()
+        .map(|path| {
+            read_recent_log_tail_after(
+                path,
+                panel.backend_log_start_offset,
+                SNAPSHOT_LOG_READ_BYTES,
+            )
+        })
+        .unwrap_or_default();
+
+    build_snapshot(
+        panel.stage,
+        panel.last_non_failed_stage,
+        panel.failure.as_deref(),
+        &desktop_log_tail,
+        &backend_log_tail,
+    )
+}
+
+pub(crate) fn build_stage_items(stage: StartupPanelStage) -> Option<[StartupPanelStageItem; 4]> {
+    let current_index = COMPACT_STAGE_DEFINITIONS
+        .iter()
+        .position(|definition| definition.stage == stage)?;
+
+    Some(std::array::from_fn(|index| {
+        let definition = &COMPACT_STAGE_DEFINITIONS[index];
+
+        StartupPanelStageItem {
+            key: definition.key,
+            label: definition.label,
+            done: index < current_index,
+            active: index == current_index,
+        }
+    }))
+}
+
+fn stage_summary(stage: StartupPanelStage, failure: Option<&str>) -> String {
+    match stage {
+        StartupPanelStage::ResolveLaunchPlan => "Resolving launch plan".to_string(),
+        StartupPanelStage::SpawnBackend => "Spawning backend".to_string(),
+        StartupPanelStage::TcpReachable => "TCP ready, waiting for HTTP".to_string(),
+        StartupPanelStage::HttpReady => "Backend ready".to_string(),
+        StartupPanelStage::Failed => failure
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .unwrap_or("Startup failed")
+            .to_string(),
+    }
+}
+
+fn current_log_end(path: &Path) -> u64 {
+    fs::metadata(path)
+        .map(|metadata| metadata.len())
+        .unwrap_or(0)
+}
+
+fn read_recent_log_tail_after(path: &Path, start_offset: u64, max_bytes: usize) -> String {
+    let mut file = match File::open(path) {
+        Ok(file) => file,
+        Err(_) => return String::new(),
+    };
+
+    read_recent_log_tail_from_reader_after(&mut file, start_offset, max_bytes).unwrap_or_default()
+}
+
+fn read_recent_log_tail_from_reader<R>(reader: &mut R, max_bytes: usize) -> io::Result<String>
+where
+    R: Read + Seek,
+{
+    read_recent_log_tail_from_reader_after(reader, 0, max_bytes)
+}
+
+fn read_recent_log_tail_from_reader_after<R>(
+    reader: &mut R,
+    start_offset: u64,
+    max_bytes: usize,
+) -> io::Result<String>
+where
+    R: Read + Seek,
+{
+    if max_bytes == 0 {
+        return Ok(String::new());
+    }
+
+    let end = reader.seek(SeekFrom::End(0))?;
+    if end == 0 {
+        return Ok(String::new());
+    }
+
+    let effective_start = if start_offset > end { 0 } else { start_offset };
+    if effective_start == end {
+        return Ok(String::new());
+    }
+
+    let read_len = (end - effective_start).min(max_bytes as u64);
+    let start = end - read_len;
+    reader.seek(SeekFrom::Start(start))?;
+
+    let mut raw = Vec::with_capacity(read_len as usize);
+    let mut limited_reader = reader.take(read_len);
+    limited_reader.read_to_end(&mut raw)?;
+    if raw.is_empty() {
+        return Ok(String::new());
+    }
+
+    let mut tail = String::from_utf8_lossy(&raw).into_owned();
+    if start > effective_start {
+        if let Some(index) = tail.find('\n') {
+            tail.drain(..=index);
+        } else {
+            tail.clear();
+        }
+    }
+    Ok(tail)
+}
+
+fn build_snapshot(
+    stage: StartupPanelStage,
+    compact_stage: StartupPanelStage,
+    failure: Option<&str>,
+    desktop_log_tail: &str,
+    backend_log_tail: &str,
+) -> StartupPanelSnapshot {
+    StartupPanelSnapshot {
+        stage,
+        summary: stage_summary(stage, failure),
+        items: build_stage_items(compact_stage)
+            .map(Vec::from)
+            .unwrap_or_default(),
+        desktop_log: trim_non_empty_log_tail(desktop_log_tail, SNAPSHOT_LOG_LINES),
+        backend_log: trim_non_empty_log_tail(backend_log_tail, SNAPSHOT_LOG_LINES),
+    }
+}
+
+pub(crate) fn trim_non_empty_log_tail(log_tail: &str, max_lines: usize) -> Vec<String> {
+    let mut trimmed = log_tail
+        .lines()
+        .map(|line| line.trim_end_matches('\r'))
+        .filter(|line| !line.trim().is_empty())
+        .rev()
+        .take(max_lines)
+        .map(str::to_owned)
+        .collect::<Vec<_>>();
+    trimmed.reverse();
+    trimmed
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        fs,
+        io::{self, Cursor, Read, Seek, SeekFrom, Write},
+        path::PathBuf,
+        time::{SystemTime, UNIX_EPOCH},
+    };
+
+    use super::{
+        build_snapshot, build_stage_items, current_startup_panel_state,
+        read_recent_log_tail_from_reader, remember_backend_log_path, remember_desktop_log_start,
+        set_failed, set_stage, snapshot_for_panel_state, trim_non_empty_log_tail,
+    };
+    use crate::{app_types::StartupPanelStage, BackendState};
+
+    fn create_temp_case_dir(name: &str) -> PathBuf {
+        let ts = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time before unix epoch")
+            .as_nanos();
+        let dir = std::env::temp_dir().join(format!(
+            "astrbot-desktop-startup-panel-test-{}-{}-{}",
+            std::process::id(),
+            ts,
+            name
+        ));
+        fs::create_dir_all(&dir).expect("create temp case dir");
+        dir
+    }
+
+    #[test]
+    fn build_stage_items_marks_previous_done_and_current_active_at_tcp_reachable() {
+        let items = build_stage_items(StartupPanelStage::TcpReachable)
+            .expect("non-failed stages should produce stage items");
+
+        assert_eq!(items.len(), 4);
+        assert_eq!(items[0].done, true);
+        assert_eq!(items[0].active, false);
+        assert_eq!(items[1].done, true);
+        assert_eq!(items[1].active, false);
+        assert_eq!(items[2].done, false);
+        assert_eq!(items[2].active, true);
+        assert_eq!(items[3].done, false);
+        assert_eq!(items[3].active, false);
+    }
+
+    #[test]
+    fn build_stage_items_covers_each_non_failed_stage() {
+        let cases = [
+            (StartupPanelStage::ResolveLaunchPlan, 0),
+            (StartupPanelStage::SpawnBackend, 1),
+            (StartupPanelStage::TcpReachable, 2),
+            (StartupPanelStage::HttpReady, 3),
+        ];
+
+        for (stage, active_index) in cases {
+            let items = build_stage_items(stage).expect("non-failed stages should produce items");
+            assert!(items[active_index].active);
+        }
+    }
+
+    #[test]
+    fn build_stage_items_use_expected_keys_and_labels() {
+        let items = build_stage_items(StartupPanelStage::ResolveLaunchPlan)
+            .expect("non-failed stages should produce stage items");
+
+        let stage_meta = items.map(|item| (item.key, item.label));
+        assert_eq!(
+            stage_meta,
+            [
+                ("plan", "Plan"),
+                ("spawn", "Spawn"),
+                ("tcp", "TCP"),
+                ("http", "HTTP")
+            ]
+        );
+    }
+
+    #[test]
+    fn build_stage_items_skips_compact_flow_for_failed_stage() {
+        assert_eq!(build_stage_items(StartupPanelStage::Failed), None);
+    }
+
+    #[test]
+    fn snapshot_failed_stage_keeps_last_non_failed_stage_items() {
+        let state = BackendState::default();
+        set_stage(&state, StartupPanelStage::TcpReachable);
+        set_failed(&state, "backend crashed");
+
+        let root = create_temp_case_dir("snapshot-failed-stage-items");
+        let desktop_log_path = root.join(crate::DESKTOP_LOG_FILE);
+        fs::write(&desktop_log_path, "tcp reachable\nbackend crashed\n")
+            .expect("write desktop log");
+
+        let snapshot =
+            snapshot_for_panel_state(&current_startup_panel_state(&state), &desktop_log_path);
+
+        assert_eq!(snapshot.stage, StartupPanelStage::Failed);
+        assert_eq!(snapshot.summary, "backend crashed");
+        assert_eq!(snapshot.items.len(), 4);
+        assert!(snapshot.items[0].done);
+        assert!(snapshot.items[1].done);
+        assert!(snapshot.items[2].active);
+        assert!(!snapshot.items[3].done);
+        assert!(!snapshot.items[3].active);
+
+        fs::remove_dir_all(&root).expect("cleanup temp case dir");
+    }
+
+    #[test]
+    fn trim_non_empty_log_tail_keeps_latest_non_empty_lines() {
+        let trimmed =
+            trim_non_empty_log_tail("\nplan ready\n\nbackend spawned\n  \nhttp ready\n", 2);
+
+        assert_eq!(trimmed, vec!["backend spawned", "http ready"]);
+    }
+
+    #[test]
+    fn trim_non_empty_log_tail_normalizes_crlf_before_filtering_blank_lines() {
+        let trimmed = trim_non_empty_log_tail("plan ready\r\n\r\nbackend spawned\r\n", 3);
+
+        assert_eq!(trimmed, vec!["plan ready", "backend spawned"]);
+    }
+
+    #[test]
+    fn build_snapshot_includes_active_stage_summary_and_trimmed_logs() {
+        let snapshot = build_snapshot(
+            StartupPanelStage::TcpReachable,
+            StartupPanelStage::TcpReachable,
+            None,
+            "\nresolve launch plan\n\nbackend spawned\n",
+            "\nlistening on 6185\nhttp still warming up\n",
+        );
+
+        assert_eq!(snapshot.stage, StartupPanelStage::TcpReachable);
+        assert_eq!(snapshot.summary, "TCP ready, waiting for HTTP");
+        assert_eq!(snapshot.items.len(), 4);
+        assert!(snapshot.items[2].active);
+        assert_eq!(
+            snapshot.desktop_log,
+            vec!["resolve launch plan", "backend spawned"]
+        );
+        assert_eq!(
+            snapshot.backend_log,
+            vec!["listening on 6185", "http still warming up"]
+        );
+    }
+
+    #[test]
+    fn snapshot_keeps_backend_log_empty_when_backend_path_is_unknown() {
+        let root = create_temp_case_dir("snapshot-no-backend-path");
+        let logs_dir = root.join("logs");
+        fs::create_dir_all(&logs_dir).expect("create logs dir");
+        let desktop_log_path = logs_dir.join(crate::DESKTOP_LOG_FILE);
+        fs::write(&desktop_log_path, "resolve launch plan\nbackend spawned\n")
+            .expect("write desktop log");
+        fs::write(logs_dir.join("backend.log"), "unexpected backend log\n")
+            .expect("write backend log");
+
+        let snapshot = snapshot_for_panel_state(
+            &current_startup_panel_state(&BackendState::default()),
+            &desktop_log_path,
+        );
+
+        assert_eq!(
+            snapshot.desktop_log,
+            vec!["resolve launch plan", "backend spawned"]
+        );
+        assert!(snapshot.backend_log.is_empty());
+
+        fs::remove_dir_all(&root).expect("cleanup temp case dir");
+    }
+
+    #[test]
+    fn remember_backend_log_path_marks_current_end_so_snapshot_skips_previous_launch_lines() {
+        let state = BackendState::default();
+        let root = create_temp_case_dir("snapshot-backend-log-start-offset");
+        let desktop_log_path = root.join(crate::DESKTOP_LOG_FILE);
+        let backend_log_path = root.join("backend.log");
+
+        fs::write(&desktop_log_path, "resolve launch plan\nbackend spawned\n")
+            .expect("write desktop log");
+        fs::write(&backend_log_path, "previous launch line\nold warmup\n")
+            .expect("write existing backend log");
+
+        remember_backend_log_path(&state, backend_log_path.clone());
+
+        let mut backend_log = fs::OpenOptions::new()
+            .append(true)
+            .open(&backend_log_path)
+            .expect("open backend log for append");
+        backend_log
+            .write_all(b"current launch line\nhttp ready\n")
+            .expect("append current backend log");
+
+        let snapshot =
+            snapshot_for_panel_state(&current_startup_panel_state(&state), &desktop_log_path);
+
+        assert_eq!(
+            snapshot.backend_log,
+            vec!["current launch line", "http ready"]
+        );
+
+        fs::remove_dir_all(&root).expect("cleanup temp case dir");
+    }
+
+    #[test]
+    fn remember_desktop_log_start_marks_current_end_so_snapshot_skips_previous_launch_lines() {
+        let state = BackendState::default();
+        let root = create_temp_case_dir("snapshot-desktop-log-start-offset");
+        let desktop_log_path = root.join(crate::DESKTOP_LOG_FILE);
+
+        fs::write(
+            &desktop_log_path,
+            "previous desktop line\nold readiness note\n",
+        )
+        .expect("write existing desktop log");
+
+        remember_desktop_log_start(&state, &desktop_log_path);
+
+        let mut desktop_log = fs::OpenOptions::new()
+            .append(true)
+            .open(&desktop_log_path)
+            .expect("open desktop log for append");
+        desktop_log
+            .write_all(b"current startup line\nhttp ready\n")
+            .expect("append current desktop log");
+
+        let snapshot =
+            snapshot_for_panel_state(&current_startup_panel_state(&state), &desktop_log_path);
+
+        assert_eq!(
+            snapshot.desktop_log,
+            vec!["current startup line", "http ready"]
+        );
+
+        fs::remove_dir_all(&root).expect("cleanup temp case dir");
+    }
+
+    struct CountingCursor {
+        inner: Cursor<Vec<u8>>,
+        bytes_read: usize,
+    }
+
+    impl CountingCursor {
+        fn new(bytes: Vec<u8>) -> Self {
+            Self {
+                inner: Cursor::new(bytes),
+                bytes_read: 0,
+            }
+        }
+    }
+
+    impl Read for CountingCursor {
+        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+            let bytes_read = self.inner.read(buf)?;
+            self.bytes_read += bytes_read;
+            Ok(bytes_read)
+        }
+    }
+
+    impl Seek for CountingCursor {
+        fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+            self.inner.seek(pos)
+        }
+    }
+
+    #[test]
+    fn read_recent_log_tail_reads_only_requested_tail_bytes() {
+        let bytes = b"prefix that should be skipped\nbackend ready\nhttp ready\n".to_vec();
+        let max_bytes = b" skipped\nbackend ready\nhttp ready\n".len();
+        let mut reader = CountingCursor::new(bytes);
+
+        let tail = read_recent_log_tail_from_reader(&mut reader, max_bytes)
+            .expect("read recent log tail from reader");
+
+        assert_eq!(tail, "backend ready\nhttp ready\n");
+        assert_eq!(reader.bytes_read, max_bytes);
+    }
+}
diff --git a/ui/index.html b/ui/index.html
index 773c8ec2..fda4306e 100644
--- a/ui/index.html
+++ b/ui/index.html
@@ -98,6 +98,193 @@
         font-size: 14px;
       }
 
+      .startup-summary {
+        margin-top: 14px;
+        min-height: 40px;
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        padding: 9px 12px;
+        border: 1px solid var(--border);
+        border-radius: 12px;
+        background: linear-gradient(180deg, #fbfcfe 0%, #f7f9fc 100%);
+      }
+
+      .startup-summary-copy {
+        flex: 1;
+        min-width: 0;
+        display: flex;
+        align-items: center;
+        gap: 8px;
+      }
+
+      .startup-summary-label {
+        flex-shrink: 0;
+        color: var(--muted);
+        font-size: 11px;
+        font-weight: 700;
+        letter-spacing: 0.05em;
+        text-transform: uppercase;
+      }
+
+      .startup-summary-text {
+        min-width: 0;
+        overflow: hidden;
+        color: #334155;
+        font-size: 13px;
+        font-weight: 600;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .startup-summary-toggle {
+        flex-shrink: 0;
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+        border: 0;
+        padding: 0;
+        background: transparent;
+        color: var(--accent);
+        font: inherit;
+        font-size: 12px;
+        font-weight: 700;
+        cursor: pointer;
+      }
+
+      .startup-summary-toggle[hidden] {
+        display: none;
+      }
+
+      .startup-summary-chevron {
+        width: 8px;
+        height: 8px;
+        border-right: 1.5px solid currentColor;
+        border-bottom: 1.5px solid currentColor;
+        transform: rotate(45deg);
+        transition: transform 0.18s ease;
+      }
+
+      .startup-summary-toggle[aria-expanded="true"] .startup-summary-chevron {
+        transform: rotate(225deg);
+      }
+
+      .startup-diagnostics {
+        margin-top: 10px;
+        display: grid;
+        gap: 10px;
+        max-height: 208px;
+        overflow-y: auto;
+        overflow-x: hidden;
+        padding: 10px 12px 12px;
+        border: 1px solid var(--border);
+        border-radius: 12px;
+        background: #fbfdff;
+      }
+
+      .startup-diagnostics[hidden] {
+        display: none;
+      }
+
+      .startup-stage-list {
+        display: flex;
+        flex-wrap: nowrap;
+        gap: 6px;
+        overflow-x: auto;
+        margin: 0;
+        padding: 0;
+        list-style: none;
+        scrollbar-width: none;
+      }
+
+      .startup-stage-list::-webkit-scrollbar {
+        display: none;
+      }
+
+      .startup-stage-chip {
+        flex: 0 0 auto;
+        padding: 4px 8px;
+        border: 1px solid #d8e3ed;
+        border-radius: 999px;
+        background: #ffffff;
+        color: #64748b;
+        font-size: 11px;
+        font-weight: 700;
+        line-height: 1;
+      }
+
+      .startup-stage-chip[data-done="true"] {
+        border-color: #bfdceb;
+        background: #eef7fc;
+        color: #246b90;
+      }
+
+      .startup-stage-chip[data-active="true"] {
+        border-color: #3c96ca;
+        background: #e1f1fa;
+        color: #0f617f;
+      }
+
+      .startup-log-grid {
+        display: grid;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+        gap: 8px;
+        min-height: 0;
+      }
+
+      .startup-log-card {
+        min-width: 0;
+        display: grid;
+        gap: 6px;
+        padding: 8px 10px;
+        border: 1px solid #e5ecf3;
+        border-radius: 10px;
+        background: #ffffff;
+      }
+
+      .startup-log-label {
+        margin: 0;
+        color: #64748b;
+        font-size: 11px;
+        font-weight: 700;
+        letter-spacing: 0.06em;
+        text-transform: uppercase;
+      }
+
+      .startup-log-lines {
+        margin: 0;
+        padding: 0;
+        list-style: none;
+        max-height: 96px;
+        overflow: auto;
+        color: #334155;
+        font-family: "SF Mono", "SFMono-Regular", Menlo, Consolas, monospace;
+        font-size: 11px;
+        line-height: 1.45;
+      }
+
+      .startup-log-line {
+        padding: 1px 0;
+        white-space: pre-wrap;
+        word-break: break-word;
+      }
+
+      .startup-log-line.is-empty {
+        color: var(--muted);
+      }
+
+      @media (max-width: 520px) {
+        .startup-log-grid {
+          grid-template-columns: 1fr;
+        }
+      }
+
+      @media (max-width: 460px) {
+        .panel {
+          padding: 20px 20px 18px;
+        }
+      }
+
       .dot {
         width: 8px;
         height: 8px;
@@ -142,6 +329,36 @@ <h1 id="startup-title" class="title"></h1>
           <span class="dot" aria-hidden="true"></span>
           <span id="startup-status" role="status" aria-live="polite"></span>
         </div>
+        <div class="startup-summary">
+          <div class="startup-summary-copy">
+            <span id="startup-summary-label" class="startup-summary-label"></span>
+            <span id="startup-summary-text" class="startup-summary-text"></span>
+          </div>
+          <button
+            id="startup-diagnostics-toggle"
+            class="startup-summary-toggle"
+            type="button"
+            aria-expanded="false"
+            aria-controls="startup-diagnostics"
+            hidden
+          >
+            <span id="startup-diagnostics-toggle-text"></span>
+            <span class="startup-summary-chevron" aria-hidden="true"></span>
+          </button>
+        </div>
+        <section id="startup-diagnostics" class="startup-diagnostics" hidden>
+          <ul id="startup-stage-list" class="startup-stage-list"></ul>
+          <div class="startup-log-grid">
+            <section class="startup-log-card">
+              <h2 id="startup-desktop-log-label" class="startup-log-label"></h2>
+              <ul id="startup-desktop-log-lines" class="startup-log-lines"></ul>
+            </section>
+            <section class="startup-log-card">
+              <h2 id="startup-backend-log-label" class="startup-log-label"></h2>
+              <ul id="startup-backend-log-lines" class="startup-log-lines"></ul>
+            </section>
+          </div>
+        </section>
       </section>
     </main>
     <script src="./startup-copy.js"></script>
@@ -150,11 +367,44 @@ <h1 id="startup-title" class="title"></h1>
         const title = document.getElementById("startup-title");
         const desc = document.getElementById("startup-desc");
         const status = document.getElementById("startup-status");
-        if (!title || !desc || !status) return;
+        const summaryLabel = document.getElementById("startup-summary-label");
+        const summaryText = document.getElementById("startup-summary-text");
+        const diagnosticsToggle = document.getElementById("startup-diagnostics-toggle");
+        const diagnosticsToggleText = document.getElementById(
+          "startup-diagnostics-toggle-text"
+        );
+        const diagnosticsPanel = document.getElementById("startup-diagnostics");
+        const stageList = document.getElementById("startup-stage-list");
+        const desktopLogLabel = document.getElementById("startup-desktop-log-label");
+        const desktopLogLines = document.getElementById("startup-desktop-log-lines");
+        const backendLogLabel = document.getElementById("startup-backend-log-label");
+        const backendLogLines = document.getElementById("startup-backend-log-lines");
+        if (
+          !title ||
+          !desc ||
+          !status ||
+          !summaryLabel ||
+          !summaryText ||
+          !diagnosticsToggle ||
+          !diagnosticsToggleText ||
+          !diagnosticsPanel ||
+          !stageList ||
+          !desktopLogLabel ||
+          !desktopLogLines ||
+          !backendLogLabel ||
+          !backendLogLines
+        ) {
+          return;
+        }
         if (!window.astrbot || !window.astrbot.startupShell) return;
 
         const startupShell = window.astrbot.startupShell;
         const { STARTUP_MODES, STARTUP_COPY } = startupShell;
+        const {
+          STARTUP_DIAGNOSTICS_COPY,
+          STARTUP_PANEL_COMMANDS,
+          STARTUP_PANEL_POLL_INTERVAL_MS,
+        } = startupShell;
 
         const resolveLocaleKey = () => {
           const locale =
@@ -165,23 +415,198 @@ <h1 id="startup-title" class="title"></h1>
         };
 
         const localeKey = resolveLocaleKey();
+        if (document.documentElement) {
+          document.documentElement.lang = localeKey === "en" ? "en" : "zh-CN";
+        }
         const resolveStartupCopy = (mode) => {
           const languageCopy = STARTUP_COPY[localeKey] || STARTUP_COPY.zh;
           return languageCopy[mode] || languageCopy[STARTUP_MODES.LOADING];
         };
+        const diagnosticsCopy =
+          STARTUP_DIAGNOSTICS_COPY[localeKey] || STARTUP_DIAGNOSTICS_COPY.zh;
+        const snapshotCommand =
+          typeof STARTUP_PANEL_COMMANDS?.GET_SNAPSHOT === "string"
+            ? STARTUP_PANEL_COMMANDS.GET_SNAPSHOT
+            : null;
+        const pollIntervalMs =
+          Number.isFinite(STARTUP_PANEL_POLL_INTERVAL_MS) &&
+          STARTUP_PANEL_POLL_INTERVAL_MS >= 400
+            ? STARTUP_PANEL_POLL_INTERVAL_MS
+            : 1500;
+        const invoke =
+          typeof window.__TAURI_INTERNALS__?.invoke === "function"
+            ? window.__TAURI_INTERNALS__.invoke
+            : typeof window.__TAURI__?.core?.invoke === "function"
+              ? window.__TAURI__.core.invoke.bind(window.__TAURI__.core)
+              : null;
+
+        let latestSnapshot = null;
+        let diagnosticsExpanded = false;
+        let pollInFlight = false;
+        let pollTimer = null;
+
+        const normalizeStatusValue = (value, fallback) =>
+          typeof value === "string" && value.trim() ? value.trim() : fallback;
+
+        const setStatusText = (value) => {
+          const nextValue = normalizeStatusValue(value, summaryText.textContent);
+          if (status.textContent === nextValue) return;
+          status.textContent = nextValue;
+        };
+
+        const setSummaryText = (value) => {
+          const nextValue =
+            normalizeStatusValue(value, status.textContent);
+          summaryText.textContent = nextValue;
+          summaryText.title = nextValue;
+        };
+
+        const setDiagnosticsExpanded = (expanded) => {
+          diagnosticsExpanded = Boolean(expanded) && !!latestSnapshot;
+          diagnosticsPanel.hidden = !diagnosticsExpanded;
+          diagnosticsToggle.setAttribute(
+            "aria-expanded",
+            diagnosticsExpanded ? "true" : "false"
+          );
+          diagnosticsToggleText.textContent = diagnosticsExpanded
+            ? diagnosticsCopy.hideDetails
+            : diagnosticsCopy.showDetails;
+        };
+
+        const renderStageItems = (items) => {
+          stageList.replaceChildren();
+          const nextItems = Array.isArray(items) ? items.slice(0, 4) : [];
+          for (const item of nextItems) {
+            const chip = document.createElement("li");
+            const localizedLabel =
+              diagnosticsCopy.stageLabels[
+                typeof item?.key === "string" ? item.key : ""
+              ];
+            chip.className = "startup-stage-chip";
+            chip.dataset.done = item?.done === true ? "true" : "false";
+            chip.dataset.active = item?.active === true ? "true" : "false";
+            chip.textContent = localizedLabel || item?.label || "-";
+            stageList.append(chip);
+          }
+        };
+
+        const renderLogLines = (container, lines) => {
+          container.replaceChildren();
+          const nextLines = Array.isArray(lines)
+            ? lines.filter((line) => typeof line === "string" && line.trim()).slice(-8)
+            : [];
+
+          if (nextLines.length === 0) {
+            const line = document.createElement("li");
+            line.className = "startup-log-line is-empty";
+            line.textContent = diagnosticsCopy.emptyLogLabel;
+            container.append(line);
+            return;
+          }
+
+          for (const entry of nextLines) {
+            const line = document.createElement("li");
+            line.className = "startup-log-line";
+            line.textContent = entry;
+            container.append(line);
+          }
+        };
+
+        const resolveSnapshotSummary = (snapshot) => {
+          const localizedSummary =
+            diagnosticsCopy.stageSummaries?.[
+              typeof snapshot?.stage === "string" ? snapshot.stage : ""
+            ];
+          const snapshotSummary =
+            typeof snapshot?.summary === "string" && snapshot.summary.trim()
+              ? snapshot.summary.trim()
+              : "";
+          const isGenericFailureSummary =
+            snapshotSummary.toLowerCase() === "startup failed";
+
+          if (snapshot?.stage === "failed") {
+            if (!snapshotSummary || isGenericFailureSummary) {
+              return localizedSummary || status.textContent;
+            }
+
+            return snapshotSummary || localizedSummary || status.textContent;
+          }
+
+          return localizedSummary || snapshotSummary || status.textContent;
+        };
+
+        const applySnapshot = (snapshot) => {
+          if (!snapshot || typeof snapshot !== "object") return;
+          latestSnapshot = snapshot;
+          renderStageItems(snapshot.items);
+          renderLogLines(desktopLogLines, snapshot.desktopLog);
+          renderLogLines(backendLogLines, snapshot.backendLog);
+          setStatusText(resolveSnapshotSummary(snapshot));
+          setSummaryText(resolveSnapshotSummary(snapshot));
+          diagnosticsToggle.hidden = false;
+          setDiagnosticsExpanded(diagnosticsExpanded);
+        };
 
         const applyStartupMode = (mode) => {
           const next = resolveStartupCopy(mode);
           title.textContent = next.title;
           desc.textContent = next.desc;
-          if (status.textContent === next.status) return;
-          status.textContent = next.status;
+          if (latestSnapshot) return;
+
+          setSummaryText(next.status);
+          setStatusText(next.status);
         };
 
+        const pollStartupPanelSnapshot = async () => {
+          if (typeof invoke !== "function" || !snapshotCommand || pollInFlight) return;
+
+          pollInFlight = true;
+          try {
+            const snapshot = await invoke(snapshotCommand);
+            applySnapshot(snapshot);
+          } catch {
+            // Keep showing the previous static copy or last successful snapshot.
+          } finally {
+            pollInFlight = false;
+          }
+        };
+
+        const startSnapshotPolling = () => {
+          if (typeof invoke !== "function" || !snapshotCommand) return;
+          void pollStartupPanelSnapshot();
+          pollTimer = window.setInterval(() => {
+            void pollStartupPanelSnapshot();
+          }, pollIntervalMs);
+          window.addEventListener(
+            "pagehide",
+            () => {
+              if (pollTimer !== null) {
+                window.clearInterval(pollTimer);
+                pollTimer = null;
+              }
+            },
+            { once: true }
+          );
+        };
+
+        summaryLabel.textContent = diagnosticsCopy.summaryLabel;
+        diagnosticsToggleText.textContent = diagnosticsCopy.showDetails;
+        stageList.setAttribute("aria-label", diagnosticsCopy.stageListLabel);
+        desktopLogLabel.textContent = diagnosticsCopy.desktopLogLabel;
+        backendLogLabel.textContent = diagnosticsCopy.backendLogLabel;
+        diagnosticsToggle.hidden = true;
+        setDiagnosticsExpanded(false);
+
+        diagnosticsToggle.addEventListener("click", () => {
+          if (!latestSnapshot) return;
+          setDiagnosticsExpanded(!diagnosticsExpanded);
+        });
+
         window.__astrbotSetStartupMode = (mode) => {
           applyStartupMode(typeof mode === "string" ? mode : STARTUP_MODES.LOADING);
         };
         applyStartupMode(STARTUP_MODES.LOADING);
+        startSnapshotPolling();
       })();
     </script>
   </body>
diff --git a/ui/startup-copy.js b/ui/startup-copy.js
index 880b2351..3f4bd11a 100644
--- a/ui/startup-copy.js
+++ b/ui/startup-copy.js
@@ -14,9 +14,17 @@ const STARTUP_MODES = {
   PANEL_UPDATE: 'panel-update',
 };
 
+const STARTUP_PANEL_COMMANDS = {
+  GET_SNAPSHOT: 'desktop_bridge_get_startup_panel_snapshot',
+};
+
+const STARTUP_PANEL_POLL_INTERVAL_MS = 1500;
+
 window.astrbot = window.astrbot || {};
 window.astrbot.startupShell = deepFreeze({
   STARTUP_MODES,
+  STARTUP_PANEL_COMMANDS,
+  STARTUP_PANEL_POLL_INTERVAL_MS,
   STARTUP_COPY: {
     en: {
       [STARTUP_MODES.LOADING]: {
@@ -43,4 +51,50 @@ window.astrbot.startupShell = deepFreeze({
       },
     },
   },
+  STARTUP_DIAGNOSTICS_COPY: {
+    en: {
+      summaryLabel: 'Startup',
+      showDetails: 'Details',
+      hideDetails: 'Hide',
+      stageListLabel: 'Startup stages',
+      stageSummaries: {
+        resolveLaunchPlan: 'Resolving launch plan',
+        spawnBackend: 'Spawning backend',
+        tcpReachable: 'TCP ready, waiting for HTTP',
+        httpReady: 'Backend ready',
+        failed: 'Startup failed',
+      },
+      desktopLogLabel: 'Desktop',
+      backendLogLabel: 'Backend',
+      emptyLogLabel: 'No recent lines',
+      stageLabels: {
+        plan: 'Plan',
+        spawn: 'Spawn',
+        tcp: 'TCP',
+        http: 'HTTP',
+      },
+    },
+    zh: {
+      summaryLabel: '启动',
+      showDetails: '详情',
+      hideDetails: '收起',
+      stageListLabel: '启动阶段',
+      stageSummaries: {
+        resolveLaunchPlan: '正在解析启动计划',
+        spawnBackend: '正在启动后端',
+        tcpReachable: 'TCP 已就绪，正在等待 HTTP',
+        httpReady: '后端已就绪',
+        failed: '启动失败',
+      },
+      desktopLogLabel: '桌面端',
+      backendLogLabel: '后端',
+      emptyLogLabel: '暂无最近日志',
+      stageLabels: {
+        plan: '计划',
+        spawn: '拉起',
+        tcp: 'TCP',
+        http: 'HTTP',
+      },
+    },
+  },
 });

From 9473b9f4f46f30b0fcfd410f4a7d3d86e4e15b7e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=82=B9=E6=B0=B8=E8=B5=AB?= <1259085392@qq.com>
Date: Thu, 19 Mar 2026 19:40:42 +0900
Subject: [PATCH 2/3] fix(startup): satisfy clippy for startup panel tests

---
 src-tauri/src/window/startup_panel.rs | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/src-tauri/src/window/startup_panel.rs b/src-tauri/src/window/startup_panel.rs
index 16d59484..37c76791 100644
--- a/src-tauri/src/window/startup_panel.rs
+++ b/src-tauri/src/window/startup_panel.rs
@@ -184,6 +184,7 @@ fn read_recent_log_tail_after(path: &Path, start_offset: u64, max_bytes: usize)
     read_recent_log_tail_from_reader_after(&mut file, start_offset, max_bytes).unwrap_or_default()
 }
 
+#[cfg(test)]
 fn read_recent_log_tail_from_reader<R>(reader: &mut R, max_bytes: usize) -> io::Result<String>
 where
     R: Read + Seek,
@@ -303,14 +304,14 @@ mod tests {
             .expect("non-failed stages should produce stage items");
 
         assert_eq!(items.len(), 4);
-        assert_eq!(items[0].done, true);
-        assert_eq!(items[0].active, false);
-        assert_eq!(items[1].done, true);
-        assert_eq!(items[1].active, false);
-        assert_eq!(items[2].done, false);
-        assert_eq!(items[2].active, true);
-        assert_eq!(items[3].done, false);
-        assert_eq!(items[3].active, false);
+        assert!(items[0].done);
+        assert!(!items[0].active);
+        assert!(items[1].done);
+        assert!(!items[1].active);
+        assert!(!items[2].done);
+        assert!(items[2].active);
+        assert!(!items[3].done);
+        assert!(!items[3].active);
     }
 
     #[test]

From 9f0d58b744c0d7a6dc5ac9a0d0a5c2514e543b5f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=82=B9=E6=B0=B8=E8=B5=AB?= <1259085392@qq.com>
Date: Thu, 19 Mar 2026 20:08:20 +0900
Subject: [PATCH 3/3] ci: update pnpm action for Node 24

---
 .github/actions/setup-desktop-build/action.yml | 2 +-
 .github/workflows/build-desktop-tauri.yml      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/actions/setup-desktop-build/action.yml b/.github/actions/setup-desktop-build/action.yml
index a181c8a3..b6fcb24b 100644
--- a/.github/actions/setup-desktop-build/action.yml
+++ b/.github/actions/setup-desktop-build/action.yml
@@ -33,7 +33,7 @@ runs:
         node-version: ${{ inputs.node-version }}
 
     - name: Setup pnpm
-      uses: pnpm/action-setup@v4.2.0
+      uses: pnpm/action-setup@v4.4.0
       with:
         version: ${{ inputs.pnpm-version }}
 
diff --git a/.github/workflows/build-desktop-tauri.yml b/.github/workflows/build-desktop-tauri.yml
index 392a7abf..8ff78439 100644
--- a/.github/workflows/build-desktop-tauri.yml
+++ b/.github/workflows/build-desktop-tauri.yml
@@ -108,7 +108,7 @@ jobs:
           setup-python: 'false'
 
       - name: Setup pnpm
-        uses: pnpm/action-setup@v4.2.0
+        uses: pnpm/action-setup@v4.4.0
         with:
           version: 10.28.2