Add startup visual modes and attempt registry

Implement startup visual behavior, de-duplicate startup attempts, and improve failure UX.

Key changes:
- Add spec and docs for startup visuals and timing contract (.trae/specs and docs/LAUNCHER_STARTUP_VISUALS.md).
- Introduce StartupVisualPreferences contract and resolver; create SplashWindow via resolved mode.
- Add StartupAttemptRecord model and a file-backed StartupAttemptRegistry to persist and coordinate in-progress startup attempts (attach/adopt, soft/hard timeouts, IPC/connect state, lifecycle updates).
- Update LauncherFlowCoordinator to: adopt/attach to existing attempts, track IPC connection and soft/hard timeouts (30s/120s), show delayed UI state, attempt foreground recovery via public IPC, compose detailed launch result metadata, and mark registry states (soft timeout, detached waiting, succeeded, failed).
- Add TryActivateExistingInstanceAsync to attempt activating an existing desktop via IPC.
- Change failure flow: ShowFailureWindowAsync now returns user choice; ErrorWindow updated to present Activate/Wait/Open Logs/Exit semantics and new layouts/styles; improved button wiring and debug/dev mode handling.
- Add UI and resource tweaks (ErrorWindow and SplashWindow changes), project asset link for nightly logo, and unit tests for StartupVisualPreferences.

These changes prevent duplicate desktop processes during slow startups, provide clearer UX for delayed startups, and persist startup attempt state across Launcher invocations for safer recovery/attach behavior.

LanMountainDesktop.Launcher/App.axaml.cs

@@ -6,6 +6,9 @@ using Avalonia.Threading;
 using LanMountainDesktop.Launcher.Models;
 using LanMountainDesktop.Launcher.Services;
 using LanMountainDesktop.Launcher.Views;
+using LanMountainDesktop.Shared.Contracts.Launcher;
+using LanMountainDesktop.Shared.IPC;
+using LanMountainDesktop.Shared.IPC.Abstractions.Services;
 
 namespace LanMountainDesktop.Launcher;
 
@@ -52,7 +55,7 @@ public partial class App : Application
             }
             else
             {
-                var splashWindow = new SplashWindow();
+                var splashWindow = CreateSplashWindow();
                 splashWindow.Show();
                 _ = RunCoordinatorWithSplashAsync(desktop, context, splashWindow);
             }
@@ -68,7 +71,7 @@ public partial class App : Application
             case "preview-splash":
             {
                 Logger.Info("Preview command: splash.");
-                var splashWindow = new SplashWindow();
+                var splashWindow = CreateSplashWindow();
                 splashWindow.SetDebugMode(true);
                 splashWindow.Show();
                 _ = SimulateSplashPreviewAsync(desktop, splashWindow);
@@ -112,6 +115,12 @@ public partial class App : Application
         }
     }
 
+    private static SplashWindow CreateSplashWindow()
+    {
+        var preferences = StartupVisualPreferencesResolver.Resolve();
+        return new SplashWindow(preferences.Mode);
+    }
+
     private async Task SimulateSplashPreviewAsync(IClassicDesktopStyleApplicationLifetime desktop, SplashWindow window)
     {
         var stages = new[] { "initializing", "update", "plugins", "launch", "ready" };
@@ -172,49 +181,76 @@ public partial class App : Application
         SplashWindow splashWindow)
     {
         LauncherResult result;
+        SplashWindow? currentSplashWindow = splashWindow;
+        var appRoot = Commands.ResolveAppRoot(context);
 
-        try
+        while (true)
         {
-            var appRoot = Commands.ResolveAppRoot(context);
-            Logger.Info(
-                $"Coordinator start. Command='{context.Command}'; AppRoot='{appRoot}'; " +
-                $"IsDebugMode={context.IsDebugMode}; LaunchSource='{context.LaunchSource}'; " +
-                $"ResultPath='{context.GetOption("result") ?? "<none>"}'.");
-
-            var deploymentLocator = new DeploymentLocator(appRoot);
-            var coordinator = new LauncherFlowCoordinator(
-                context,
-                deploymentLocator,
-                new OobeStateService(appRoot),
-                new UpdateEngineService(deploymentLocator),
-                new PluginInstallerService());
-
-            result = await coordinator.RunAsync(splashWindow).ConfigureAwait(false);
-        }
-        catch (Exception ex)
-        {
-            Logger.Error("Coordinator threw an unhandled exception.", ex);
-            result = new LauncherResult
+            try
             {
-                Success = false,
-                Stage = "launch",
-                Code = "exception",
-                Message = $"Launcher failed: {ex.Message}",
-                ErrorMessage = ex.ToString()
-            };
+                Logger.Info(
+                    $"Coordinator start. Command='{context.Command}'; AppRoot='{appRoot}'; " +
+                    $"IsDebugMode={context.IsDebugMode}; LaunchSource='{context.LaunchSource}'; " +
+                    $"ResultPath='{context.GetOption("result") ?? "<none>"}'.");
+
+                var deploymentLocator = new DeploymentLocator(appRoot);
+                var coordinator = new LauncherFlowCoordinator(
+                    context,
+                    deploymentLocator,
+                    new OobeStateService(appRoot),
+                    new UpdateEngineService(deploymentLocator),
+                    new PluginInstallerService());
+
+                result = await coordinator.RunAsync(currentSplashWindow).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                Logger.Error("Coordinator threw an unhandled exception.", ex);
+                result = new LauncherResult
+                {
+                    Success = false,
+                    Stage = "launch",
+                    Code = "exception",
+                    Message = $"Launcher failed: {ex.Message}",
+                    ErrorMessage = ex.ToString()
+                };
+            }
+
+            if (result.Success ||
+                result.Code == "host_not_found" ||
+                (!string.Equals(result.Stage, "launch", StringComparison.OrdinalIgnoreCase) &&
+                 !string.Equals(result.Stage, "launchHost", StringComparison.OrdinalIgnoreCase)))
+            {
+                break;
+            }
+
+            var failureAction = await ShowFailureWindowAsync(result).ConfigureAwait(false);
+            if (failureAction == ErrorWindowResult.Exit)
+            {
+                break;
+            }
+
+            if (failureAction == ErrorWindowResult.ActivateExisting &&
+                await TryActivateExistingInstanceAsync().ConfigureAwait(false))
+            {
+                result = new LauncherResult
+                {
+                    Success = true,
+                    Stage = "launch",
+                    Code = "activation_requested",
+                    Message = "Launcher activated the existing desktop instance.",
+                    Details = result.Details
+                };
+                break;
+            }
+
+            currentSplashWindow = CreateSplashWindow();
+            currentSplashWindow.Show();
         }
 
         Logger.Info($"Coordinator completed. Success={result.Success}; Stage='{result.Stage}'; Code='{result.Code}'.");
         await WriteLauncherResultAsync(context, result).ConfigureAwait(false);
 
-        if (!result.Success &&
-            result.Code is not "host_not_found" &&
-            (string.Equals(result.Stage, "launch", StringComparison.OrdinalIgnoreCase) ||
-             string.Equals(result.Stage, "launchHost", StringComparison.OrdinalIgnoreCase)))
-        {
-            await ShowFailureWindowAsync(result).ConfigureAwait(false);
-        }
-
         Environment.ExitCode = result.Success ? 0 : 1;
         await Dispatcher.UIThread.InvokeAsync(() => desktop.Shutdown(Environment.ExitCode), DispatcherPriority.Background);
     }
@@ -238,15 +274,31 @@ public partial class App : Application
         }
     }
 
