fix(pairing): clarify reconnect and startup state (#616)

* fix(pairing): surface durable reconnect state

* fix(pairing): preserve credential source during node refresh

Preserve the operator credential source when reconnecting the Windows node without replacing an existing same-gateway operator connection. Move the scheduled-task auto-start work off the WinUI thread and terminate schtasks.exe if it times out.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: Scott Hanselman <scott@hanselman.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 3 people

src/OpenClaw.Connection/ConnectionStateMachine.cs

@@ -13,6 +13,8 @@ internal sealed class ConnectionStateMachine
     private RoleConnectionState _nodeState = RoleConnectionState.Idle;
     private string? _operatorError;
     private string? _nodeError;
+    private string? _operatorCredentialSource;
+    private string? _nodeCredentialSource;
     private bool _nodeEnabled;
 
     /// <summary>
@@ -134,6 +136,8 @@ public void Reset()
         _nodeState = _nodeEnabled ? RoleConnectionState.Idle : RoleConnectionState.Disabled;
         _operatorError = null;
         _nodeError = null;
+        _operatorCredentialSource = null;
+        _nodeCredentialSource = null;
         RebuildSnapshot();
     }
 
@@ -154,6 +158,12 @@ internal void SetOperatorDeviceId(string? deviceId)
         Current = Current with { OperatorDeviceId = deviceId };
     }
 
+    internal void SetOperatorCredentialSource(string? source)
+    {
+        _operatorCredentialSource = source;
+        RebuildSnapshot();
+    }
+
     /// <summary>Update node info (device ID, pairing status, optional request ID) in the snapshot.</summary>
     internal void SetNodeInfo(
         string? deviceId,
@@ -183,6 +193,12 @@ internal void SetNodeInfo(
         };
     }
 
