MainWindow.xaml.cs

using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Text.Json;
using System.Windows;
using System.Windows.Automation;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media.Animation;
using System.Windows.Media;
using KimiMultilingual.Services;
using Microsoft.Web.WebView2.Core;
using Button = System.Windows.Controls.Button;
using Brush = System.Windows.Media.Brush;
using Color = System.Windows.Media.Color;
using FontFamily = System.Windows.Media.FontFamily;
using HorizontalAlignment = System.Windows.HorizontalAlignment;
using Key = System.Windows.Input.Key;
using KeyEventArgs = System.Windows.Input.KeyEventArgs;
using Point = System.Windows.Point;
using SystemColors = System.Windows.SystemColors;
using VerticalAlignment = System.Windows.VerticalAlignment;

namespace KimiMultilingual;

public partial class MainWindow : Window
{
    public const string ProjectContact = "Discord: NN6";
    private const string OnboardingCompleteMessage = "kimi-multilingual:onboarding-complete";
    private const string OnboardingBridgeScript = """
        (() => {
          if (window.__kimiMultilingualOnboardingBridge) return;
          window.__kimiMultilingualOnboardingBridge = true;
          const key = 'kimi-web.onboarded';
          const message = 'kimi-multilingual:onboarding-complete';
          let sent = false;
          let timer = 0;
          const report = () => {
            if (sent) return;
            try {
              if (localStorage.getItem(key) !== '1') return;
              sent = true;
              window.chrome?.webview?.postMessage(message);
              if (timer) window.clearInterval(timer);
            } catch {
              // Kimi Web remains usable if browser storage is unavailable.
            }
          };
          timer = window.setInterval(report, 250);
          report();
          window.addEventListener('pagehide', () => window.clearInterval(timer), { once: true });
        })();
        """;
    private readonly CancellationTokenSource _lifetime = new();
    private readonly string? _updateDemoVersion =
        Environment.GetEnvironmentVariable("KIMI_MULTILINGUAL_UPDATE_DEMO_VERSION");
    private AppPaths? _paths;
    private KimiServerHost? _server;
    private LlamaCppModelHost? _localModel;
    private AirLlmServerHost? _airLlm;
    private KimiUpdateService? _updateService;
    private DesktopNotification? _desktopNotification;
    private KimiUpdateStatus? _updateStatus;
    private RuntimePreference? _runtimePreference;
    private IReadOnlyList<LocalModelDefinition> _localModels = Array.Empty<LocalModelDefinition>();
    private LocalModelDefinition? _activeLocalModel;
    private LocalModelState? _lastLocalModelState;
    private bool _webViewInitialized;
    private bool _onboardingStateLoaded;
    private bool _onboardingComplete;
    private bool _shuttingDown;
    private bool _allowClose;
    private bool _syncingUpdatePreference;
    private bool _switchingRuntime;
    private bool _recoveringRuntime;
    private int _runtimeRecoveryAttempts;
    private DateTimeOffset _runtimeRecoveryWindowStarted;
    private DateTimeOffset _runtimeCenterClosedAt;

    public MainWindow()
    {
        InitializeComponent();
        ProjectContactText.Text = ProjectContact;
        ApplyHighContrastChrome();
    }

    private void ApplyHighContrastChrome()
    {
        if (!SystemParameters.HighContrast)
        {
            return;
        }

        OuterFrame.Background = SystemColors.WindowBrush;
        OuterFrame.BorderBrush = SystemColors.WindowTextBrush;
        CommandBar.Background = SystemColors.ControlBrush;
        LoadingOverlay.Background = SystemColors.WindowBrush;
        LoadingLocalGlow.Visibility = Visibility.Collapsed;
        LoadingCloudGlow.Visibility = Visibility.Collapsed;
        LoadingCard.Background = SystemColors.WindowBrush;
        LoadingCard.BorderBrush = SystemColors.WindowTextBrush;
        LoadingCard.Effect = null;
        LoadingModeBadge.Background = SystemColors.ControlBrush;
        LoadingModeBadge.BorderBrush = SystemColors.WindowTextBrush;
        LoadingModeBadgeText.Foreground = SystemColors.WindowTextBrush;
        RuntimeCenterSurface.Background = SystemColors.WindowBrush;
        RuntimeCenterSurface.BorderBrush = SystemColors.WindowTextBrush;
        RuntimeCenterSurface.Effect = null;
        RuntimeActiveCard.Background = SystemColors.ControlBrush;
        RuntimeActiveCard.BorderBrush = SystemColors.WindowTextBrush;
    }

    private async void OnLoaded(object sender, RoutedEventArgs e)
    {
        _desktopNotification = new DesktopNotification();
        ApplyResponsiveChrome(ActualWidth);
        if (!SystemParameters.ClientAreaAnimation || SystemParameters.HighContrast)
        {
            RuntimeCenterPopup.PopupAnimation = System.Windows.Controls.Primitives.PopupAnimation.None;
        }
        StartAmbientMotion();
        await StartWorkspaceAsync();
    }

    private void OnSourceInitialized(object? sender, EventArgs e)
    {
        WindowBackdrop.TryApply(this);
    }

    private void OnWindowStateChanged(object? sender, EventArgs e)
    {
        var maximized = WindowState == WindowState.Maximized;
        OuterFrame.CornerRadius = maximized ? new CornerRadius(0) : new CornerRadius(14);
        OuterFrame.BorderThickness = maximized ? new Thickness(0) : new Thickness(1);
        MaximizeGlyph.Text = maximized ? "\uE923" : "\uE922";
        MaximizeButton.ToolTip = maximized ? "Restore" : "Maximize";
        AutomationProperties.SetName(MaximizeButton, maximized ? "Restore" : "Maximize");
    }

    private void OnWindowSizeChanged(object sender, SizeChangedEventArgs e)
    {
        ApplyResponsiveChrome(e.NewSize.Width);
    }

    private void ApplyResponsiveChrome(double width)
    {
        var compact = width < 1260;
        BrandBadge.Visibility = width < 1360 ? Visibility.Collapsed : Visibility.Visible;
        BrandSubtitle.Visibility = width < 1420 ? Visibility.Collapsed : Visibility.Visible;
        BrandDetails.Visibility = width < 1080 ? Visibility.Collapsed : Visibility.Visible;
        HeaderStatusPill.Visibility = width < 1120 ? Visibility.Collapsed : Visibility.Visible;
        EngineVersionText.Visibility = width < 1320 ? Visibility.Collapsed : Visibility.Visible;
        OpenBrowserButton.Visibility = width < 1180 ? Visibility.Collapsed : Visibility.Visible;
        HeaderStatusPill.MaxWidth = compact ? 270 : 360;
        RuntimeModeButton.MaxWidth = compact ? 176 : 206;
    }