-    private static async Task ShowFailureWindowAsync(LauncherResult result)
+    private static async Task<ErrorWindowResult> ShowFailureWindowAsync(LauncherResult result)
     {
         ErrorWindow? errorWindow = null;
+        var hostProcessAlive = result.Details.TryGetValue("hostProcessAlive", out var hostProcessAliveText) &&
+                               bool.TryParse(hostProcessAliveText, out var hostProcessAliveValue) &&
+                               hostProcessAliveValue;
+        var hostPid = result.Details.TryGetValue("hostPid", out var hostPidText) &&
+                      int.TryParse(hostPidText, out var parsedPid)
+            ? parsedPid
+            : (int?)null;
 
         await Dispatcher.UIThread.InvokeAsync(() =>
         {
             try
             {
                 errorWindow = new ErrorWindow();
+                if (hostProcessAlive)
+                {
+                    errorWindow.ConfigureForRunningHostFailure(hostPid);
+                }
+                else
+                {
+                    errorWindow.ConfigureForGenericFailure(allowRetry: true);
+                }
+
                 errorWindow.SetErrorMessage(
                     $"Failed to start LanMountainDesktop.\n\nStage: {result.Stage}\nCode: {result.Code}\n\n{result.Message}");
                 errorWindow.Show();
@@ -259,16 +311,38 @@ public partial class App : Application
 
         if (errorWindow is null)
         {
-            return;
+            return ErrorWindowResult.Exit;
         }
 
         try
         {
-            await errorWindow.WaitForChoiceAsync().ConfigureAwait(false);
+            return await errorWindow.WaitForChoiceAsync().ConfigureAwait(false);
         }
         catch (Exception ex)
         {
             Logger.Error("Failure window closed unexpectedly.", ex);
+            return ErrorWindowResult.Exit;
+        }
+    }
+
+    private static async Task<bool> TryActivateExistingInstanceAsync()
+    {
+        try
+        {
+            using var ipcClient = new LanMountainDesktopIpcClient();
+            await ipcClient.ConnectAsync().ConfigureAwait(false);
+            if (!ipcClient.IsConnected)
+            {
+                return false;
+            }
+
+            var shellProxy = ipcClient.CreateProxy<IPublicShellControlService>();
+            return await shellProxy.ActivateMainWindowAsync().ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"Failed to activate the existing desktop instance: {ex.Message}");
+            return false;
         }
     }
 

LanMountainDesktop.Launcher/LanMountainDesktop.Launcher.csproj

@@ -35,6 +35,7 @@
     <None Include="Assets\public-key.pem" CopyToOutputDirectory="PreserveNewest" />
     <!-- Avalonia 资源文件 -->
     <AvaloniaResource Include="Assets\logo.ico" />
+    <AvaloniaResource Include="..\LanMountainDesktop\Assets\logo_nightly.png" Link="Assets\logo_nightly.png" />
   </ItemGroup>
 
   <Target Name="CopyPublicKeyToLauncherDir" AfterTargets="Build">

LanMountainDesktop.Launcher/Models/StartupAttemptRecord.cs

@@ -0,0 +1,46 @@
+using System.Text.Json.Serialization;
+using LanMountainDesktop.Shared.Contracts.Launcher;
+
+namespace LanMountainDesktop.Launcher.Models;
+
+internal enum StartupAttemptState
+{
+    Pending,
+    SoftTimeout,
+    DetachedWaiting,
+    Succeeded,
+    Failed
+}
+
+internal sealed class StartupAttemptRecord
+{
+    [JsonPropertyName("attemptId")]
+    public string AttemptId { get; set; } = Guid.NewGuid().ToString("N");
+
+    [JsonPropertyName("hostPid")]
+    public int HostPid { get; set; }
+
+    [JsonPropertyName("startedAtUtc")]
+    public DateTimeOffset StartedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+
+    [JsonPropertyName("updatedAtUtc")]
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+
+    [JsonPropertyName("launchSource")]
+    public string LaunchSource { get; set; } = string.Empty;
+
+    [JsonPropertyName("successPolicy")]
+    public string SuccessPolicy { get; set; } = string.Empty;
+
+    [JsonPropertyName("lastObservedStage")]
+    public StartupStage LastObservedStage { get; set; } = StartupStage.Initializing;
+
+    [JsonPropertyName("lastObservedMessage")]
+    public string LastObservedMessage { get; set; } = string.Empty;
+
+    [JsonPropertyName("ipcConnected")]
+    public bool IpcConnected { get; set; }
+
+    [JsonPropertyName("state")]
+    public StartupAttemptState State { get; set; } = StartupAttemptState.Pending;
+}

LanMountainDesktop.Launcher/Services/LauncherFlowCoordinator.cs

@@ -10,6 +10,11 @@ namespace LanMountainDesktop.Launcher.Services;
 
 internal sealed class LauncherFlowCoordinator
 {
+    private static readonly TimeSpan StartupSoftTimeout = TimeSpan.FromSeconds(30);
+    private static readonly TimeSpan StartupHardTimeout = TimeSpan.FromSeconds(120);
+    private const string SoftTimeoutStatusMessage = "设备较慢，仍在启动，请稍候。";
+    private const string SoftTimeoutDetailsMessage = "桌面主进程仍在运行，Launcher 会继续等待，不会重复启动。";
+
     private static readonly string[] LauncherOnlyOptions =
     [
         "debug", "show-loading-details", "plugins-dir", "source", "result",
@@ -25,6 +30,7 @@ internal sealed class LauncherFlowCoordinator
     private readonly OobeStateService _oobeStateService;
     private readonly UpdateEngineService _updateEngine;
     private readonly PluginInstallerService _pluginInstallerService;
+    private readonly StartupAttemptRegistry _startupAttemptRegistry;
     private readonly IReadOnlyList<IOobeStep> _oobeSteps;
 
     public LauncherFlowCoordinator(
@@ -39,6 +45,7 @@ internal sealed class LauncherFlowCoordinator
         _oobeStateService = oobeStateService;
         _updateEngine = updateEngine;
         _pluginInstallerService = pluginInstallerService;
+        _startupAttemptRegistry = new StartupAttemptRegistry();
         _oobeSteps = [new WelcomeOobeStep(_oobeStateService, _context)];
     }
 
@@ -66,6 +73,7 @@ internal sealed class LauncherFlowCoordinator
                 window.Show();
                 return window;
             });
+            var windowsClosingByCoordinator = false;
             var versionInfo = _deploymentLocator.GetVersionInfo();
             splashWindow.SetVersionInfo(versionInfo.Version, versionInfo.Codename);
             var reporter = (ISplashStageReporter)splashWindow;
@@ -85,8 +93,25 @@ internal sealed class LauncherFlowCoordinator
             var lastStage = StartupStage.Initializing;
             var lastStageMessage = "launcher-started";
             var startupSuccessTracker = new StartupSuccessTracker(_context);
+            var activationFailureReason = string.Empty;
+            var ipcConnected = false;
+            var softTimeoutShown = false;
+            var attachedToExistingAttempt = false;
+            StartupAttemptRecord? trackedAttempt = null;
 
             var loadingState = new LoadingStateMessage();
+            EventHandler? splashClosedHandler = null;
+            splashClosedHandler = (_, _) =>
+            {
+                if (windowsClosingByCoordinator)
+                {
+                    return;
+                }
+
+                _startupAttemptRegistry.MarkOwnedDetachedWaiting();
+                Logger.Warn("Splash window was closed manually. Launcher will continue monitoring the current startup attempt.");
+            };
+            splashWindow.Closed += splashClosedHandler;
             using var ipcClient = new LanMountainDesktopIpcClient();
             ipcClient.RegisterNotifyHandler<StartupProgressMessage>(IpcRoutedNotifyIds.LauncherStartupProgress, message =>
             {
@@ -94,8 +119,9 @@ internal sealed class LauncherFlowCoordinator
                 {
                     try
                     {
+                        ipcConnected = true;
                         lastStage = message.Stage;
-                        lastStageMessage = message.Message ?? string.Empty;
+                        lastStageMessage = message.Message ?? message.Stage.ToString();
                         Logger.Info($"IPC stage received. Stage='{message.Stage}'; Message='{message.Message ?? string.Empty}'.");
 
                         loadingState = loadingState with
@@ -108,6 +134,7 @@ internal sealed class LauncherFlowCoordinator
 
                         reporter.Report(MapStartupStageToSplashStage(message.Stage), message.Message ?? message.Stage.ToString());
                         loadingDetailsWindow?.UpdateLoadingState(loadingState);
+                        _startupAttemptRegistry.UpdateOwnedStage(message.Stage, message.Message, ipcConnected: true);
 
                         if (startupSuccessTracker.TryResolve(message.Stage, out var successState))
                         {
@@ -116,6 +143,7 @@ internal sealed class LauncherFlowCoordinator
 
                         if (message.Stage == StartupStage.ActivationFailed)
                         {
+                            activationFailureReason = message.Message ?? "activation_failed";
                             activationFailedTcs.TrySetResult(message.Message ?? "activation_failed");
                         }
                     }
@@ -170,7 +198,90 @@ internal sealed class LauncherFlowCoordinator
                 }
 
                 reporter.Report("launch", "Launching desktop...");
-                var launchOutcome = await LaunchHostWithIpcAsync().ConfigureAwait(false);
+                var launchOutcome = default(HostLaunchOutcome);
+                var attachableAttempt = _startupAttemptRegistry.TryGetAttachableAttempt(_context.LaunchSource, startupSuccessTracker.PolicyKey);
+                if (attachableAttempt is not null &&
+                    _startupAttemptRegistry.AdoptAttempt(attachableAttempt.AttemptId) &&
+                    TryGetLiveProcess(attachableAttempt.HostPid, out var attachedProcess))
+                {
+                    trackedAttempt = attachableAttempt;
+                    attachedToExistingAttempt = true;
+                    ipcConnected = attachableAttempt.IpcConnected;
+                    lastStage = attachableAttempt.LastObservedStage;
+                    lastStageMessage = string.IsNullOrWhiteSpace(attachableAttempt.LastObservedMessage)
+                        ? "Attached to the existing startup attempt."
+                        : attachableAttempt.LastObservedMessage;
+                    reporter.Report(MapStartupStageToSplashStage(lastStage), lastStageMessage);
+
+                    if (startupSuccessTracker.TryResolve(lastStage, out var attachedSuccessState))
+                    {
+                        windowsClosingByCoordinator = true;
+                        _startupAttemptRegistry.MarkOwnedSucceeded(attachedSuccessState.Stage, attachedSuccessState.Message);
+                        await CloseWindowsAsync(splashWindow, loadingDetailsWindow).ConfigureAwait(false);
+                        return BuildResult(
+                            success: true,
+                            stage: "launch",
+                            code: attachedSuccessState.Code,
+                            message: attachedSuccessState.Message,
+                            details: MergeDetails(
+                                launcherContextDetails,
+                                BuildAttemptDetails(
+                                    trackedAttempt,
+                                    attachedToExistingAttempt,
+                                    ipcConnected,
+                                    hostProcessAlive: true,
+                                    lastStage,
+                                    lastStageMessage,
+                                    activationFailureReason,
+                                    softTimeoutShown: false,
+                                    recoveryActivationAttempted: false)));
+                    }
+
+                    if (attachableAttempt.State is StartupAttemptState.SoftTimeout or StartupAttemptState.DetachedWaiting)
+                    {
+                        softTimeoutShown = true;
+                        reporter.Report("delayed", SoftTimeoutStatusMessage);
+                        loadingState = BuildDelayedLoadingState(
+                            loadingState,
+                            SoftTimeoutStatusMessage,
+                            SoftTimeoutDetailsMessage,
+                            trackedAttempt.StartedAtUtc);
+                        loadingDetailsWindow?.UpdateLoadingState(loadingState);
+                    }
+
+                    launchOutcome = HostLaunchOutcome.FromProcess(
+                        attachedProcess!,
+                        BuildResult(
+                            true,
+                            "launchHost",
+                            "attached_attempt",
+                            "Attached to an existing startup attempt.",
+                            BuildAttemptDetails(
+                                trackedAttempt,
+                                attachedToExistingAttempt,
+                                ipcConnected,
+                                hostProcessAlive: true,
+                                lastStage,
+                                lastStageMessage,
+                                activationFailureReason,
+                                softTimeoutShown,
+                                recoveryActivationAttempted: false)),
+                        BuildAttemptDetails(
+                            trackedAttempt,
+                            attachedToExistingAttempt,
+                            ipcConnected,
+                            hostProcessAlive: true,
+                            lastStage,
+                            lastStageMessage,
+                            activationFailureReason,
+                            softTimeoutShown,
+                            recoveryActivationAttempted: false));
+                }
+                else
+                {
+                    launchOutcome = await LaunchHostWithIpcAsync().ConfigureAwait(false);
+                }
+
                 if (!launchOutcome.Result.Success)
                 {
                     return WithAdditionalDetails(launchOutcome.Result, launcherContextDetails);
@@ -189,7 +300,30 @@ internal sealed class LauncherFlowCoordinator
                         stage: "launch",
                         code: "host_start_failed",
                         message: "Host launch did not create a process.",
-                        details: MergeDetails(launcherContextDetails, launchOutcome.Details));
+                        details: MergeDetails(
+                            launcherContextDetails,
+                            MergeDetails(
+                                launchOutcome.Details,
+                                BuildAttemptDetails(
+                                    trackedAttempt,
+                                    attachedToExistingAttempt,
+                                    ipcConnected,
+                                    hostProcessAlive: false,
+                                    lastStage,
+                                    lastStageMessage,
+                                    activationFailureReason,
+                                    softTimeoutShown,
+                                    recoveryActivationAttempted: false))));
+                }
+
+                if (!attachedToExistingAttempt)
+                {
+                    trackedAttempt = _startupAttemptRegistry.StartOwnedAttempt(
+                        launchOutcome.Process.Id,
+                        _context.LaunchSource,
+                        startupSuccessTracker.PolicyKey,
+                        lastStage,
+                        lastStageMessage);
                 }
 
                 var connected = await TryConnectToPublicIpcAsync(ipcClient, TimeSpan.FromSeconds(5)).ConfigureAwait(false);
@@ -197,68 +331,172 @@ internal sealed class LauncherFlowCoordinator
                 {
                     Logger.Warn("Timed out waiting for host public IPC. Launcher will continue without live startup notifications.");
                 }
+                else
+                {
+                    ipcConnected = true;
+                    _startupAttemptRegistry.MarkOwnedIpcConnected();
+                }
+
+                Dictionary<string, string> ComposeLaunchDetails(bool hostProcessAlive, bool recoveryActivationAttempted = false)
+                {
+                    return MergeDetails(
+                        launcherContextDetails,
+                        MergeDetails(
+                            launchOutcome.Details,
+                            BuildAttemptDetails(
+                                trackedAttempt,
+                                attachedToExistingAttempt,
+                                ipcConnected,
+                                hostProcessAlive,
+                                lastStage,
+                                lastStageMessage,
+                                activationFailureReason,
+                                softTimeoutShown,
+                                recoveryActivationAttempted)));
+                }
 
                 var processExitTask = launchOutcome.Process.WaitForExitAsync();
-                var completedTask = await Task.WhenAny(
-                    successTcs.Task,
-                    activationFailedTcs.Task,
-                    processExitTask,
-                    Task.Delay(TimeSpan.FromSeconds(30))).ConfigureAwait(false);
+                var startedAt = trackedAttempt?.StartedAtUtc ?? DateTimeOffset.UtcNow;
+                var softTimeoutAt = startedAt + StartupSoftTimeout;
+                var hardTimeoutAt = startedAt + StartupHardTimeout;
+                var nextReconnectAttemptAt = DateTimeOffset.UtcNow.AddSeconds(5);
 
-                if (completedTask == successTcs.Task)
+                while (true)
                 {
-                    var successState = await successTcs.Task.ConfigureAwait(false);
-                    await CloseWindowsAsync(splashWindow, loadingDetailsWindow).ConfigureAwait(false);
-                    return BuildResult(
-                        success: true,
-                        stage: "launch",
-                        code: successState.Code,
-                        message: successState.Message,
-                        details: MergeDetails(launcherContextDetails, launchOutcome.Details));
-                }
-
-                if (completedTask == activationFailedTcs.Task)
-                {
-                    Logger.Warn($"Activation failure received before desktop visibility. Reason='{await activationFailedTcs.Task.ConfigureAwait(false)}'.");
-                    var retryOutcome = await RetryActivationAfterEarlyFailureAsync().ConfigureAwait(false);
-                    if (retryOutcome is not null)
+                    if (successTcs.Task.IsCompleted)
                     {
+                        var successState = await successTcs.Task.ConfigureAwait(false);
+                        windowsClosingByCoordinator = true;
+                        _startupAttemptRegistry.MarkOwnedSucceeded(successState.Stage, successState.Message);
                         await CloseWindowsAsync(splashWindow, loadingDetailsWindow).ConfigureAwait(false);
-                        return WithAdditionalDetails(retryOutcome, launcherContextDetails);
+                        return BuildResult(
+                            success: true,
+                            stage: "launch",
+                            code: successState.Code,
+                            message: successState.Message,
+                            details: ComposeLaunchDetails(!launchOutcome.Process.HasExited));
                     }
+
+                    if (activationFailedTcs.Task.IsCompleted && string.IsNullOrWhiteSpace(activationFailureReason))
+                    {
+                        activationFailureReason = await activationFailedTcs.Task.ConfigureAwait(false);
+                        Logger.Warn($"Activation failure received before startup success. Reason='{activationFailureReason}'.");
+                    }
+
+                    if (processExitTask.IsCompleted)
+                    {
+                        var exitCode = launchOutcome.Process.ExitCode;
+                        Logger.Warn($"Host exited before startup success criteria were met. ExitCode={exitCode}.");
+
+                        windowsClosingByCoordinator = true;
+                        if (exitCode == HostExitCodes.SecondaryActivationSucceeded)
+                        {
+                            _startupAttemptRegistry.MarkOwnedSucceeded(StartupStage.ActivationRedirected, "Host redirected activation to the existing desktop instance.");
+                            await CloseWindowsAsync(splashWindow, loadingDetailsWindow).ConfigureAwait(false);
+                            return BuildResult(
+                                success: true,
+                                stage: "launch",
+                                code: "activation_redirected",
+                                message: "Host redirected activation to the existing desktop instance.",
+                                details: MergeDetails(
+                                    ComposeLaunchDetails(hostProcessAlive: false),
+                                    new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+                                    {
+                                        ["exitCode"] = exitCode.ToString()
+                                    }));
+                        }
+
+                        _startupAttemptRegistry.MarkOwnedFailed(lastStage, activationFailureReason);
+                        await CloseWindowsAsync(splashWindow, loadingDetailsWindow).ConfigureAwait(false);
+                        return BuildResult(
+                            success: false,
+                            stage: "launch",
+                            code: exitCode is HostExitCodes.SecondaryActivationFailed or HostExitCodes.RestartLockNotAcquired
+                                ? "activation_failed"
+                                : "host_exited_early",
+                            message: exitCode is HostExitCodes.SecondaryActivationFailed or HostExitCodes.RestartLockNotAcquired
+                                ? $"Host activation handshake failed before the required startup state was reported. ExitCode={exitCode}."
+                                : $"Host exited before the required startup state was reported. ExitCode={exitCode}.",
+                            details: MergeDetails(
+                                ComposeLaunchDetails(hostProcessAlive: false),
+                                new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+                                {
+                                    ["exitCode"] = exitCode.ToString()
+                                }));
+                    }
+
+                    var now = DateTimeOffset.UtcNow;
+                    if (!ipcConnected &&
+                        !launchOutcome.Process.HasExited &&
+                        now >= nextReconnectAttemptAt)
+                    {
+                        connected = await TryConnectToPublicIpcAsync(ipcClient, TimeSpan.FromMilliseconds(800)).ConfigureAwait(false);
+                        if (connected)
+                        {
+                            ipcConnected = true;
+                            _startupAttemptRegistry.MarkOwnedIpcConnected();
+                        }
+
+                        nextReconnectAttemptAt = DateTimeOffset.UtcNow.AddSeconds(5);
+                    }
+
+                    if (!softTimeoutShown &&
+                        now >= softTimeoutAt &&
+                        (!launchOutcome.Process.HasExited || ipcConnected))
+                    {
+                        softTimeoutShown = true;
+                        _startupAttemptRegistry.MarkOwnedSoftTimeout(SoftTimeoutStatusMessage);
+                        reporter.Report("delayed", SoftTimeoutStatusMessage);
+                        loadingState = BuildDelayedLoadingState(
+                            loadingState,
+                            SoftTimeoutStatusMessage,
+                            SoftTimeoutDetailsMessage,
+                            trackedAttempt?.StartedAtUtc ?? startedAt);
+                        loadingDetailsWindow?.UpdateLoadingState(loadingState);
+                    }
+
+                    if (now >= hardTimeoutAt)
+                    {
+                        break;
+                    }
+
+                    var nextCheckpointAt = hardTimeoutAt;
+                    if (!softTimeoutShown && softTimeoutAt < nextCheckpointAt)
+                    {
+                        nextCheckpointAt = softTimeoutAt;
+                    }
+
+                    var delay = nextCheckpointAt - now;
+                    if (delay > TimeSpan.FromSeconds(1))
+                    {
+                        delay = TimeSpan.FromSeconds(1);
+                    }
+                    else if (delay < TimeSpan.FromMilliseconds(100))
+                    {
+                        delay = TimeSpan.FromMilliseconds(100);
+                    }
+
+                    await Task.WhenAny(
+                        successTcs.Task,
+                        activationFailedTcs.Task,
+                        processExitTask,
+                        Task.Delay(delay)).ConfigureAwait(false);
                 }
 
-                if (completedTask == processExitTask)
+                var recoveryActivationAttempted = false;
+                if (!connected && !launchOutcome.Process.HasExited)
                 {
-                    var exitCode = launchOutcome.Process.ExitCode;
-                    Logger.Warn($"Host exited before startup success criteria were met. ExitCode={exitCode}.");
-
-                    if (exitCode is HostExitCodes.SecondaryActivationFailed or HostExitCodes.RestartLockNotAcquired)
+                    connected = await TryConnectToPublicIpcAsync(ipcClient, TimeSpan.FromSeconds(1)).ConfigureAwait(false);
+                    if (connected)
                     {
-                        var retryOutcome = await RetryActivationAfterEarlyFailureAsync().ConfigureAwait(false);
-                        if (retryOutcome is not null)
-                        {
-                            await CloseWindowsAsync(splashWindow, loadingDetailsWindow).ConfigureAwait(false);
-                            return WithAdditionalDetails(retryOutcome, launcherContextDetails);
-                        }
+                        ipcConnected = true;
+                        _startupAttemptRegistry.MarkOwnedIpcConnected();
                     }
-
-                    await CloseWindowsAsync(splashWindow, loadingDetailsWindow).ConfigureAwait(false);
-                    return BuildResult(
-                        success: false,
-                        stage: "launch",
-                        code: exitCode == HostExitCodes.SecondaryActivationSucceeded ? "activation_redirected" : "host_exited_early",
-                        message: exitCode == HostExitCodes.SecondaryActivationSucceeded
-                            ? "Host redirected activation to the existing desktop instance."
-                            : $"Host exited before the required startup state was reported. ExitCode={exitCode}.",
-                        details: MergeDetails(launcherContextDetails, MergeDetails(launchOutcome.Details, new Dictionary<string, string>
-                        {
-                            ["exitCode"] = exitCode.ToString()
-                        })));
                 }
 
                 if (connected && !launchOutcome.Process.HasExited)
                 {
+                    recoveryActivationAttempted = true;
                     var recoveryOutcome = await TryRecoverWithPublicActivationAsync(
                         ipcClient,
                         launchOutcome.Process,
@@ -266,48 +504,57 @@ internal sealed class LauncherFlowCoordinator
                         startupSuccessTracker).ConfigureAwait(false);
                     if (recoveryOutcome is not null)
                     {
+                        windowsClosingByCoordinator = true;
+                        _startupAttemptRegistry.MarkOwnedSucceeded(recoveryOutcome.Stage, recoveryOutcome.Message);
                         await CloseWindowsAsync(splashWindow, loadingDetailsWindow).ConfigureAwait(false);
                         return BuildResult(
                             success: true,
                             stage: "launch",
                             code: recoveryOutcome.Code,
                             message: recoveryOutcome.Message,
-                            details: MergeDetails(launcherContextDetails, MergeDetails(launchOutcome.Details, new Dictionary<string, string>
-                            {
-                                ["recoveryActivationAttempted"] = bool.TrueString
-                            })));
+                            details: ComposeLaunchDetails(
+                                !launchOutcome.Process.HasExited,
+                                recoveryActivationAttempted: true));
                     }
                 }
 
+                windowsClosingByCoordinator = true;
+                _startupAttemptRegistry.MarkOwnedFailed(lastStage, activationFailureReason);
                 await CloseWindowsAsync(splashWindow, loadingDetailsWindow).ConfigureAwait(false);
                 return BuildResult(
                     success: false,
                     stage: "launch",
                     code: "desktop_not_visible",
-                    message: "Host process started, but it never reached the required startup state within 30 seconds.",
-                    details: MergeDetails(launcherContextDetails, MergeDetails(launchOutcome.Details, new Dictionary<string, string>
-                    {
-                        ["ipcStage"] = lastStage.ToString(),
-                        ["ipcMessage"] = lastStageMessage
-                    })));
+                    message: "Host process started, but it never reached the required startup state within 120 seconds.",
+                    details: ComposeLaunchDetails(
+                        !launchOutcome.Process.HasExited,
+                        recoveryActivationAttempted));
             }
             finally
             {
-                await Dispatcher.UIThread.InvokeAsync(() =>
+                if (splashClosedHandler is not null)
                 {
-                    try
+                    splashWindow.Closed -= splashClosedHandler;
+                }
+
+                if (!windowsClosingByCoordinator)
+                {
+                    await Dispatcher.UIThread.InvokeAsync(() =>
                     {
-                        if (splashWindow.IsVisible && splashWindow.IsLoaded)
+                        try
                         {
-                            splashWindow.Close();
-                            Logger.Info("Splash window closed in coordinator cleanup.");
+                            if (splashWindow.IsVisible && splashWindow.IsLoaded)
+                            {
+                                splashWindow.Close();
+                                Logger.Info("Splash window closed in coordinator cleanup.");
+                            }
                         }
-                    }
-                    catch (Exception ex)
-                    {
-                        Logger.Error("Failed to close splash window during coordinator cleanup.", ex);
-                    }
-                });
+                        catch (Exception ex)
+                        {
+                            Logger.Error("Failed to close splash window during coordinator cleanup.", ex);
+                        }
+                    });
+                }
             }
         }
         catch (Exception ex)
