diff --git a/src/OpenClaw.Shared/IOperatorGatewayClient.cs b/src/OpenClaw.Shared/IOperatorGatewayClient.cs
index d8af7a0bd..08ea6a7c1 100644
--- a/src/OpenClaw.Shared/IOperatorGatewayClient.cs
+++ b/src/OpenClaw.Shared/IOperatorGatewayClient.cs
@@ -35,6 +35,7 @@ public interface IOperatorGatewayClient
     event EventHandler<JsonElement>? AgentsListUpdated;
     event EventHandler<JsonElement>? AgentFilesListUpdated;
     event EventHandler<JsonElement>? AgentFileContentUpdated;
+    event EventHandler<AgentEventInfo>? ChatEventReceived;
 
     // ─── Query ───
     string? OperatorDeviceId { get; }
@@ -53,6 +54,7 @@ public interface IOperatorGatewayClient
 
     // ─── Request Methods ───
     Task SendChatMessageAsync(string message, string? sessionKey = null);
+    Task<ChatSendResult> SendChatMessageForRunAsync(string message, string? sessionKey = null);
     Task CheckHealthAsync();
     Task RequestSessionsAsync(string? agentId = null);
     Task RequestUsageAsync();
diff --git a/src/OpenClaw.Shared/Models.cs b/src/OpenClaw.Shared/Models.cs
index 0c39e0800..d38d0fb08 100644
--- a/src/OpenClaw.Shared/Models.cs
+++ b/src/OpenClaw.Shared/Models.cs
@@ -1660,6 +1660,13 @@ public string DataJson
     }
 }
 
+public sealed class ChatSendResult
+{
+    public string? RunId { get; init; }
+    public string? SessionKey { get; init; }
+    public bool Cached { get; init; }
+}
+
 // ── Node/Device Pairing ──
 
 public class PairingRequest
diff --git a/src/OpenClaw.Shared/OpenClawGatewayClient.cs b/src/OpenClaw.Shared/OpenClawGatewayClient.cs
index 324a51a14..5504f2031 100644
--- a/src/OpenClaw.Shared/OpenClawGatewayClient.cs
+++ b/src/OpenClaw.Shared/OpenClawGatewayClient.cs
@@ -38,7 +38,7 @@ public class OpenClawGatewayClient : WebSocketClientBase, IOperatorGatewayClient
     private GatewayUsageStatusInfo? _usageStatus;
     private GatewayCostUsageInfo? _usageCost;
     private readonly Dictionary<string, string> _pendingRequestMethods = new();
-    private readonly Dictionary<string, TaskCompletionSource<bool>> _pendingChatSendRequests = new();
+    private readonly Dictionary<string, TaskCompletionSource<ChatSendResult>> _pendingChatSendRequests = new();
     private readonly object _pendingRequestLock = new();
     private readonly object _pendingChatSendLock = new();
     private readonly object _sessionsLock = new();
@@ -175,6 +175,7 @@ protected override void OnDisposing()
     public event EventHandler<JsonElement>? AgentsListUpdated;
     public event EventHandler<JsonElement>? AgentFilesListUpdated;
     public event EventHandler<JsonElement>? AgentFileContentUpdated;
+    public event EventHandler<AgentEventInfo>? ChatEventReceived;
 
     /// <summary>Raised when a device token is received from the gateway during hello-ok handshake.</summary>
     public event EventHandler<DeviceTokenReceivedEventArgs>? DeviceTokenReceived;
@@ -251,6 +252,11 @@ public async Task CheckHealthAsync()
     }
 
     public async Task SendChatMessageAsync(string message, string? sessionKey = null)
+    {
+        _ = await SendChatMessageForRunAsync(message, sessionKey).ConfigureAwait(false);
+    }
+
+    public async Task<ChatSendResult> SendChatMessageForRunAsync(string message, string? sessionKey = null)
     {
         if (!IsConnected)
             throw new InvalidOperationException("Gateway connection is not open");
@@ -262,7 +268,7 @@ public async Task SendChatMessageAsync(string message, string? sessionKey = null
             : sessionKey.Trim();
 
         var requestId = Guid.NewGuid().ToString();
-        var completion = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var completion = new TaskCompletionSource<ChatSendResult>(TaskCreationOptions.RunContinuationsAsynchronously);
         TrackPendingChatSend(requestId, completion);
 
         var req = new
@@ -287,8 +293,9 @@ public async Task SendChatMessageAsync(string message, string? sessionKey = null
             throw new TimeoutException("Timed out waiting for chat.send response from gateway");
         }
 
-        await completion.Task;
+        var result = await completion.Task.ConfigureAwait(false);
         _logger.Info($"Sent chat message ({message.Length} chars)");
+        return result;
     }
 
     /// <summary>
@@ -886,7 +893,7 @@ private void ClearPendingRequests()
         _pendingWizardResponses.Clear();
     }
 
-    private void TrackPendingChatSend(string requestId, TaskCompletionSource<bool> completion)
+    private void TrackPendingChatSend(string requestId, TaskCompletionSource<ChatSendResult> completion)
     {
         lock (_pendingChatSendLock)
         {
@@ -902,7 +909,7 @@ private void RemovePendingChatSend(string requestId)
         }
     }
 
-    private TaskCompletionSource<bool>? TakePendingChatSend(string? requestId)
+    private TaskCompletionSource<ChatSendResult>? TakePendingChatSend(string? requestId)
     {
         if (string.IsNullOrWhiteSpace(requestId))
         {
@@ -975,7 +982,7 @@ private void HandleResponse(JsonElement root)
                 return;
             }
 
-            pendingChatSend.TrySetResult(true);
+            pendingChatSend.TrySetResult(ParseChatSendResult(root));
             return;
         }
 
@@ -1205,6 +1212,36 @@ private bool HandleKnownResponse(string method, JsonElement payload)
         }
     }
 
+    private static ChatSendResult ParseChatSendResult(JsonElement root)
+    {
+        string? runId = null;
+        string? sessionKey = null;
+        var cached = false;
+
+        if (root.TryGetProperty("payload", out var payload) && payload.ValueKind == JsonValueKind.Object)
+        {
+            if (payload.TryGetProperty("runId", out var runIdProp))
+                runId = runIdProp.GetString();
+            if (payload.TryGetProperty("sessionKey", out var sessionKeyProp))
+                sessionKey = sessionKeyProp.GetString();
+        }
+
+        if (root.TryGetProperty("meta", out var meta) &&
+            meta.ValueKind == JsonValueKind.Object &&
+            meta.TryGetProperty("cached", out var cachedProp) &&
+            cachedProp.ValueKind is JsonValueKind.True or JsonValueKind.False)
+        {
+            cached = cachedProp.GetBoolean();
+        }
+
+        return new ChatSendResult
+        {
+            RunId = runId,
+            SessionKey = sessionKey,
+            Cached = cached
+        };
+    }
+
     private void HandleRequestError(string? method, JsonElement root)
     {
         var message = TryGetErrorMessage(root) ?? "request failed";
@@ -1979,6 +2016,7 @@ private void HandleChatEvent(JsonElement root)
         _logger.Debug($"Chat event received: {rawText[..Math.Min(200, rawText.Length)]}");
         
         if (!root.TryGetProperty("payload", out var payload)) return;
+        EmitRawChatEvent(payload);
 
         // Try new format: payload.message.role + payload.message.content[].text
         if (payload.TryGetProperty("message", out var message))
@@ -2021,6 +2059,38 @@ private void HandleChatEvent(JsonElement root)
         }
     }
 
+    private void EmitRawChatEvent(JsonElement payload)
+    {
+        try
+        {
+            var stream = "chat";
+            if (payload.TryGetProperty("message", out var message) &&
+                message.TryGetProperty("role", out var roleProp))
+            {
+                stream = roleProp.GetString() ?? stream;
+            }
+            else if (payload.TryGetProperty("role", out var legacyRoleProp))
+            {
+                stream = legacyRoleProp.GetString() ?? stream;
+            }
+
+            var evt = new AgentEventInfo
+            {
+                RunId = payload.TryGetProperty("runId", out var rid) ? rid.GetString() ?? "" : "",
+                Seq = payload.TryGetProperty("seq", out var seqProp) && seqProp.ValueKind == JsonValueKind.Number ? seqProp.GetInt32() : 0,
+                Stream = stream,
+                Ts = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                Data = payload.Clone(),
+                SessionKey = payload.TryGetProperty("sessionKey", out var sk) ? sk.GetString() : null
+            };
+            ChatEventReceived?.Invoke(this, evt);
+        }
+        catch (Exception ex)
+        {
+            _logger.Warn($"Failed to emit chat event: {ex.Message}");
+        }
+    }
+
     private void EmitChatNotification(string text)
     {
         var displayText = text.Length > 200 ? text[..200] + "…" : text;
diff --git a/src/OpenClaw.Tray.WinUI/App.xaml.cs b/src/OpenClaw.Tray.WinUI/App.xaml.cs
index dae0e2dc6..93dc96324 100644
--- a/src/OpenClaw.Tray.WinUI/App.xaml.cs
+++ b/src/OpenClaw.Tray.WinUI/App.xaml.cs
@@ -482,7 +482,8 @@ protected override async void OnLaunched(LaunchActivatedEventArgs args)
             nodeConnector: nodeConnector,
             isNodeEnabled: ShouldInitializeNodeService,
             diagnostics: diagnostics,
-            tunnelManager: tunnelManager);
+            tunnelManager: tunnelManager,
+            shouldStartNodeConnection: ShouldInitializeNodeService);
         _connectionManager.OperatorClientChanged += OnOperatorClientChanged;
         _connectionManager.StateChanged += OnManagerStateChanged;
 
@@ -2189,6 +2190,27 @@ private bool ShouldInitializeNodeService()
         return _settings?.EnableNodeMode == true || _settings?.EnableMcpServer == true;
     }
 