    private async Task StartWorkspaceAsync()
    {
        LoadingTitle.Text = "Opening your multilingual Kimi space";
        SetLoading("Starting Kimi workspace… | جارٍ تشغيل مساحة عمل كيمي…");
        RetryButton.Visibility = Visibility.Collapsed;
        LoadingProgress.Visibility = Visibility.Visible;
        ReloadButton.IsEnabled = false;
        OpenBrowserButton.IsEnabled = false;
        RuntimeModeButton.IsEnabled = false;
        LocalModelButton.IsEnabled = false;
        LocalModelButtonText.Text = "Checking…";
        LocalModelDot.Fill = new SolidColorBrush(Color.FromRgb(242, 197, 103));
        ConnectionDot.Fill = new SolidColorBrush(Color.FromRgb(240, 185, 77));

        try
        {
            if (_server is not null)
            {
                _server.UnexpectedExit -= OnRuntimeUnexpectedExit;
                await _server.DisposeAsync();
                _server = null;
            }

            if (_localModel is not null)
            {
                _localModel.UnexpectedExit -= OnRuntimeUnexpectedExit;
                await _localModel.DisposeAsync();
                _localModel = null;
            }

            if (_airLlm is not null)
            {
                _airLlm.UnexpectedExit -= OnRuntimeUnexpectedExit;
                await _airLlm.DisposeAsync();
                _airLlm = null;
            }

            _paths ??= AppPaths.Discover();
            if (!_onboardingStateLoaded)
            {
                _onboardingComplete = await KimiOnboardingStore.LoadAsync(_paths, _lifetime.Token);
                _onboardingStateLoaded = true;
            }
            _runtimePreference ??= await RuntimePreferenceStore.LoadAsync(_paths, _lifetime.Token);
            await KimiLocalConfigMigration.ApplyAsync(
                _paths,
                _runtimePreference.Kind,
                _lifetime.Token);
            _localModels = LocalModelCatalog.Discover(_paths);
            KimiModelEnvironment? modelEnvironment = null;
            string runtimeLabel;
            if (_runtimePreference.Kind == KimiRuntimeKind.AirLlmK3)
            {
                _activeLocalModel = null;
                _lastLocalModelState = null;
                LocalModelButton.Visibility = Visibility.Visible;
                _airLlm = new AirLlmServerHost(_paths, SetLocalModelStateThreadSafe);
                _airLlm.UnexpectedExit += OnRuntimeUnexpectedExit;
                UpdateRuntimeModeUi();
                await _airLlm.StartAsync(_lifetime.Token);
                modelEnvironment = _airLlm.CreateKimiModelEnvironment();
                runtimeLabel = AirLlmServerHost.DisplayName;
            }
            else if (_runtimePreference.Kind == KimiRuntimeKind.LocalGguf)
            {
                _activeLocalModel = LocalModelCatalog.Resolve(_localModels, _runtimePreference.LocalModelPath)
                    ?? throw new FileNotFoundException(
                        $"No runnable GGUF checkpoint was found under {Path.Combine(_paths.KimiRoot, "models")}.");
                _lastLocalModelState = null;
                LocalModelButton.Visibility = Visibility.Visible;
                _localModel = new LlamaCppModelHost(_paths, SetLocalModelStateThreadSafe, _activeLocalModel);
                _localModel.UnexpectedExit += OnRuntimeUnexpectedExit;
                UpdateRuntimeModeUi();
                await _localModel.StartAsync(_lifetime.Token);
                modelEnvironment = _localModel.CreateKimiModelEnvironment();
                runtimeLabel = _activeLocalModel.CompactDisplayName;
            }
            else
            {
                _activeLocalModel = null;
                _lastLocalModelState = null;
                LocalModelButton.Visibility = Visibility.Collapsed;
                runtimeLabel = "Original Kimi cloud";
                SetLocalModelStateThreadSafe(new LocalModelState(runtimeLabel, false, false));
                UpdateRuntimeModeUi();
            }

            // Runtime initialization can take many minutes for Kimi K3. Reflect the
            // persisted selection before awaiting it so the loading screen never
            // mislabels AirLLM as the default GGUF runtime.
            UpdateRuntimeModeUi();

            // The Kimi child must inherit this launch's private endpoint and API
            // token, so attaching to a pre-existing server is deliberately disabled.
            _server = new KimiServerHost(_paths, SetStatusThreadSafe, modelEnvironment, allowAttach: false);
            _server.UnexpectedExit += OnRuntimeUnexpectedExit;
            await _server.StartAsync(_lifetime.Token);
            EngineVersionText.Text = $"Kimi Code {_server.ServerVersion ?? "local"} - {runtimeLabel}";
            UpdateRuntimeModeUi();

            // This build carries local compatibility fixes in its Kimi engine.
            // An upstream auto-update would replace those fixes, so updates are
            // intentionally pinned to app releases that are tested as a unit.
            UpdateButton.Visibility = Visibility.Collapsed;
            UpdateBanner.Visibility = Visibility.Collapsed;
            AutoUpdateCheckBox.IsChecked = false;
            AutoUpdateCheckBox.IsEnabled = false;
            InstallUpdateButton.IsEnabled = false;
            await InitializeWebViewAsync(_paths);

            if (Environment.GetEnvironmentVariable("KIMI_MULTILINGUAL_RTL_DEMO") == "1")
            {
                KimiWebView.Source = new Uri("https://kimi-multilingual.test/rtl-showcase.html");
            }
            else
            {
                KimiWebView.Source = GetKimiWebUri();
            }
            ReloadButton.IsEnabled = true;
            OpenBrowserButton.IsEnabled = true;
            RuntimeModeButton.IsEnabled = true;
            if (!_recoveringRuntime)
            {
                _runtimeRecoveryAttempts = 0;
            }
        }
        catch (OperationCanceledException) when (_lifetime.IsCancellationRequested)
        {
        }
        catch (Exception error)
        {
            if (_server is not null)
            {
                try
                {
                    _server.UnexpectedExit -= OnRuntimeUnexpectedExit;
                    await _server.DisposeAsync();
                }
                catch
                {
                    // Preserve the startup error shown below.
                }
                _server = null;
            }
            if (_localModel is not null)
            {
                try
                {
                    _localModel.UnexpectedExit -= OnRuntimeUnexpectedExit;
                    await _localModel.DisposeAsync();
                }
                catch
                {
                    // Preserve the startup error shown below.
                }
                _localModel = null;
            }
            if (_airLlm is not null)
            {
                try
                {
                    _airLlm.UnexpectedExit -= OnRuntimeUnexpectedExit;
                    await _airLlm.DisposeAsync();
                }
                catch
                {
                    // Preserve the startup error shown below.
                }
                _airLlm = null;
            }

            ShowError(error);
        }
        finally
        {
            RuntimeModeButton.IsEnabled = !_shuttingDown && !_switchingRuntime && !_recoveringRuntime;
        }
    }

