Refactor TODO/voice flows and add agent event notifications

Consolidate shared TODO prompt handling, add core agent SSE listener, wire Android/Windows system notifications, add simplified desktop voice tab, and update McpServer submodule.

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

Author: sharpninja

docs/todo.yaml

@@ -94,3 +94,11 @@ Features:
       done: true
     - task: Build and verify no compilation errors
       done: true
+DEPLOY-STATUS:
+  high-priority:
+  - id: deploy-status-20260302-1512z
+    title: APK Published and Verified at 20260302-1512Z
+    done: true
+    description:
+    - Pipeline run 22580481045 completed successfully.
+    - F-Droid index-v1.json resolves to McpServerManager-0.0.1-160.apk (versionCode 101) at https://sharpninja.github.io/McpServerManager/repo.

lib/McpServer

@@ -76,12 +76,14 @@ void OpenMainView(string mcpBaseUrl, string? mcpApiKey, string? bearerToken)
                         }
 
                         var clipboardService = new AndroidClipboardService();
-                        var vm = new MainWindowViewModel(clipboardService, mcpBaseUrl, mcpApiKey, bearerToken);
+                        var systemNotificationService = new AndroidSystemNotificationService();
+                        var vm = new MainWindowViewModel(clipboardService, mcpBaseUrl, mcpApiKey, bearerToken, systemNotificationService);
                         vm.SaveWorkspaceKey = AndroidConnectionPreferencesService.SaveWorkspaceKey;
                         vm.LoadWorkspaceKey = AndroidConnectionPreferencesService.LoadWorkspaceKey;
                         vm.LogoutRequested += (_, _) =>
                         {
                             _logger.LogInformation("Logout requested; clearing tokens and returning to connection dialog");
+                            connectionVm.LogoutCommand.Execute(null);
                             AndroidConnectionPreferencesService.ClearOidcJwt();
                             connectionVm.IsConnecting = false;
                             connectionVm.ErrorMessage = "";
@@ -145,6 +147,13 @@ private static void WireGlobalExceptionHandlers()
             StatusViewModel.Instance.AddStatus(ex?.ToString() ?? args.ExceptionObject?.ToString() ?? "Unknown unhandled exception");
         };
 