+    private bool ShouldInitializeNodeService(GatewayRecord activeGateway, string managerIdentityPath)
+    {
+        if (!ShouldInitializeNodeService()) return false;
+
+        if (LocalNodeServiceOwnsIdentityFor(activeGateway))
+        {
+            Logger.Info("[ConnMgr] Suppressing manager-owned NodeConnector because local NodeService owns the active local gateway identity");
+            return false;
+        }
+
+        return true;
+    }
+
+    private bool LocalNodeServiceOwnsIdentityFor(GatewayRecord activeGateway)
+    {
+        if (!activeGateway.IsLocal || _settings == null) return false;
+        if (!StartupSetupState.HasStoredNodeDeviceToken(IdentityDataPath)) return false;
+
+        return EnsureNodeServiceForLocalGatewaySetup(_settings) != null;
+    }
+
     private void OnNodeStatusChanged(object? sender, ConnectionStatus status)
     {
         Logger.Info($"Node status: {status}");
diff --git a/src/OpenClaw.Tray.WinUI/Onboarding/OnboardingWindow.cs b/src/OpenClaw.Tray.WinUI/Onboarding/OnboardingWindow.cs
index 8e45e583b..516cbea43 100644
--- a/src/OpenClaw.Tray.WinUI/Onboarding/OnboardingWindow.cs
+++ b/src/OpenClaw.Tray.WinUI/Onboarding/OnboardingWindow.cs
@@ -446,7 +446,6 @@ private async Task InitializeChatWebViewAsync()
                             })();
                         ");
 
-                        _ = SendBootstrapMessageAsync();
                     }
                 });
             };
@@ -517,25 +516,6 @@ private void ShowChatError(string message)
         }
     }
 
-    private bool _bootstrapSent;
-
-    /// <summary>
-    /// Auto-sends the bootstrap kickoff message after the web chat loads.
-    /// Delegates to <see cref="BootstrapMessageInjector"/> so the same gated
-    /// kickoff fires from both the (legacy) onboarding chat overlay and from
-    /// post-wizard HubWindow chat navigation — guarded by
-    /// <see cref="SettingsManager.HasInjectedFirstRunBootstrap"/>.
-    /// </summary>
-    private async Task SendBootstrapMessageAsync()
-    {
-        if (_bootstrapSent || _chatWebView?.CoreWebView2 == null) return;
-        _bootstrapSent = true;
-
-        await BootstrapMessageInjector.InjectAsync(
-            script => _chatWebView.CoreWebView2.ExecuteScriptAsync(script).AsTask(),
-            _settings);
-    }
-
     /// <summary>
     /// Captures the current window content to a PNG file.
     /// Called automatically on page navigation when OPENCLAW_VISUAL_TEST=1.
diff --git a/src/OpenClaw.Tray.WinUI/Pages/ChatPage.xaml b/src/OpenClaw.Tray.WinUI/Pages/ChatPage.xaml
index c95e88bfa..7f4400374 100644
--- a/src/OpenClaw.Tray.WinUI/Pages/ChatPage.xaml
+++ b/src/OpenClaw.Tray.WinUI/Pages/ChatPage.xaml
@@ -56,7 +56,23 @@
 
         <!-- Loading -->
         <ProgressRing x:Name="LoadingRing" Grid.Row="1" IsActive="False"
-                      HorizontalAlignment="Center" VerticalAlignment="Center"/>
+                       HorizontalAlignment="Center" VerticalAlignment="Center"/>
+
+        <StackPanel x:Name="WaitingPanel" Grid.Row="1"
+                    Visibility="Collapsed"
+                    VerticalAlignment="Center" HorizontalAlignment="Center" Spacing="12">
+            <TextBlock Text="💬" FontSize="48" HorizontalAlignment="Center"/>
+            <TextBlock Text="Waiting for chat to start…"
+                       Style="{StaticResource SubtitleTextBlockStyle}"
+                       HorizontalAlignment="Center"/>
+            <TextBlock x:Name="WaitingStatusText"
+                       Text="The gateway is connected; the chat surface is still coming online."
+                       Style="{StaticResource CaptionTextBlockStyle}"
+                       Foreground="{ThemeResource TextFillColorSecondaryBrush}"
+                       HorizontalAlignment="Center" TextWrapping="Wrap" MaxWidth="360"/>
+            <Button x:Name="RetryChatButton" Content="Retry" Click="OnRetryChat" Visibility="Collapsed"
+                    HorizontalAlignment="Center"/>
+        </StackPanel>
 
         <!-- Placeholder (shown when not connected) -->
         <StackPanel x:Name="PlaceholderPanel" Grid.Row="1"
diff --git a/src/OpenClaw.Tray.WinUI/Pages/ChatPage.xaml.cs b/src/OpenClaw.Tray.WinUI/Pages/ChatPage.xaml.cs
index 9eb74f96c..82e9767e9 100644
--- a/src/OpenClaw.Tray.WinUI/Pages/ChatPage.xaml.cs
+++ b/src/OpenClaw.Tray.WinUI/Pages/ChatPage.xaml.cs
@@ -8,7 +8,11 @@
 using System;
 using System.Diagnostics;
 using System.IO;
+using System.Net.Http;
+using System.Runtime.InteropServices.WindowsRuntime;
+using System.Threading;
 using System.Threading.Tasks;
+using Windows.Storage.Streams;
 
 namespace OpenClawTray.Pages;
 
@@ -17,8 +21,15 @@ public sealed partial class ChatPage : Page
     private HubWindow? _hub;
     private string _chatUrl = "";
     private bool _webViewInitialized;
+    private bool _navigationStarted;
+    private CancellationTokenSource? _navigationCts;
     private global::Windows.Foundation.TypedEventHandler<CoreWebView2, CoreWebView2NavigationCompletedEventArgs>? _navCompletedHandler;
     private global::Windows.Foundation.TypedEventHandler<CoreWebView2, CoreWebView2NavigationStartingEventArgs>? _navStartingHandler;
+    private IGatewayConnectionManager? _connectionManager;
+    private static readonly HttpClient s_httpClient = new()
+    {
+        Timeout = TimeSpan.FromSeconds(3)
+    };
 
     public ChatPage()
     {
@@ -28,6 +39,7 @@ public ChatPage()
 
     private void OnUnloaded(object sender, RoutedEventArgs e)
     {
+        _navigationCts?.Cancel();
         if (WebView.CoreWebView2 != null)
         {
             if (_navCompletedHandler != null)
@@ -83,6 +95,11 @@ private async Task InitializeWebViewAsync(SettingsManager settings)
             _chatUrl = chatUrl;
 
             PlaceholderPanel.Visibility = Visibility.Collapsed;
+            ErrorPanel.Visibility = Visibility.Collapsed;
+            WebView.Visibility = Visibility.Collapsed;
+            WaitingPanel.Visibility = Visibility.Visible;
+            WaitingStatusText.Text = "The gateway is connected; the chat surface is still coming online.";
+            RetryChatButton.Visibility = Visibility.Collapsed;
             LoadingRing.IsActive = true;
             LoadingRing.Visibility = Visibility.Visible;
 
@@ -114,8 +131,7 @@ private async Task InitializeWebViewAsync(SettingsManager settings)
                             document.head.appendChild(style);
                         })();
                     ");
-                    BootstrapMessageInjector.ScriptExecutor exec = script => WebView.CoreWebView2.ExecuteScriptAsync(script).AsTask();
-                    _ = BootstrapMessageInjector.InjectAsync(exec, ((App)Application.Current).Settings, initialDelayMs: 500);
+                    _ = CaptureVisualTestChatAsync();
                 }
                 else if (e.WebErrorStatus == CoreWebView2WebErrorStatus.ConnectionAborted ||
                                       e.WebErrorStatus == CoreWebView2WebErrorStatus.CannotConnect ||
@@ -136,8 +152,10 @@ private async Task InitializeWebViewAsync(SettingsManager settings)
             };
             WebView.CoreWebView2.NavigationStarting += _navStartingHandler;
 
-            WebView.Visibility = Visibility.Visible;
-            WebView.CoreWebView2.Navigate(_chatUrl);
+            _connectionManager = _hub?.ConnectionManager;
+            _navigationCts?.Cancel();
+            _navigationCts = new CancellationTokenSource();
+            _ = NavigateWhenChatReadyAsync(_connectionManager, credential.GatewayUrl, _navigationCts.Token);
         }
         catch (Exception ex)
         {
@@ -150,6 +168,138 @@ private async Task InitializeWebViewAsync(SettingsManager settings)
         }
     }
 