    private async Task InitializeWebViewAsync(AppPaths paths)
    {
        if (_webViewInitialized)
        {
            return;
        }

        SetLoading("Starting browser-grade multilingual renderer… | جارٍ تشغيل عارض اللغات…");
        var environment = await CoreWebView2Environment.CreateAsync(
            browserExecutableFolder: null,
            userDataFolder: paths.WebViewProfile);
        await KimiWebView.EnsureCoreWebView2Async(environment);

        var core = KimiWebView.CoreWebView2;
        core.Settings.AreDevToolsEnabled = false;
        core.Settings.IsStatusBarEnabled = false;
        core.Settings.AreBrowserAcceleratorKeysEnabled = true;
        core.Settings.IsZoomControlEnabled = true;

        if (Environment.GetEnvironmentVariable("KIMI_MULTILINGUAL_RTL_DEMO") == "1")
        {
            core.SetVirtualHostNameToFolderMapping(
                "kimi-multilingual.test",
                Path.GetDirectoryName(paths.ShowcasePath)!,
                CoreWebView2HostResourceAccessKind.DenyCors);
        }

        var bidiScript = await File.ReadAllTextAsync(paths.BidiScriptPath, _lifetime.Token);
        await core.AddScriptToExecuteOnDocumentCreatedAsync(bidiScript);
        await core.AddScriptToExecuteOnDocumentCreatedAsync(OnboardingBridgeScript);
        core.NavigationStarting += OnNavigationStarting;
        core.NavigationCompleted += OnNavigationCompleted;
        core.NewWindowRequested += OnNewWindowRequested;
        core.ProcessFailed += OnWebProcessFailed;
        core.WebMessageReceived += OnWebMessageReceived;
        _webViewInitialized = true;
    }

    private void OnNavigationStarting(object? sender, CoreWebView2NavigationStartingEventArgs e)
    {
        if (IsLocalKimiUri(e.Uri))
        {
            return;
        }

        e.Cancel = true;
        OpenExternalUri(e.Uri);
    }

    private void OnNewWindowRequested(object? sender, CoreWebView2NewWindowRequestedEventArgs e)
    {
        e.Handled = true;
        if (IsLocalKimiUri(e.Uri) && Uri.TryCreate(e.Uri, UriKind.Absolute, out var localUri))
        {
            KimiWebView.Source = localUri;
            return;
        }

        OpenExternalUri(e.Uri);
    }

    private async void OnNavigationCompleted(object? sender, CoreWebView2NavigationCompletedEventArgs e)
    {
        if (!e.IsSuccess)
        {
            if (e.WebErrorStatus == CoreWebView2WebErrorStatus.OperationCanceled)
            {
                return;
            }

            ShowError(new InvalidOperationException($"Kimi Web failed to load: {e.WebErrorStatus}"));
            return;
        }

        // A successful document is usable immediately. Direction QA runs after
        // reveal so valid non-chat routes (including the one-time welcome page)
        // can never be hidden behind a composer-specific startup check.
        KimiWebView.Visibility = Visibility.Visible;
        LoadingOverlay.Visibility = Visibility.Collapsed;
        ConnectionDot.Fill = new SolidColorBrush(Color.FromRgb(82, 227, 164));
        HeaderStatusText.Text = "Connected · Automatic direction";
        HeaderStatusText.ToolTip = null;
        try
        {
            if (!await VerifyBidiPolicyAsync())
            {
                ConnectionDot.Fill = new SolidColorBrush(Color.FromRgb(242, 197, 103));
                HeaderStatusText.Text = "Connected · Direction helper needs attention";
                HeaderStatusText.ToolTip = "The page is usable, but automatic RTL/LTR initialization did not pass its check.";
            }
        }
        catch (OperationCanceledException) when (_lifetime.IsCancellationRequested)
        {
        }
        catch (Exception error)
        {
            // Renderer diagnostics must not replace a working Kimi page. Keep
            // the application usable and expose the diagnostic in the status UI.
            ConnectionDot.Fill = new SolidColorBrush(Color.FromRgb(242, 197, 103));
            HeaderStatusText.Text = "Connected · Direction check unavailable";
            HeaderStatusText.ToolTip = error.Message;
        }
    }

    private void OnWebProcessFailed(object? sender, CoreWebView2ProcessFailedEventArgs e)
    {
        ShowError(new InvalidOperationException($"The multilingual renderer stopped: {e.ProcessFailedKind}"));
    }

    private async void OnWebMessageReceived(object? sender, CoreWebView2WebMessageReceivedEventArgs e)
    {
        if (_onboardingComplete || _paths is null || !IsLocalKimiUri(e.Source))
        {
            return;
        }

        string message;
        try
        {
            message = e.TryGetWebMessageAsString();
        }
        catch (ArgumentException)
        {
            return;
        }
        if (!message.Equals(OnboardingCompleteMessage, StringComparison.Ordinal))
        {
            return;
        }

        _onboardingComplete = true;
        try
        {
            await KimiOnboardingStore.MarkCompletedAsync(
                _paths,
                "web-onboarding-completed",
                _lifetime.Token);
        }
        catch (OperationCanceledException) when (_lifetime.IsCancellationRequested)
        {
        }
        catch (Exception error) when (error is IOException or UnauthorizedAccessException)
        {
            _onboardingComplete = false;
            HeaderStatusText.Text = "Connected · first-run choice could not be saved";
        }
    }

    private async Task<bool> VerifyBidiPolicyAsync()
    {
        const string probe = """
            (() => {
              const composer = document.querySelector('textarea, [contenteditable="true"], [role="textbox"]');
              const sentMessages = Array.from(document.querySelectorAll('.u-text'));
              const style = composer ? getComputedStyle(composer) : null;
              return {
                composerFound: composer !== null,
                composerDirection: composer?.getAttribute('dir') ?? null,
                composerUnicodeBidi: style?.unicodeBidi ?? null,
                sentMessagesFound: sentMessages.length,
                sentMessagesReady: sentMessages.every((node) => node.getAttribute('dir') === 'auto'),
              };
            })()
            """;

        var sawDirectionSensitiveContent = false;
        for (var attempt = 0; attempt < 30; attempt++)
        {
            var result = await KimiWebView.CoreWebView2.ExecuteScriptAsync(probe);
            using var document = JsonDocument.Parse(result);
            var root = document.RootElement;
            var composerFound = root.GetProperty("composerFound").GetBoolean();
            var composerDirection = root.GetProperty("composerDirection").GetString();
            var composerUnicodeBidi = root.GetProperty("composerUnicodeBidi").GetString();
            var sentMessagesFound = root.GetProperty("sentMessagesFound").GetInt32();
            var sentMessagesReady = root.GetProperty("sentMessagesReady").GetBoolean();

            sawDirectionSensitiveContent |= composerFound || sentMessagesFound > 0;

            if (ShouldAcceptBidiProbe(
                    composerFound,
                    composerDirection,
                    composerUnicodeBidi,
                    sentMessagesFound,
                    sentMessagesReady,
                    sawDirectionSensitiveContent,
                    attempt))
            {
                return true;
            }

            await Task.Delay(200, _lifetime.Token);
        }

        return !sawDirectionSensitiveContent;
    }

