feat: perpetual session analyzer for automated reliability monitoring

PolyPilot.Tests/PolyPilot.Tests.csproj

@@ -44,6 +44,7 @@
     <Compile Include="../PolyPilot/Models/PromptLibrary.cs" Link="Shared/PromptLibrary.cs" />
     <Compile Include="../PolyPilot/Models/UsageStatistics.cs" Link="Shared/UsageStatistics.cs" />
     <Compile Include="../PolyPilot/Services/PromptLibraryService.cs" Link="Shared/PromptLibraryService.cs" />
+    <Compile Include="../PolyPilot/Services/SessionAnalyzerService.cs" Link="Shared/SessionAnalyzerService.cs" />
     <Compile Include="../PolyPilot/Services/UsageStatsService.cs" Link="Shared/UsageStatsService.cs" />
     <Compile Include="../PolyPilot/Services/NotificationMessageBuilder.cs" Link="Shared/NotificationMessageBuilder.cs" />
     <Compile Include="../PolyPilot/Services/IChatDatabase.cs" Link="Shared/IChatDatabase.cs" />

PolyPilot.Tests/SessionAnalyzerTests.cs

@@ -0,0 +1,295 @@
+using PolyPilot.Services;
+
+namespace PolyPilot.Tests;
+
+[Collection("BaseDir")]
+public class SessionAnalyzerTests
+{
+    [Fact]
+    public void CollectDiagnostics_IncludesServerHealth()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), $"analyzer-test-{Guid.NewGuid()}");
+        Directory.CreateDirectory(tempDir);
+        try
+        {
+            SessionAnalyzerService.SetBaseDirForTesting(tempDir);
+
+            File.WriteAllText(
+                Path.Combine(tempDir, "event-diagnostics.log"),
+                "[SEND] 'TestSession' IsProcessing=true\n[COMPLETE] 'TestSession' done\n");
+
+            var copilotService = CreateService();
+            var serverManager = new TestServerManager { IsRunning = true, Pid = 12345, Port = 4321 };
+            var analyzer = new SessionAnalyzerService(copilotService, serverManager);
+
+            var diagnostics = analyzer.CollectDiagnostics();
+
+            Assert.Contains("Event Diagnostics", diagnostics);
+            Assert.Contains("[SEND]", diagnostics);
+            Assert.Contains("[COMPLETE]", diagnostics);
+            Assert.Contains("Server running: True", diagnostics);
+            Assert.Contains("12345", diagnostics);
+        }
+        finally
+        {
+            SessionAnalyzerService.SetBaseDirForTesting(TestSetup.TestBaseDir);
+            Directory.Delete(tempDir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public void CollectDiagnostics_IncludesCrashLog_WhenPresent()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), $"analyzer-test-{Guid.NewGuid()}");
+        Directory.CreateDirectory(tempDir);
+        try
+        {
+            SessionAnalyzerService.SetBaseDirForTesting(tempDir);
+
+            File.WriteAllText(
+                Path.Combine(tempDir, "crash.log"),
+                "=== 2026-04-18 ===\nSystem.Exception: test crash\n");
+
+            var copilotService = CreateService();
+            var serverManager = new TestServerManager();
+            var analyzer = new SessionAnalyzerService(copilotService, serverManager);
+
+            var diagnostics = analyzer.CollectDiagnostics();
+
+            Assert.Contains("Crash Log", diagnostics);
+            Assert.Contains("test crash", diagnostics);
+        }
+        finally
+        {
+            SessionAnalyzerService.SetBaseDirForTesting(TestSetup.TestBaseDir);
+            Directory.Delete(tempDir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public void CollectDiagnostics_HandlesEmptyLogs()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), $"analyzer-test-{Guid.NewGuid()}");
+        Directory.CreateDirectory(tempDir);
+        try
+        {
+            SessionAnalyzerService.SetBaseDirForTesting(tempDir);
+
+            var copilotService = CreateService();
+            var serverManager = new TestServerManager();
+            var analyzer = new SessionAnalyzerService(copilotService, serverManager);
+
+            var diagnostics = analyzer.CollectDiagnostics();
+
+            Assert.Contains("Active Session States", diagnostics);
+            Assert.Contains("Server Health", diagnostics);
+        }
+        finally
+        {
+            SessionAnalyzerService.SetBaseDirForTesting(TestSetup.TestBaseDir);
+            Directory.Delete(tempDir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public void BuildAnalysisPrompt_ContainsDiagnosticData()
+    {
+        var diagnostics = "## Test Data\nSome diagnostic info here";
+        var prompt = SessionAnalyzerService.BuildAnalysisPrompt(diagnostics);
+
+        Assert.Contains("PolyPilot Session Analyzer", prompt);
+        Assert.Contains("Stuck sessions", prompt);
+        Assert.Contains("Watchdog kills", prompt);
+        Assert.Contains("Test Data", prompt);
+        Assert.Contains("Some diagnostic info here", prompt);
+    }
+
+    [Fact]
+    public void BuildAnalysisPrompt_InstructsSingleBranchPrStrategy()
+    {
+        var prompt = SessionAnalyzerService.BuildAnalysisPrompt("data");
+
+        // Must instruct reuse of a single branch and PR
+        Assert.Contains("fix/session-analyzer-findings", prompt);
+        Assert.Contains("Always reuse the SAME branch", prompt);
+        Assert.Contains("Never create a new branch per finding", prompt);
+    }
+
+    [Fact]
+    public void Constants_HaveReasonableDefaults()
+    {
+        Assert.Equal(10, SessionAnalyzerService.DefaultAnalysisIntervalMinutes);
+        Assert.Equal(1, SessionAnalyzerService.MinAnalysisIntervalMinutes);
+        Assert.Equal(1440, SessionAnalyzerService.MaxAnalysisIntervalMinutes);
+        Assert.Equal(200, SessionAnalyzerService.DiagnosticLogTailLines);
+        Assert.Equal(50, SessionAnalyzerService.CrashLogTailLines);
+        Assert.Equal("PolyPilot Monitor", SessionAnalyzerService.AnalyzerSessionName);
+        Assert.Equal(10 * 1024 * 1024, SessionAnalyzerService.MaxLogFileSizeBytes);
+    }
+
+    [Fact]
+    public void IsRunning_FalseBeforeStart()
+    {
+        var copilotService = CreateService();
+        var serverManager = new TestServerManager();
+        var analyzer = new SessionAnalyzerService(copilotService, serverManager);
+
+        Assert.False(analyzer.IsRunning);
+        Assert.Null(analyzer.LastAnalysisAt);
+        Assert.Equal(0, analyzer.AnalysisCount);
+    }
+
+    [Fact]
+    public void Dispose_StopsAnalyzer()
+    {
+        var copilotService = CreateService();
+        var serverManager = new TestServerManager();
+        var analyzer = new SessionAnalyzerService(copilotService, serverManager);
+
+        analyzer.Dispose();
+        analyzer.Dispose(); // double dispose is safe
+        Assert.False(analyzer.IsRunning);
+    }
+
+    [Fact]
+    public async Task DisposeAsync_StopsAnalyzer()
+    {
+        var copilotService = CreateService();
+        var serverManager = new TestServerManager();
+        var analyzer = new SessionAnalyzerService(copilotService, serverManager);
+
+        await analyzer.DisposeAsync();
+        await analyzer.DisposeAsync(); // double dispose is safe
+        Assert.False(analyzer.IsRunning);
+    }
+
+    [Fact]
+    public async Task RunSingleAnalysis_ReturnsNull_WhenNoSessionCreated()
+    {
+        var copilotService = CreateService();
+        var serverManager = new TestServerManager();
+        var analyzer = new SessionAnalyzerService(copilotService, serverManager);
+
+        // _analyzerSessionName is null — no session was created
+        var result = await analyzer.RunSingleAnalysisAsync();
+        Assert.Null(result);
+        Assert.Equal(0, analyzer.AnalysisCount);
+    }
+
+    [Fact]
+    public void TailFile_CapsLargeFiles()
+    {
+        var tempFile = Path.GetTempFileName();
+        try
+        {
+            // Write a small file — TailFile should return last N lines
+            var lines = Enumerable.Range(1, 500).Select(i => $"line {i}").ToArray();
+            File.WriteAllLines(tempFile, lines);
+
+            var result = SessionAnalyzerService.TailFile(tempFile, 10);
+            Assert.Equal(10, result.Length);
+            Assert.Equal("line 491", result[0]);
+            Assert.Equal("line 500", result[9]);
+        }
+        finally
+        {
+            File.Delete(tempFile);
+        }
+    }
+
+    [Fact]
+    public void TailFile_HandlesSmallFile()
+    {
+        var tempFile = Path.GetTempFileName();
+        try
+        {
+            File.WriteAllLines(tempFile, new[] { "a", "b", "c" });
+            var result = SessionAnalyzerService.TailFile(tempFile, 10);
+            Assert.Equal(3, result.Length);
+        }
+        finally
+        {
+            File.Delete(tempFile);
+        }
+    }
+
+    [Fact]
+    public void TailFile_HandlesNonexistentFile()
+    {
+        var result = SessionAnalyzerService.TailFile("/nonexistent/path", 10);
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public void SessionAnalyzerIntervalMinutes_ClampsToMinimum()
+    {
+        var settings = new PolyPilot.Models.ConnectionSettings();
+
+        settings.SessionAnalyzerIntervalMinutes = 0;
+        Assert.Equal(1, settings.SessionAnalyzerIntervalMinutes);
+
+        settings.SessionAnalyzerIntervalMinutes = -5;
+        Assert.Equal(1, settings.SessionAnalyzerIntervalMinutes);
+
+        settings.SessionAnalyzerIntervalMinutes = 30;
+        Assert.Equal(30, settings.SessionAnalyzerIntervalMinutes);
+    }
+
+    [Fact]
+    public void SessionAnalyzerIntervalMinutes_ClampsToMaximum()
+    {
+        var settings = new PolyPilot.Models.ConnectionSettings();
+
+        settings.SessionAnalyzerIntervalMinutes = 2000;
+        Assert.Equal(1440, settings.SessionAnalyzerIntervalMinutes);
+
+        settings.SessionAnalyzerIntervalMinutes = int.MaxValue;
+        Assert.Equal(1440, settings.SessionAnalyzerIntervalMinutes);
+    }
+
+    [Fact]
+    public void BuildAnalysisPrompt_UsesAutopilotMode()
+    {
+        // The analyzer runs in autopilot so it can create/update PRs
+        var prompt = SessionAnalyzerService.BuildAnalysisPrompt("data");
+
+        Assert.Contains("Write the fix, run tests, commit", prompt);
+        Assert.Contains("open one with a clear title", prompt);
+    }
+
+    private static string GetTempDir() => Path.GetTempPath();
+
+    private static CopilotService CreateService()
+    {
+        var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection();
+        var serviceProvider = Microsoft.Extensions.DependencyInjection.ServiceCollectionContainerBuilderExtensions
+            .BuildServiceProvider(services);
+        return new CopilotService(
+            new StubChatDatabase(),
+            new StubServerManager(),
+            new StubWsBridgeClient(),
+            new RepoManager(),
+            serviceProvider,
+            new StubDemoService());
+    }
+
+    private class TestServerManager : IServerManager
+    {
+        public bool IsRunning { get; set; }
+        public int? Pid { get; set; }
+        public int Port { get; set; } = 4321;
+        public string? Error { get; set; }
+
+        bool IServerManager.IsServerRunning => IsRunning;
+        int? IServerManager.ServerPid => Pid;
+        int IServerManager.ServerPort => Port;
+        string? IServerManager.LastError => Error;
+
+        public event Action? OnStatusChanged;
+
+        public bool CheckServerRunning(string host = "127.0.0.1", int? port = null) => IsRunning;
+        public Task<bool> StartServerAsync(int port, string? githubToken = null) => Task.FromResult(true);
+        public void StopServer() { }
+        public bool DetectExistingServer() => IsRunning;
+    }
+}

PolyPilot.Tests/TestSetup.cs

@@ -36,5 +36,6 @@ internal static void Initialize()
         FiestaService.SetStateFilePathForTesting(Path.Combine(TestBaseDir, "fiesta.json"));
         ConnectionSettings.SetSettingsFilePathForTesting(Path.Combine(TestBaseDir, "settings.json"));
         ScheduledTaskService.SetTasksFilePathForTesting(Path.Combine(TestBaseDir, "scheduled-tasks.json"));
+        SessionAnalyzerService.SetBaseDirForTesting(TestBaseDir);
     }
 }