+    private async Task NavigateWhenChatReadyAsync(
+        IGatewayConnectionManager? connectionManager,
+        string gatewayUrl,
+        CancellationToken cancellationToken)
+    {
+        if (_navigationStarted) return;
+
+        try
+        {
+            Logger.Info("[ChatPage] Waiting for operator handshake before chat navigation");
+            var ready = await ChatNavigationReadiness.WaitForOperatorHandshakeAsync(connectionManager, TimeSpan.FromSeconds(30), cancellationToken);
+            if (!ready)
+            {
+                ShowChatReadinessFailure("Timed out waiting for the gateway operator handshake. Retry once the gateway is ready.");
+                Logger.Warn("[ChatPage] Timed out waiting for operator handshake before chat navigation");
+                return;
+            }
+
+            Logger.Info("[ChatPage] Operator handshake ready; probing chat HTTP surface");
+            ready = await ProbeChatSurfaceAsync(_chatUrl, TimeSpan.FromSeconds(30), cancellationToken);
+            if (!ready)
+            {
+                ShowChatReadinessFailure($"Timed out waiting for chat at {gatewayUrl}. Retry once the gateway is ready.");
+                Logger.Warn("[ChatPage] Timed out waiting for chat HTTP surface before navigation");
+                return;
+            }
+
+            WaitingStatusText.Text = "Chat is ready; starting your first hatching conversation…";
+            var bootstrapped = await OnboardingChatBootstrapper.BootstrapAsync(
+                connectionManager?.OperatorClient,
+                ((App)Application.Current).Settings,
+                TimeSpan.FromSeconds(90),
+                cancellationToken).ConfigureAwait(true);
+            if (!bootstrapped && !((App)Application.Current).Settings.HasInjectedFirstRunBootstrap)
+            {
+                Logger.Warn("[ChatPage] Gateway hatching bootstrap did not complete; navigating to empty chat");
+            }
+
+            if (cancellationToken.IsCancellationRequested || _navigationStarted) return;
+
+            _navigationStarted = true;
+            WaitingPanel.Visibility = Visibility.Collapsed;
+            RetryChatButton.Visibility = Visibility.Collapsed;
+            WebView.Visibility = Visibility.Visible;
+            Logger.Info("[ChatPage] Chat HTTP surface is serving; navigating WebView");
+            WebView.CoreWebView2.Navigate(_chatUrl);
+        }
+        catch (OperationCanceledException)
+        {
+        }
+        catch (Exception ex)
+        {
+            ShowChatReadinessFailure($"Chat failed to start:\n{ex.Message}");
+            Logger.Warn($"[ChatPage] Chat readiness wait failed: {ex.Message}");
+        }
+    }
+
+    private static async Task<bool> ProbeChatSurfaceAsync(string chatUrl, TimeSpan timeout, CancellationToken cancellationToken)
+    {
+        var deadline = DateTimeOffset.UtcNow + timeout;
+        var attempts = 0;
+        while (DateTimeOffset.UtcNow < deadline)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            attempts++;
+            try
+            {
+                using var request = new HttpRequestMessage(HttpMethod.Get, chatUrl);
+                using var response = await s_httpClient.SendAsync(
+                    request,
+                    HttpCompletionOption.ResponseHeadersRead,
+                    cancellationToken).ConfigureAwait(true);
+
+                if ((int)response.StatusCode is >= 200 and < 400)
+                    return true;
+
+                Logger.Warn($"[ChatPage] Chat readiness probe attempt {attempts} returned {(int)response.StatusCode}");
+            }
+            catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException or OperationCanceledException)
+            {
+                if (ex is OperationCanceledException && cancellationToken.IsCancellationRequested)
+                    throw;
+                Logger.Warn($"[ChatPage] Chat readiness probe attempt {attempts} failed: {ex.Message}");
+            }
+
+            await Task.Delay(TimeSpan.FromMilliseconds(250), cancellationToken).ConfigureAwait(true);
+        }
+
+        return false;
+    }
+
+    private void ShowChatReadinessFailure(string message)
+    {
+        LoadingRing.IsActive = false;
+        LoadingRing.Visibility = Visibility.Collapsed;
+        WebView.Visibility = Visibility.Collapsed;
+        PlaceholderPanel.Visibility = Visibility.Collapsed;
+        WaitingPanel.Visibility = Visibility.Visible;
+        WaitingStatusText.Text = message;
+        RetryChatButton.Visibility = Visibility.Visible;
+        ErrorPanel.Visibility = Visibility.Collapsed;
+    }
+
+    private async Task CaptureVisualTestChatAsync()
+    {
+        if (Environment.GetEnvironmentVariable("OPENCLAW_VISUAL_TEST") != "1") return;
+        if (WebView.CoreWebView2 == null) return;
+
+        try
+        {
+            await Task.Delay(5000);
+            var outputDir = Environment.GetEnvironmentVariable("OPENCLAW_VISUAL_TEST_DIR");
+            if (string.IsNullOrWhiteSpace(outputDir)) return;
+
+            Directory.CreateDirectory(outputDir);
+            var path = Path.Combine(outputDir, $"chat-{DateTime.Now:yyyyMMddHHmmss}.png");
+            using var stream = new InMemoryRandomAccessStream();
+            await WebView.CoreWebView2.CapturePreviewAsync(CoreWebView2CapturePreviewImageFormat.Png, stream);
+            stream.Seek(0);
+            var reader = new DataReader(stream);
+            await reader.LoadAsync((uint)stream.Size);
+            var bytes = new byte[stream.Size];
+            reader.ReadBytes(bytes);
+            await File.WriteAllBytesAsync(path, bytes);
+            Logger.Info($"[VisualTest] Captured chat WebView {path}");
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"[VisualTest] Chat WebView capture failed: {ex.Message}");
+        }
+    }
+
     private static bool TryBuildChatUrl(string gatewayUrl, string token, out string url, out string errorMessage)
     {
         url = string.Empty;
@@ -195,4 +345,20 @@ private void OnDevTools(object sender, RoutedEventArgs e)
         if (_webViewInitialized)
             WebView.CoreWebView2?.OpenDevToolsWindow();
     }
+
+    private void OnRetryChat(object sender, RoutedEventArgs e)
+    {
+        if (!_webViewInitialized || string.IsNullOrEmpty(_chatUrl))
+            return;
+
+        _navigationStarted = false;
+        _navigationCts?.Cancel();
+        _navigationCts = new CancellationTokenSource();
+        ErrorPanel.Visibility = Visibility.Collapsed;
+        WaitingPanel.Visibility = Visibility.Visible;
+        RetryChatButton.Visibility = Visibility.Collapsed;
+        LoadingRing.IsActive = true;
+        LoadingRing.Visibility = Visibility.Visible;
+        _ = NavigateWhenChatReadyAsync(_connectionManager, _hub?.GatewayRegistry?.GetById(_hub.GatewayRegistry.ActiveGatewayId ?? "")?.Url ?? "gateway", _navigationCts.Token);
+    }
 }