    internal static bool ShouldAcceptBidiProbe(
        bool composerFound,
        string? composerDirection,
        string? composerUnicodeBidi,
        int sentMessagesFound,
        bool sentMessagesReady,
        bool sawDirectionSensitiveContent,
        int attempt)
    {
        var relevant = sawDirectionSensitiveContent || composerFound || sentMessagesFound > 0;
        var ready = (!composerFound ||
                     (composerDirection == "auto" && composerUnicodeBidi == "plaintext")) &&
                    (composerFound || sentMessagesFound > 0) &&
                    sentMessagesReady;
        if (ready)
        {
            return true;
        }

        // Welcome, settings, and other valid Kimi routes have no composer.
        // Give the SPA a short render window, then accept an irrelevant route.
        return !relevant && attempt >= 2;
    }

    private void OnReload(object sender, RoutedEventArgs e)
    {
        KimiWebView.Reload();
    }

    private void OnMinimize(object sender, RoutedEventArgs e)
    {
        WindowState = WindowState.Minimized;
    }

    private void OnMaximizeRestore(object sender, RoutedEventArgs e)
    {
        WindowState = WindowState == WindowState.Maximized
            ? WindowState.Normal
            : WindowState.Maximized;
    }

    private void OnCloseWindow(object sender, RoutedEventArgs e)
    {
        Close();
    }

    private void OnUpdateButton(object sender, RoutedEventArgs e)
    {
        if (UpdateBanner.Visibility == Visibility.Visible)
        {
            HideUpdateBanner();
        }
        else
        {
            ShowUpdateBanner();
        }
    }

    private void OnDismissUpdate(object sender, RoutedEventArgs e)
    {
        HideUpdateBanner();
    }

    private async void OnAutoUpdateChanged(object sender, RoutedEventArgs e)
    {
        if (_syncingUpdatePreference || _updateService is null)
        {
            return;
        }

        await _updateService.SetAutomaticInstallAsync(AutoUpdateCheckBox.IsChecked == true, _lifetime.Token);
    }

    private async void OnInstallUpdate(object sender, RoutedEventArgs e)
    {
        if (_updateService is null)
        {
            return;
        }

        if (_updateStatus?.Phase == KimiUpdatePhase.RestartPending)
        {
            if (_server is null)
            {
                return;
            }

            var confirmation = System.Windows.MessageBox.Show(
                "The verified Kimi update is installed.\n\n" +
                "Send any unsent draft first. Restarting reloads the local Kimi page, while saved session history and files remain in place.\n\n" +
                "تم تثبيت التحديث. أرسل أي مسودة غير مرسلة أولاً، ثم أعد تشغيل المحرك.\n\n" +
                "Restart the local Kimi engine now?",
                "Restart Kimi engine",
                MessageBoxButton.YesNo,
                MessageBoxImage.Information,
                MessageBoxResult.No);
            if (confirmation != MessageBoxResult.Yes)
            {
                return;
            }

            InstallUpdateButton.IsEnabled = false;
            SetLoading("Restarting the verified Kimi engine… | جارٍ إعادة تشغيل محرك كيمي المحدّث…");
            try
            {
                await _server.RestartAsync(_lifetime.Token);
                _updateService.SetRunningVersion(_server.ServerVersion);
                KimiWebView.Source = GetKimiWebUri();
                await _updateService.CheckNowAsync(_lifetime.Token);
            }
            catch (OperationCanceledException) when (_lifetime.IsCancellationRequested)
            {
            }
            catch (Exception error)
            {
                ShowError(error);
            }
            return;
        }

        await _updateService.InstallAvailableAsync(_lifetime.Token);
    }

    private void OnOpenInBrowser(object sender, RoutedEventArgs e)
    {
        if (_server?.WebUri is null)
        {
            return;
        }

        Process.Start(new ProcessStartInfo(GetKimiWebUri()!.AbsoluteUri) { UseShellExecute = true });
    }

    private bool IsLocalKimiUri(string value)
    {
        if (value.Equals("about:blank", StringComparison.OrdinalIgnoreCase))
        {
            return true;
        }

        if (Environment.GetEnvironmentVariable("KIMI_MULTILINGUAL_RTL_DEMO") == "1" &&
            Uri.TryCreate(value, UriKind.Absolute, out var demoUri) &&
            demoUri.Scheme.Equals(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) &&
            demoUri.Host.Equals("kimi-multilingual.test", StringComparison.OrdinalIgnoreCase))
        {
            return true;
        }

        return _server is not null &&
               Uri.TryCreate(value, UriKind.Absolute, out var uri) &&
               uri.Scheme.Equals(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) &&
               uri.Host.Equals("127.0.0.1", StringComparison.OrdinalIgnoreCase) &&
               uri.Port == _server.Port;
    }

    private Uri? GetKimiWebUri() => _server?.WebUri is { } webUri
        ? KimiOnboardingStore.ApplyCompletionFlag(webUri, _onboardingComplete)
        : null;

    private static void OpenExternalUri(string value)
    {
        if (!Uri.TryCreate(value, UriKind.Absolute, out var uri) ||
            (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps))
        {
            return;
        }

        Process.Start(new ProcessStartInfo(uri.AbsoluteUri) { UseShellExecute = true });
    }

    private async void OnRetry(object sender, RoutedEventArgs e)
    {
        _runtimeRecoveryAttempts = 0;
        await StartWorkspaceAsync();
    }

    private void OnRuntimeUnexpectedExit(object? sender, EventArgs e)
    {
        _ = Dispatcher.BeginInvoke(new Action(() => _ = RecoverWorkspaceAsync()));
    }

    private async Task RecoverWorkspaceAsync()
    {
        if (_shuttingDown || _switchingRuntime || _recoveringRuntime)
        {
            return;
        }

        var now = DateTimeOffset.UtcNow;
        if (_runtimeRecoveryWindowStarted == default ||
            now - _runtimeRecoveryWindowStarted > TimeSpan.FromMinutes(5))
        {
            _runtimeRecoveryWindowStarted = now;
            _runtimeRecoveryAttempts = 0;
        }
        if (_runtimeRecoveryAttempts >= 2)
        {
            ShowError(new InvalidOperationException(
                "The selected runtime stopped repeatedly. Choose Original Kimi, AirLLM K3, or another GGUF model, then Retry."));
            return;
        }

        _runtimeRecoveryAttempts++;
        _recoveringRuntime = true;
        RuntimeModeButton.IsEnabled = false;
        try
        {
            SetLoading("Recovering the selected Kimi runtime...");
            await Task.Delay(750, _lifetime.Token);
            await StartWorkspaceAsync();
        }
        catch (OperationCanceledException) when (_lifetime.IsCancellationRequested)
        {
        }
        finally
        {
            _recoveringRuntime = false;
            RuntimeModeButton.IsEnabled = !_shuttingDown && !_switchingRuntime;
        }
    }

