Fix #1294: Log startup connect exceptions to the rolling file sink

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

Author: JoshuaRowePhantom

Phantom.Workspaces.Tests/MainWindowIntegrationTests.cs

@@ -6107,6 +6107,7 @@ public async Task App_Startup_DefaultWorkspaceWithRestorableSubAgents_DismissesL
         await using var viewModel = CreateTestMainWindowViewModel();
 
         var succeeded = await StartupSplashRunner.RunWithSplashDismissAsync(
+            loggerFactory: Microsoft.Extensions.Logging.Abstractions.NullLoggerFactory.Instance,
             initializeAsync: () => viewModel.InitializeAsync(),
             setStatus: _ => { },
             onFaultDelay: () => Task.CompletedTask,
@@ -6127,6 +6128,7 @@ public async Task App_Startup_ViewModelInitializeAsyncFaults_LoadingWindowIsClos
         var postInitializeRan = false;
 
         var succeeded = await StartupSplashRunner.RunWithSplashDismissAsync(
+            loggerFactory: Microsoft.Extensions.Logging.Abstractions.NullLoggerFactory.Instance,
             initializeAsync: () => Task.FromException(new InvalidOperationException("boom")),
             setStatus: _ => { },
             onFaultDelay: () => Task.CompletedTask,
@@ -6150,6 +6152,7 @@ public async Task App_Startup_SubAgentRestoreThrows_DoesNotHangSplash()
         var statusMessages = new List<string>();
 
         var succeeded = await StartupSplashRunner.RunWithSplashDismissAsync(
+            loggerFactory: Microsoft.Extensions.Logging.Abstractions.NullLoggerFactory.Instance,
             initializeAsync: () => Task.FromException(
                 new InvalidOperationException("Agent definition does not specify a model.")),
             setStatus: msg => statusMessages.Add(msg),
@@ -6163,6 +6166,121 @@ public async Task App_Startup_SubAgentRestoreThrows_DoesNotHangSplash()
         Assert.Contains(statusMessages, m => m.Contains("Agent definition does not specify a model.", StringComparison.Ordinal));
     }
 
+    // ── Issue #1294: startup connect failures must be written to the rolling log file ──
+
+    private sealed class RecordingStartupLoggerFactory : Microsoft.Extensions.Logging.ILoggerFactory
+    {
+        public List<TestLogger<StartupSplashRunner>.LogEntry> Entries { get; } = [];
+        private readonly TestLogger<StartupSplashRunner> logger;
+
+        public RecordingStartupLoggerFactory()
+        {
+            this.logger = new TestLogger<StartupSplashRunner>();
+        }
+
+        public void AddProvider(Microsoft.Extensions.Logging.ILoggerProvider provider) { }
+        public Microsoft.Extensions.Logging.ILogger CreateLogger(string categoryName) => this.logger;
+        public void Dispose() { }
+
+        public IReadOnlyList<TestLogger<StartupSplashRunner>.LogEntry> Snapshot() => this.logger.Entries;
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task StartupSplashRunner_WhenInitializeThrows_LogsError()
+    {
+        var factory = new RecordingStartupLoggerFactory();
+        var boom = new InvalidOperationException("boom-1294");
+
+        await StartupSplashRunner.RunWithSplashDismissAsync(
+            loggerFactory: factory,
+            initializeAsync: () => Task.FromException(boom),
+            setStatus: _ => { },
+            onFaultDelay: () => Task.CompletedTask,
+            shutdown: () => { },
+            postInitialize: () => { },
+            closeSplash: () => { });
+
+        var errors = factory.Snapshot()
+            .Where(e => e.Level == Microsoft.Extensions.Logging.LogLevel.Error)
+            .ToList();
+        Assert.Single(errors);
+        Assert.Same(boom, errors[0].Exception);
+        Assert.Contains("Startup connect failed", errors[0].Message, StringComparison.Ordinal);
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task StartupSplashRunner_WhenInitializeThrows_SetsSplashStatus()
+    {
+        var factory = new RecordingStartupLoggerFactory();
+        var statusMessages = new List<string>();
+
+        await StartupSplashRunner.RunWithSplashDismissAsync(
+            loggerFactory: factory,
+            initializeAsync: () => Task.FromException(new InvalidOperationException("boom-status")),
+            setStatus: msg => statusMessages.Add(msg),
+            onFaultDelay: () => Task.CompletedTask,
+            shutdown: () => { },
+            postInitialize: () => { },
+            closeSplash: () => { });
+
+        Assert.Contains("Failed to connect: boom-status", statusMessages);
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task StartupSplashRunner_WhenInitializeSucceeds_DoesNotLogError()
+    {
+        var factory = new RecordingStartupLoggerFactory();
+
+        await StartupSplashRunner.RunWithSplashDismissAsync(
+            loggerFactory: factory,
+            initializeAsync: () => Task.CompletedTask,
+            setStatus: _ => { },
+            onFaultDelay: () => Task.CompletedTask,
+            shutdown: () => { },
+            postInitialize: () => { },
+            closeSplash: () => { });
+
+        Assert.DoesNotContain(factory.Snapshot(), e => e.Level == Microsoft.Extensions.Logging.LogLevel.Error);
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task StartupSplashRunner_WhenInitializeThrows_LogsBeforeShutdown()
+    {
+        var factory = new RecordingStartupLoggerFactory();
+        var events = new List<string>();
+
+        // TestLogger records to factory.Snapshot() synchronously; we also snapshot ordering
+        // via events for the shutdown/onFaultDelay callbacks so we can assert LogError fired
+        // strictly before either.
+        await StartupSplashRunner.RunWithSplashDismissAsync(
+            loggerFactory: factory,
+            initializeAsync: () => Task.FromException(new InvalidOperationException("order-check")),
+            setStatus: _ => events.Add("setStatus"),
+            onFaultDelay: () =>
+            {
+                events.Add("onFaultDelay");
+                return Task.CompletedTask;
+            },
+            shutdown: () => events.Add("shutdown"),
+            postInitialize: () => events.Add("postInitialize"),
+            closeSplash: () => events.Add("closeSplash"));
+
+        // Snapshot the error entry — the RecordingStartupLoggerFactory records synchronously
+        // inside LogError, so its presence at snapshot time means LogError has returned.
+        var errorEntry = factory.Snapshot()
+            .Single(e => e.Level == Microsoft.Extensions.Logging.LogLevel.Error);
+        Assert.Contains("Startup connect failed", errorEntry.Message, StringComparison.Ordinal);
+
+        // Ordering: shutdown and onFaultDelay both follow the LogError call, which happens
+        // before setStatus in the catch block. shutdown must not precede either.
+        var shutdownIndex = events.IndexOf("shutdown");
+        var onFaultDelayIndex = events.IndexOf("onFaultDelay");
+        var setStatusIndex = events.IndexOf("setStatus");
+        Assert.True(setStatusIndex >= 0);
+        Assert.True(onFaultDelayIndex > setStatusIndex, "onFaultDelay must run after setStatus (and after LogError).");
+        Assert.True(shutdownIndex > onFaultDelayIndex, "shutdown must run after onFaultDelay (and after LogError).");
+    }
+
     private static RepositorySource CreateInMemoryRepositorySource()
     {
         return new UnknownRepositorySource();

Phantom.Workspaces/App.axaml.cs

@@ -331,6 +331,7 @@ public override async void OnFrameworkInitializationCompleted()
             // RestoreSubAgentsAsync (the reported #1186 cause) left it stuck in
             // front indefinitely.
             var succeeded = await StartupSplashRunner.RunWithSplashDismissAsync(
+                loggerFactory: loggerFactory,
                 initializeAsync: () => viewModel.InitializeAsync(),
                 setStatus: msg => loadingViewModel.StatusText = msg,
                 onFaultDelay: () => Task.Delay(5000), // Give user time to read the error

Phantom.Workspaces/StartupSplashRunner.cs

@@ -1,5 +1,7 @@
 namespace Phantom.Workspaces;
 
+using Microsoft.Extensions.Logging;
+
 /// <summary>
 /// Issue #1186: Centralises the "initialize the view-model behind the splash" run so
 /// that the loading window is ALWAYS dismissed via <see langword="finally"/>, no matter
@@ -8,34 +10,49 @@ namespace Phantom.Workspaces;
 /// a fault inside <c>viewModel.InitializeAsync()</c> — or, per the diagnosed bug, an
 /// unobserved fault buried inside <c>RestoreSubAgentsAsync</c> — could leave the
 /// splash stuck in front of every other window indefinitely.
+/// Issue #1294: The runner now also owns startup-connect logging so exceptions that would
+/// otherwise be shown only in the splash <c>StatusText</c> are written to the rolling
+/// file sink via the injected <see cref="ILoggerFactory"/>.
 /// </summary>
-internal static class StartupSplashRunner
+internal sealed class StartupSplashRunner
 {
+    private StartupSplashRunner() { }
+
     /// <summary>
     /// Runs <paramref name="initializeAsync"/>. On success invokes
     /// <paramref name="postInitialize"/> and returns <see langword="true"/>. On
-    /// exception invokes <paramref name="setStatus"/> with the failure message,
-    /// awaits <paramref name="onFaultDelay"/>, invokes <paramref name="shutdown"/>
-    /// and returns <see langword="false"/>. In every case, <paramref name="closeSplash"/>
+    /// exception logs the exception via <paramref name="loggerFactory"/> BEFORE invoking
+    /// <paramref name="setStatus"/> with the failure message, awaiting
+    /// <paramref name="onFaultDelay"/>, invoking <paramref name="shutdown"/>
+    /// and returning <see langword="false"/>. In every case, <paramref name="closeSplash"/>
     /// runs from a <see langword="finally"/> block so the loading window is always
     /// dismissed.
     /// </summary>
     internal static async Task<bool> RunWithSplashDismissAsync(
+        ILoggerFactory loggerFactory,
         Func<Task> initializeAsync,
         Action<string> setStatus,
         Func<Task> onFaultDelay,
         Action shutdown,
         Action postInitialize,
         Action closeSplash)
     {
+        ArgumentNullException.ThrowIfNull(loggerFactory);
+        var logger = loggerFactory.CreateLogger<StartupSplashRunner>();
         try
         {
             try
             {
+                logger.LogInformation("Startup connect: beginning initialize.");
                 await initializeAsync().ConfigureAwait(true);
             }
             catch (Exception ex)
             {
+                // Issue #1294: Log the full exception (type + message + stack) to the rolling
+                // file sink BEFORE showing the splash message, awaiting the fault delay, or
+                // shutting down. Doing it first keeps the entry flushable even if shutdown
+                // races the file sink and gives users a diagnostic trail beyond ex.Message.
+                logger.LogError(ex, "Startup connect failed.");
                 setStatus($"Failed to connect: {ex.Message}");
                 await onFaultDelay().ConfigureAwait(true);
                 shutdown();