diff --git a/src/OpenClaw.Tray.WinUI/Services/BootstrapMessageInjector.cs b/src/OpenClaw.Tray.WinUI/Services/BootstrapMessageInjector.cs
deleted file mode 100644
index 61f7a5494..000000000
--- a/src/OpenClaw.Tray.WinUI/Services/BootstrapMessageInjector.cs
+++ /dev/null
@@ -1,375 +0,0 @@
-using System;
-using System.Text.Json;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace OpenClawTray.Services;
-
-/// <summary>
-/// Injects the first-run "BOOTSTRAP.md" kickoff message into the chat WebView2
-/// exactly once after onboarding completes.
-///
-/// Originally lived inline on <see cref="OpenClawTray.Onboarding.OnboardingWindow"/> and
-/// was wired to the (now-removed) in-wizard chat preview page. PR #274 dropped that
-/// page from the page order, leaving the kickoff dead. This shared service can be
-/// invoked from any chat first-show site (onboarding chat overlay, HubWindow chat
-/// page, etc.).
-///
-/// Gating: <see cref="SettingsManager.HasInjectedFirstRunBootstrap"/> is the
-/// persistent one-shot flag. Once set, no further injection is performed.
-///
-/// This service deliberately does NOT depend on <c>Microsoft.Web.WebView2</c>
-/// directly — callers pass in a <see cref="ScriptExecutor"/> delegate that
-/// wraps <c>CoreWebView2.ExecuteScriptAsync</c>. This keeps the gate logic
-/// testable without bringing WebView2 into the test project.
-/// </summary>
-public static class BootstrapMessageInjector
-{
-    /// <summary>
-    /// Delegate matching <c>CoreWebView2.ExecuteScriptAsync(string)</c>.
-    /// Returns the JSON-serialized result of the script (unused here).
-    /// </summary>
-    public delegate Task<string> ScriptExecutor(string script);
-
-    /// <summary>
-    /// The kickoff message sent to the agent on first run. Mirrors the macOS
-    /// behavior (maybeKickoffOnboardingChat) and references BOOTSTRAP.md.
-    /// </summary>
-    public const string Message =
-        "Hi! I just installed OpenClaw and you're my brand-new agent. " +
-        "Please start the first-run ritual from BOOTSTRAP.md, ask one question at a time, " +
-        "and before we talk about WhatsApp/Telegram, visit soul.md with me to craft SOUL.md: " +
-        "ask what matters to me and how you should be. Then guide me through choosing " +
-        "how we should talk (web-only, WhatsApp, or Telegram).";
-
-    /// <summary>
-    /// Builds the JS payload that locates the chat input (traversing shadow DOMs
-    /// so it works against the Lit-based gateway chat UI), injects the message,
-    /// and tries to send it via the input's own form/composer controls. The
-    /// message is encoded via JsonSerializer to prevent JS template/string injection.
-    /// </summary>
-    public static string BuildInjectionScript(string message)
-    {
-        var safeMsg = JsonSerializer.Serialize(message);
-        return $$"""
-        (async function() {
-            const msg = {{safeMsg}};
-            const seen = new Set();
-            const attempts = [0, 1500];
-            const pollCount = 5;
-            const pollDelayMs = 200;
-
-            function walk(root, visit) {
-                if (!root || seen.has(root)) return null;
-                seen.add(root);
-                const found = visit(root);
-                if (found) return found;
-                const elements = root.querySelectorAll ? root.querySelectorAll('*') : [];
-                for (const el of elements) {
-                    if (el.shadowRoot) {
-                        const nested = walk(el.shadowRoot, visit);
-                        if (nested) return nested;
-                    }
-                }
-                return null;
-            }
-
-            function isVisible(el) {
-                return !!(el.offsetWidth || el.offsetHeight || el.getClientRects().length);
-            }
-
-            function isUsableInput(el) {
-                return isVisible(el) && !el.disabled && !el.readOnly;
-            }
-
-            function findInput(root) {
-                seen.clear();
-                return walk(root, r => {
-                    const inputs = r.querySelectorAll(
-                        'textarea, input[type="text"], input:not([type]), [contenteditable="true"], [role="textbox"]');
-                    return Array.from(inputs).find(isUsableInput) || null;
-                });
-            }
-
-            function getRoot(el) {
-                return (el && el.getRootNode && el.getRootNode()) || document;
-            }
-
-            function findForm(input) {
-                if (!input) return null;
-                if (input.form) return input.form;
-                if (input.closest) {
-                    const direct = input.closest('form');
-                    if (direct) return direct;
-                }
-
-                const root = getRoot(input);
-                const host = root && root.host;
-                return host && host.closest ? host.closest('form') : null;
-            }
-
-            function isSendButton(btn) {
-                if (!btn || !isVisible(btn) || btn.disabled || btn.getAttribute('aria-disabled') === 'true') return false;
-                const text = (btn.textContent || '').trim().toLowerCase();
-                const label = (btn.getAttribute('aria-label') || '').trim().toLowerCase();
-                const title = (btn.getAttribute('title') || '').trim().toLowerCase();
-                const type = (btn.getAttribute('type') || '').trim().toLowerCase();
-
-                return type === 'submit' ||
-                    label === 'send' || label === 'send message' || label.includes('send message') ||
-                    title === 'send' || title === 'send message' || title.includes('send message') ||
-                    text === 'send' || text === '➤' || text === '↑';
-            }
-
-            function findComposerContainer(input) {
-                const selectors = [
-                    'form',
-                    '[role="form"]',
-                    '[data-composer]',
-                    '[data-testid*="composer" i]',
-                    '[class*="composer" i]',
-                    '[class*="chat-input" i]',
-                    '[class*="message-input" i]'
-                ];
-
-                for (const selector of selectors) {
-                    if (input.closest) {
-                        const container = input.closest(selector);
-                        if (container) return container;
-                    }
-                }
-
-                return input.parentElement || getRoot(input);
-            }
-
-            function findSendButton(input) {
-                const form = findForm(input);
-                if (form) {
-                    const formButton = Array.from(form.querySelectorAll('button:not([disabled]), [role="button"]:not([aria-disabled="true"])'))
-                        .find(isSendButton);
-                    if (formButton) return formButton;
-                }
-
-                const container = findComposerContainer(input);
-                const roots = [container, getRoot(input)].filter(Boolean);
-                for (const root of roots) {
-                    const buttons = root.querySelectorAll
-                        ? Array.from(root.querySelectorAll('button:not([disabled]), [role="button"]:not([aria-disabled="true"])'))
-                        : [];
-                    const button = buttons.find(isSendButton);
-                    if (button) return button;
-                }
-
-                return null;
-            }
-
-            function setNativeValue(el, value) {
-                if (el.isContentEditable) {
-                    el.textContent = value;
-                    return;
-                }
-                const proto = el.tagName === 'TEXTAREA'
-                    ? window.HTMLTextAreaElement.prototype
-                    : window.HTMLInputElement.prototype;
-                const setter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
-                setter ? setter.call(el, value) : (el.value = value);
-            }
-
-            function getInputValue(el) {
-                if (!el) return '';
-                if (el.isContentEditable) return el.textContent || '';
-                return el.value || el.textContent || '';
-            }
-
-            function normalize(value) {
-                return (value || '').replace(/\s+/g, ' ').trim();
-            }
-
-            function collectVisibleText(root) {
-                if (!root || seen.has(root)) return '';
-                seen.add(root);
-
-                let text = '';
-                if (root.nodeType === Node.TEXT_NODE) {
-                    const parent = root.parentElement;
-                    if (parent && isVisible(parent)) text += root.nodeValue || '';
-                }
-
-                const elements = root.querySelectorAll ? root.querySelectorAll('*') : [];
-                for (const el of elements) {
-                    if (!isVisible(el)) continue;
-                    if (el.matches && el.matches('textarea,input,[contenteditable="true"],[role="textbox"]')) continue;
-                    text += ' ' + (el.childNodes && Array.from(el.childNodes)
-                        .filter(n => n.nodeType === Node.TEXT_NODE)
-                        .map(n => n.nodeValue || '')
-                        .join(' ') || '');
-                    if (el.shadowRoot) text += ' ' + collectVisibleText(el.shadowRoot);
-                }
-
-                return text;
-            }
-
-            function messageAppearsInTranscript() {
-                seen.clear();
-                return normalize(collectVisibleText(document)).includes(normalize(msg));
-            }
-
-            function inputWasAccepted(input) {
-                const value = normalize(getInputValue(input));
-                return value.length === 0 || value !== normalize(msg);
-            }
-
-            function sleep(ms) {
-                return new Promise(resolve => setTimeout(resolve, ms));
-            }
-
-            async function confirmAccepted(input) {
-                for (let i = 0; i < pollCount; i++) {
-                    if (inputWasAccepted(input) || messageAppearsInTranscript()) {
-                        return true;
-                    }
-                    await sleep(pollDelayMs);
-                }
-
-                return false;
-            }
-
-            async function tryInjectOnce() {
-                seen.clear();
-                const input = findInput(document);
-                if (!input) {
-                    console.warn('[OpenClaw] Could not find chat input for bootstrap');
-                    return 'no-input';
-                }
-
-                input.focus();
-                setNativeValue(input, msg);
-                input.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertText', data: msg }));
-                input.dispatchEvent(new Event('change', { bubbles: true }));
-
-                const form = findForm(input);
-                if (form?.requestSubmit) {
-                    form.requestSubmit();
-                    console.log('[OpenClaw] Bootstrap message submitted via composer form');
-                    return await confirmAccepted(input) ? 'sent' : 'sent-unverified';
-                }
-
-                const btn = findSendButton(input);
-                if (btn) {
-                    btn.click();
-                    console.log('[OpenClaw] Bootstrap message submitted via composer send button');
-                    return await confirmAccepted(input) ? 'sent' : 'sent-unverified';
-                }
-
-                input.dispatchEvent(new KeyboardEvent('keydown', {
-                    key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true
-                }));
-
-                if (await confirmAccepted(input)) {
-                    console.log('[OpenClaw] Bootstrap message submitted via Enter key');
-                    return 'sent';
-                }
-
-                console.warn('[OpenClaw] Bootstrap message not accepted by composer');
-                return 'no-send-button';
-            }
-
-            const inputCount = document.querySelectorAll('input,textarea,button,[contenteditable="true"],[role="textbox"]').length;
-            console.log('[OpenClaw] Bootstrap probe controls=' + inputCount);
-
-            let lastStatus = 'no-input';
-            for (const delay of attempts) {
-                if (delay > 0) await sleep(delay);
-                lastStatus = await tryInjectOnce();
-                if (lastStatus !== 'no-input') return lastStatus;
-            }
-
-            return lastStatus;
-        })();
-        """;
-    }
-
-    /// <summary>
-    /// Should the gate allow an injection right now? Returns true only if the
-    /// settings flag has not yet been set.
-    /// </summary>
-    public static bool ShouldInject(SettingsManager settings)
-    {
-        if (settings is null) return false;
-        return !settings.HasInjectedFirstRunBootstrap;
-    }
-
-    /// <summary>
-    /// Marks the gate as consumed and persists. Public so the rare external
-    /// caller (e.g. a test, or a code path that injects via a different
-    /// mechanism) can flip the gate without going through <see cref="InjectAsync"/>.
-    /// </summary>
-    public static void MarkInjected(SettingsManager settings)
-    {
-        if (settings is null) return;
-        if (settings.HasInjectedFirstRunBootstrap) return;
-        settings.HasInjectedFirstRunBootstrap = true;
-        settings.Save();
-    }
-
-    /// <summary>
-    /// Attempts to inject the bootstrap kickoff via <paramref name="executor"/>
-    /// (typically a delegate wrapping <c>CoreWebView2.ExecuteScriptAsync</c>).
-    /// Returns true only if the script confirmed that the message was accepted
-    /// by the chat UI. The gate flag is not flipped for unverified sends so the
-    /// next chat-tab visit can retry.
-    /// </summary>
-    public static async Task<bool> InjectAsync(
-        ScriptExecutor? executor,
-        SettingsManager settings,
-        int initialDelayMs = 3000,
-        CancellationToken cancellationToken = default)
-    {
-        if (settings is null) return false;
-        if (!ShouldInject(settings)) return false;
-        if (executor is null) return false;
-
-        try
-        {
-            if (initialDelayMs > 0)
-            {
-                await Task.Delay(initialDelayMs, cancellationToken).ConfigureAwait(true);
-            }
-
-            var js = BuildInjectionScript(Message);
-            var result = await executor(js).ConfigureAwait(true);
-            var status = TryParseScriptResult(result);
-            if (string.Equals(status, "sent", StringComparison.Ordinal))
-            {
-                MarkInjected(settings);
-                Logger.Info("[BootstrapMessageInjector] Bootstrap message injection sent");
-                return true;
-            }
-
-            Logger.Warn($"[BootstrapMessageInjector] Bootstrap injection did not send; status={status ?? result ?? "<null>"}");
-            return false;
-        }
-        catch (OperationCanceledException)
-        {
-            return false;
-        }
-        catch (Exception ex)
-        {
-            Logger.Warn($"[BootstrapMessageInjector] Bootstrap injection failed: {ex.Message}");
-            return false;
-        }
-    }
-
-    private static string? TryParseScriptResult(string? result)
-    {
-        if (string.IsNullOrWhiteSpace(result)) return result;
-        try
-        {
-            return JsonSerializer.Deserialize<string>(result);
-        }
-        catch (JsonException)
-        {
-            return result;
-        }
-    }
-}
diff --git a/src/OpenClaw.Tray.WinUI/Services/Connection/ChatNavigationReadiness.cs b/src/OpenClaw.Tray.WinUI/Services/Connection/ChatNavigationReadiness.cs
new file mode 100644
index 000000000..5eae1bce0
--- /dev/null
+++ b/src/OpenClaw.Tray.WinUI/Services/Connection/ChatNavigationReadiness.cs
@@ -0,0 +1,43 @@
+namespace OpenClawTray.Services.Connection;
+
+public static class ChatNavigationReadiness
+{
+    public static bool IsOperatorHandshakeReady(IGatewayConnectionManager? connectionManager) =>
+        connectionManager == null ||
+        connectionManager.CurrentSnapshot.OperatorState == RoleConnectionState.Connected;
+
+    public static async Task<bool> WaitForOperatorHandshakeAsync(
+        IGatewayConnectionManager? connectionManager,
+        TimeSpan timeout,
+        CancellationToken cancellationToken = default)
+    {
+        if (IsOperatorHandshakeReady(connectionManager))
+            return true;
+
+        var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        EventHandler<GatewayConnectionSnapshot>? handler = null;
+        handler = (_, snapshot) =>
+        {
+            if (snapshot.OperatorState == RoleConnectionState.Connected)
+                tcs.TrySetResult(true);
+        };
+
+        connectionManager!.StateChanged += handler;
+        try
+        {
+            if (IsOperatorHandshakeReady(connectionManager))
+                return true;
+
+            var completed = await Task.WhenAny(tcs.Task, Task.Delay(timeout, cancellationToken)).ConfigureAwait(true);
+            if (completed == tcs.Task)
+                return await tcs.Task.ConfigureAwait(true);
+
+            cancellationToken.ThrowIfCancellationRequested();
+            return false;
+        }
+        finally
+        {
+            connectionManager.StateChanged -= handler;
+        }
+    }
+}
diff --git a/src/OpenClaw.Tray.WinUI/Services/Connection/GatewayConnectionManager.cs b/src/OpenClaw.Tray.WinUI/Services/Connection/GatewayConnectionManager.cs
index ac572fb75..da37f3efb 100644
--- a/src/OpenClaw.Tray.WinUI/Services/Connection/GatewayConnectionManager.cs
+++ b/src/OpenClaw.Tray.WinUI/Services/Connection/GatewayConnectionManager.cs
@@ -19,6 +19,7 @@ public sealed class GatewayConnectionManager : IGatewayConnectionManager
     private readonly INodeConnector? _nodeConnector;
     private readonly ISshTunnelManager? _tunnelManager;
     private readonly Func<bool>? _isNodeEnabled;