    private void OnRuntimeMode(object sender, RoutedEventArgs e)
    {
        if (_paths is null || _switchingRuntime)
        {
            return;
        }

        if (RuntimeCenterPopup.IsOpen)
        {
            RuntimeCenterPopup.IsOpen = false;
            return;
        }

        // A StaysOpen=false popup closes during preview input when its anchor is
        // clicked. Suppress the same click's later Button.Click so it toggles
        // closed instead of immediately reopening.
        if (RuntimeModeButton.IsMouseOver &&
            DateTimeOffset.UtcNow - _runtimeCenterClosedAt < TimeSpan.FromMilliseconds(300))
        {
            return;
        }

        RefreshRuntimeCenter();
        RuntimeCenterPopup.IsOpen = true;
        _ = Dispatcher.BeginInvoke(
            () => RuntimeOptionsPanel.Children.OfType<Button>().FirstOrDefault()?.Focus(),
            System.Windows.Threading.DispatcherPriority.Input);
    }

    private void OnCloseRuntimeCenter(object sender, RoutedEventArgs e)
    {
        RuntimeCenterPopup.IsOpen = false;
        RuntimeModeButton.Focus();
    }

    private void OnRuntimeCenterClosed(object? sender, EventArgs e)
    {
        _runtimeCenterClosedAt = DateTimeOffset.UtcNow;
    }

    private void OnRuntimeCenterKeyDown(object sender, KeyEventArgs e)
    {
        if (e.Key != Key.Escape)
        {
            return;
        }

        RuntimeCenterPopup.IsOpen = false;
        RuntimeModeButton.Focus();
        e.Handled = true;
    }

    private void OnOpenModelsFolder(object sender, RoutedEventArgs e)
    {
        RuntimeCenterPopup.IsOpen = false;
        OpenModelsFolder();
    }

    private void OnOpenBrowserFromRuntimeCenter(object sender, RoutedEventArgs e)
    {
        RuntimeCenterPopup.IsOpen = false;
        OnOpenInBrowser(sender, e);
    }

    private void RefreshRuntimeCenter()
    {
        if (_paths is null)
        {
            return;
        }

        _localModels = LocalModelCatalog.Discover(_paths);
        RuntimeOptionsPanel.Children.Clear();
        RuntimeOptionsPanel.Children.Add(CreateRuntimeChoiceButton(
            "Original Kimi",
            "Cloud account · Official models, vision, tools, and internet",
            _runtimePreference?.Kind == KimiRuntimeKind.OriginalKimi,
            isCloud: true,
            new RuntimePreference(KimiRuntimeKind.OriginalKimi, _runtimePreference?.LocalModelPath),
            "Uses the isolated Kimi profile and never inherits a stale local endpoint."));

        RuntimeOptionsPanel.Children.Add(CreateRuntimeChoiceButton(
            "Kimi K3 (2.8T)",
            "AirLLM 3.1 · Offline · 2K proof · 1 token · RTX single-card",
            _runtimePreference?.Kind == KimiRuntimeKind.AirLlmK3,
            isCloud: false,
            new RuntimePreference(KimiRuntimeKind.AirLlmK3, _runtimePreference?.LocalModelPath),
            Path.Combine(_paths.KimiRoot, "airllm-v3.1.0", "models", "moonshotai--Kimi-K3")));

        foreach (var model in _localModels)
        {
            var selected = _runtimePreference?.Kind == KimiRuntimeKind.LocalGguf &&
                           _activeLocalModel is not null &&
                           string.Equals(
                               Path.GetFullPath(_activeLocalModel.ModelPath),
                               Path.GetFullPath(model.ModelPath),
                               StringComparison.OrdinalIgnoreCase);
            var capability = model.ProjectorPath is null ? "Text + tools" : "Text + tools + vision";
            RuntimeOptionsPanel.Children.Add(CreateRuntimeChoiceButton(
                model.CompactDisplayName,
                $"{(model.IsBundled ? "Standalone" : "Local GGUF")} · {model.ContextSize:N0} context · {capability}",
                selected,
                isCloud: false,
                new RuntimePreference(KimiRuntimeKind.LocalGguf, model.ModelPath),
                $"{model.DisplayName}\n{model.ModelPath}"));
        }

        if (_localModels.Count == 0)
        {
            RuntimeOptionsPanel.Children.Add(new Border
            {
                Background = new SolidColorBrush(Color.FromArgb(15, 255, 255, 255)),
                BorderBrush = new SolidColorBrush(Color.FromArgb(36, 255, 255, 255)),
                BorderThickness = new Thickness(1),
                CornerRadius = new CornerRadius(14),
                Padding = new Thickness(14, 12, 14, 12),
                Margin = new Thickness(0, 4, 0, 0),
                Child = new TextBlock
                {
                    Text = "No GGUF checkpoints found. Open the models folder to add one.",
                    Foreground = (Brush)FindResource("SecondaryText"),
                    FontSize = 11,
                    TextWrapping = TextWrapping.Wrap,
                },
            });
        }

        UpdateRuntimeModeUi();
    }