+    internal void SetNodeCredentialSource(string? source)
+    {
+        _nodeCredentialSource = source;
+        RebuildSnapshot();
+    }
+
     /// <summary>Update the operator pairing request ID in the snapshot.</summary>
     internal void SetOperatorPairingRequestId(string? requestId)
     {
@@ -257,6 +273,8 @@ private void ApplyTransition(ConnectionTrigger trigger, string? detail)
                 _nodeState = _nodeEnabled ? RoleConnectionState.Idle : RoleConnectionState.Disabled;
                 _operatorError = null;
                 _nodeError = null;
+                _operatorCredentialSource = null;
+                _nodeCredentialSource = null;
                 break;
 
             case ConnectionTrigger.ReconnectScheduled:
@@ -317,12 +335,14 @@ private void RebuildSnapshot()
             OverallState = GatewayConnectionSnapshot.DeriveOverall(_operatorState, _nodeState, _nodeEnabled),
             OperatorState = _operatorState,
             OperatorError = _operatorError,
+            OperatorCredentialSource = _operatorCredentialSource,
             OperatorPairingRequired = _operatorState == RoleConnectionState.PairingRequired,
             // Clear requestId when no longer in PairingRequired to prevent stale reads
             OperatorPairingRequestId = _operatorState == RoleConnectionState.PairingRequired
                 ? Current.OperatorPairingRequestId : null,
             NodeState = _nodeState,
             NodeError = _nodeError,
+            NodeCredentialSource = _nodeCredentialSource,
             // Clear requestId when no longer in PairingRequired to prevent stale reads
             NodePairingRequestId = _nodeState == RoleConnectionState.PairingRequired
                 ? Current.NodePairingRequestId : null,

src/OpenClaw.Connection/GatewayConnectionManager.cs

@@ -209,6 +209,7 @@ private async Task ConnectCoreAsync(string? gatewayId = null)
                 var prev = _stateMachine.Current.OverallState;
                 // Must go through Connecting → Error since AuthenticationFailed requires Connecting state
                 _stateMachine.TryTransition(ConnectionTrigger.ConnectRequested);
+                _stateMachine.SetOperatorCredentialSource(null);
                 _stateMachine.TryTransition(ConnectionTrigger.AuthenticationFailed, "No credential available");
                 EmitStateChanged(prev);
                 return;
@@ -217,6 +218,7 @@ private async Task ConnectCoreAsync(string? gatewayId = null)
             // Transition to Connecting
             var prevState = _stateMachine.Current.OverallState;
             _stateMachine.TryTransition(ConnectionTrigger.ConnectRequested);
+            _stateMachine.SetOperatorCredentialSource(credential.Source);
             _diagnostics.RecordStateChange(prevState, _stateMachine.Current.OverallState);
             EmitStateChanged(prevState);
 
@@ -370,6 +372,9 @@ tunnel.SshPort is < 1 or > 65535 ||
             string.Equals(_activeGatewayRecordId, record.Id, StringComparison.Ordinal) &&
             string.Equals(_stateMachine.Current.GatewayUrl, record.Url, StringComparison.Ordinal) &&
             Equals(_activeSshTunnel, record.SshTunnel);
+        var operatorCredentialSource = preservesOperatorConnection
+            ? _stateMachine.Current.OperatorCredentialSource
+            : null;
         var gen = Interlocked.Read(ref _generation);
         if (!preservesOperatorConnection)
         {
@@ -393,6 +398,8 @@ tunnel.SshPort is < 1 or > 65535 ||
         };
 
         _diagnostics.RecordCredentialResolution(nodeCredential);
+        _stateMachine.SetOperatorCredentialSource(operatorCredentialSource);
+        _stateMachine.SetNodeCredentialSource(nodeCredential.Source);
         _diagnostics.Record("node", $"Starting node-only connection to {record.Url}",
             $"Credential source: {nodeCredential.Source}");
 
@@ -1214,6 +1221,7 @@ private async Task<bool> StartNodeConnectionCoreAsync(
         try
         {
             _stateMachine.SetNodeEnabled(true);
+            _stateMachine.SetNodeCredentialSource(nodeCredential.Source);
         }
         finally
         {

src/OpenClaw.Connection/GatewayConnectionSnapshot.cs

@@ -14,6 +14,7 @@ public sealed record GatewayConnectionSnapshot
     public string? OperatorError { get; init; }
     public bool OperatorPairingRequired { get; init; }
     public string? OperatorDeviceId { get; init; }
+    public string? OperatorCredentialSource { get; init; }
     /// <summary>
     /// The requestId returned by the gateway when operator pairing is required.
     /// Used by setup flows to approve the specific pairing request via CLI.
@@ -25,6 +26,7 @@ public sealed record GatewayConnectionSnapshot
     public string? NodeError { get; init; }
     public OpenClaw.Shared.PairingStatus NodePairingStatus { get; init; }
     public string? NodeDeviceId { get; init; }
+    public string? NodeCredentialSource { get; init; }
     /// <summary>
     /// The requestId returned by the gateway when node pairing is required.
     /// Used by the connection page to show the correct approval command.

src/OpenClaw.SetupEngine/OpenClaw.SetupEngine.csproj

@@ -9,6 +9,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\OpenClaw.Connection\OpenClaw.Connection.csproj" />
+    <ProjectReference Include="..\OpenClaw.Shared\OpenClaw.Shared.csproj" />
   </ItemGroup>
 
 </Project>

src/OpenClaw.SetupEngine/StartupTaskRegistration.cs

@@ -0,0 +1,27 @@
+using System.Diagnostics;
+using OpenClaw.Shared;
+
+namespace OpenClaw.SetupEngine;
+
+public static class StartupTaskRegistration
+{
+    internal const string TaskName = WindowsStartupTaskRegistration.TaskName;
+
+    public static bool Register(string trayExecutablePath) =>
+        WindowsStartupTaskRegistration.Register(trayExecutablePath);
+
+    public static bool Unregister() =>
+        WindowsStartupTaskRegistration.Unregister();
+
+    internal static ProcessStartInfo CreateRegisterProcessStartInfo(string trayExecutablePath) =>
+        WindowsStartupTaskRegistration.CreateRegisterProcessStartInfo(trayExecutablePath);
+
+    internal static ProcessStartInfo CreateUnregisterProcessStartInfo() =>
+        WindowsStartupTaskRegistration.CreateUnregisterProcessStartInfo();
+
+    internal static ProcessStartInfo CreateQueryProcessStartInfo() =>
+        WindowsStartupTaskRegistration.CreateQueryProcessStartInfo();
+
+    internal static string ResolveSchtasksPath() =>
+        WindowsStartupTaskRegistration.ResolveSchtasksPath();
+}

src/OpenClaw.SetupEngine/TrayArtifactCleanup.cs

@@ -1,6 +1,7 @@
 using System.Runtime.Versioning;
 using Microsoft.Win32;
 using OpenClaw.Connection;
+using OpenClaw.Shared;
 
 namespace OpenClaw.SetupEngine;
 
@@ -20,7 +21,7 @@ public static void Run(SetupContext ctx, bool preserveLogs = false)
         var appDataDir = ctx.DataDir; // %APPDATA%\OpenClawTray
         var localDataDir = ctx.LocalDataDir;
 
-        // 1. Remove autostart registry key
+        // 1. Remove autostart entries
         try
         {
             using var key = Registry.CurrentUser.OpenSubKey(AutoStartKey, writable: true);
@@ -39,6 +40,11 @@ public static void Run(SetupContext ctx, bool preserveLogs = false)
             logger.Warn($"[Uninstall] Failed to remove autostart registry key: {ex.Message}");
         }
 
+        if (WindowsStartupTaskRegistration.Unregister())
+            logger.Info("[Uninstall] Removed autostart scheduled task");
+        else
+            logger.Info("[Uninstall] Autostart scheduled task already absent or unavailable");
+
         // 2. Delete run.marker
         DeleteFileIfExists(Path.Combine(localDataDir, "run.marker"), "run.marker", logger);
 

src/OpenClaw.Shared/InstanceMerger.cs

@@ -245,7 +245,7 @@ private static MergedInstance BuildFromPresence(
             IsThisInstance = !isGateway && IsLocalIdentity(node, p, options),
             DisplayName = node?.DisplayName is { Length: > 0 } dn ? dn : p.DisplayName,
             Ip = p.Ip ?? node?.RemoteIp,
-            Version = p.Version ?? node?.Version,
+            Version = p.Version ?? DisplayVersionForNode(node, hasPresence: true),
             Platform = p.Platform ?? node?.Platform,
             DeviceFamily = p.DeviceFamily ?? node?.DeviceFamily,
             ModelIdentifier = p.ModelIdentifier ?? node?.ModelIdentifier,
@@ -279,7 +279,7 @@ private static MergedInstance BuildFromOrphanNode(
             IsThisInstance = IsLocalIdentity(node, presence: null, options),
             DisplayName = string.IsNullOrWhiteSpace(node.DisplayName) ? node.ShortId : node.DisplayName,
             Ip = node.RemoteIp,
-            Version = node.Version,
+            Version = DisplayVersionForNode(node, hasPresence: false),
             Platform = node.Platform,
             DeviceFamily = node.DeviceFamily,
             ModelIdentifier = node.ModelIdentifier,
@@ -310,6 +310,19 @@ private static MergedInstance BuildFromOrphanNode(
         return n;
     }
 
+    private static string? DisplayVersionForNode(GatewayNodeInfo? node, bool hasPresence)
+    {
+        var version = node?.Version;
+        if (!hasPresence &&
+            node is { IsOnline: false } &&
+            string.Equals(version?.Trim(), "1.0.0", StringComparison.OrdinalIgnoreCase))
+        {
+            return null;
+        }
+
+        return version;
+    }
+
     private static PresenceStatus ClassifyPresence(
         PresenceEntry p,
         DateTime nowUtc,

src/OpenClaw.Shared/OpenClaw.Shared.csproj

@@ -8,6 +8,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <InternalsVisibleTo Include="OpenClaw.SetupEngine" />
     <InternalsVisibleTo Include="OpenClaw.Shared.Tests" />
     <InternalsVisibleTo Include="OpenClaw.Tray.WinUI" />
   </ItemGroup>

src/OpenClaw.Shared/WindowsStartupTaskRegistration.cs

@@ -0,0 +1,99 @@
+using System.Diagnostics;
+
+namespace OpenClaw.Shared;
+
+public static class WindowsStartupTaskRegistration
+{
+    public const string TaskName = "OpenClaw Companion";
+
+    public static bool Register(string trayExecutablePath)
+    {
+        if (string.IsNullOrWhiteSpace(trayExecutablePath) || !File.Exists(trayExecutablePath))
+            return false;
+
+        return Run(CreateRegisterProcessStartInfo(trayExecutablePath));
+    }
+
+    public static bool Unregister() => Run(CreateUnregisterProcessStartInfo());
+
+    public static bool Exists() => Run(CreateQueryProcessStartInfo());
+
+    internal static ProcessStartInfo CreateRegisterProcessStartInfo(string trayExecutablePath)
+    {
+        var fullPath = Path.GetFullPath(trayExecutablePath);
+        return CreateStartInfo(
+            "/Create",
+            "/TN", TaskName,
+            "/TR", Quote(fullPath),
+            "/SC", "ONLOGON",
+            "/F");
+    }
+
+    internal static ProcessStartInfo CreateUnregisterProcessStartInfo() =>
+        CreateStartInfo(
+            "/Delete",
+            "/TN", TaskName,
+            "/F");
+
+    internal static ProcessStartInfo CreateQueryProcessStartInfo() =>
+        CreateStartInfo(
+            "/Query",
+            "/TN", TaskName);
+
+    private static bool Run(ProcessStartInfo startInfo)
+    {
+        try
+        {
+            using var process = Process.Start(startInfo);
+            if (process == null)
+                return false;
+
+            if (process.WaitForExit(10_000))
+                return process.ExitCode == 0;
+
+            try
+            {
+                process.Kill(entireProcessTree: false);
+            }
+            catch
+            {
+            }
+
+            return false;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    internal static string ResolveSchtasksPath()
+    {
+        var systemRoot = Environment.GetFolderPath(Environment.SpecialFolder.Windows);
+        if (string.IsNullOrWhiteSpace(systemRoot))
+            systemRoot = Environment.GetEnvironmentVariable("SystemRoot");
+
+        return !string.IsNullOrWhiteSpace(systemRoot)
+            ? Path.Combine(systemRoot, "System32", "schtasks.exe")
+            : Path.Combine("C:\\", "Windows", "System32", "schtasks.exe");
+    }
+
+    private static ProcessStartInfo CreateStartInfo(params string[] arguments)
+    {
+        var startInfo = new ProcessStartInfo
+        {
+            FileName = ResolveSchtasksPath(),
+            UseShellExecute = false,
+            CreateNoWindow = true,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+        };
+
+        foreach (var argument in arguments)
+            startInfo.ArgumentList.Add(argument);
+
+        return startInfo;
+    }
+
+    private static string Quote(string value) => "\"" + value.Replace("\"", "\\\"") + "\"";
+}

src/OpenClaw.Tray.WinUI/App.xaml.cs

@@ -2900,7 +2900,9 @@ private void OnSettingsSaved(object? sender, EventArgs e)
             _globalHotkey?.Unregister();
         }
 
-        AutoStartManager.SetAutoStart(_settings.AutoStart);
+        ObserveBackgroundFault(
+            AutoStartManager.SetAutoStartAsync(_settings.AutoStart),
+            "[App] Failed to apply auto-start setting");
 
         // Notify ad-hoc listeners (e.g. ChatWindow may be alive but not
         // owned by the hub) that settings have changed. Marshal onto the
@@ -3189,7 +3191,7 @@ private async Task RestartAfterSetupAsync(bool enableAutoStart)
             {
                 try
                 {
-                    AutoStartManager.SetAutoStart(true);
+                    await AutoStartManager.SetAutoStartAsync(true);
                 }
                 catch (Exception ex)
                 {
@@ -3402,12 +3404,18 @@ private async Task ToggleChannelAsync(string channelName)
         }
     }
 
-    private void ToggleAutoStart()
+    private void ToggleAutoStart() =>
+        AsyncEventHandlerGuard.Run(
+            ToggleAutoStartAsync,
+            new AppLogger(),
+            nameof(ToggleAutoStart));
+
+    private async Task ToggleAutoStartAsync()
     {
         if (_settings == null) return;
         _settings.AutoStart = !_settings.AutoStart;
         _settings.Save();
-        AutoStartManager.SetAutoStart(_settings.AutoStart);
+        await AutoStartManager.SetAutoStartAsync(_settings.AutoStart);
     }
 
     private void OpenLogFile()