+    private readonly Func<GatewayRecord, string, bool>? _shouldStartNodeConnection;
     private readonly SemaphoreSlim _transitionSemaphore = new(1, 1);
 
     private long _generation;
@@ -44,7 +45,8 @@ public GatewayConnectionManager(
         INodeConnector? nodeConnector = null,
         Func<bool>? isNodeEnabled = null,
         ConnectionDiagnostics? diagnostics = null,
-        ISshTunnelManager? tunnelManager = null)
+        ISshTunnelManager? tunnelManager = null,
+        Func<GatewayRecord, string, bool>? shouldStartNodeConnection = null)
     {
         _credentialResolver = credentialResolver ?? throw new ArgumentNullException(nameof(credentialResolver));
         _clientFactory = clientFactory ?? throw new ArgumentNullException(nameof(clientFactory));
@@ -54,6 +56,7 @@ public GatewayConnectionManager(
         _nodeConnector = nodeConnector;
         _tunnelManager = tunnelManager;
         _isNodeEnabled = isNodeEnabled;
+        _shouldStartNodeConnection = shouldStartNodeConnection;
         _diagnostics = diagnostics ?? new ConnectionDiagnostics(clock: clock);
         _diagnostics.EventRecorded += (_, e) => DiagnosticEvent?.Invoke(this, e);
 
@@ -467,7 +470,7 @@ private async Task HandleHandshakeSucceededAsync(long gen)
         }
 
         // Start node connection outside the semaphore to avoid deadlocks
-        if (_nodeConnector != null && (_isNodeEnabled?.Invoke() ?? false))
+        if (_nodeConnector != null && ShouldStartNodeConnection())
         {
             await StartNodeConnectionAsync();
         }
@@ -528,6 +531,21 @@ private async Task HandlePairingRequiredAsync(string? requestId, long gen)
 
     // ─── Node Connection ───
 
+    private bool ShouldStartNodeConnection()
+    {
+        if (_activeGatewayRecordId == null || _activeIdentityPath == null)
+            return _isNodeEnabled?.Invoke() ?? false;
+
+        var record = _registry.GetById(_activeGatewayRecordId);
+        if (record == null)
+            return false;
+
+        if (_shouldStartNodeConnection != null)
+            return _shouldStartNodeConnection(record, _activeIdentityPath);
+
+        return _isNodeEnabled?.Invoke() ?? false;
+    }
+
     private async Task StartNodeConnectionAsync()
     {
         if (_nodeConnector == null || _activeGatewayRecordId == null || _activeIdentityPath == null) return;
diff --git a/src/OpenClaw.Tray.WinUI/Services/OnboardingChatBootstrapper.cs b/src/OpenClaw.Tray.WinUI/Services/OnboardingChatBootstrapper.cs
new file mode 100644
index 000000000..4a458f30c
--- /dev/null
+++ b/src/OpenClaw.Tray.WinUI/Services/OnboardingChatBootstrapper.cs
@@ -0,0 +1,203 @@
+using OpenClaw.Shared;
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace OpenClawTray.Services;
+
+public static class OnboardingChatBootstrapper
+{
+    private static int s_inFlight;
+
+    public const string Message =
+        "Hi! I just installed OpenClaw and you're my brand-new agent. " +
+        "Please start the first-run ritual from BOOTSTRAP.md, ask one question at a time, " +
+        "and before we talk about WhatsApp/Telegram, visit soul.md with me to craft SOUL.md: " +
+        "ask what matters to me and how you should be. Then guide me through choosing " +
+        "how we should talk (web-only, WhatsApp, or Telegram).";
+
+    public static bool ShouldBootstrap(SettingsManager settings)
+    {
+        ArgumentNullException.ThrowIfNull(settings);
+        return !settings.HasInjectedFirstRunBootstrap;
+    }
+
+    public static void MarkBootstrapped(SettingsManager settings)
+    {
+        ArgumentNullException.ThrowIfNull(settings);
+        if (settings.HasInjectedFirstRunBootstrap) return;
+        settings.HasInjectedFirstRunBootstrap = true;
+        settings.Save();
+    }
+
+    public static async Task<bool> BootstrapAsync(
+        IOperatorGatewayClient? client,
+        SettingsManager settings,
+        TimeSpan? completionTimeout = null,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(settings);
+
+        if (settings.HasInjectedFirstRunBootstrap)
+            return true;
+        if (client == null || !client.IsConnectedToGateway)
+            return false;
+        if (Interlocked.CompareExchange(ref s_inFlight, 1, 0) != 0)
+        {
+            Logger.Info("[OnboardingChatBootstrapper] Bootstrap skipped because another gateway send is in flight");
+            return false;
+        }
+
+        try
+        {
+            if (settings.HasInjectedFirstRunBootstrap)
+                return true;
+
+            var timeout = completionTimeout ?? TimeSpan.FromSeconds(90);
+            var timeoutAt = DateTimeOffset.UtcNow + timeout;
+            using var runCompletion = new RunCompletionObserver(client);
+
+            Logger.Info("[OnboardingChatBootstrapper] Sending hatching bootstrap through gateway chat.send");
+            var result = await client.SendChatMessageForRunAsync(Message).ConfigureAwait(true);
+            if (settings.HasInjectedFirstRunBootstrap)
+                return true;
+
+            var completed = await runCompletion.WaitForCompletionAsync(
+                result.RunId,
+                timeoutAt,
+                cancellationToken).ConfigureAwait(true);
+
+            if (!completed)
+            {
+                Logger.Warn($"[OnboardingChatBootstrapper] chat.send acknowledged but run completion was not observed (runId={result.RunId ?? "<none>"})");
+                return false;
+            }
+
+            MarkBootstrapped(settings);
+            Logger.Info($"[OnboardingChatBootstrapper] Hatching bootstrap completed via gateway (runId={result.RunId ?? "<none>"})");
+            return true;
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"[OnboardingChatBootstrapper] Gateway bootstrap failed: {ex.Message}");
+            return false;
+        }
+        finally
+        {
+            Interlocked.Exchange(ref s_inFlight, 0);
+        }
+    }
+
+    private sealed class RunCompletionObserver : IDisposable
+    {
+        private readonly IOperatorGatewayClient _client;
+        private readonly object _gate = new();
+        private readonly HashSet<string> _completedRunIds = new(StringComparer.Ordinal);
+        private readonly TaskCompletionSource<bool> _completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        private string? _runId;
+
+        public RunCompletionObserver(IOperatorGatewayClient client)
+        {
+            _client = client;
+            _client.AgentEventReceived += OnEventReceived;
+            _client.ChatEventReceived += OnEventReceived;
+        }
+
+        public async Task<bool> WaitForCompletionAsync(
+            string? runId,
+            DateTimeOffset timeoutAt,
+            CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrWhiteSpace(runId))
+                return true;
+
+            lock (_gate)
+            {
+                _runId = runId;
+                if (_completedRunIds.Contains(runId))
+                {
+                    _completion.TrySetResult(true);
+                }
+            }
+
+            if (_completion.Task.IsCompleted)
+                return await _completion.Task.ConfigureAwait(true);
+
+            var remaining = timeoutAt - DateTimeOffset.UtcNow;
+            if (remaining <= TimeSpan.Zero)
+                return false;
+
+            var completed = await Task.WhenAny(_completion.Task, Task.Delay(remaining, cancellationToken)).ConfigureAwait(true);
+            if (completed != _completion.Task)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                return false;
+            }
+
+            return await _completion.Task.ConfigureAwait(true);
+        }
+
+        public void Dispose()
+        {
+            _client.AgentEventReceived -= OnEventReceived;
+            _client.ChatEventReceived -= OnEventReceived;
+        }
+
+        private void OnEventReceived(object? sender, AgentEventInfo evt)
+        {
+            if (string.IsNullOrWhiteSpace(evt.RunId))
+                return;
+            if (!IsFinalAssistantEvent(evt) && !IsLifecycleFinalEvent(evt))
+                return;
+
+            lock (_gate)
+            {
+                if (_runId == null)
+                {
+                    _completedRunIds.Add(evt.RunId);
+                    return;
+                }
+
+                if (string.Equals(evt.RunId, _runId, StringComparison.Ordinal))
+                {
+                    _completion.TrySetResult(true);
+                }
+            }
+        }
+    }
+
+    private static bool IsFinalAssistantEvent(AgentEventInfo evt)
+    {
+        if (!string.Equals(evt.Stream, "assistant", StringComparison.OrdinalIgnoreCase))
+            return false;
+        if (evt.Data.ValueKind != JsonValueKind.Object)
+            return false;
+        if (evt.Data.TryGetProperty("state", out var state) &&
+            string.Equals(state.GetString(), "final", StringComparison.OrdinalIgnoreCase))
+            return true;
+        return evt.Data.TryGetProperty("type", out var type) &&
+               string.Equals(type.GetString(), "final", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static bool IsLifecycleFinalEvent(AgentEventInfo evt)
+    {
+        if (string.Equals(evt.Stream, "final", StringComparison.OrdinalIgnoreCase) ||
+            string.Equals(evt.Stream, "done", StringComparison.OrdinalIgnoreCase))
+            return true;
+        if (!string.Equals(evt.Stream, "lifecycle", StringComparison.OrdinalIgnoreCase))
+            return false;
+        if (evt.Data.ValueKind != JsonValueKind.Object)
+            return false;
+        if (evt.Data.TryGetProperty("state", out var state) &&
+            string.Equals(state.GetString(), "final", StringComparison.OrdinalIgnoreCase))
+            return true;
+        return evt.Data.TryGetProperty("type", out var type) &&
+               string.Equals(type.GetString(), "session.completed", StringComparison.OrdinalIgnoreCase);
+    }
+}
diff --git a/src/OpenClaw.Tray.WinUI/Services/StartupSetupState.cs b/src/OpenClaw.Tray.WinUI/Services/StartupSetupState.cs
index 3fc2ca100..933f59f2e 100644
--- a/src/OpenClaw.Tray.WinUI/Services/StartupSetupState.cs
+++ b/src/OpenClaw.Tray.WinUI/Services/StartupSetupState.cs
@@ -5,7 +5,7 @@ namespace OpenClawTray.Services;
 internal static class StartupSetupState
 {
     public static bool HasStoredNodeDeviceToken(string dataPath) =>
-        DeviceIdentity.HasStoredDeviceToken(dataPath, NullLogger.Instance);
+        DeviceIdentity.HasStoredDeviceTokenForRole(dataPath, "node", NullLogger.Instance);
 
     public static bool CanStartNodeGateway(SettingsManager settings, string dataPath)
     {
diff --git a/src/OpenClaw.Tray.WinUI/Windows/ChatWindow.xaml.cs b/src/OpenClaw.Tray.WinUI/Windows/ChatWindow.xaml.cs
index a69319c6d..273dcc888 100644
--- a/src/OpenClaw.Tray.WinUI/Windows/ChatWindow.xaml.cs
+++ b/src/OpenClaw.Tray.WinUI/Windows/ChatWindow.xaml.cs
@@ -179,22 +179,6 @@ public void RefreshCredentials(string gatewayUrl, string token)
         }
     }
 
-    /// <summary>
-    /// Bug 4 (PR #274): exposes a script executor wrapping CoreWebView2.ExecuteScriptAsync
-    /// so callers (e.g. App.ShowChatWindow) can invoke BootstrapMessageInjector without
-    /// the WebView2 control field leaking out of this window. Returns null if the
-    /// CoreWebView2 isn't ready yet.
-    /// </summary>
-    public Func<string, Task<string>>? TryGetScriptExecutor()
-    {
-        if (!_webViewInitialized || WebView?.CoreWebView2 == null)
-        {
-            return null;
-        }
-        var core = WebView.CoreWebView2;
-        return script => core.ExecuteScriptAsync(script).AsTask();
-    }
-
     /// <summary>Actually close and dispose (called on app shutdown).</summary>
     public void ForceClose()
     {
@@ -247,8 +231,6 @@ CoreWebView2WebErrorStatus.ServerUnreachable or
                     ErrorPanel.Visibility = Visibility.Collapsed;
                     WebView.Visibility = Visibility.Visible;
                     RequestChatInputFocus();
-                    OpenClawTray.Services.BootstrapMessageInjector.ScriptExecutor exec = script => WebView.CoreWebView2.ExecuteScriptAsync(script).AsTask();
-                    _ = OpenClawTray.Services.BootstrapMessageInjector.InjectAsync(exec, ((App)Microsoft.UI.Xaml.Application.Current).Settings, initialDelayMs: 500);
                 }
             };
 
