Simplify session status presentation (#1057)

* feat: simplify session status presentation

* test: preserve session presentation priority

* test: pin active session run field

* test: align chat threads with session run state

* test: seed session status UI fixture

* test: add background session to UI fixture

* fix: retain session run state

* fix: update session fixture for flattened fields

* fix: preserve localized resource nodes

* fix: align chat activity with run liveness

Author: RomneyDa

docs/MISSION_CONTROL.md

@@ -469,7 +469,7 @@ Recent native chat behavior implemented during this phase:
 
 - Queued-message UI tracks local send state (`Queued`, `Sending`, `Failed`) until the gateway confirms or rejects the turn.
 - Timeline virtualization keeps long chat histories responsive while preserving stable render identity for visible entries.
-- Completed sessions are hidden by default in the native chat session list, with active/in-progress sessions surfaced first.
+- The Sessions page hides only successful completed runs by default; reusable sessions remain available in the native chat picker, with working sessions surfaced first.
 - TTS notification speech preserves full assistant text while UI preview truncation remains visual-only.
 - Slash-command suggestions use the gateway command catalog grouped into Mac-compatible command buckets.
 - Local MCP chat automation exposes `app.chat.snapshot`, `app.chat.send`, and `app.chat.reset` for current-thread inspection, send, and reset flows.

src/OpenClaw.Shared/Models.cs

@@ -302,6 +302,11 @@ public SessionInfo Clone()
     public string? VerboseLevel { get; set; }
     public bool SystemSent { get; set; }
     public bool AbortedLastRun { get; set; }
+    /// <summary>
+    /// Gateway-provided liveness for the session's current run. Null means an
+    /// older Gateway did not provide the field, so callers may use legacy status.
+    /// </summary>
+    public bool? HasActiveRun { get; set; }
     public long InputTokens { get; set; }
     public long OutputTokens { get; set; }
     public long TotalTokens { get; set; }

src/OpenClaw.Shared/OpenClawGatewayClient.cs

@@ -3813,7 +3813,15 @@ private void UpdateSessionMainStatus(SessionInfo session, string sessionKey, Jso
     private void PopulateSessionFromObject(SessionInfo session, JsonElement item)
     {
         if (item.TryGetProperty("status", out var status))
-            session.Status = status.GetString() ?? "active";
+            session.Status = status.ValueKind == JsonValueKind.String
+                ? status.GetString() ?? "unknown"
+                : "unknown";
+        if (item.TryGetProperty("hasActiveRun", out var hasActiveRun))
+        {
+            session.HasActiveRun = hasActiveRun.ValueKind is JsonValueKind.True or JsonValueKind.False
+                ? hasActiveRun.GetBoolean()
+                : null;
+        }
         if (item.TryGetProperty("model", out var model))
         {
             var newModel = model.GetString();

src/OpenClaw.Shared/Sessions/SessionRunState.cs

@@ -0,0 +1,82 @@
+using OpenClaw.Shared;
+
+namespace OpenClaw.Shared.Sessions;
+
+/// <summary>
+/// Canonical interpretation of the Gateway's latest-run outcome and live-run flag.
+/// Keep this separate from presentation: the Gateway records outcomes per run, while a
+/// session remains available for a later turn after that run finishes.
+/// </summary>
+public enum SessionRunStatus
+{
+    Unknown,
+    Running,
+    Completed,
+    Failed,
+    Stopped,
+    TimedOut,
+}
+
+/// <summary>The intentionally small set of session states shown by the Windows app.</summary>
+public enum SessionDisplayState
+{
+    Working,
+    Ready,
+    NeedsAttention,
+}
+
+public static class SessionRunState
+{
+    public static SessionRunStatus ResolveStatus(string? status) => status?.Trim().ToLowerInvariant() switch
+    {
+        "active" or "running" => SessionRunStatus.Running,
+        "done" or "completed" => SessionRunStatus.Completed,
+        "error" or "failed" or "failure" => SessionRunStatus.Failed,
+        "killed" or "aborted" or "cancelled" or "canceled" => SessionRunStatus.Stopped,
+        "timeout" or "timed_out" => SessionRunStatus.TimedOut,
+        _ => SessionRunStatus.Unknown,
+    };
+
+    /// <summary>
+    /// The Gateway's current-run flag is authoritative when present. Older Gateways
+    /// omit it, so only those payloads fall back to the latest recorded outcome.
+    /// </summary>
+    public static bool IsWorking(SessionInfo session)
+    {
+        if (session.HasActiveRun is { } hasActiveRun)
+            return hasActiveRun;
+
+        return ResolveStatus(session.Status) == SessionRunStatus.Running;
+    }
+
+    public static SessionDisplayState GetDisplayState(SessionInfo session)
+    {
+        if (IsWorking(session))
+            return SessionDisplayState.Working;
+
+        return ResolveStatus(session.Status) is SessionRunStatus.Failed or SessionRunStatus.TimedOut
+            ? SessionDisplayState.NeedsAttention
+            : SessionDisplayState.Ready;
+    }
+
+    /// <summary>Stable priority for compact lists: live work, attention, then ready sessions.</summary>
+    public static int GetDisplaySortOrder(SessionInfo session) => GetDisplayState(session) switch
+    {
+        SessionDisplayState.Working => 0,
+        SessionDisplayState.NeedsAttention => 1,
+        _ => 2,
+    };
+
+    /// <summary>Successful completed runs may be hidden from the compact session list.</summary>
+    public static bool IsCompleted(SessionInfo session) =>
+        !IsWorking(session)
+        && !session.AbortedLastRun
+        && ResolveStatus(session.Status) == SessionRunStatus.Completed;
+
+    /// <summary>
+    /// A stopped run is useful context in a row or transcript, but is not a
+    /// fourth primary session status: the session is still ready for another turn.
+    /// </summary>
+    public static bool HasStoppedLastRun(SessionInfo session) =>
+        session.AbortedLastRun || ResolveStatus(session.Status) == SessionRunStatus.Stopped;
+}

src/OpenClaw.Tray.WinUI/Chat/OpenClawChatDataProvider.cs

@@ -6261,7 +6261,7 @@ private static ChatThread ToThread(SessionInfo s, string title)
             AgentId = display.AgentId,
             IsBackground = display.IsBackground,
             Status = SessionVisibilityFilter.ToChatThreadStatus(s),
-            Activity = string.IsNullOrEmpty(s.CurrentActivity) ? ChatActivity.Idle : ChatActivity.Working,
+            Activity = SessionVisibilityFilter.ToChatThreadActivity(s),
             Workspace = s.Channel,
             Model = s.Model,
             ModelProvider = s.Provider,

src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs

@@ -6,6 +6,7 @@
 using Microsoft.UI.Xaml.Media;
 using OpenClaw.Connection;
 using OpenClaw.Shared;
+using OpenClaw.Shared.Sessions;
 using OpenClawTray.Helpers;
 using OpenClawTray.Services;
 using System;
@@ -730,9 +731,7 @@ private void ApplyOperatorCard(ConnectionPagePlan plan)
         // Status sub-row (mirrors PermissionsPage NodeStatusDot pattern):
         // colored dot + descriptive label that reflects the live state.
         var sessions = _appState?.Sessions;
-        int activeSessions = sessions?.Count(s =>
-            string.Equals(s.Status, "active", StringComparison.OrdinalIgnoreCase) ||
-            string.Equals(s.Status, "running", StringComparison.OrdinalIgnoreCase)) ?? 0;
+        int activeSessions = sessions?.Count(SessionRunState.IsWorking) ?? 0;
 
         var (statusGlyph, statusBrushKey, statusText) = plan.OperatorCard switch
         {

src/OpenClaw.Tray.WinUI/Pages/SessionsPage.xaml

@@ -35,7 +35,7 @@
                     </SelectorBar>
 
                     <ToggleSwitch x:Uid="SessionsPage_ShowCompleted" x:Name="ShowCompletedToggle" Grid.Column="1"
-                                  Header="Show ended"
+                                  Header="Show completed"
                                   MinWidth="0"
                                   OnContent="" OffContent=""
                                   Toggled="OnShowCompletedToggled"
@@ -97,7 +97,7 @@
                                   HorizontalAlignment="Center"
                                   Foreground="{ThemeResource TextFillColorTertiaryBrush}"/>
                         <TextBlock x:Uid="SessionsPage_NoActiveSessions"
-                                   Text="No active sessions"
+                                   Text="No sessions"
                                    Style="{StaticResource BodyStrongTextBlockStyle}"
                                    HorizontalAlignment="Center"/>
                         <TextBlock x:Uid="SessionsPage_EmptyHint" Text="Sessions appear here when a channel is connected and traffic is flowing."
@@ -142,6 +142,10 @@
                                                      VerticalAlignment="Center"
                                                      Fill="{Binding StatusBrush}"
                                                      ToolTipService.ToolTip="{Binding StatusTooltip}"/>
+                                            <TextBlock Text="{Binding StatusText}"
+                                                       Style="{StaticResource CaptionTextBlockStyle}"
+                                                       Foreground="{ThemeResource TextFillColorSecondaryBrush}"
+                                                       VerticalAlignment="Center"/>
                                             <TextBlock Text="{Binding DisplayName}"
                                                        Style="{StaticResource BodyStrongTextBlockStyle}"
                                                        TextTrimming="CharacterEllipsis"

src/OpenClaw.Tray.WinUI/Pages/SessionsPage.xaml.cs

@@ -73,16 +73,56 @@ public void Initialize()
                     Key = "agent:main:main",
                     IsMain = true,
                     Status = "active",
+                    HasActiveRun = true,
                     DisplayName = "OpenClaw Windows Tray",
                     UpdatedAt = DateTime.UtcNow,
                 },
                 new SessionInfo
                 {
                     Key = "agent:main:fork",
-                    Status = "active",
+                    Status = "running",
+                    HasActiveRun = false,
                     DisplayName = "OpenClaw Windows Tray",
                     UpdatedAt = DateTime.UtcNow.AddSeconds(-1),
                 },
+                new SessionInfo
+                {
+                    Key = "agent:main:deploy-migration",
+                    Status = "failed",
+                    DisplayName = "Deploy migration",
+                    UpdatedAt = DateTime.UtcNow.AddMinutes(-2),
+                },
+                new SessionInfo
+                {
+                    Key = "agent:main:research-labels",
+                    Status = "timeout",
+                    DisplayName = "Research status labels",
+                    UpdatedAt = DateTime.UtcNow.AddMinutes(-4),
+                },
+                new SessionInfo
+                {
+                    Key = "agent:main:release-notes",
+                    Status = "killed",
+                    DisplayName = "Draft release notes",
+                    UpdatedAt = DateTime.UtcNow.AddMinutes(-6),
+                },
+                new SessionInfo
+                {
+                    Key = "agent:main:cron:nightly-cleanup",
+                    Status = "active",
+                    HasActiveRun = true,
+                    DisplayName = "Nightly cleanup",
+                    Classification = "cron",
+                    IsBackground = true,
+                    UpdatedAt = DateTime.UtcNow.AddMinutes(-7),
+                },
+                new SessionInfo
+                {
+                    Key = "agent:main:completed-cleanup",
+                    Status = "done",
+                    DisplayName = "Completed cleanup",
+                    UpdatedAt = DateTime.UtcNow.AddMinutes(-8),
+                },
             ]);
             return;
         }
@@ -186,12 +226,12 @@ private void ApplyFilter()
             return;
         }
 