    private Button CreateRuntimeChoiceButton(
        string title,
        string subtitle,
        bool selected,
        bool isCloud,
        RuntimePreference preference,
        string toolTip)
    {
        var button = new Button
        {
            Style = (Style)FindResource("RuntimeChoiceButtonStyle"),
            ToolTip = toolTip,
        };
        if (SystemParameters.HighContrast)
        {
            button.Background = selected ? SystemColors.HighlightBrush : SystemColors.ControlBrush;
            button.BorderBrush = SystemColors.WindowTextBrush;
        }
        else if (selected)
        {
            button.Background = new SolidColorBrush(isCloud
                ? Color.FromArgb(28, 165, 150, 255)
                : Color.FromArgb(28, 82, 227, 164));
            button.BorderBrush = new SolidColorBrush(isCloud
                ? Color.FromArgb(74, 165, 150, 255)
                : Color.FromArgb(74, 82, 227, 164));
        }
        AutomationProperties.SetName(button, $"{title}. {subtitle}");
        var primaryChoiceText = SystemParameters.HighContrast
            ? selected ? SystemColors.HighlightTextBrush : SystemColors.WindowTextBrush
            : (Brush)FindResource("PrimaryText");
        var secondaryChoiceText = SystemParameters.HighContrast
            ? selected ? SystemColors.HighlightTextBrush : SystemColors.WindowTextBrush
            : (Brush)FindResource("SecondaryText");

        var layout = new Grid();
        layout.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
        layout.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
        layout.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
        var icon = new Border
        {
            Width = 28,
            Height = 28,
            CornerRadius = new CornerRadius(10),
            Background = SystemParameters.HighContrast
                ? selected ? SystemColors.HighlightBrush : SystemColors.ControlBrush
                : new SolidColorBrush(isCloud
                    ? Color.FromArgb(30, 165, 150, 255)
                    : Color.FromArgb(30, 82, 227, 164)),
            BorderBrush = SystemParameters.HighContrast
                ? SystemColors.WindowTextBrush
                : new SolidColorBrush(isCloud
                    ? Color.FromArgb(60, 165, 150, 255)
                    : Color.FromArgb(60, 82, 227, 164)),
            BorderThickness = new Thickness(1),
            Margin = new Thickness(0, 0, 11, 0),
            Child = new TextBlock
            {
                Text = isCloud ? "\uE753" : "\uE950",
                FontFamily = new FontFamily("Segoe Fluent Icons"),
                FontSize = 12,
                Foreground = SystemParameters.HighContrast
                    ? primaryChoiceText
                    : isCloud
                        ? new SolidColorBrush(Color.FromRgb(191, 180, 255))
                        : new SolidColorBrush(Color.FromRgb(142, 240, 196)),
                HorizontalAlignment = HorizontalAlignment.Center,
                VerticalAlignment = VerticalAlignment.Center,
            },
        };
        layout.Children.Add(icon);

        var labels = new StackPanel { VerticalAlignment = VerticalAlignment.Center };
        labels.Children.Add(new TextBlock
        {
            Text = title,
            Foreground = primaryChoiceText,
            FontSize = 12,
            FontWeight = FontWeights.SemiBold,
            TextTrimming = TextTrimming.CharacterEllipsis,
        });
        labels.Children.Add(new TextBlock
        {
            Text = subtitle,
            Foreground = secondaryChoiceText,
            FontSize = 10,
            Margin = new Thickness(0, 3, 0, 0),
            TextTrimming = TextTrimming.CharacterEllipsis,
        });
        Grid.SetColumn(labels, 1);
        layout.Children.Add(labels);

        if (selected)
        {
            var check = new TextBlock
            {
                Text = "\uE73E",
                FontFamily = new FontFamily("Segoe Fluent Icons"),
                Foreground = SystemParameters.HighContrast
                    ? SystemColors.HighlightTextBrush
                    : isCloud
                        ? new SolidColorBrush(Color.FromRgb(191, 180, 255))
                        : new SolidColorBrush(Color.FromRgb(82, 227, 164)),
                FontSize = 13,
                Margin = new Thickness(10, 0, 0, 0),
                VerticalAlignment = VerticalAlignment.Center,
            };
            Grid.SetColumn(check, 2);
            layout.Children.Add(check);
        }

        button.Content = layout;
        button.Click += async (_, _) =>
        {
            RuntimeCenterPopup.IsOpen = false;
            await SwitchRuntimeAsync(preference);
        };
        return button;
    }

    private async Task SwitchRuntimeAsync(RuntimePreference preference)
    {
        if (_paths is null || _switchingRuntime || preference == _runtimePreference)
        {
            return;
        }

        _switchingRuntime = true;
        _runtimeRecoveryAttempts = 0;
        _runtimeRecoveryWindowStarted = default;
        RuntimeModeButton.IsEnabled = false;
        try
        {
            await RuntimePreferenceStore.SaveAsync(_paths, preference, _lifetime.Token);
            _runtimePreference = preference;
            UpdateRuntimeModeUi();
            await StartWorkspaceAsync();
        }
        catch (OperationCanceledException) when (_lifetime.IsCancellationRequested)
        {
        }
        catch (Exception error)
        {
            ShowError(error);
        }
        finally
        {
            _switchingRuntime = false;
            RuntimeModeButton.IsEnabled = !_shuttingDown;
        }
    }

    private void UpdateRuntimeModeUi()
    {
        var isCloud = _runtimePreference?.Kind == KimiRuntimeKind.OriginalKimi;
        var isAirLlm = _runtimePreference?.Kind == KimiRuntimeKind.AirLlmK3;
        var fullTitle = isCloud
            ? "Original Kimi"
            : isAirLlm
                ? AirLlmServerHost.FullDisplayName
                : _activeLocalModel?.DisplayName ?? "Local GGUF";
        var compactTitle = isCloud
            ? "Original Kimi"
            : isAirLlm
                ? AirLlmServerHost.DisplayName
                : _activeLocalModel?.CompactDisplayName ?? "Local GGUF";
        RuntimeModeButtonText.Text = compactTitle;
        RuntimeModeEyebrowText.Text = isCloud
            ? "ORIGINAL KIMI · CLOUD"
            : isAirLlm
                ? "AIRLLM 3.1 · PRIVATE"
                : "LOCAL · PRIVATE";
        RuntimeModeButton.ToolTip = isCloud
            ? "Original Kimi cloud - click to choose another runtime"
            : isAirLlm
                ? "Local Kimi K3 hardware proof through AirLLM 3.1 - 2K context, one output token, extremely slow"
                : $"Standalone local runtime - {_activeLocalModel?.ModelPath ?? "choose a GGUF model"}";
        RuntimeModeDot.Fill = new SolidColorBrush(isCloud
            ? Color.FromRgb(165, 150, 255)
            : Color.FromRgb(82, 227, 164));

        RuntimeCenterTitleText.Text = fullTitle;
        RuntimeCenterTitleText.ToolTip = fullTitle;
        RuntimeScopeChipText.Text = isCloud ? "Official cloud" : isAirLlm ? "Offline model" : "Private loopback";
        RuntimeContextChipText.Text = isCloud
            ? "Account models"
            : isAirLlm
                ? $"{AirLlmServerHost.ContextSize / 1024}K context"
                : $"{(_activeLocalModel?.ContextSize ?? 0) / 1024}K context";
        RuntimeCapabilitiesChipText.Text = isCloud
            ? "Vision + tools + web"
            : isAirLlm
                ? "1-token proof"
                : _activeLocalModel?.ProjectorPath is null ? "Text + tools" : "Vision + tools";
        LoadingModeBadgeText.Text = isCloud
            ? "ORIGINAL KIMI · CLOUD"
            : isAirLlm
                ? "AIRLLM K3 · PRIVATE RUNTIME"
                : "LOCAL · PRIVATE RUNTIME";
        LoadingRuntimeTypeChipText.Text = isCloud
            ? "Official Kimi"
            : isAirLlm
                ? "AirLLM 3.1 · Kimi K3"
                : "Independent GGUF";

        if (isCloud)
        {
            RuntimeCenterDetailText.Text = "Official Kimi services through this app's isolated account profile.";
            RuntimeCenterStatusDot.Fill = new SolidColorBrush(Color.FromRgb(165, 150, 255));
        }
        else if (_lastLocalModelState is { } localState)
        {
            RuntimeCenterDetailText.Text = localState.Message;
            RuntimeCenterStatusDot.Fill = new SolidColorBrush(localState.IsReady
                ? Color.FromRgb(82, 227, 164)
                : localState.CanTest
                    ? Color.FromRgb(165, 150, 255)
                    : Color.FromRgb(242, 197, 103));
        }
        else
        {
            RuntimeCenterDetailText.Text = isAirLlm
                ? "Preparing the installed Kimi K3 checkpoint through AirLLM 3.1."
                : "Preparing the selected standalone GGUF runtime.";
            RuntimeCenterStatusDot.Fill = new SolidColorBrush(Color.FromRgb(242, 197, 103));
        }
    }