PolyPilot/Components/Pages/Settings.razor

@@ -536,6 +536,30 @@
         </div>
     }
 
+    @if (PlatformHelper.IsDesktop)
+    {
+        <div class="settings-section">
+            <div class="notifications-toggle">
+                <label class="toggle-label">
+                    <input type="checkbox" checked="@settings.EnableSessionAnalyzer"
+                           @onchange="ToggleSessionAnalyzer" />
+                    <span class="toggle-text">🔍 Session Analyzer</span>
+                </label>
+                <p class="toggle-hint">Background monitor that analyzes sessions for reliability issues and can auto-fix bugs via PR</p>
+            </div>
+            @if (settings.EnableSessionAnalyzer)
+            {
+                <div class="notifications-toggle" style="margin-left: 1.5em;">
+                    <label class="toggle-label">
+                        <span class="toggle-text">Analysis interval (minutes):</span>
+                        <input type="number" min="1" max="1440" value="@settings.SessionAnalyzerIntervalMinutes"
+                               @onchange="OnAnalyzerIntervalChanged" style="width: 5em; margin-left: 0.5em;" class="form-input" />
+                    </label>
+                </div>
+            }
+        </div>
+    }
+
     <div class="settings-section">
         <div class="save-row">
             <button class="save-btn" @onclick="SaveAndApply">