@@ -373,20 +620,17 @@ internal sealed class LauncherFlowCoordinator
 
     private static async Task CloseWindowsAsync(SplashWindow splashWindow, LoadingDetailsWindow? loadingDetailsWindow)
     {
+        try
+        {
+            await splashWindow.DismissAsync().ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            Logger.Error("Failed to dismiss splash window.", ex);
+        }
+
         await Dispatcher.UIThread.InvokeAsync(() =>
         {
-            try
-            {
-                if (splashWindow.IsVisible && splashWindow.IsLoaded)
-                {
-                    splashWindow.Close();
-                }
-            }
-            catch (Exception ex)
-            {
-                Logger.Error("Failed to close splash window.", ex);
-            }
-
             try
             {
                 if (loadingDetailsWindow is not null && loadingDetailsWindow.IsVisible)
@@ -672,6 +916,7 @@ internal sealed class LauncherFlowCoordinator
             try
             {
                 errorWindow = new ErrorWindow();
+                errorWindow.ConfigureForHostNotFound();
                 errorWindow.SetErrorMessage("LanMountainDesktop host executable was not found.");
                 errorWindow.Show();
                 Logger.Warn("Host not found. Showing error window.");
@@ -1000,6 +1245,94 @@ internal sealed class LauncherFlowCoordinator
         return null;
     }
 
+    private static LoadingStateMessage BuildDelayedLoadingState(
+        LoadingStateMessage loadingState,
+        string summaryMessage,
+        string detailMessage,
+        DateTimeOffset startedAtUtc)
+    {
+        var delayedItems = loadingState.ActiveItems
+            .Where(item => !string.Equals(item.Id, "launcher-soft-timeout", StringComparison.OrdinalIgnoreCase))
+            .ToList();
+
+        delayedItems.Insert(0, new LoadingItem
+        {
+            Id = "launcher-soft-timeout",
+            Type = LoadingItemType.System,
+            Name = "Startup still in progress",
+            Description = detailMessage,
+            State = LoadingState.Delayed,
+            ProgressPercent = Math.Max(loadingState.OverallProgressPercent, 1),
+            Message = detailMessage,
+            StartTime = startedAtUtc
+        });
+
+        return loadingState with
+        {
+            ActiveItems = delayedItems,
+            Message = summaryMessage,
+            Timestamp = DateTimeOffset.UtcNow,
+            TotalCount = Math.Max(loadingState.TotalCount, delayedItems.Count)
+        };
+    }
+
+    private static Dictionary<string, string> BuildAttemptDetails(
+        StartupAttemptRecord? trackedAttempt,
+        bool attachedToExistingAttempt,
+        bool ipcConnected,
+        bool hostProcessAlive,
+        StartupStage lastStage,
+        string lastStageMessage,
+        string? activationFailureReason,
+        bool softTimeoutShown,
+        bool recoveryActivationAttempted)
+    {
+        var details = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        {
+            ["hostProcessAlive"] = hostProcessAlive.ToString(),
+            ["attachedToExistingAttempt"] = attachedToExistingAttempt.ToString(),
+            ["ipcConnected"] = ipcConnected.ToString(),
+            ["ipcStage"] = lastStage.ToString(),
+            ["ipcMessage"] = lastStageMessage,
+            ["activationFailureReason"] = activationFailureReason ?? string.Empty,
+            ["softTimeoutShown"] = softTimeoutShown.ToString(),
+            ["recoveryActivationAttempted"] = recoveryActivationAttempted.ToString()
+        };
+
+        if (trackedAttempt is not null)
+        {
+            details["startupAttemptId"] = trackedAttempt.AttemptId;
+            details["startupAttemptState"] = trackedAttempt.State.ToString();
+            details["startupAttemptStartedAtUtc"] = trackedAttempt.StartedAtUtc.ToString("O");
+            details["startupAttemptUpdatedAtUtc"] = trackedAttempt.UpdatedAtUtc.ToString("O");
+            details["successPolicy"] = trackedAttempt.SuccessPolicy;
+            details["hostPid"] = trackedAttempt.HostPid.ToString();
+        }
+
+        return details;
+    }
+
+    private static bool TryGetLiveProcess(int processId, out Process? process)
+    {
+        process = null;
+        if (processId <= 0)
+        {
+            return false;
+        }
+
+        try
+        {
+            process = Process.GetProcessById(processId);
+            return !process.HasExited;
+        }
+        catch
+        {
+            process?.Dispose();
+            process = null;
+            return false;
+        }
+    }
+
     private enum HostStartMode
     {
         ShellExecute,
@@ -1048,6 +1381,8 @@ internal sealed class LauncherFlowCoordinator
         private bool _trayReady;
         private bool _backgroundReady;
 
+        public string PolicyKey => _policy.ToString();
+
         public StartupSuccessTracker(CommandContext context)
         {
             var restartPresentation = LauncherRuntimeMetadata.GetRestartPresentationMode(context.RawArgs);

LanMountainDesktop.Launcher/Services/StartupAttemptRegistry.cs

@@ -0,0 +1,313 @@
+using System.Diagnostics;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using LanMountainDesktop.Launcher.Models;
+using LanMountainDesktop.Shared.Contracts.Launcher;
+
+namespace LanMountainDesktop.Launcher.Services;
+
+internal sealed class StartupAttemptRegistry
+{
+    private static readonly JsonSerializerOptions SerializerOptions = new()
+    {
+        WriteIndented = true
+    };
+
+    private readonly string _statePath;
+    private readonly string _mutexName;
+    private string? _ownedAttemptId;
+
+    public StartupAttemptRegistry()
+        : this(Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+            "LanMountainDesktop",
+            ".launcher",
+            "state",
+            "startup-attempt.json"))
+    {
+    }
+
+    internal StartupAttemptRegistry(string statePath)
+    {
+        _statePath = statePath;
+        _mutexName = $"LanMountainDesktop.Launcher.StartupAttempt.{ComputePathHash(statePath)}";
+    }
+
+    public StartupAttemptRecord StartOwnedAttempt(
+        int hostPid,
+        string launchSource,
+        string successPolicy,
+        StartupStage stage,
+        string? message)
+    {
+        var record = new StartupAttemptRecord
+        {
+            AttemptId = Guid.NewGuid().ToString("N"),
+            HostPid = hostPid,
+            LaunchSource = launchSource,
+            SuccessPolicy = successPolicy,
+            LastObservedStage = stage,
+            LastObservedMessage = message ?? string.Empty,
+            StartedAtUtc = DateTimeOffset.UtcNow,
+            UpdatedAtUtc = DateTimeOffset.UtcNow,
+            State = StartupAttemptState.Pending
+        };
+
+        ExecuteWithLock(() =>
+        {
+            SaveUnsafe(record);
+            _ownedAttemptId = record.AttemptId;
+        });
+
+        return Clone(record);
+    }
+
+    public bool AdoptAttempt(string attemptId)
+    {
+        if (string.IsNullOrWhiteSpace(attemptId))
+        {
+            return false;
+        }
+
+        var adopted = false;
+        ExecuteWithLock(() =>
+        {
+            var record = LoadUnsafe();
+            if (record is null || !string.Equals(record.AttemptId, attemptId, StringComparison.Ordinal))
+            {
+                return;
+            }
+
+            if (!IsAttachable(record))
+            {
+                return;
+            }
+
+            _ownedAttemptId = record.AttemptId;
+            if (record.State == StartupAttemptState.DetachedWaiting)
+            {
+                record.State = StartupAttemptState.SoftTimeout;
+            }
+
+            record.UpdatedAtUtc = DateTimeOffset.UtcNow;
+            SaveUnsafe(record);
+            adopted = true;
+        });
+
+        return adopted;
+    }
+
+    public StartupAttemptRecord? TryGetAttachableAttempt(string launchSource, string successPolicy)
+    {
+        StartupAttemptRecord? result = null;
+        ExecuteWithLock(() =>
+        {
+            var record = LoadUnsafe();
+            if (record is null ||
+                !IsAttachable(record) ||
+                !string.Equals(record.LaunchSource, launchSource, StringComparison.OrdinalIgnoreCase) ||
+                !string.Equals(record.SuccessPolicy, successPolicy, StringComparison.OrdinalIgnoreCase))
+            {
+                return;
+            }
+
+            result = Clone(record);
+        });
+
+        return result;
+    }
+
+    public void MarkOwnedIpcConnected()
+    {
+        UpdateOwned(record => record.IpcConnected = true);
+    }
+
+    public void UpdateOwnedStage(StartupStage stage, string? message, bool ipcConnected)
+    {
+        UpdateOwned(record =>
+        {
+            record.LastObservedStage = stage;
+            record.LastObservedMessage = message ?? string.Empty;
+            if (ipcConnected)
+            {
+                record.IpcConnected = true;
+            }
+        });
+    }
+
+    public void MarkOwnedSoftTimeout(string? message)
+    {
+        UpdateOwned(record =>
+        {
+            record.State = StartupAttemptState.SoftTimeout;
+            record.LastObservedMessage = message ?? record.LastObservedMessage;
+        });
+    }
+
+    public void MarkOwnedDetachedWaiting()
+    {
+        UpdateOwned(record =>
+        {
+            if (record.State is StartupAttemptState.Pending or StartupAttemptState.SoftTimeout)
+            {
+                record.State = StartupAttemptState.DetachedWaiting;
+            }
+        });
+    }
+
+    public void MarkOwnedSucceeded(StartupStage stage, string? message)
+    {
+        UpdateOwned(record =>
+        {
+            record.State = StartupAttemptState.Succeeded;
+            record.LastObservedStage = stage;
+            record.LastObservedMessage = message ?? record.LastObservedMessage;
+        });
+    }
+
+    public void MarkOwnedFailed(StartupStage stage, string? message)
+    {
+        UpdateOwned(record =>
+        {
+            record.State = StartupAttemptState.Failed;
+            record.LastObservedStage = stage;
+            record.LastObservedMessage = message ?? record.LastObservedMessage;
+        });
+    }
+
+    private void UpdateOwned(Action<StartupAttemptRecord> update)
+    {
+        if (string.IsNullOrWhiteSpace(_ownedAttemptId))
+        {
+            return;
+        }
+
+        ExecuteWithLock(() =>
+        {
+            var record = LoadUnsafe();
+            if (record is null || !string.Equals(record.AttemptId, _ownedAttemptId, StringComparison.Ordinal))
+            {
+                return;
+            }
+
+            update(record);
+            record.UpdatedAtUtc = DateTimeOffset.UtcNow;
+            SaveUnsafe(record);
+        });
+    }
+
+    private void ExecuteWithLock(Action action)
+    {
+        using var mutex = new Mutex(false, _mutexName);
+        var hasHandle = false;
+        try
+        {
+            try
+            {
+                hasHandle = mutex.WaitOne(TimeSpan.FromSeconds(2));
+            }
+            catch (AbandonedMutexException)
+            {
+                hasHandle = true;
+            }
+
+            if (!hasHandle)
+            {
+                return;
+            }
+
+            action();
+        }
+        finally
+        {
+            if (hasHandle)
+            {
+                mutex.ReleaseMutex();
+            }
+        }
+    }
+
+    private StartupAttemptRecord? LoadUnsafe()
+    {
+        if (!File.Exists(_statePath))
+        {
+            return null;
+        }
+
+        try
+        {
+            var json = File.ReadAllText(_statePath);
+            return JsonSerializer.Deserialize<StartupAttemptRecord>(json, SerializerOptions);
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    private void SaveUnsafe(StartupAttemptRecord record)
+    {
+        var directory = Path.GetDirectoryName(_statePath);
+        if (!string.IsNullOrWhiteSpace(directory))
+        {
+            Directory.CreateDirectory(directory);
+        }
+
+        File.WriteAllText(_statePath, JsonSerializer.Serialize(record, SerializerOptions));
+    }
+
+    private static bool IsAttachable(StartupAttemptRecord record)
+    {
+        if (record.State is not (StartupAttemptState.Pending or StartupAttemptState.SoftTimeout or StartupAttemptState.DetachedWaiting))
+        {
+            return false;
+        }
+
+        return TryGetLiveProcess(record.HostPid, out _);
+    }
+
+    private static bool TryGetLiveProcess(int processId, out Process? process)
+    {
+        process = null;
+        if (processId <= 0)
+        {
+            return false;
+        }
+
+        try
+        {
+            process = Process.GetProcessById(processId);
+            return !process.HasExited;
+        }
+        catch
+        {
+            process?.Dispose();
+            process = null;
+            return false;
+        }
+    }
+
+    private static string ComputePathHash(string statePath)
+    {
+        var bytes = SHA256.HashData(Encoding.UTF8.GetBytes(statePath.ToLowerInvariant()));
+        return Convert.ToHexString(bytes[..8]);
+    }
+
+    private static StartupAttemptRecord Clone(StartupAttemptRecord record)
+    {
+        return new StartupAttemptRecord
+        {
+            AttemptId = record.AttemptId,
+            HostPid = record.HostPid,
+            StartedAtUtc = record.StartedAtUtc,
+            UpdatedAtUtc = record.UpdatedAtUtc,
+            LaunchSource = record.LaunchSource,
+            SuccessPolicy = record.SuccessPolicy,
+            LastObservedStage = record.LastObservedStage,
+            LastObservedMessage = record.LastObservedMessage,
+            IpcConnected = record.IpcConnected,
+            State = record.State
+        };
+    }
+}

LanMountainDesktop.Launcher/Views/ErrorWindow.axaml

@@ -3,102 +3,96 @@
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:views="clr-namespace:LanMountainDesktop.Launcher.Views"
-        xmlns:ui="using:FluentAvalonia.UI.Controls"
         mc:Ignorable="d"
-        d:DesignWidth="520"
-        d:DesignHeight="280"
         x:Class="LanMountainDesktop.Launcher.Views.ErrorWindow"
         x:DataType="views:ErrorWindow"
-        Title="阑山桌面"
-        Width="520"
-        Height="280"
+        Title="LanMountain Desktop"
+        Width="560"
+        Height="320"
         CanResize="False"
         WindowStartupLocation="CenterScreen"
-        Background="{DynamicResource SolidBackgroundFillColorBaseBrush}"
+        Background="#111318"
         TransparencyLevelHint="None"
         Icon="/Assets/logo.ico">
   <Design.DataContext>
     <views:ErrorWindow />
   </Design.DataContext>
 
-  <!-- Fluent Design 风格对话框布局 -->
   <Grid RowDefinitions="*,Auto">
-    <!-- 主内容区域：左侧图标 + 右侧文字 -->
-    <Grid Grid.Row="0" Margin="24,24,24,16" ColumnDefinitions="Auto,*">
-      
-      <!-- 左侧：错误图标（可点击进入调试模式） -->
+    <Grid Grid.Row="0"
+          Margin="24"
+          ColumnDefinitions="Auto,*">
       <Border x:Name="ErrorIconBorder"
               Grid.Column="0"
-              Width="48"
-              Height="48"
-              Margin="0,4,16,0"
-              Background="{DynamicResource SystemFillColorCriticalBackgroundBrush}"
-              CornerRadius="24"
+              Width="52"
+              Height="52"
+              Margin="0,4,18,0"
+              Background="#2B161A"
+              CornerRadius="26"
               VerticalAlignment="Top">
-        <TextBlock Text="&#xEA39;"
+        <TextBlock Text="!"
                    FontSize="24"
-                   FontFamily="{DynamicResource SymbolThemeFontFamily}"
-                   Foreground="{DynamicResource SystemFillColorCriticalBrush}"
+                   FontWeight="Bold"
+                   Foreground="#FFB4AB"
                    HorizontalAlignment="Center"
-                   VerticalAlignment="Center"/>
+                   VerticalAlignment="Center" />
       </Border>
-      
-      <!-- 右侧：标题 + 内容 -->
-      <StackPanel Grid.Column="1" Spacing="8">
-        <!-- 标题 -->
+
+      <StackPanel Grid.Column="1"
+                  Spacing="10">
         <TextBlock x:Name="TitleText"
-                   Text="启动失败"
-                   FontSize="18"
+                   Text="Launcher could not confirm startup"
+                   FontSize="20"
                    FontWeight="SemiBold"
-                   Foreground="{DynamicResource TextFillColorPrimaryBrush}"
-                   TextWrapping="Wrap"/>
-        
-        <!-- 错误信息 -->
+                   Foreground="#F6F7FB"
+                   TextWrapping="Wrap" />
+
         <TextBlock x:Name="ErrorMessageText"
-                   Text="找不到阑山桌面应用程序。"
+                   Text="LanMountain Desktop did not reach the expected startup state."
                    FontSize="14"
-                   Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+                   Foreground="#D2D7E1"
                    TextWrapping="Wrap"
-                   LineHeight="20"/>
-        
-        <!-- 建议信息 -->
+                   LineHeight="22" />
+
         <TextBlock x:Name="SuggestionText"
-                   Text="请确保应用程序已正确安装，或尝试重新安装。"
+                   Text="You can inspect logs, retry when the old process is gone, or reactivate the current instance."
                    FontSize="13"
-                   Foreground="{DynamicResource TextFillColorTertiaryBrush}"
+                   Foreground="#9BA5B7"
                    TextWrapping="Wrap"
-                   LineHeight="18"
-                   Margin="0,4,0,0"/>
+                   LineHeight="20" />
       </StackPanel>
     </Grid>
 
-    <!-- 底部：按钮区域 -->
     <Border Grid.Row="1"
-            Background="{DynamicResource CardBackgroundFillColorDefaultBrush}"
-            Padding="24,16">
-      <Grid ColumnDefinitions="*,Auto">
+            Padding="24,16"
+            Background="#171A21">
+      <Grid ColumnDefinitions="*,Auto,Auto,Auto"
+            ColumnSpacing="8">
         <Button x:Name="OpenLogButton"
                 Grid.Column="0"
-                Content="打开日志"
-                Width="100"
-                Height="32"
-                FontSize="13"
-                HorizontalAlignment="Left"/>
-        <StackPanel Grid.Column="1"
-                    Orientation="Horizontal" 
-                    Spacing="8">
-          <Button x:Name="ExitButton"
-                  Content="退出"
-                  Width="80"
-                  Height="32"
-                  FontSize="13"/>
-          <Button x:Name="RetryButton"
-                  Content="重试"
-                  Width="80"
-                  Height="32"
-                  FontSize="13"
-                  Theme="{DynamicResource AccentButtonTheme}"/>
-        </StackPanel>
+                Content="Open Logs"
+                MinWidth="108"
+                Height="34"
+                HorizontalAlignment="Left" />
+
+        <Button x:Name="SecondaryActionButton"
+                Grid.Column="1"
+                Content="Wait"
+                MinWidth="108"
+                Height="34"
+                IsVisible="False" />
+
+        <Button x:Name="ExitButton"
+                Grid.Column="2"
+                Content="Exit"
+                MinWidth="90"
+                Height="34" />
+
+        <Button x:Name="PrimaryActionButton"
+                Grid.Column="3"
+                Content="Retry"
+                MinWidth="108"
+                Height="34" />
       </Grid>
     </Border>
   </Grid>

LanMountainDesktop.Launcher/Views/ErrorWindow.axaml.cs

@@ -1,542 +1,365 @@
+using System.Diagnostics;
 using Avalonia.Controls;
+using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Markup.Xaml;
-using Avalonia.Platform.Storage;
 using LanMountainDesktop.Launcher.Services;
-using System.Diagnostics;
 
 namespace LanMountainDesktop.Launcher.Views;
 
-/// <summary>
-/// 错误窗口 - 显示启动失败信息，支持调试模式（隐藏入口）
-/// </summary>
 public partial class ErrorWindow : Window
 {
-    private readonly TaskCompletionSource<ErrorWindowResult> _completionSource = new();
-    private int _iconClickCount = 0;
     private const int DebugModeClickThreshold = 5;
-    private bool _isDebugMode = false;
-    private string? _customHostPath;
+
+    private readonly TaskCompletionSource<ErrorWindowResult> _completionSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
+    private int _iconClickCount;
+    private bool _isDebugMode;
     private bool _devModeEnabled;
+    private string? _customHostPath;
+    private ErrorWindowResult _primaryAction = ErrorWindowResult.Retry;
+    private ErrorWindowResult? _secondaryAction;
 
     public ErrorWindow()
     {
         AvaloniaXamlLoader.Load(this);
 
-        // 先加载保存的状态
         _devModeEnabled = LoadDevModeStateInternal();
         _customHostPath = LoadCustomHostPathInternal();
 
-        // 延迟到窗口加载完成后再初始化组件，确保视觉树已准备好
-        this.Loaded += OnWindowLoaded;
-        this.Opened += OnWindowOpened;
+        Loaded += OnWindowLoaded;
+        Closed += (_, _) => _completionSource.TrySetResult(ErrorWindowResult.Exit);
+        ConfigureForGenericFailure(allowRetry: true);
     }
 
-    /// <summary>
-    /// 窗口加载完成事件 - 视觉树已准备好
-    /// </summary>
-    private void OnWindowLoaded(object? sender, RoutedEventArgs e)
-    {
-        Console.WriteLine("[ErrorWindow] Window loaded, initializing components...");
-        InitializeComponents();
-    }
-
-    /// <summary>
-    /// 窗口打开事件
-    /// </summary>
-    private void OnWindowOpened(object? sender, EventArgs e)
-    {
-        Console.WriteLine("[ErrorWindow] Window opened and visible");
-    }
-
-    private void InitializeComponents()
-    {
-        Console.WriteLine("[ErrorWindow] Initializing components...");
-        
-        // 错误图标点击事件（进入调试模式 - 隐藏功能）
-        var errorIconBorder = this.FindControl<Border>("ErrorIconBorder");
-        if (errorIconBorder is not null)
-        {
-            errorIconBorder.PointerPressed += OnErrorIconClick;
-            Console.WriteLine("[ErrorWindow] ErrorIconBorder event bound successfully");
-        }
-        else
-        {
-            Console.Error.WriteLine("[ErrorWindow] Failed to find ErrorIconBorder!");
-        }
-
-        // 按钮事件
-        var retryButton = this.FindControl<Button>("RetryButton");
-        var exitButton = this.FindControl<Button>("ExitButton");
-        var openLogButton = this.FindControl<Button>("OpenLogButton");
-
-        if (retryButton is not null)
-        {
-            retryButton.Click += OnRetryClick;
-            Console.WriteLine("[ErrorWindow] RetryButton event bound");
-        }
-        else
-        {
-            Console.Error.WriteLine("[ErrorWindow] Failed to find RetryButton!");
-        }
-
-        if (exitButton is not null)
-        {
-            exitButton.Click += OnExitClick;
-            Console.WriteLine("[ErrorWindow] ExitButton event bound");
-        }
-        else
-        {
-            Console.Error.WriteLine("[ErrorWindow] Failed to find ExitButton!");
-        }
-
-        if (openLogButton is not null)
-        {
-            openLogButton.Click += OnOpenLogClick;
-            Console.WriteLine("[ErrorWindow] OpenLogButton event bound");
-        }
-        else
-        {
-            Console.Error.WriteLine("[ErrorWindow] Failed to find OpenLogButton!");
-        }
-        
-        Console.WriteLine("[ErrorWindow] Components initialization completed");
-    }
-
-    /// <summary>
-    /// 设置错误消息
-    /// </summary>
     public void SetErrorMessage(string message)
     {
-        var errorText = this.FindControl<TextBlock>("ErrorMessageText");
-        if (errorText is not null)
+        if (this.FindControl<TextBlock>("ErrorMessageText") is { } errorText)
         {
             errorText.Text = message;
         }
     }
 
-    /// <summary>
-    /// 设置调试模式
-    /// </summary>
     public void SetDebugMode(bool isDebugMode)
     {
         _isDebugMode = isDebugMode;
-        var titleText = this.FindControl<TextBlock>("TitleText");
-        if (titleText is not null && isDebugMode)
+        if (isDebugMode && this.FindControl<TextBlock>("TitleText") is { } titleText)
         {
-            titleText.Text = "[调试模式] 错误页面";
+            titleText.Text = "[Debug] Launcher error";
         }
     }
 
-    /// <summary>
-    /// 获取用户选择的主程序路径
-    /// </summary>
-    public string? GetCustomHostPath() => _customHostPath;
-
-    /// <summary>
-    /// 是否启用了开发模式
-    /// </summary>
-    public bool IsDevModeEnabled() => _devModeEnabled;
-
-    /// <summary>
-    /// 等待用户选择
-    /// </summary>
-    public Task<ErrorWindowResult> WaitForChoiceAsync()
+    public void ConfigureForHostNotFound()
     {
-        return _completionSource.Task;
+        ApplyActionLayout(
+            title: "Launcher could not find the desktop executable",
+            suggestion: "Pick another executable in debug mode, inspect logs, or retry after fixing the deployment path.",
+            primaryLabel: "Retry",
+            primaryAction: ErrorWindowResult.Retry,
+            secondaryLabel: null,
+            secondaryAction: null);
     }
 
-    /// <summary>
-    /// 错误图标点击事件 - 连续点击 5 次进入调试模式（隐藏功能）
-    /// </summary>
-    private void OnErrorIconClick(object? sender, Avalonia.Input.PointerPressedEventArgs e)
+    public void ConfigureForGenericFailure(bool allowRetry)
+    {
+        ApplyActionLayout(
+            title: "Launcher could not confirm startup",
+            suggestion: allowRetry
+                ? "Inspect logs, then retry once the previous startup attempt has fully finished."
+                : "Inspect logs or exit. Launcher will avoid creating another desktop process while the old one is still running.",
+            primaryLabel: allowRetry ? "Retry" : "Activate",
+            primaryAction: allowRetry ? ErrorWindowResult.Retry : ErrorWindowResult.ActivateExisting,
+            secondaryLabel: allowRetry ? null : "Wait",
+            secondaryAction: allowRetry ? null : ErrorWindowResult.ContinueWaiting);
+    }
+
+    public void ConfigureForRunningHostFailure(int? hostPid)
+    {
+        var pidHint = hostPid is > 0 ? $" Current host PID: {hostPid}." : string.Empty;
+        ApplyActionLayout(
+            title: "Startup is still pending",
+            suggestion: $"The desktop process is still running, so Launcher will not start a second instance.{pidHint}",
+            primaryLabel: "Activate",
+            primaryAction: ErrorWindowResult.ActivateExisting,
+            secondaryLabel: "Wait",
+            secondaryAction: ErrorWindowResult.ContinueWaiting);
+    }
+
+    public string? GetCustomHostPath() => _customHostPath;
+
+    public bool IsDevModeEnabled() => _devModeEnabled;
+
+    public Task<ErrorWindowResult> WaitForChoiceAsync() => _completionSource.Task;
+
+    public static bool CheckDevModeEnabled() => LoadDevModeStateInternal();
+
+    public static string? GetSavedCustomHostPath() => LoadCustomHostPathInternal();
+
+    private void OnWindowLoaded(object? sender, RoutedEventArgs e)
+    {
+        if (this.FindControl<Border>("ErrorIconBorder") is { } errorIconBorder)
+        {
+            errorIconBorder.PointerPressed += OnErrorIconClick;
+        }
+
+        if (this.FindControl<Button>("PrimaryActionButton") is { } primaryActionButton)
+        {
+            primaryActionButton.Click += OnPrimaryActionClick;
+        }
+
+        if (this.FindControl<Button>("SecondaryActionButton") is { } secondaryActionButton)
+        {
+            secondaryActionButton.Click += OnSecondaryActionClick;
+        }
+
+        if (this.FindControl<Button>("ExitButton") is { } exitButton)
+        {
+            exitButton.Click += (_, _) => _completionSource.TrySetResult(ErrorWindowResult.Exit);
+        }
+
+        if (this.FindControl<Button>("OpenLogButton") is { } openLogButton)
+        {
+            openLogButton.Click += OnOpenLogClick;
+        }
+    }
+
+    private void ApplyActionLayout(
+        string title,
+        string suggestion,
+        string primaryLabel,
+        ErrorWindowResult primaryAction,
+        string? secondaryLabel,
+        ErrorWindowResult? secondaryAction)
+    {
+        _primaryAction = primaryAction;
+        _secondaryAction = secondaryAction;
+
+        if (this.FindControl<TextBlock>("TitleText") is { } titleText && !_isDebugMode)
+        {
+            titleText.Text = title;
+        }
+
+        if (this.FindControl<TextBlock>("SuggestionText") is { } suggestionText)
+        {
+            suggestionText.Text = suggestion;
+        }
+
+        if (this.FindControl<Button>("PrimaryActionButton") is { } primaryButton)
+        {
+            primaryButton.Content = primaryLabel;
+        }
+
+        if (this.FindControl<Button>("SecondaryActionButton") is { } secondaryButton)
+        {
+            secondaryButton.IsVisible = !string.IsNullOrWhiteSpace(secondaryLabel);
+            secondaryButton.Content = secondaryLabel ?? string.Empty;
+        }
+    }
+
+    private void OnPrimaryActionClick(object? sender, RoutedEventArgs e)
+    {
+        _completionSource.TrySetResult(_primaryAction);
+    }
+
+    private void OnSecondaryActionClick(object? sender, RoutedEventArgs e)
+    {
+        _completionSource.TrySetResult(_secondaryAction ?? ErrorWindowResult.Exit);
+    }
+
+    private void OnErrorIconClick(object? sender, PointerPressedEventArgs e)
     {
         _iconClickCount++;
-
         if (_iconClickCount >= DebugModeClickThreshold && !_isDebugMode)
         {
             EnterDebugMode();
         }
     }
 
-    /// <summary>
-    /// 进入调试模式 - 显示调试窗口
-    /// </summary>
     private async void EnterDebugMode()
     {
         _isDebugMode = true;
 
-        // 创建并显示调试窗口
         var debugWindow = new ErrorDebugWindow(_devModeEnabled, _customHostPath)
         {
             WindowStartupLocation = WindowStartupLocation.CenterOwner
         };
 
-        // 订阅调试窗口关闭事件
-        debugWindow.Closed += (s, e) =>
+        debugWindow.Closed += (_, _) =>
         {
-            // 更新状态
             _devModeEnabled = debugWindow.IsDevModeEnabled;
             _customHostPath = debugWindow.SelectedHostPath;
-
-            // 保存开发模式状态和自定义路径
             SaveDevModeStateInternal(_devModeEnabled);
             SaveCustomHostPathInternal(_customHostPath);
 
-            // 如果启用了开发模式且没有选择路径，自动扫描
-            if (_devModeEnabled && string.IsNullOrEmpty(_customHostPath))
+            if (_devModeEnabled && string.IsNullOrWhiteSpace(_customHostPath))
             {
                 ScanDevPaths();
-                // 扫描到路径后也保存
-                if (!string.IsNullOrEmpty(_customHostPath))
-                {
-                    SaveCustomHostPathInternal(_customHostPath);
-                }
+                SaveCustomHostPathInternal(_customHostPath);
             }
+
+            _isDebugMode = false;
+            _iconClickCount = 0;
         };
 
         await debugWindow.ShowDialog(this);
     }
 
-    /// <summary>
-    /// 扫描开发路径
-    /// </summary>
-    private void ScanDevPaths()
-    {
-        var executable = OperatingSystem.IsWindows() ? "LanMountainDesktop.exe" : "LanMountainDesktop";
-        var possiblePaths = new[]
-        {
-            Path.Combine(AppContext.BaseDirectory, "..", "..", "LanMountainDesktop", "bin", "Debug", "net10.0", executable),
-            Path.Combine(AppContext.BaseDirectory, "..", "..", "LanMountainDesktop", "bin", "Release", "net10.0", executable),
-            Path.Combine(AppContext.BaseDirectory, "..", "LanMountainDesktop", "bin", "Debug", "net10.0", executable),
-            Path.Combine(AppContext.BaseDirectory, "..", "LanMountainDesktop", "bin", "Release", "net10.0", executable),
-            Path.Combine(AppContext.BaseDirectory, "..", "dev-test", "app-1.0.0-dev", executable),
-        };
-
-        foreach (var path in possiblePaths.Select(Path.GetFullPath).Distinct())
-        {
-            if (File.Exists(path))
-            {
-                _customHostPath = path;
-                break;
-            }
-        }
-    }
-
-    /// <summary>
-    /// 获取配置存储的基础目录
-    /// </summary>
-    private static string GetConfigBaseDirectory()
-    {
-        try
-        {
-            // 优先使用 LocalApplicationData（用户状态）
-            var appData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
-            if (!string.IsNullOrEmpty(appData))
-            {
-                var configDir = Path.Combine(appData, "LanMountainDesktop", ".launcher");
-                return configDir;
-            }
-        }
-        catch
-        {
-            // LocalApplicationData 不可用，回退到 Launcher 所在目录
-        }
-
-        // 回退方案：使用 Launcher 所在目录
-        try
-        {
-            var launcherDir = AppContext.BaseDirectory;
-            var configDir = Path.Combine(launcherDir, ".launcher");
-            return configDir;
-        }
-        catch
-        {
-            // 最后的兜底：使用当前目录
-            return Path.Combine(Directory.GetCurrentDirectory(), ".launcher");
-        }
-    }
-
-    /// <summary>
-    /// 确保配置目录存在
-    /// </summary>
-    private static bool EnsureConfigDirectory(string dirPath)
-    {
-        try
-        {
-            if (!Directory.Exists(dirPath))
-            {
-                Directory.CreateDirectory(dirPath);
-                Console.WriteLine($"[ErrorWindow] Created config directory: {dirPath}");
-            }
-            return true;
-        }
-        catch (Exception ex)
-        {
-            Console.Error.WriteLine($"[ErrorWindow] Failed to create config directory: {ex.Message}");
-            return false;
-        }
-    }
-
-    /// <summary>
-    /// 保存开发模式状态（内部方法）
-    /// </summary>
-    private static void SaveDevModeStateInternal(bool enabled)
-    {
-        try
-        {
-            var configDir = GetConfigBaseDirectory();
-            if (!EnsureConfigDirectory(configDir))
-            {
-                Console.Error.WriteLine("[ErrorWindow] Cannot save dev mode: config directory unavailable");
-                return;
-            }
-
-            var devModeFile = Path.Combine(configDir, "devmode.config");
-            File.WriteAllText(devModeFile, enabled ? "1" : "0");
-            Console.WriteLine($"[ErrorWindow] Dev mode state saved: {enabled}");
-        }
-        catch (Exception ex)
-        {
-            Console.Error.WriteLine($"[ErrorWindow] Failed to save dev mode state: {ex.Message}");
-        }
-    }
-
-    /// <summary>
-    /// 加载开发模式状态（内部方法）
-    /// </summary>
-    private static bool LoadDevModeStateInternal()
-    {
-        try
-        {
-            var configDir = GetConfigBaseDirectory();
-            var devModeFile = Path.Combine(configDir, "devmode.config");
-
-            if (File.Exists(devModeFile))
-            {
-                var content = File.ReadAllText(devModeFile).Trim();
-                var enabled = content == "1";
-                Console.WriteLine($"[ErrorWindow] Dev mode state loaded: {enabled}");
-                return enabled;
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.Error.WriteLine($"[ErrorWindow] Failed to load dev mode state: {ex.Message}");
-        }
-        return false;
-    }
-
-    /// <summary>
-    /// 保存自定义主程序路径（内部方法）
-    /// </summary>
-    private static void SaveCustomHostPathInternal(string? path)
-    {
-        try
-        {
-            var configDir = GetConfigBaseDirectory();
-            if (!EnsureConfigDirectory(configDir))
-            {
-                Console.Error.WriteLine("[ErrorWindow] Cannot save custom path: config directory unavailable");
-                return;
-            }
-
-            var hostPathFile = Path.Combine(configDir, "custom-host-path.config");
-            File.WriteAllText(hostPathFile, path ?? string.Empty);
-            Console.WriteLine($"[ErrorWindow] Custom host path saved: {path}");
-        }
-        catch (Exception ex)
-        {
-            Console.Error.WriteLine($"[ErrorWindow] Failed to save custom host path: {ex.Message}");
-        }
-    }
-
-    /// <summary>
-    /// 加载自定义主程序路径（内部方法）
-    /// </summary>
-    private static string? LoadCustomHostPathInternal()
-    {
-        try
-        {
-            var configDir = GetConfigBaseDirectory();
-            var hostPathFile = Path.Combine(configDir, "custom-host-path.config");
-
-            if (File.Exists(hostPathFile))
-            {
-                var content = File.ReadAllText(hostPathFile).Trim();
-                // 验证路径是否仍然有效
-                if (!string.IsNullOrEmpty(content) && File.Exists(content))
-                {
-                    Console.WriteLine($"[ErrorWindow] Custom host path loaded: {content}");
-                    return content;
-                }
-
-                // 路径已失效，清理配置文件
-                if (!string.IsNullOrEmpty(content))
-                {
-                    Console.WriteLine($"[ErrorWindow] Custom host path is no longer valid: {content}");
-                    try
-                    {
-                        File.Delete(hostPathFile);
-                        Console.WriteLine("[ErrorWindow] Cleared invalid custom host path");
-                    }
-                    catch (Exception clearEx)
-                    {
-                        Console.Error.WriteLine($"[ErrorWindow] Failed to clear invalid host path: {clearEx.Message}");
-                    }
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.Error.WriteLine($"[ErrorWindow] Failed to load custom host path: {ex.Message}");
-        }
-        return null;
-    }
-
-    /// <summary>
-    /// 检查是否启用了开发模式（静态方法，启动时调用）
-    /// </summary>
-    public static bool CheckDevModeEnabled()
-    {
-        return LoadDevModeStateInternal();
-    }
-
-    /// <summary>
-    /// 获取保存的自定义主程序路径（静态方法，启动时调用）
-    /// </summary>
-    public static string? GetSavedCustomHostPath()
-    {
-        return LoadCustomHostPathInternal();
-    }
-
-    private void OnRetryClick(object? sender, RoutedEventArgs e)
-    {
-        _completionSource.TrySetResult(ErrorWindowResult.Retry);
-    }
-
-    private void OnExitClick(object? sender, RoutedEventArgs e)
-    {
-        _completionSource.TrySetResult(ErrorWindowResult.Exit);
-    }
-
-    /// <summary>
-    /// 打开日志文件
-    /// </summary>
     private async void OnOpenLogClick(object? sender, RoutedEventArgs e)
     {
         try
         {
             var logFilePath = Logger.GetLogFilePath();
-
-            if (string.IsNullOrEmpty(logFilePath) || !File.Exists(logFilePath))
+            if (!string.IsNullOrWhiteSpace(logFilePath) && File.Exists(logFilePath))
             {
-                // 如果没有日志文件，打开日志目录
-                var logDir = Path.GetDirectoryName(logFilePath);
-                if (!string.IsNullOrEmpty(logDir) && Directory.Exists(logDir))
-                {
-                    OpenFolder(logDir);
-                }
-                else
-                {
-                    // 尝试打开配置目录
-                    var configDir = GetConfigBaseDirectory();
-                    if (Directory.Exists(configDir))
-                    {
-                        OpenFolder(configDir);
-                    }
-                    else
-                    {
-                        Console.WriteLine("[ErrorWindow] No log file or directory available");
-                    }
-                }
+                OpenPath(logFilePath);
                 return;
             }
 
-            Console.WriteLine($"[ErrorWindow] Opening log file: {logFilePath}");
-            OpenFile(logFilePath);
+            var logDirectory = !string.IsNullOrWhiteSpace(logFilePath)
+                ? Path.GetDirectoryName(logFilePath)
+                : null;
+            if (!string.IsNullOrWhiteSpace(logDirectory) && Directory.Exists(logDirectory))
+            {
+                OpenPath(logDirectory);
+                return;
+            }
+
+            var configDirectory = GetConfigBaseDirectory();
+            if (Directory.Exists(configDirectory))
+            {
+                OpenPath(configDirectory);
+            }
         }
         catch (Exception ex)
         {
-            Console.Error.WriteLine($"[ErrorWindow] Failed to open log: {ex.Message}");
+            Debug.WriteLine($"[ErrorWindow] Failed to open log path: {ex}");
+        }
+
+        await Task.CompletedTask;
+    }
+
+    private void ScanDevPaths()
+    {
+        var executable = OperatingSystem.IsWindows() ? "LanMountainDesktop.exe" : "LanMountainDesktop";
+        var candidatePaths = new[]
+        {
+            Path.Combine(AppContext.BaseDirectory, "..", "..", "LanMountainDesktop", "bin", "Debug", "net10.0", executable),
+            Path.Combine(AppContext.BaseDirectory, "..", "..", "LanMountainDesktop", "bin", "Release", "net10.0", executable),
+            Path.Combine(AppContext.BaseDirectory, "..", "LanMountainDesktop", "bin", "Debug", "net10.0", executable),
+            Path.Combine(AppContext.BaseDirectory, "..", "LanMountainDesktop", "bin", "Release", "net10.0", executable)
+        };
+
+        foreach (var candidate in candidatePaths.Select(Path.GetFullPath).Distinct())
+        {
+            if (File.Exists(candidate))
+            {
+                _customHostPath = candidate;
+                break;
+            }
         }
     }
 
-    /// <summary>
-    /// 打开文件
-    /// </summary>
-    private static void OpenFile(string filePath)
+    private static void OpenPath(string path)
     {
-        try
+        if (OperatingSystem.IsWindows())
         {
-            if (OperatingSystem.IsWindows())
+            Process.Start(new ProcessStartInfo
             {
-                Process.Start(new ProcessStartInfo
-                {
-                    FileName = "explorer.exe",
-                    Arguments = $"\"{filePath}\"",
-                    UseShellExecute = true
-                });
-            }
-            else if (OperatingSystem.IsMacOS())
-            {
-                Process.Start("open", filePath);
-            }
-            else if (OperatingSystem.IsLinux())
-            {
-                Process.Start("xdg-open", filePath);
-            }
+                FileName = "explorer.exe",
+                Arguments = $"\"{path}\"",
+                UseShellExecute = true
+            });
+            return;
         }
-        catch (Exception ex)
+
+        if (OperatingSystem.IsMacOS())
         {
-            Console.Error.WriteLine($"[ErrorWindow] Failed to open file: {ex.Message}");
+            Process.Start("open", path);
+            return;
+        }
+
+        if (OperatingSystem.IsLinux())
+        {
+            Process.Start("xdg-open", path);
         }
     }
 
-    /// <summary>
-    /// 打开文件夹
-    /// </summary>
-    private static void OpenFolder(string folderPath)
+    private static string GetConfigBaseDirectory()
+    {
+        var appData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+        if (!string.IsNullOrWhiteSpace(appData))
+        {
+            return Path.Combine(appData, "LanMountainDesktop", ".launcher");
+        }
+
+        return Path.Combine(AppContext.BaseDirectory, ".launcher");
+    }
+
+    private static string GetDevModePath() => Path.Combine(GetConfigBaseDirectory(), "dev-mode.flag");
+
+    private static string GetCustomHostPathFile() => Path.Combine(GetConfigBaseDirectory(), "custom-host-path.txt");
+
+    private static bool LoadDevModeStateInternal()
     {
         try
         {
-            if (OperatingSystem.IsWindows())
-            {
-                Process.Start(new ProcessStartInfo
-                {
-                    FileName = "explorer.exe",
-                    Arguments = $"\"{folderPath}\"",
-                    UseShellExecute = true
-                });
-            }
-            else if (OperatingSystem.IsMacOS())
-            {
-                Process.Start("open", folderPath);
-            }
-            else if (OperatingSystem.IsLinux())
-            {
-                Process.Start("xdg-open", folderPath);
-            }
+            return File.Exists(GetDevModePath()) &&
+                   bool.TryParse(File.ReadAllText(GetDevModePath()).Trim(), out var enabled) &&
+                   enabled;
         }
-        catch (Exception ex)
+        catch
+        {
+            return false;
+        }
+    }
+
+    private static void SaveDevModeStateInternal(bool enabled)
+    {
+        try
+        {
+            Directory.CreateDirectory(GetConfigBaseDirectory());
+            File.WriteAllText(GetDevModePath(), enabled.ToString());
+        }
+        catch
+        {
+        }
+    }
+
+    private static string? LoadCustomHostPathInternal()
+    {
+        try
+        {
+            var pathFile = GetCustomHostPathFile();
+            if (!File.Exists(pathFile))
+            {
+                return null;
+            }
+
+            var savedPath = File.ReadAllText(pathFile).Trim();
+            return string.IsNullOrWhiteSpace(savedPath) ? null : savedPath;
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    private static void SaveCustomHostPathInternal(string? customHostPath)
+    {
+        try
+        {
+            Directory.CreateDirectory(GetConfigBaseDirectory());
+            File.WriteAllText(GetCustomHostPathFile(), customHostPath ?? string.Empty);
+        }
+        catch
         {
-            Console.Error.WriteLine($"[ErrorWindow] Failed to open folder: {ex.Message}");
         }
     }
 }
 
-/// <summary>
-/// 错误窗口用户选择结果
-/// </summary>
 public enum ErrorWindowResult
 {
-    /// <summary>
-    /// 重试
-    /// </summary>
     Retry,
-
-    /// <summary>
-    /// 退出
-    /// </summary>
-    Exit
+    Exit,
+    ActivateExisting,
+    ContinueWaiting
 }

LanMountainDesktop.Launcher/Views/SplashWindow.axaml

@@ -3,85 +3,92 @@
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:views="clr-namespace:LanMountainDesktop.Launcher.Views"
-        xmlns:ui="using:FluentAvalonia.UI.Controls"
         mc:Ignorable="d"
-        d:DesignWidth="480"
-        d:DesignHeight="320"
         x:Class="LanMountainDesktop.Launcher.Views.SplashWindow"
         x:DataType="views:SplashWindow"
         Title="LanMountain Desktop"
         Width="480"
         Height="320"
         CanResize="False"
+        ShowInTaskbar="False"
         WindowStartupLocation="CenterScreen"
         SystemDecorations="None"
-        Background="{DynamicResource SolidBackgroundFillColorBaseBrush}"
+        Background="#0B0B0B"
         TransparencyLevelHint="None"
         Icon="/Assets/logo.ico">
   <Design.DataContext>
     <views:SplashWindow />
   </Design.DataContext>
 
-  <Grid>
-    <!-- 左上角：应用名称 -->
-    <TextBlock x:Name="AppNameText"
-               Text="LanMountain Desktop"
-               FontSize="24"
-               FontWeight="SemiBold"
-               VerticalAlignment="Top"
-               HorizontalAlignment="Left"
-               Margin="24,24,0,0"
-               Foreground="{DynamicResource TextFillColorPrimaryBrush}" />
-
-    <!-- 底部区域：进度条和状态 -->
-    <Grid VerticalAlignment="Bottom" Margin="24,0,24,24">
-      <Grid.RowDefinitions>
-        <RowDefinition Height="Auto"/>
-        <RowDefinition Height="Auto"/>
-      </Grid.RowDefinitions>
-      
-      <!-- 第一行：左下角版本信息，右下角阶段文字 -->
-      <Grid Grid.Row="0" Margin="0,0,0,8">
-        <Grid.ColumnDefinitions>
-          <ColumnDefinition Width="*"/>
-          <ColumnDefinition Width="Auto"/>
-        </Grid.ColumnDefinitions>
-        
-        <!-- 左下角：版本和开发代号 - 可点击打开开发者界面（隐藏功能） -->
-        <Border x:Name="VersionTextBorder"
-                Grid.Column="0"
-                Background="Transparent"
-                Cursor="Hand"
-                HorizontalAlignment="Left"
-                VerticalAlignment="Bottom">
-          <TextBlock x:Name="VersionText"
-                     FontSize="11"
-                     Foreground="{DynamicResource TextFillColorSecondaryBrush}"
-                     Opacity="0.8"
-                     Text="1.0.0 (Administrate)" />
-        </Border>
-        
-        <!-- 右下角：阶段文字 -->
-        <TextBlock x:Name="StatusText"
-                   Grid.Column="1"
-                   FontSize="11"
-                   Foreground="{DynamicResource TextFillColorSecondaryBrush}"
-                   HorizontalAlignment="Right"
-                   VerticalAlignment="Bottom"
-                   Opacity="0.8"
-                   Text="Initializing..." />
+  <Grid RowDefinitions="*,Auto"
+        Background="#0B0B0B">
+    <Grid Grid.Row="0">
+      <Grid x:Name="CompactHero"
+            Margin="24">
+        <TextBlock x:Name="AppNameText"
+                   Text="LanMountain Desktop"
+                   FontSize="24"
+                   FontWeight="SemiBold"
+                   VerticalAlignment="Top"
+                   HorizontalAlignment="Left"
+                   Foreground="#F6F7FB" />
+      </Grid>
+
+      <Grid x:Name="FullscreenHero"
+            IsVisible="False">
+        <StackPanel HorizontalAlignment="Center"
+                    VerticalAlignment="Center"
+                    Spacing="24">
+          <Border Width="240"
+                  Height="240"
+                  Background="Transparent">
+            <Image Source="/Assets/logo_nightly.png"
+                   Stretch="Uniform" />
+          </Border>
+
+          <TextBlock Text="LanMountain Desktop"
+                     HorizontalAlignment="Center"
+                     FontSize="26"
+                     FontWeight="SemiBold"
+                     Foreground="#F6F7FB" />
+        </StackPanel>
       </Grid>
-      
-      <!-- 底部：进度条 -->
-      <ProgressBar x:Name="ProgressIndicator"
-                   Grid.Row="1"
-                   Minimum="0"
-                   Maximum="100"
-                   Value="0"
-                   Height="4"
-                   IsIndeterminate="False"
-                   Foreground="{DynamicResource AccentFillColorDefaultBrush}"
-                   Background="{DynamicResource ControlStrokeColorDefaultBrush}" />
     </Grid>
+
+    <Border Grid.Row="1"
+            Padding="24,18,24,24"
+            Background="Transparent">
+      <Grid RowDefinitions="Auto,Auto"
+            RowSpacing="10">
+        <Grid ColumnDefinitions="*,Auto">
+          <Border x:Name="VersionTextBorder"
+                  Background="Transparent"
+                  Cursor="Hand"
+                  HorizontalAlignment="Left">
+            <TextBlock x:Name="VersionText"
+                       FontSize="11"
+                       Foreground="#B9C0CC"
+                       Text="0.0.0-dev (Administrate)" />
+          </Border>
+
+          <TextBlock x:Name="StatusText"
+                     Grid.Column="1"
+                     FontSize="11"
+                     Foreground="#B9C0CC"
+                     HorizontalAlignment="Right"
+                     Text="Initializing..." />
+        </Grid>
+
+        <ProgressBar x:Name="ProgressIndicator"
+                     Grid.Row="1"
+                     Minimum="0"
+                     Maximum="100"
+                     Value="0"
+                     Height="4"
+                     IsIndeterminate="False"
+                     Foreground="#F6F7FB"
+                     Background="#2C313D" />
+      </Grid>
+    </Border>
   </Grid>
 </Window>

LanMountainDesktop.Launcher/Views/SplashWindow.axaml.cs

@@ -1,88 +1,266 @@
+using System.Diagnostics;
+using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Markup.Xaml;
+using Avalonia.Media;
 using Avalonia.Threading;
 using LanMountainDesktop.Launcher.Services;
+using LanMountainDesktop.Shared.Contracts.Launcher;
 
 namespace LanMountainDesktop.Launcher.Views;
 
-/// <summary>
-/// 启动画面窗口 - 简洁设计
-/// </summary>
 public partial class SplashWindow : Window, ISplashStageReporter
 {
-    private int _versionTextClickCount = 0;
     private const int DebugModeClickThreshold = 5;
-    private bool _isDebugModeOpened = false;
+    private static readonly TimeSpan FadeAnimationDuration = TimeSpan.FromMilliseconds(160);
+    private static readonly TimeSpan SlideAnimationDuration = TimeSpan.FromMilliseconds(260);
+
+    private readonly StartupVisualMode _mode;
+    private int _versionTextClickCount;
+    private bool _isDebugModeOpened;
+    private bool _isOpened;
+    private bool _layoutConfigured;
+    private bool _dismissed;
+    private PixelPoint _targetPosition;
+    private PixelPoint _slideHiddenPosition;
 
     public SplashWindow()
+        : this(StartupVisualMode.Fade)
     {
-        AvaloniaXamlLoader.Load(this);
-        
-        // 延迟到窗口加载完成后再绑定事件
-        this.Loaded += OnWindowLoaded;
     }
 
-    /// <summary>
-    /// 窗口加载完成事件
-    /// </summary>
+    public SplashWindow(StartupVisualMode mode)
+    {
+        _mode = mode;
+        AvaloniaXamlLoader.Load(this);
+        Loaded += OnWindowLoaded;
+        Opened += OnWindowOpened;
+    }
+
     private void OnWindowLoaded(object? sender, RoutedEventArgs e)
     {
-        Console.WriteLine("[SplashWindow] Window loaded, binding events...");
-        
-        // 绑定版本文本点击事件（隐藏功能：点击5次打开开发者界面）
-        var versionTextBorder = this.FindControl<Border>("VersionTextBorder");
-        if (versionTextBorder is not null)
+        if (this.FindControl<Border>("VersionTextBorder") is { } versionBorder)
         {
-            versionTextBorder.PointerPressed += OnVersionTextClick;
-            Console.WriteLine("[SplashWindow] VersionTextBorder click event bound");
-        }
-        else
-        {
-            Console.Error.WriteLine("[SplashWindow] Failed to find VersionTextBorder!");
+            versionBorder.PointerPressed += OnVersionTextClick;
         }
     }
 
-    /// <summary>
-    /// 版本文本点击事件 - 连续点击5次打开开发者界面（隐藏功能）
-    /// </summary>
+    private async void OnWindowOpened(object? sender, EventArgs e)
+    {
+        if (_isOpened)
+        {
+            return;
+        }
+
+        _isOpened = true;
+        ConfigureForVisualMode();
+
+        if (_mode == StartupVisualMode.Fade)
+        {
+            Opacity = 0d;
+            await AnimateOpacityAsync(0d, 1d, FadeAnimationDuration).ConfigureAwait(false);
+            return;
+        }
+
+        Opacity = 1d;
+        if (_mode == StartupVisualMode.SlideSplash)
+        {
+            await AnimateWindowPositionAsync(_slideHiddenPosition, _targetPosition, SlideAnimationDuration, EaseOutCubic).ConfigureAwait(false);
+        }
+    }
+
+    public async Task DismissAsync()
+    {
+        if (_dismissed)
+        {
+            return;
+        }
+
+        _dismissed = true;
+        ConfigureForVisualMode();
+
+        if (_mode == StartupVisualMode.SlideSplash)
+        {
+            var from = Position;
+            await AnimateWindowPositionAsync(from, _slideHiddenPosition, SlideAnimationDuration, EaseInCubic).ConfigureAwait(false);
+        }
+        else if (_mode == StartupVisualMode.Fade)
+        {
+            await AnimateOpacityAsync(Opacity, 0d, FadeAnimationDuration).ConfigureAwait(false);
+        }
+
+        await Dispatcher.UIThread.InvokeAsync(() =>
+        {
+            if (IsVisible)
+            {
+                Close();
+            }
+        });
+    }
+
+    public void Report(string stage, string message)
+    {
+        Dispatcher.UIThread.Post(() =>
+        {
+            if (this.FindControl<TextBlock>("StatusText") is { } statusText)
+            {
+                statusText.Text = message;
+            }
+
+            if (this.FindControl<ProgressBar>("ProgressIndicator") is { } progressIndicator)
+            {
+                var progress = ResolveProgress(stage);
+                if (progress > 0)
+                {
+                    progressIndicator.IsIndeterminate = false;
+                    progressIndicator.Value = progress;
+                }
+                else
+                {
+                    progressIndicator.IsIndeterminate = true;
+                }
+            }
+        });
+    }
+
+    public void ReportStage(string stage, int progress)
+    {
+        Dispatcher.UIThread.Post(() =>
+        {
+            if (this.FindControl<TextBlock>("StatusText") is { } statusText)
+            {
+                statusText.Text = stage;
+            }
+
+            if (this.FindControl<ProgressBar>("ProgressIndicator") is { } progressIndicator)
+            {
+                progressIndicator.IsIndeterminate = false;
+                progressIndicator.Value = Math.Clamp(progress, 0, 100);
+            }
+        });
+    }
+
+    public void UpdateProgress(int percent, string? message = null)
+    {
+        Dispatcher.UIThread.Post(() =>
+        {
+            if (!string.IsNullOrWhiteSpace(message) &&
+                this.FindControl<TextBlock>("StatusText") is { } statusText)
+            {
+                statusText.Text = message;
+            }
+
+            if (this.FindControl<ProgressBar>("ProgressIndicator") is { } progressIndicator)
+            {
+                progressIndicator.IsIndeterminate = false;
+                progressIndicator.Value = Math.Clamp(percent, 0, 100);
+            }
+        });
+    }
+
+    public void UpdateStatus(string message)
+    {
+        Dispatcher.UIThread.Post(() =>
+        {
+            if (this.FindControl<TextBlock>("StatusText") is { } statusText)
+            {
+                statusText.Text = message;
+            }
+        });
+    }
+
+    public void SetVersionInfo(string version, string codename)
+    {
+        Dispatcher.UIThread.Post(() =>
+        {
+            if (this.FindControl<TextBlock>("VersionText") is { } versionText)
+            {
+                versionText.Text = $"{version} ({codename})";
+            }
+        });
+    }
+
+    public void SetDebugMode(bool isDebugMode)
+    {
+        if (!isDebugMode)
+        {
+            return;
+        }
+
+        UpdateStatus("[Debug Mode] Splash Preview");
+    }
+
+    private void ConfigureForVisualMode()
+    {
+        if (_layoutConfigured)
+        {
+            return;
+        }
+
+        _layoutConfigured = true;
+        var compactHero = this.FindControl<Grid>("CompactHero");
+        var fullscreenHero = this.FindControl<Grid>("FullscreenHero");
+
+        if (_mode == StartupVisualMode.Fade)
+        {
+            compactHero?.SetCurrentValue(IsVisibleProperty, true);
+            fullscreenHero?.SetCurrentValue(IsVisibleProperty, false);
+            Background = new SolidColorBrush(Color.Parse("#0B0B0B"));
+            Width = 480;
+            Height = 320;
+            WindowStartupLocation = WindowStartupLocation.CenterScreen;
+            return;
+        }
+
+        compactHero?.SetCurrentValue(IsVisibleProperty, false);
+        fullscreenHero?.SetCurrentValue(IsVisibleProperty, true);
+        Background = Brushes.Black;
+        WindowStartupLocation = WindowStartupLocation.Manual;
+
+        var screen = Screens?.Primary ?? Screens?.All.FirstOrDefault();
+        var workingArea = screen?.WorkingArea ?? new PixelRect(0, 0, 1920, 1080);
+        var scale = Math.Max(screen?.Scaling ?? 1d, 0.01d);
+
+        Width = workingArea.Width / scale;
+        Height = workingArea.Height / scale;
+        _targetPosition = new PixelPoint(workingArea.X, workingArea.Y);
+        _slideHiddenPosition = new PixelPoint(workingArea.X + workingArea.Width, workingArea.Y);
+        Position = _mode == StartupVisualMode.SlideSplash
+            ? _slideHiddenPosition
+            : _targetPosition;
+    }
+
     private void OnVersionTextClick(object? sender, PointerPressedEventArgs e)
     {
-        if (_isDebugModeOpened) return;
-        
-        _versionTextClickCount++;
-        Console.WriteLine($"[SplashWindow] Version text clicked {_versionTextClickCount}/{DebugModeClickThreshold}");
+        if (_isDebugModeOpened)
+        {
+            return;
+        }
 
+        _versionTextClickCount++;
         if (_versionTextClickCount >= DebugModeClickThreshold)
         {
             OpenDebugWindow();
         }
     }
 
-    /// <summary>
-    /// 打开开发者调试窗口
-    /// </summary>
     private async void OpenDebugWindow()
     {
         _isDebugModeOpened = true;
-        Console.WriteLine("[SplashWindow] Opening debug window...");
 
         try
         {
-            // 加载保存的状态
-            var devModeEnabled = ErrorWindow.CheckDevModeEnabled();
-            var customHostPath = ErrorWindow.GetSavedCustomHostPath();
-
-            var debugWindow = new ErrorDebugWindow(devModeEnabled, customHostPath)
+            var debugWindow = new ErrorDebugWindow(
+                ErrorWindow.CheckDevModeEnabled(),
+                ErrorWindow.GetSavedCustomHostPath())
             {
-                WindowStartupLocation = WindowStartupLocation.CenterScreen
+                WindowStartupLocation = WindowStartupLocation.CenterOwner
             };
 
-            // 订阅窗口关闭事件以保存状态
-            debugWindow.Closed += (s, e) =>
+            debugWindow.Closed += (_, _) =>
             {
-                Console.WriteLine("[SplashWindow] Debug window closed");
                 _isDebugModeOpened = false;
                 _versionTextClickCount = 0;
             };
@@ -91,160 +269,75 @@ public partial class SplashWindow : Window, ISplashStageReporter
         }
         catch (Exception ex)
         {
-            Console.Error.WriteLine($"[SplashWindow] Error opening debug window: {ex.Message}");
+            Debug.WriteLine($"[SplashWindow] Failed to open debug window: {ex}");
             _isDebugModeOpened = false;
             _versionTextClickCount = 0;
         }
     }
 
-    /// <summary>
-    /// 更新进度和状态
-    /// </summary>
-    public void Report(string stage, string message)
+    private async Task AnimateOpacityAsync(double from, double to, TimeSpan duration)
     {
-        Dispatcher.UIThread.Post(() =>
+        await AnimateAsync(progress =>
         {
-            var statusText = this.FindControl<TextBlock>("StatusText");
-            var progressIndicator = this.FindControl<ProgressBar>("ProgressIndicator");
-            
-            if (statusText is null || progressIndicator is null)
-            {
-                Console.Error.WriteLine($"[SplashWindow] Controls not found: StatusText={statusText != null}, ProgressIndicator={progressIndicator != null}");
-                return;
-            }
-
-            // 更新状态文本
-            statusText.Text = message;
-
-            // 根据阶段更新进度
-            var progress = ResolveProgress(stage);
-            if (progress > 0)
-            {
-                progressIndicator.IsIndeterminate = false;
-                progressIndicator.Value = progress;
-            }
-            else
-            {
-                progressIndicator.IsIndeterminate = true;
-            }
-        });
+            Opacity = from + ((to - from) * progress);
+        }, duration, EaseOutCubic).ConfigureAwait(false);
     }
 
-    /// <summary>
-    /// 更新进度（0-100）
-    /// </summary>
-    public void UpdateProgress(int percent, string? message = null)
+    private async Task AnimateWindowPositionAsync(
+        PixelPoint from,
+        PixelPoint to,
+        TimeSpan duration,
+        Func<double, double> easing)
     {
-        Dispatcher.UIThread.Post(() =>
+        await AnimateAsync(progress =>
         {
-            var statusText = this.FindControl<TextBlock>("StatusText");
-            var progressIndicator = this.FindControl<ProgressBar>("ProgressIndicator");
-            
-            if (statusText is null || progressIndicator is null)
-            {
-                Console.Error.WriteLine($"[SplashWindow] Controls not found in UpdateProgress");
-                return;
-            }
-
-            if (!string.IsNullOrEmpty(message))
-            {
-                statusText.Text = message;
-            }
-
-            progressIndicator.IsIndeterminate = false;
-            progressIndicator.Value = Math.Clamp(percent, 0, 100);
-        });
+            var currentX = (int)Math.Round(from.X + ((to.X - from.X) * progress));
+            var currentY = (int)Math.Round(from.Y + ((to.Y - from.Y) * progress));
+            Position = new PixelPoint(currentX, currentY);
+        }, duration, easing).ConfigureAwait(false);
     }
 
-    /// <summary>
-    /// 更新状态文本
-    /// </summary>
-    public void UpdateStatus(string message)
+    private async Task AnimateAsync(Action<double> update, TimeSpan duration, Func<double, double> easing)
     {
-        Dispatcher.UIThread.Post(() =>
+        if (duration <= TimeSpan.Zero)
         {
-            var statusText = this.FindControl<TextBlock>("StatusText");
-            if (statusText is null)
-            {
-                Console.Error.WriteLine($"[SplashWindow] StatusText not found in UpdateStatus");
-                return;
-            }
-            statusText.Text = message;
-        });
+            await Dispatcher.UIThread.InvokeAsync(() => update(1d));
+            return;
+        }
+
+        var stopwatch = Stopwatch.StartNew();
+        while (stopwatch.Elapsed < duration)
+        {
+            var raw = stopwatch.Elapsed.TotalMilliseconds / duration.TotalMilliseconds;
+            var progress = easing(Math.Clamp(raw, 0d, 1d));
+            await Dispatcher.UIThread.InvokeAsync(() => update(progress));
+            await Task.Delay(16).ConfigureAwait(false);
+        }
+
+        await Dispatcher.UIThread.InvokeAsync(() => update(1d));
     }
 
-    /// <summary>
-    /// 报告阶段和进度（0-100）
-    /// </summary>
-    public void ReportStage(string stage, int progress)
-    {
-        Dispatcher.UIThread.Post(() =>
-        {
-            var statusText = this.FindControl<TextBlock>("StatusText");
-            var progressIndicator = this.FindControl<ProgressBar>("ProgressIndicator");
-            
-            if (statusText is null || progressIndicator is null)
-            {
-                Console.Error.WriteLine($"[SplashWindow] Controls not found in ReportStage");
-                return;
-            }
-
-            statusText.Text = stage;
-            progressIndicator.IsIndeterminate = false;
-            progressIndicator.Value = Math.Clamp(progress, 0, 100);
-        });
-    }
-
-    /// <summary>
-    /// 设置版本和开发代号
-    /// </summary>
-    public void SetVersionInfo(string version, string codename)
-    {
-        Dispatcher.UIThread.Post(() =>
-        {
-            var versionText = this.FindControl<TextBlock>("VersionText");
-            if (versionText is null)
-            {
-                Console.Error.WriteLine($"[SplashWindow] VersionText not found in SetVersionInfo");
-                return;
-            }
-            versionText.Text = $"{version} ({codename})";
-        });
-    }
-
-    /// <summary>
-    /// 设置调试模式
-    /// </summary>
-    public void SetDebugMode(bool isDebugMode)
-    {
-        Dispatcher.UIThread.Post(() =>
-        {
-            var statusText = this.FindControl<TextBlock>("StatusText");
-            if (statusText is null)
-            {
-                Console.Error.WriteLine($"[SplashWindow] StatusText not found in SetDebugMode");
-                return;
-            }
-            if (isDebugMode)
-            {
-                statusText.Text = "[Debug Mode] Splash Preview";
-            }
-        });
-    }
-
-    /// <summary>
-    /// 根据阶段名称解析进度值
-    /// </summary>
     private static int ResolveProgress(string stage)
     {
         return stage.ToLowerInvariant() switch
         {
             "initializing" => 10,
+            "settings" => 25,
             "update" => 30,
             "plugins" => 50,
-            "launch" => 70,
+            "ui" => 65,
+            "shell" => 80,
+            "activation" => 90,
             "ready" => 100,
             _ => 0
         };
     }
+
+    private static double EaseOutCubic(double value)
+    {
+        var inverse = 1d - value;
+        return 1d - (inverse * inverse * inverse);
+    }
+
+    private static double EaseInCubic(double value) => value * value * value;
 }