    private void OpenModelsFolder()
    {
        if (_paths is null)
        {
            return;
        }

        var path = Path.Combine(_paths.KimiRoot, "models");
        Directory.CreateDirectory(path);
        Process.Start(new ProcessStartInfo("explorer.exe")
        {
            UseShellExecute = true,
            ArgumentList = { path },
        });
    }

    private async void OnLocalModel(object sender, RoutedEventArgs e)
    {
        if (_localModel is null && _airLlm is null)
        {
            return;
        }

        LocalModelButton.IsEnabled = false;
        try
        {
            if (_airLlm is not null)
            {
                await _airLlm.RunSelfTestAsync(_lifetime.Token);
            }
            else
            {
                await _localModel!.RunSelfTestAsync(_lifetime.Token);
            }
        }
        catch (OperationCanceledException) when (_lifetime.IsCancellationRequested)
        {
        }
        catch (Exception error)
        {
            LocalModelButton.ToolTip = error.Message;
        }
    }

    private async void OnClosing(object? sender, CancelEventArgs e)
    {
        if (_allowClose)
        {
            return;
        }

        e.Cancel = true;
        if (_shuttingDown)
        {
            return;
        }

        _shuttingDown = true;
        IsEnabled = false;
        SetLoading("Closing Kimi safely… | جارٍ إغلاق كيمي بأمان…");
        _lifetime.Cancel();

        try
        {
            if (_updateService is not null)
            {
                await _updateService.DisposeAsync();
                _updateService = null;
            }

            if (_server is not null)
            {
                _server.UnexpectedExit -= OnRuntimeUnexpectedExit;
                await _server.DisposeAsync();
                _server = null;
            }

            if (_localModel is not null)
            {
                _localModel.UnexpectedExit -= OnRuntimeUnexpectedExit;
                await _localModel.DisposeAsync();
                _localModel = null;
            }

            if (_airLlm is not null)
            {
                _airLlm.UnexpectedExit -= OnRuntimeUnexpectedExit;
                await _airLlm.DisposeAsync();
                _airLlm = null;
            }
        }
        finally
        {
            _desktopNotification?.Dispose();
            _desktopNotification = null;
            _allowClose = true;
            _ = Dispatcher.BeginInvoke(Close);
        }
    }

    private void SetStatusThreadSafe(string message)
    {
        Dispatcher.BeginInvoke(() =>
        {
            HeaderStatusText.Text = message;
            LoadingStatusText.Text = message;
        });
    }

    private void SetLocalModelStateThreadSafe(LocalModelState state)
    {
        _lastLocalModelState = state;
        _ = Dispatcher.BeginInvoke(() =>
        {
            if (_runtimePreference?.Kind == KimiRuntimeKind.OriginalKimi)
            {
                LocalModelButton.Visibility = Visibility.Collapsed;
                RuntimeCenterDetailText.Text = "Official Kimi services through this app's isolated account profile.";
                RuntimeCenterStatusDot.Fill = new SolidColorBrush(Color.FromRgb(165, 150, 255));
                return;
            }

            LocalModelButtonText.Text = state.IsReady ? "Model ready" : "Test model";
            LocalModelButton.IsEnabled = state.CanTest && !_shuttingDown;
            LocalModelButton.ToolTip = state.Message;
            RuntimeCenterDetailText.Text = state.Message;
            RuntimeCenterStatusDot.Fill = new SolidColorBrush(state.IsReady
                ? Color.FromRgb(82, 227, 164)
                : state.CanTest
                    ? Color.FromRgb(165, 150, 255)
                    : Color.FromRgb(242, 197, 103));
            LocalModelDot.Fill = new SolidColorBrush(state.IsReady
                ? Color.FromRgb(82, 227, 164)
                : state.CanTest
                    ? Color.FromRgb(165, 150, 255)
                    : Color.FromRgb(242, 197, 103));
        });
    }

    private void SetLoading(string message)
    {
        KimiWebView.Visibility = Visibility.Collapsed;
        LoadingOverlay.Visibility = Visibility.Visible;
        LoadingProgress.Visibility = Visibility.Visible;
        RetryButton.Visibility = Visibility.Collapsed;
        LoadingStatusText.Text = message;
        HeaderStatusText.Text = message;
    }

    private void ShowError(Exception error)
    {
        KimiWebView.Visibility = Visibility.Collapsed;
        LoadingOverlay.Visibility = Visibility.Visible;
        LoadingProgress.Visibility = Visibility.Collapsed;
        LoadingTitle.Text = "Kimi could not start · تعذر تشغيل كيمي";
        LoadingStatusText.Text = error.Message;
        HeaderStatusText.Text = "Needs attention | يحتاج إلى مراجعة";
        ConnectionDot.Fill = new SolidColorBrush(Color.FromRgb(238, 92, 92));
        RuntimeCenterDetailText.Text = error.Message;
        RuntimeCenterStatusDot.Fill = new SolidColorBrush(Color.FromRgb(255, 122, 134));
        LocalModelButton.IsEnabled = false;
        LocalModelButtonText.Text = "Unavailable";
        RetryButton.Visibility = Visibility.Visible;
    }

    private void StartAmbientMotion()
    {
        if (!SystemParameters.ClientAreaAnimation || SystemParameters.HighContrast)
        {
            return;
        }

        LoadingLogo.RenderTransformOrigin = new Point(0.5, 0.5);
        var scale = new ScaleTransform(1, 1);
        LoadingLogo.RenderTransform = scale;
        var animation = new DoubleAnimation
        {
            From = 0.985,
            To = 1.025,
            Duration = TimeSpan.FromSeconds(1.8),
            AutoReverse = true,
            RepeatBehavior = RepeatBehavior.Forever,
            EasingFunction = new SineEase { EasingMode = EasingMode.EaseInOut },
        };
        scale.BeginAnimation(ScaleTransform.ScaleXProperty, animation);
        scale.BeginAnimation(ScaleTransform.ScaleYProperty, animation);
    }