-        var activeSessions = SessionVisibilityFilter.VisibleSessions(
+        var visibleSessions = SessionVisibilityFilter.VisibleSessions(
                 SessionsForCurrentBackgroundScope(),
                 ShowCompletedSessions)
             .ToList();
-        var activeTitles = SessionTitleFormatter.FormatUnique(activeSessions);
-        IEnumerable<(SessionInfo Session, string Title)> filtered = activeSessions
+        var activeTitles = SessionTitleFormatter.FormatUnique(visibleSessions);
+        IEnumerable<(SessionInfo Session, string Title)> filtered = visibleSessions
             .Select((session, index) => (Session: session, Title: activeTitles[index]));
 
         if (_activeChannel != "all")
@@ -201,7 +241,8 @@ private void ApplyFilter()
         }
 
         var viewModels = filtered
-            .OrderByDescending(item => item.Session.UpdatedAt ?? item.Session.LastSeen)
+            .OrderBy(item => SessionRunState.GetDisplaySortOrder(item.Session))
+            .ThenByDescending(item => item.Session.UpdatedAt ?? item.Session.LastSeen)
             .Select(item => ToViewModel(item.Session, item.Title))
             .ToList();
 
@@ -272,12 +313,14 @@ private void OnAppStateChanged(object? sender, PropertyChangedEventArgs e)
     private SessionViewModel ToViewModel(SessionInfo s, string displayName)
     {
         var subtitle = SessionTitleFormatter.FormatSubtitle(s);
-        var parts = new List<string>(4);
+        var parts = new List<string>(5);
         if (!string.IsNullOrWhiteSpace(subtitle)) parts.Add(subtitle!);
         if (!string.IsNullOrWhiteSpace(s.Provider)) parts.Add(s.Provider!);
         if (!string.IsNullOrWhiteSpace(s.Model)) parts.Add(s.Model!);
         if (string.IsNullOrWhiteSpace(subtitle) && !string.IsNullOrWhiteSpace(s.Channel))
             parts.Add(s.Channel!);
+        if (SessionRunState.HasStoppedLastRun(s))
+            parts.Add(LocalizationHelper.GetString("SessionsPage_LastRunStopped"));
 
         var hasTokens = s.InputTokens > 0 || s.OutputTokens > 0;
         var tokensText = hasTokens
@@ -303,7 +346,8 @@ private SessionViewModel ToViewModel(SessionInfo s, string displayName)
             AgeText = s.AgeText,
             DetailLine = parts.Count > 0 ? string.Join(" · ", parts) : "",
             StatusBrush = ResolveStatusBrush(s),
-            StatusTooltip = ResolveStatusTooltip(s),
+            StatusText = ResolveStatusText(s),
+            StatusTooltip = ResolveStatusText(s),
             TokensText = tokensText,
             ContextPercent = contextPercent,
             HasTokenData = hasTokens || contextPercent > 0,
@@ -315,23 +359,22 @@ private SessionViewModel ToViewModel(SessionInfo s, string displayName)
 
     private static Brush ResolveStatusBrush(SessionInfo s)
     {
-        var status = s.Status?.Trim().ToLowerInvariant();
-        if (status is "error" or "failed" or "failure")
-            return s_criticalBrush.Value;
-        if (s.AbortedLastRun)
-            return s_cautionBrush.Value;
-        if (status is "active" or "running")
-            return s_successBrush.Value;
-        return s_neutralBrush.Value;
+        return SessionRunState.GetDisplayState(s) switch
+        {
+            SessionDisplayState.Working => s_successBrush.Value,
+            SessionDisplayState.NeedsAttention => s_criticalBrush.Value,
+            _ => s_neutralBrush.Value,
+        };
     }
 
-    private static string ResolveStatusTooltip(SessionInfo s)
+    private static string ResolveStatusText(SessionInfo s)
     {
-        var status = s.Status?.Trim().ToLowerInvariant();
-        if (status is "error" or "failed" or "failure") return "Error";
-        if (s.AbortedLastRun) return "Aborted last run";
-        if (status is "active" or "running") return "Running";
-        return "Idle";
+        return SessionRunState.GetDisplayState(s) switch
+        {
+            SessionDisplayState.Working => LocalizationHelper.GetString("SessionsPage_Status_Working"),
+            SessionDisplayState.NeedsAttention => LocalizationHelper.GetString("SessionsPage_Status_NeedsAttention"),
+            _ => LocalizationHelper.GetString("SessionsPage_Status_Ready"),
+        };
     }
 
     private static readonly Lazy<Brush> s_successBrush =
@@ -701,7 +744,8 @@ public class SessionViewModel
     public string AgeText { get; set; } = "";
     public string DetailLine { get; set; } = "";
     public Brush StatusBrush { get; set; } = new SolidColorBrush(Colors.Gray);
-    public string StatusTooltip { get; set; } = "Idle";
+    public string StatusText { get; set; } = "Ready";
+    public string StatusTooltip { get; set; } = "Ready";
     public string TokensText { get; set; } = "";
     public double ContextPercent { get; set; }
     public bool HasTokenData { get; set; }

src/OpenClaw.Tray.WinUI/Services/SessionVisibilityFilter.cs

@@ -1,31 +1,24 @@
 using OpenClaw.Chat;
 using OpenClaw.Shared;
+using OpenClaw.Shared.Sessions;
 
 namespace OpenClawTray.Services;
 
 public static class SessionVisibilityFilter
 {
-    public static IEnumerable<SessionInfo> VisibleSessions(IEnumerable<SessionInfo> sessions, bool showEnded)
-        => showEnded ? sessions : sessions.Where(IsVisibleWhenEndedHidden);
+    public static IEnumerable<SessionInfo> VisibleSessions(IEnumerable<SessionInfo> sessions, bool showCompleted)
+        => showCompleted ? sessions : sessions.Where(IsVisibleWhenCompletedHidden);
 
-    public static bool IsVisibleWhenEndedHidden(SessionInfo session)
-        => !IsEnded(session);
+    public static bool IsVisibleWhenCompletedHidden(SessionInfo session)
+        => !IsCompleted(session);
 
-    public static bool IsEnded(SessionInfo session)
-    {
-        if (session.AbortedLastRun)
-            return false;
-
-        var status = session.Status?.Trim();
-        return string.Equals(status, "done", StringComparison.OrdinalIgnoreCase)
-            || string.Equals(status, "completed", StringComparison.OrdinalIgnoreCase)
-            || string.Equals(status, "failed", StringComparison.OrdinalIgnoreCase)
-            || string.Equals(status, "killed", StringComparison.OrdinalIgnoreCase)
-            || string.Equals(status, "timeout", StringComparison.OrdinalIgnoreCase);
-    }
+    public static bool IsCompleted(SessionInfo session) => SessionRunState.IsCompleted(session);
 
     public static ChatThreadStatus ToChatThreadStatus(SessionInfo session)
-        => IsEnded(session) ? ChatThreadStatus.Ended : ChatThreadStatus.Running;
+        => SessionRunState.IsWorking(session) ? ChatThreadStatus.Running : ChatThreadStatus.Created;
+
+    public static ChatActivity ToChatThreadActivity(SessionInfo session)
+        => SessionRunState.IsWorking(session) ? ChatActivity.Working : ChatActivity.Idle;
 
     public static IEnumerable<ChatThread> VisibleChatPickerThreads(
         IEnumerable<ChatThread> threads,