+        global::Android.Runtime.AndroidEnvironment.UnhandledExceptionRaiser += (_, args) =>
+        {
+            _logger.LogError(args.Exception, "Android Java unhandled exception");
+            StatusViewModel.Instance.AddStatus(args.Exception?.ToString() ?? "Unknown Android Java unhandled exception");
+            args.Handled = false;
+        };
+
         TaskScheduler.UnobservedTaskException += (_, args) =>
         {
             _logger.LogError(args.Exception, "Unobserved task exception");

src/McpServerManager.Android/App.axaml.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Android.App;
+using Android.Content;
+using Android.Content.PM;
+using Android.OS;
+using Microsoft.Extensions.Logging;
+using McpServerManager.Core.Models;
+using McpServerManager.Core.Services;
+
+namespace McpServerManager.Android.Services;
+
+/// <summary>
+/// Android implementation for posting actionable agent event notifications.
+/// </summary>
+public sealed class AndroidSystemNotificationService : ISystemNotificationService
+{
+    private const string ChannelId = "mcp_agent_events";
+    private const int LaunchRequestCode = 43001;
+    private static int _nextNotificationId = 43000;
+
+    private static readonly ILogger _logger = AppLogService.Instance.CreateLogger("AndroidSystemNotificationService");
+
+    public async Task NotifyAgentEventAsync(
+        McpIncomingChangeEvent changeEvent,
+        string message,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(changeEvent);
+
+        var notificationMessage = string.IsNullOrWhiteSpace(message)
+            ? "Agent event received."
+            : message.Trim();
+
+        try
+        {
+            var context = Application.Context;
+            if (context == null)
+            {
+                _logger.LogWarning("Skipping agent event notification: Android application context is null.");
+                return;
+            }
+
+            if (!await EnsureNotificationPermissionAsync(context, cancellationToken).ConfigureAwait(false))
+                return;
+
+            var manager = context.GetSystemService(Context.NotificationService) as NotificationManager;
+            if (manager == null)
+            {
+                _logger.LogWarning("Skipping agent event notification: NotificationManager unavailable.");
+                return;
+            }
+
+            EnsureChannel(manager);
+
+            var builder = new Notification.Builder(context)
+                .SetSmallIcon(global::Android.Resource.Drawable.IcDialogInfo)
+                .SetContentTitle("Request Tracker")
+                .SetContentText(notificationMessage)
+                .SetStyle(new Notification.BigTextStyle().BigText(notificationMessage))
+                .SetAutoCancel(true)
+                .SetWhen(Java.Lang.JavaSystem.CurrentTimeMillis())
+                .SetPriority((int)NotificationPriority.Default);
+
+            var launchPendingIntent = CreateLaunchPendingIntent(context);
+            if (launchPendingIntent != null)
+                builder.SetContentIntent(launchPendingIntent);
+
+            if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
+                builder.SetChannelId(ChannelId);
+
+            manager.Notify(Interlocked.Increment(ref _nextNotificationId), builder.Build());
+        }
+        catch (System.OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to post agent event notification.");
+        }
+    }
+
+    private static async Task<bool> EnsureNotificationPermissionAsync(Context context, CancellationToken cancellationToken)
+    {
+        if ((int)Build.VERSION.SdkInt < (int)BuildVersionCodes.Tiramisu)
+            return true;
+
+        if (context.CheckSelfPermission(global::Android.Manifest.Permission.PostNotifications) == Permission.Granted)
+            return true;
+
+        var activity = AndroidActivityHost.TryGetCurrentActivity();
+        if (activity == null)
+        {
+            _logger.LogDebug("Skipping agent event notification: no activity available to request POST_NOTIFICATIONS.");
+            return false;
+        }
+
+        try
+        {
+            var granted = await AndroidActivityHost
+                .RequestPostNotificationsPermissionAsync(activity, cancellationToken)
+                .ConfigureAwait(false);
+
+            if (!granted)
+                _logger.LogDebug("Skipping agent event notification: POST_NOTIFICATIONS permission denied.");
+
+            return granted;
+        }
+        catch (System.OperationCanceledException)
+        {
+            return false;
+        }
+    }
+
+    private static PendingIntent? CreateLaunchPendingIntent(Context context)
+    {
+        var packageName = context.PackageName;
+        if (string.IsNullOrWhiteSpace(packageName))
+            return null;
+
+        var launchIntent = context.PackageManager?.GetLaunchIntentForPackage(packageName);
+        if (launchIntent == null)
+            return null;
+
+        launchIntent.AddFlags(
+            ActivityFlags.NewTask |
+            ActivityFlags.SingleTop |
+            ActivityFlags.ClearTop |
+            ActivityFlags.ReorderToFront);
+
+        var flags = PendingIntentFlags.UpdateCurrent;
+        if (Build.VERSION.SdkInt >= BuildVersionCodes.M)
+            flags |= PendingIntentFlags.Immutable;
+
+        return PendingIntent.GetActivity(context, LaunchRequestCode, launchIntent, flags);
+    }
+
+    private static void EnsureChannel(NotificationManager manager)
+    {
+        if (Build.VERSION.SdkInt < BuildVersionCodes.O)
+            return;
+
+        if (manager.GetNotificationChannel(ChannelId) != null)
+            return;
+
+        var channel = new NotificationChannel(
+            ChannelId,
+            "Agent Events",
+            NotificationImportance.Default)
+        {
+            Description = "Notifications for actionable agent events."
+        };
+
+        manager.CreateNotificationChannel(channel);
+    }
+}

src/McpServerManager.Android/Services/AndroidSystemNotificationService.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace McpServerManager.Core.Models;
+
+/// <summary>
+/// Incoming change event payload emitted by <c>/mcpserver/events</c>.
+/// Includes extension data for forward-compatible fields.
+/// </summary>
+public sealed record McpIncomingChangeEvent
+{
+    [JsonPropertyName("category")]
+    public string? Category { get; init; }
+
+    [JsonPropertyName("action")]
+    public string? Action { get; init; }
+
+    [JsonPropertyName("entityId")]
+    public string? EntityId { get; init; }
+
+    [JsonPropertyName("resourceUri")]
+    public string? ResourceUri { get; init; }
+
+    [JsonPropertyName("timestamp")]
+    public DateTimeOffset? Timestamp { get; init; }
+
+    [JsonPropertyName("agentId")]
+    public string? AgentId { get; init; }
+
+    [JsonPropertyName("eventType")]
+    public string? EventType { get; init; }
+
+    [JsonPropertyName("status")]
+    public string? Status { get; init; }
+
+    [JsonPropertyName("workspacePath")]
+    public string? WorkspacePath { get; init; }
+
+    [JsonPropertyName("message")]
+    public string? Message { get; init; }
+
+    /// <summary>SSE event name from the <c>event:</c> line when provided.</summary>
+    [JsonIgnore]
+    public string? SseEvent { get; init; }
+
+    [JsonExtensionData]
+    public IDictionary<string, JsonElement>? ExtensionData { get; init; }
+}

src/McpServerManager.Core/Models/McpChangeEventContracts.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using McpServerManager.Core.Models;
+
+namespace McpServerManager.Core.Services;
+
+/// <summary>
+/// Abstraction for delivering system-level notifications from actionable agent events.
+/// </summary>
+public interface ISystemNotificationService
+{
+    /// <summary>
+    /// Notifies the user about an actionable agent event.
+    /// </summary>
+    Task NotifyAgentEventAsync(
+        McpIncomingChangeEvent changeEvent,
+        string message,
+        CancellationToken cancellationToken = default);
+}
+
+/// <summary>
+/// Default no-op notification service when a platform implementation is not provided.
+/// </summary>
+public sealed class NoOpSystemNotificationService : ISystemNotificationService
+{
+    public static NoOpSystemNotificationService Instance { get; } = new();
+
+    private NoOpSystemNotificationService()
+    {
+    }
+
+    public Task NotifyAgentEventAsync(
+        McpIncomingChangeEvent changeEvent,
+        string message,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(changeEvent);
+        return Task.CompletedTask;
+    }
+}