    private async Task InitializeUpdateServiceAsync(AppPaths paths, string? runningVersion)
    {
        if (_updateService is not null || _shuttingDown)
        {
            return;
        }

        var service = new KimiUpdateService(paths, runningVersion);
        _updateService = service;
        service.StatusChanged += OnUpdateStatusChanged;
        try
        {
            await service.StartAsync(_lifetime.Token);
            try
            {
                _syncingUpdatePreference = true;
                AutoUpdateCheckBox.IsChecked = service.AutomaticInstall;
            }
            finally
            {
                _syncingUpdatePreference = false;
            }

            if (!string.IsNullOrWhiteSpace(_updateDemoVersion))
            {
                ApplyUpdateStatus(new KimiUpdateStatus(
                    KimiUpdatePhase.Available,
                    runningVersion ?? "0.34.0",
                    _updateDemoVersion,
                    "Sanitized visual preview of the update notification"));
            }
        }
        catch (OperationCanceledException) when (_lifetime.IsCancellationRequested)
        {
        }
        catch (Exception error)
        {
            service.StatusChanged -= OnUpdateStatusChanged;
            await service.DisposeAsync();
            if (ReferenceEquals(_updateService, service))
            {
                _updateService = null;
            }
            ApplyUpdateStatus(new KimiUpdateStatus(
                KimiUpdatePhase.Failed,
                runningVersion ?? "unknown",
                Detail: $"Automatic update checks are unavailable: {error.Message}"));
        }
    }

    private void OnUpdateStatusChanged(object? sender, KimiUpdateStatus status)
    {
        if (!string.IsNullOrWhiteSpace(_updateDemoVersion))
        {
            return;
        }

        _ = Dispatcher.BeginInvoke(() => ApplyUpdateStatus(status));
    }

    private void ApplyUpdateStatus(KimiUpdateStatus status)
    {
        if (_shuttingDown)
        {
            return;
        }

        _updateStatus = status;
        EngineVersionText.Text = status.Phase switch
        {
            KimiUpdatePhase.Checking => $"Kimi Code {status.CurrentVersion} · Checking updates",
            KimiUpdatePhase.Current => $"Kimi Code {status.CurrentVersion} · Up to date",
            KimiUpdatePhase.Available =>
                $"Kimi Code {status.CurrentVersion} installed · {status.TargetVersion} available",
            KimiUpdatePhase.RestartPending =>
                $"Kimi Code {status.TargetVersion} · Installed, restart pending",
            _ => $"Kimi Code {status.CurrentVersion} · {status.Phase}",
        };

        switch (status.Phase)
        {
            case KimiUpdatePhase.Current:
                UpdateButton.Visibility = Visibility.Collapsed;
                HideUpdateBanner();
                break;

            case KimiUpdatePhase.Available:
                UpdateButton.Visibility = Visibility.Visible;
                UpdateButtonText.Text = $"Kimi {status.TargetVersion} ready";
                UpdateTitleText.Text = $"Kimi Code {status.TargetVersion} is ready";
                UpdateDetailText.Text = _updateService?.AutomaticInstall == true
                    ? $"Queued for automatic verification and install from {status.CurrentVersion}. Your active session will not be interrupted."
                    : $"Current {status.CurrentVersion} · New {status.TargetVersion} · Official Kimi CDN";
                UpdateProgressBar.Visibility = Visibility.Collapsed;
                InstallUpdateButton.IsEnabled = true;
                InstallUpdateButton.Content = "Install now · تثبيت الآن";
                ShowUpdateBanner();
                if (status.ShouldNotify)
                {
                    _desktopNotification?.ShowUpdate(status.TargetVersion ?? "new version", ActivateUpdateCenter);
                }
                break;

            case KimiUpdatePhase.Downloading:
            case KimiUpdatePhase.Verifying:
            case KimiUpdatePhase.Installing:
                UpdateButton.Visibility = Visibility.Visible;
                UpdateButtonText.Text = status.Phase.ToString();
                UpdateTitleText.Text = status.Phase switch
                {
                    KimiUpdatePhase.Downloading => $"Downloading Kimi {status.TargetVersion}",
                    KimiUpdatePhase.Verifying => "Verifying the official release",
                    _ => "Installing with a recoverable backup",
                };
                UpdateDetailText.Text = status.Detail ?? "Preparing update";
                UpdateProgressBar.Visibility = Visibility.Visible;
                UpdateProgressBar.Value = status.Progress ?? 0;
                InstallUpdateButton.IsEnabled = false;
                InstallUpdateButton.Content = $"{status.Progress ?? 0}%";
                ShowUpdateBanner();
                break;

            case KimiUpdatePhase.RestartPending:
                UpdateButton.Visibility = Visibility.Visible;
                UpdateButtonText.Text = "Restart pending";
                UpdateTitleText.Text = $"Kimi {status.TargetVersion} is installed";
                UpdateDetailText.Text = _server?.OwnsProcess == true
                    ? "Your saved session is preserved. Send any draft, then restart the local engine when convenient."
                    : "This app attached to an existing engine, so closing the window will not replace it. Send any draft, then choose Restart engine.";
                UpdateProgressBar.Visibility = Visibility.Visible;
                UpdateProgressBar.Value = 100;
                InstallUpdateButton.IsEnabled = true;
                InstallUpdateButton.Content = "Restart engine · إعادة التشغيل";
                ShowUpdateBanner();
                break;

            case KimiUpdatePhase.Failed:
                UpdateButton.Visibility = Visibility.Visible;
                UpdateButtonText.Text = "Update needs attention";
                UpdateTitleText.Text = "Kimi update was not installed";
                UpdateDetailText.Text = status.Detail ?? "The current Kimi engine was left unchanged.";
                UpdateProgressBar.Visibility = Visibility.Collapsed;
                InstallUpdateButton.IsEnabled = true;
                InstallUpdateButton.Content = "Try again · إعادة المحاولة";
                ShowUpdateBanner();
                break;
        }
    }

    private void ActivateUpdateCenter()
    {
        _ = Dispatcher.BeginInvoke(() =>
        {
            if (WindowState == WindowState.Minimized)
            {
                WindowState = WindowState.Normal;
            }
            Show();
            Activate();
            Topmost = true;
            Topmost = false;
            ShowUpdateBanner();
        });
    }

    private void ShowUpdateBanner()
    {
        UpdateBanner.Visibility = Visibility.Visible;
        UpdateBanner.BeginAnimation(
            OpacityProperty,
            new DoubleAnimation(0, 1, TimeSpan.FromMilliseconds(SystemParameters.ClientAreaAnimation ? 220 : 0)));
    }

    private void HideUpdateBanner()
    {
        if (UpdateBanner.Visibility != Visibility.Visible)
        {
            return;
        }

        if (!SystemParameters.ClientAreaAnimation)
        {
            UpdateBanner.Visibility = Visibility.Collapsed;
            UpdateBanner.Opacity = 0;
            return;
        }

        var fade = new DoubleAnimation(1, 0, TimeSpan.FromMilliseconds(160));
        fade.Completed += (_, _) => UpdateBanner.Visibility = Visibility.Collapsed;
        UpdateBanner.BeginAnimation(OpacityProperty, fade);
    }
}