diff --git a/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs b/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs
index e9cc0f590..d971cc59b 100644
--- a/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs
+++ b/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs
@@ -65,9 +65,9 @@ public string TruncateLabel(string text, int maxLen = 60)
             return MenuDisplayHelper.TruncateText(text, maxLen);
         }
 
-        public Task<bool> RegisterPendingChatSend(string requestId)
+        public Task<ChatSendResult> RegisterPendingChatSend(string requestId)
         {
-            var completion = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+            var completion = new TaskCompletionSource<ChatSendResult>(TaskCreationOptions.RunContinuationsAsynchronously);
             var method = typeof(OpenClawGatewayClient).GetMethod(
                 "TrackPendingChatSend",
                 System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
@@ -694,11 +694,12 @@ public async Task PendingChatSend_CompletesOnSuccessfulResponse()
             "type": "res",
             "id": "chat-1",
             "ok": true,
-            "payload": { "accepted": true }
+            "payload": { "accepted": true, "runId": "run-1" }
         }
         """);
 
-        Assert.True(await task);
+        var result = await task;
+        Assert.Equal("run-1", result.RunId);
     }
 
     [Fact]
diff --git a/tests/OpenClaw.Tray.Tests/BootstrapMessageInjectorTests.cs b/tests/OpenClaw.Tray.Tests/BootstrapMessageInjectorTests.cs
deleted file mode 100644
index 292d45dab..000000000
--- a/tests/OpenClaw.Tray.Tests/BootstrapMessageInjectorTests.cs
+++ /dev/null
@@ -1,140 +0,0 @@
-using OpenClawTray.Services;
-
-namespace OpenClaw.Tray.Tests;
-
-public sealed class BootstrapMessageInjectorTests : IDisposable
-{
-    private readonly string _isolatedDir;
-
-    public BootstrapMessageInjectorTests()
-    {
-        _isolatedDir = Path.Combine(Path.GetTempPath(), "OpenClawTray.Tests", Guid.NewGuid().ToString("N"));
-        Directory.CreateDirectory(_isolatedDir);
-    }
-
-    public void Dispose()
-    {
-        try { Directory.Delete(_isolatedDir, recursive: true); } catch { /* ignore */ }
-    }
-
-    [Fact]
-    public void ShouldInject_ReturnsTrue_OnFreshSettings()
-    {
-        var settings = new SettingsManager(_isolatedDir);
-        Assert.False(settings.HasInjectedFirstRunBootstrap);
-        Assert.True(BootstrapMessageInjector.ShouldInject(settings));
-    }
-
-    [Fact]
-    public void MarkInjected_FlipsGate_AndPersists()
-    {
-        var settings = new SettingsManager(_isolatedDir);
-
-        BootstrapMessageInjector.MarkInjected(settings);
-
-        Assert.True(settings.HasInjectedFirstRunBootstrap);
-        Assert.False(BootstrapMessageInjector.ShouldInject(settings));
-
-        // Reload from disk — the flag must round-trip through SettingsData.
-        var reloaded = new SettingsManager(_isolatedDir);
-        Assert.True(reloaded.HasInjectedFirstRunBootstrap);
-        Assert.False(BootstrapMessageInjector.ShouldInject(reloaded));
-    }
-
-    [Fact]
-    public void MarkInjected_IsIdempotent()
-    {
-        var settings = new SettingsManager(_isolatedDir);
-        BootstrapMessageInjector.MarkInjected(settings);
-        BootstrapMessageInjector.MarkInjected(settings);
-        BootstrapMessageInjector.MarkInjected(settings);
-        Assert.True(settings.HasInjectedFirstRunBootstrap);
-    }
-
-    [Fact]
-    public async Task InjectAsync_ReturnsFalse_WhenExecutorIsNull()
-    {
-        var settings = new SettingsManager(_isolatedDir);
-        var result = await BootstrapMessageInjector.InjectAsync(null, settings, initialDelayMs: 0);
-        Assert.False(result);
-        Assert.False(settings.HasInjectedFirstRunBootstrap);
-    }
-
-    [Fact]
-    public async Task InjectAsync_ReturnsFalse_WhenGateAlreadyConsumed()
-    {
-        var settings = new SettingsManager(_isolatedDir);
-        BootstrapMessageInjector.MarkInjected(settings);
-        var result = await BootstrapMessageInjector.InjectAsync(null, settings, initialDelayMs: 0);
-        Assert.False(result);
-    }
-
-    [Fact]
-    public async Task InjectAsync_FlipsGate_OnSuccessfulExecution()
-    {
-        var settings = new SettingsManager(_isolatedDir);
-        string? capturedScript = null;
-        BootstrapMessageInjector.ScriptExecutor executor = script =>
-        {
-            capturedScript = script;
-            return Task.FromResult("\"sent\"");
-        };
-
-        var result = await BootstrapMessageInjector.InjectAsync(executor, settings, initialDelayMs: 0);
-
-        Assert.True(result);
-        Assert.True(settings.HasInjectedFirstRunBootstrap);
-        Assert.NotNull(capturedScript);
-        Assert.Contains("BOOTSTRAP.md", capturedScript!);
-    }
-
-    [Theory]
-    [InlineData("\"sent-unverified\"")]
-    [InlineData("\"no-input\"")]
-    [InlineData("\"no-send-button\"")]
-    [InlineData("\"unknown\"")]
-    public async Task InjectAsync_DoesNotFlipGate_WhenSendIsUnverified(string scriptResult)
-    {
-        var settings = new SettingsManager(_isolatedDir);
-        BootstrapMessageInjector.ScriptExecutor executor = _ => Task.FromResult(scriptResult);
-
-        var result = await BootstrapMessageInjector.InjectAsync(executor, settings, initialDelayMs: 0);
-
-        Assert.False(result);
-        Assert.False(settings.HasInjectedFirstRunBootstrap);
-
-        var reloaded = new SettingsManager(_isolatedDir);
-        Assert.False(reloaded.HasInjectedFirstRunBootstrap);
-    }
-
-    [Fact]
-    public async Task InjectAsync_DoesNotFireTwice()
-    {
-        var settings = new SettingsManager(_isolatedDir);
-        int callCount = 0;
-        BootstrapMessageInjector.ScriptExecutor executor = _ =>
-        {
-            callCount++;
-            return Task.FromResult("\"sent\"");
-        };
-
-        await BootstrapMessageInjector.InjectAsync(executor, settings, initialDelayMs: 0);
-        await BootstrapMessageInjector.InjectAsync(executor, settings, initialDelayMs: 0);
-        await BootstrapMessageInjector.InjectAsync(executor, settings, initialDelayMs: 0);
-
-        Assert.Equal(1, callCount);
-    }
-
-    [Fact]
-    public void BuildInjectionScript_EncodesMessageSafely()
-    {
-        // Adversarial message: would break naive ${...} or quoted concatenation.
-        var hostile = "abc\"; alert(1); //${evil}\\";
-        var script = BootstrapMessageInjector.BuildInjectionScript(hostile);
-
-        // Raw hostile substring must NOT appear unescaped inside a JS string literal.
-        Assert.DoesNotContain("abc\"; alert(1); //${evil}\\", script);
-        // JSON-escaped form embeds the encoded payload (escaped quote).
-        Assert.Contains("\\\"", script);
-    }
-}
diff --git a/tests/OpenClaw.Tray.Tests/Connection/GatewayConnectionManagerTests.cs b/tests/OpenClaw.Tray.Tests/Connection/GatewayConnectionManagerTests.cs
index f9d5724e5..2adb57ea8 100644
--- a/tests/OpenClaw.Tray.Tests/Connection/GatewayConnectionManagerTests.cs
+++ b/tests/OpenClaw.Tray.Tests/Connection/GatewayConnectionManagerTests.cs
@@ -158,14 +158,80 @@ public void Diagnostics_IsAccessible()
         Assert.Equal(0, _manager.Diagnostics.Count);
     }
 
+    [Fact]
+    public async Task HandshakeSucceeded_SuppressesManagerNodeConnector_WhenLocalNodeServiceOwnsIdentity()
+    {
+        SetupGateway("gw-local", "ws://localhost:18789", isLocal: true);
+        _resolver.OperatorCredential = new GatewayCredential("op-tok", false, "test");
+        _resolver.NodeCredential = new GatewayCredential("node-tok", false, "test");
+        var nodeConnector = new CountingNodeConnector();
+        using var manager = new GatewayConnectionManager(
+            _resolver, _factory, _registry, NullLogger.Instance,
+            nodeConnector: nodeConnector,
+            shouldStartNodeConnection: (record, _) => !record.IsLocal);
+
+        await manager.ConnectAsync("gw-local");
+        await InvokeHandshakeSucceededAsync(manager);
+
+        Assert.Equal(0, nodeConnector.ConnectCount);
+    }
+
+    [Fact]
+    public async Task HandshakeSucceeded_StartsManagerNodeConnector_WhenNoLocalNodeServiceOwnsIdentity()
+    {
+        SetupGateway("gw-remote", "wss://remote.example", isLocal: false);
+        _resolver.OperatorCredential = new GatewayCredential("op-tok", false, "test");
+        _resolver.NodeCredential = new GatewayCredential("node-tok", false, "test");
+        var nodeConnector = new CountingNodeConnector();
+        using var manager = new GatewayConnectionManager(
+            _resolver, _factory, _registry, NullLogger.Instance,
+            nodeConnector: nodeConnector,
+            shouldStartNodeConnection: (record, _) => !record.IsLocal);
+
+        await manager.ConnectAsync("gw-remote");
+        await InvokeHandshakeSucceededAsync(manager);
+
+        Assert.Equal(1, nodeConnector.ConnectCount);
+        Assert.Equal("wss://remote.example", nodeConnector.LastGatewayUrl);
+    }
+
+    [Fact]
+    public async Task ChatPageNavigationReadiness_DoesNotCompleteUntilHandshakeSucceeded()
+    {
+        SetupGateway("gw-chat", "ws://localhost:18789", isLocal: true);
+        _resolver.OperatorCredential = new GatewayCredential("op-tok", false, "test");
+
+        await _manager.ConnectAsync("gw-chat");
+
+        var readiness = ChatNavigationReadiness.WaitForOperatorHandshakeAsync(
+            _manager,
+            TimeSpan.FromSeconds(5));
+
+        Assert.False(readiness.IsCompleted);
+
+        await InvokeHandshakeSucceededAsync(_manager);
+
+        Assert.True(await readiness);
+    }
+
     // ─── Helpers ───
 
-    private void SetupGateway(string id, string url)
+    private void SetupGateway(string id, string url, bool isLocal = false)
     {
-        _registry.AddOrUpdate(new GatewayRecord { Id = id, Url = url });
+        _registry.AddOrUpdate(new GatewayRecord { Id = id, Url = url, IsLocal = isLocal });
         _registry.SetActive(id);
     }
 
+    private static async Task InvokeHandshakeSucceededAsync(GatewayConnectionManager manager)
+    {
+        var method = typeof(GatewayConnectionManager).GetMethod(
+            "HandleHandshakeSucceededAsync",
+            System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
+        Assert.NotNull(method);
+        var task = (Task)method!.Invoke(manager, [1L])!;
+        await task;
+    }
+
     // ─── Mocks ───
 
     private sealed class MockCredentialResolver : ICredentialResolver
@@ -218,4 +284,31 @@ private sealed class MockGatewayClient : OpenClawGatewayClient
         public MockGatewayClient(string url)
             : base(url, "mock-token", NullLogger.Instance) { }
     }
+
+    private sealed class CountingNodeConnector : INodeConnector
+    {
+        public int ConnectCount { get; private set; }
+        public string? LastGatewayUrl { get; private set; }
+        public bool IsConnected => ConnectCount > 0;
+        public PairingStatus PairingStatus { get; private set; } = PairingStatus.Unknown;
+        public string? NodeDeviceId => "test-node";
+        public NodeConnectionMode Mode => IsConnected ? NodeConnectionMode.Gateway : NodeConnectionMode.Disabled;
+
+#pragma warning disable CS0067 // Events required by interface but not fired in tests
+        public event EventHandler<ConnectionStatus>? StatusChanged;
+        public event EventHandler<PairingStatusEventArgs>? PairingStatusChanged;
+#pragma warning restore CS0067
+
+        public Task ConnectAsync(string gatewayUrl, GatewayCredential credential, string identityPath, bool useV2Signature = false)
+        {
+            ConnectCount++;
+            LastGatewayUrl = gatewayUrl;
+            PairingStatus = PairingStatus.Paired;
+            return Task.CompletedTask;
+        }
+
+        public Task DisconnectAsync() => Task.CompletedTask;
+
+        public void Dispose() { }
+    }
 }
diff --git a/tests/OpenClaw.Tray.Tests/OnboardingChatBootstrapperTests.cs b/tests/OpenClaw.Tray.Tests/OnboardingChatBootstrapperTests.cs
new file mode 100644
index 000000000..8237757c2
--- /dev/null
+++ b/tests/OpenClaw.Tray.Tests/OnboardingChatBootstrapperTests.cs
@@ -0,0 +1,192 @@
+using OpenClaw.Shared;
+using OpenClawTray.Services;
+using System.Text.Json;
+
+namespace OpenClaw.Tray.Tests;
+
+public sealed class OnboardingChatBootstrapperTests : IDisposable
+{
+    private readonly string _settingsDir;
+
+    public OnboardingChatBootstrapperTests()
+    {
+        _settingsDir = Path.Combine(Directory.GetCurrentDirectory(), "test-artifacts", "bootstrapper-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(_settingsDir);
+    }
+
+    public void Dispose()
+    {
+        try { Directory.Delete(_settingsDir, true); } catch { }
+    }
+
+    [Fact]
+    public async Task BootstrapAsync_SendsOnceAndConsumesGate_OnCompletedRun()
+    {
+        var settings = new SettingsManager(_settingsDir);
+        var client = new FakeOperatorGatewayClient { Result = new ChatSendResult { RunId = "run-1", SessionKey = "agent:main:main" } };
+
+        var task = OnboardingChatBootstrapper.BootstrapAsync(client, settings, TimeSpan.FromSeconds(5));
+        await Task.Delay(50);
+        client.RaiseFinalAssistant("run-1");
+        var result = await task;
+
+        Assert.True(result);
+        Assert.Equal(1, client.SendCount);
+        Assert.Equal(OnboardingChatBootstrapper.Message, client.LastMessage);
+        Assert.True(settings.HasInjectedFirstRunBootstrap);
+    }
+
+    [Fact]
+    public async Task BootstrapAsync_ConsumesGate_WhenCompletionArrivesSynchronouslyDuringSend()
+    {
+        var settings = new SettingsManager(_settingsDir);
+        var client = new FakeOperatorGatewayClient
+        {
+            Result = new ChatSendResult { RunId = "run-sync", SessionKey = "agent:main:main" },
+            FinalRunIdRaisedDuringSend = "run-sync"
+        };
+
+        var result = await OnboardingChatBootstrapper.BootstrapAsync(client, settings, TimeSpan.FromMilliseconds(25));
+
+        Assert.True(result);
+        Assert.Equal(1, client.SendCount);
+        Assert.Equal(OnboardingChatBootstrapper.Message, client.LastMessage);
+        Assert.True(settings.HasInjectedFirstRunBootstrap);
+    }
+
+    [Fact]
+    public async Task BootstrapAsync_DoesNotConsumeGate_WhenSendFails()
+    {
+        var settings = new SettingsManager(_settingsDir);
+        var client = new FakeOperatorGatewayClient { SendException = new InvalidOperationException("rejected") };
+
+        var result = await OnboardingChatBootstrapper.BootstrapAsync(client, settings, TimeSpan.FromMilliseconds(10));
+
+        Assert.False(result);
+        Assert.Equal(1, client.SendCount);
+        Assert.False(settings.HasInjectedFirstRunBootstrap);
+    }
+
+    [Fact]
+    public async Task BootstrapAsync_DoesNotConsumeGate_WhenCompletionTimesOut()
+    {
+        var settings = new SettingsManager(_settingsDir);
+        var client = new FakeOperatorGatewayClient { Result = new ChatSendResult { RunId = "run-timeout" } };
+
+        var result = await OnboardingChatBootstrapper.BootstrapAsync(client, settings, TimeSpan.FromMilliseconds(25));
+
+        Assert.False(result);
+        Assert.Equal(1, client.SendCount);
+        Assert.False(settings.HasInjectedFirstRunBootstrap);
+    }
+
+#pragma warning disable CS0067
+    private sealed class FakeOperatorGatewayClient : IOperatorGatewayClient
+    {
+        public int SendCount { get; private set; }
+        public string? LastMessage { get; private set; }
+        public Exception? SendException { get; init; }
+        public ChatSendResult Result { get; init; } = new();
+        public string? FinalRunIdRaisedDuringSend { get; init; }
+        public bool IsConnectedToGateway { get; init; } = true;
+        public string? OperatorDeviceId => "operator";
+        public IReadOnlyList<string> GrantedOperatorScopes => Array.Empty<string>();
+
+        public event EventHandler<OpenClawNotification>? NotificationReceived;
+        public event EventHandler<AgentActivity>? ActivityChanged;
+        public event EventHandler<ChannelHealth[]>? ChannelHealthUpdated;
+        public event EventHandler<SessionInfo[]>? SessionsUpdated;
+        public event EventHandler<GatewayUsageInfo>? UsageUpdated;
+        public event EventHandler<GatewayUsageStatusInfo>? UsageStatusUpdated;
+        public event EventHandler<GatewayCostUsageInfo>? UsageCostUpdated;
+        public event EventHandler<GatewayNodeInfo[]>? NodesUpdated;
+        public event EventHandler<SessionsPreviewPayloadInfo>? SessionPreviewUpdated;
+        public event EventHandler<SessionCommandResult>? SessionCommandCompleted;
+        public event EventHandler<GatewaySelfInfo>? GatewaySelfUpdated;
+        public event EventHandler<JsonElement>? CronListUpdated;
+        public event EventHandler<JsonElement>? CronStatusUpdated;
+        public event EventHandler<JsonElement>? CronRunsUpdated;
+        public event EventHandler<JsonElement>? SkillsStatusUpdated;
+        public event EventHandler<JsonElement>? ConfigUpdated;
+        public event EventHandler<JsonElement>? ConfigSchemaUpdated;
+        public event EventHandler<AgentEventInfo>? AgentEventReceived;
+        public event EventHandler<PairingListInfo>? NodePairListUpdated;
+        public event EventHandler<DevicePairingListInfo>? DevicePairListUpdated;
+        public event EventHandler<ModelsListInfo>? ModelsListUpdated;
+        public event EventHandler<PresenceEntry[]>? PresenceUpdated;
+        public event EventHandler<JsonElement>? AgentsListUpdated;
+        public event EventHandler<JsonElement>? AgentFilesListUpdated;
+        public event EventHandler<JsonElement>? AgentFileContentUpdated;
+        public event EventHandler<AgentEventInfo>? ChatEventReceived;
+        public event EventHandler<ConnectionStatus>? StatusChanged;
+        public event EventHandler<string>? AuthenticationFailed;
+        public event EventHandler<DeviceTokenReceivedEventArgs>? DeviceTokenReceived;
+        public event EventHandler? HandshakeSucceeded;
+
+        public Task SendChatMessageAsync(string message, string? sessionKey = null) => SendChatMessageForRunAsync(message, sessionKey);
+
+        public Task<ChatSendResult> SendChatMessageForRunAsync(string message, string? sessionKey = null)
+        {
+            SendCount++;
+            LastMessage = message;
+            if (SendException != null) throw SendException;
+            if (!string.IsNullOrWhiteSpace(FinalRunIdRaisedDuringSend))
+                RaiseFinalAssistant(FinalRunIdRaisedDuringSend);
+            return Task.FromResult(Result);
+        }
+
+        public void RaiseFinalAssistant(string runId)
+        {
+            using var doc = JsonDocument.Parse("""{"state":"final"}""");
+            ChatEventReceived?.Invoke(this, new AgentEventInfo
+            {
+                RunId = runId,
+                Stream = "assistant",
+                Data = doc.RootElement.Clone()
+            });
+        }
+
+        public void SetUserRules(IReadOnlyList<UserNotificationRule>? rules) { }
+        public void SetPreferStructuredCategories(bool value) { }
+        public Task CheckHealthAsync() => Task.CompletedTask;
+        public Task RequestSessionsAsync(string? agentId = null) => Task.CompletedTask;
+        public Task RequestUsageAsync() => Task.CompletedTask;
+        public Task RequestNodesAsync() => Task.CompletedTask;
+        public Task RequestUsageStatusAsync() => Task.CompletedTask;
+        public Task RequestUsageCostAsync(int days = 30) => Task.CompletedTask;
+        public Task RequestSessionPreviewAsync(string[] keys, int limit = 12, int maxChars = 240) => Task.CompletedTask;
+        public Task<bool> PatchSessionAsync(string key, string? thinkingLevel = null, string? verboseLevel = null) => Task.FromResult(false);
+        public Task<bool> ResetSessionAsync(string key) => Task.FromResult(false);
+        public Task<bool> DeleteSessionAsync(string key, bool deleteTranscript = true) => Task.FromResult(false);
+        public Task<bool> CompactSessionAsync(string key, int maxLines = 400) => Task.FromResult(false);
+        public Task RequestCronListAsync() => Task.CompletedTask;
+        public Task RequestCronStatusAsync() => Task.CompletedTask;
+        public Task<bool> RunCronJobAsync(string jobId, bool force = true) => Task.FromResult(false);
+        public Task<bool> RemoveCronJobAsync(string jobId) => Task.FromResult(false);
+        // Stubbed for interface compliance — not exercised by these tests.
+        public Task<bool> AddCronJobAsync(object jobDefinition) => Task.FromResult(false);
+        public Task<bool> UpdateCronJobAsync(string id, object patch) => Task.FromResult(false);
+        public Task RequestCronRunsAsync(string? id = null, int limit = 20, int offset = 0) => Task.CompletedTask;
+        public Task RequestSkillsStatusAsync(string? agentId = null) => Task.CompletedTask;
+        public Task<bool> InstallSkillAsync(string skillId) => Task.FromResult(false);
+        public Task<bool> UpdateSkillAsync(string skillId) => Task.FromResult(false);
+        public Task RequestConfigAsync() => Task.CompletedTask;
+        public Task RequestConfigSchemaAsync() => Task.CompletedTask;
+        public Task<bool> SetConfigAsync(string path, object value) => Task.FromResult(false);
+        public Task<bool> PatchConfigAsync(JsonElement fullConfig, string? baseHash) => Task.FromResult(false);
+        public Task RequestAgentsListAsync() => Task.CompletedTask;
+        public Task RequestAgentFilesListAsync(string agentId = "main") => Task.CompletedTask;
+        public Task RequestAgentFileGetAsync(string agentId, string name) => Task.CompletedTask;
+        public Task RequestModelsListAsync() => Task.CompletedTask;
+        public Task RequestNodePairListAsync() => Task.CompletedTask;
+        public Task<bool> NodePairApproveAsync(string requestId) => Task.FromResult(false);
+        public Task<bool> NodePairRejectAsync(string requestId) => Task.FromResult(false);
+        public Task RequestDevicePairListAsync() => Task.CompletedTask;
+        public Task<bool> DevicePairApproveAsync(string requestId) => Task.FromResult(false);
+        public Task<bool> DevicePairRejectAsync(string requestId) => Task.FromResult(false);
+        public Task<bool> StartChannelAsync(string channelName) => Task.FromResult(false);
+        public Task<bool> StopChannelAsync(string channelName) => Task.FromResult(false);
+        public Task<JsonElement> SendWizardRequestAsync(string method, object? parameters = null, int timeoutMs = 30000) => Task.FromResult(default(JsonElement));
+    }
+#pragma warning restore CS0067
+}
diff --git a/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj b/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj
index 0d920bfd3..966e5ba92 100644
--- a/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj
+++ b/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj
@@ -24,7 +24,7 @@
     <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\DeepLinkHandler.cs" Link="Services\DeepLinkHandler.cs" />
     <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\Logger.cs" Link="Services\Logger.cs" />
     <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\SettingsManager.cs" Link="Services\SettingsManager.cs" />
-    <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\BootstrapMessageInjector.cs" Link="Services\BootstrapMessageInjector.cs" />
+    <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\OnboardingChatBootstrapper.cs" Link="Services\OnboardingChatBootstrapper.cs" />
     <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\GatewayCredentialResolver.cs" Link="Services\GatewayCredentialResolver.cs" />
     <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\StartupSetupState.cs" Link="Services\StartupSetupState.cs" />
     <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\ActivityStreamService.cs" Link="Services\ActivityStreamService.cs" />
@@ -66,6 +66,7 @@
     <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\Connection\ConnectionDiagnosticEvent.cs" Link="Services\Connection\ConnectionDiagnosticEvent.cs" />
     <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\Connection\IGatewayConnectionManager.cs" Link="Services\Connection\IGatewayConnectionManager.cs" />
     <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\Connection\GatewayConnectionManager.cs" Link="Services\Connection\GatewayConnectionManager.cs" />
+    <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\Connection\ChatNavigationReadiness.cs" Link="Services\Connection\ChatNavigationReadiness.cs" />
     <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\Connection\IGatewayClientFactory.cs" Link="Services\Connection\IGatewayClientFactory.cs" />
     <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\Connection\GatewayClientFactory.cs" Link="Services\Connection\GatewayClientFactory.cs" />
     <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\Connection\ConnectionErrorCategory.cs" Link="Services\Connection\ConnectionErrorCategory.cs" />
diff --git a/tests/OpenClaw.Tray.Tests/StartupSetupStateTests.cs b/tests/OpenClaw.Tray.Tests/StartupSetupStateTests.cs
index 9eb91425a..b1167f8e2 100644
--- a/tests/OpenClaw.Tray.Tests/StartupSetupStateTests.cs
+++ b/tests/OpenClaw.Tray.Tests/StartupSetupStateTests.cs
@@ -9,13 +9,24 @@ public class StartupSetupStateTests
     public void RequiresSetup_ReturnsFalse_WhenNodeHasStoredDeviceToken()
     {
         using var temp = TempSettings.Create();
-        StoreDeviceToken(temp.Path);
+        StoreNodeDeviceToken(temp.Path);
         var settings = new SettingsManager(temp.Path) { EnableNodeMode = true };
 
         Assert.False(StartupSetupState.RequiresSetup(settings, temp.Path));
         Assert.True(StartupSetupState.CanStartNodeGateway(settings, temp.Path));
     }
 
+    [Fact]
+    public void RequiresSetup_ReturnsTrue_WhenOnlyOperatorTokenExistsForNodeMode()
+    {
+        using var temp = TempSettings.Create();
+        StoreDeviceToken(temp.Path);
+        var settings = new SettingsManager(temp.Path) { EnableNodeMode = true };
+
+        Assert.True(StartupSetupState.RequiresSetup(settings, temp.Path));
+        Assert.False(StartupSetupState.CanStartNodeGateway(settings, temp.Path));
+    }
+
     [Fact]
     public void RequiresSetup_ReturnsFalse_WhenMcpOnlyModeIsEnabled()
     {
@@ -42,6 +53,13 @@ private static void StoreDeviceToken(string dataPath)
         identity.StoreDeviceToken("stored-device-token");
     }
 
+    private static void StoreNodeDeviceToken(string dataPath)
+    {
+        var identity = new DeviceIdentity(dataPath);
+        identity.Initialize();
+        identity.StoreDeviceTokenForRole("node", "stored-node-token");
+    }
+
     private sealed class TempSettings : IDisposable
     {
         public string Path { get; }