@@ -1398,6 +1422,29 @@
         SaveSettingsQuietly();
     }
 
+    private async Task ToggleSessionAnalyzer(ChangeEventArgs e)
+    {
+        settings.EnableSessionAnalyzer = e.Value is true;
+        settings.Save();
+        if (settings.EnableSessionAnalyzer)
+        {
+            CopilotService.StartSessionAnalyzerIfEnabled();
+        }
+        else
+        {
+            await CopilotService.StopSessionAnalyzerAsync();
+        }
+    }
+
+    private void OnAnalyzerIntervalChanged(ChangeEventArgs e)
+    {
+        if (int.TryParse(e.Value?.ToString(), out var val))
+        {
+            settings.SessionAnalyzerIntervalMinutes = val;
+            SaveSettingsQuietly();
+        }
+    }
+
     private void ToggleAutoUpdate()
     {
         if (GitAutoUpdate.IsEnabled)

PolyPilot/MauiProgram.cs

@@ -120,6 +120,7 @@ public static MauiApp CreateMauiApp()
 	builder.Services.AddSingleton<EfficiencyAnalysisService>();
 	builder.Services.AddSingleton<PrLinkService>();
 	builder.Services.AddSingleton<ScheduledTaskService>();
+	builder.Services.AddSingleton<SessionAnalyzerService>();
 
 #if DEBUG
 		builder.Services.AddBlazorWebViewDeveloperTools();