fix: accumulate tool progress into existing activity log bubbles

Non-final replies now append to the source's activity log bubble instead
of creating a new bubble per message. Activity logs are keyed by
category + agentName so multiple concurrent sources (primary, subagent-X,
scheduled-system) each accumulate into their own bubble.

BlazorUserFrontend routes non-final DisplayReplyAsync calls through
AppendActivityLogEntry. Activity log headers now show category badge,
agent name, and entry count.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: rockfordlhotka

src/RockBot.UserProxy.Blazor/Pages/Chat.razor

@@ -28,15 +28,24 @@
             {
                 <!-- Activity log bubble: collapsed one-liner with spinner, expandable to full log -->
                 <div class="message-wrapper mb-3 agent-message">
-                    <div class="message-bubble activity-log-bubble p-2 rounded @(message.IsExpanded ? "expanded" : "collapsed")"
+                    <div class="message-bubble activity-log-bubble p-2 rounded category-@message.Category.ToString().ToLowerInvariant() @(message.IsExpanded ? "expanded" : "collapsed")"
                          @onclick="() => ChatState.ToggleExpanded(message.MessageId)">
                         <div class="activity-log-header">
                             <span class="chevron-indicator @(message.IsExpanded ? "open" : "")">&#9654;</span>
                             @if (ChatState.IsProcessing)
                             {
                                 <span class="spinner-border spinner-border-sm me-1" role="status" aria-hidden="true"></span>
                             }
-                            <span class="activity-log-summary">@TruncateText(message.Content, 100)</span>
+                            @if (message.Category != MessageCategory.PrimaryProgress)
+                            {
+                                <span class="category-badge">@GetCategoryLabel(message.Category)</span>
+                            }
+                            @if (!string.IsNullOrEmpty(message.AgentName))
+                            {
+                                <span class="collapsible-agent-name">@message.AgentName</span>
+                            }
+                            <span class="activity-log-summary">@TruncateText(message.Content, 80)</span>
+                            <span class="activity-log-count">(@(message.ActivityLogEntries.Count))</span>
                         </div>
                         @if (message.IsExpanded)
                         {

src/RockBot.UserProxy.Blazor/Services/BlazorUserFrontend.cs

@@ -17,10 +17,9 @@ public Task DisplayReplyAsync(AgentReply reply, CancellationToken cancellationTo
         }
         else
         {
-            // Intermediate progress — update thinking indicator AND add a bubble so
-            // all agent traffic is visible for debugging.
-            chatState.SetThinkingMessage(reply.Content);
-            chatState.AddAgentReply(reply, category);
+            // Non-final progress — append to the source's activity log bubble
+            // instead of creating a separate bubble per message
+            chatState.AppendActivityLogEntry(reply.Content, category, reply.AgentName);
         }
         return Task.CompletedTask;
     }
@@ -40,7 +39,7 @@ private static MessageCategory CategorizeReply(AgentReply reply)
             return MessageCategory.ScheduledUser;
 
         if (reply.AgentName?.StartsWith("subagent-", StringComparison.OrdinalIgnoreCase) == true)
-            return reply.IsFinal ? MessageCategory.SubagentActivity : MessageCategory.SubagentActivity;
+            return MessageCategory.SubagentActivity;
 
         if (reply.IsFinal)
             return MessageCategory.PrimaryFinal;

src/RockBot.UserProxy.Blazor/Services/ChatStateService.cs

@@ -23,7 +23,12 @@ public sealed class ChatStateService
     private readonly object _lock = new();
     private string? _currentThinkingMessage;
     private bool _isProcessing;
-    private string? _activeActivityLogId;
+
+    /// <summary>
+    /// Active activity log bubbles keyed by source key (category + agentName).
+    /// Multiple sources can accumulate concurrently (e.g. primary + subagent).
+    /// </summary>
+    private readonly Dictionary<string, string> _activeActivityLogs = new();
 
     public event Action? OnStateChanged;
 
@@ -79,9 +84,9 @@ public void AddAgentReply(AgentReply reply, MessageCategory category = MessageCa
     {
         lock (_lock)
         {
-            // When a PrimaryFinal message arrives, close any active activity log
+            // When a PrimaryFinal message arrives, close the primary activity log
             if (category == MessageCategory.PrimaryFinal)
-                _activeActivityLogId = null;
+                _activeActivityLogs.Remove(ActivityLogKey(MessageCategory.PrimaryProgress, null));
 
             _messages.Add(new ChatMessage
             {
@@ -103,16 +108,22 @@ or MessageCategory.Error
     }
 
     /// <summary>
-    /// Appends an entry to the active WIP activity log bubble. Creates the bubble
-    /// if one doesn't exist yet for the current processing cycle.
+    /// Appends an entry to an activity log bubble for the given source.
+    /// Creates the bubble if one doesn't exist yet. Multiple concurrent sources
+    /// (primary, subagent-X, scheduled-system) each get their own activity log.
     /// </summary>
-    public void AppendActivityLogEntry(string content)
+    public void AppendActivityLogEntry(
+        string content,
+        MessageCategory category = MessageCategory.PrimaryProgress,
+        string? agentName = null)
     {
         lock (_lock)
         {
+            var key = ActivityLogKey(category, agentName);
+
             ChatMessage? logBubble = null;
-            if (_activeActivityLogId is not null)
-                logBubble = _messages.FirstOrDefault(m => m.MessageId == _activeActivityLogId);
+            if (_activeActivityLogs.TryGetValue(key, out var logId))
+                logBubble = _messages.FirstOrDefault(m => m.MessageId == logId);
 
             if (logBubble is null)
             {
@@ -121,12 +132,13 @@ public void AppendActivityLogEntry(string content)
                     Content = content,
                     IsFromUser = false,
                     Timestamp = DateTime.UtcNow,
-                    Category = MessageCategory.PrimaryProgress,
+                    AgentName = agentName,
+                    Category = category,
                     IsActivityLog = true,
                     IsExpanded = false
                 };
                 _messages.Add(logBubble);
-                _activeActivityLogId = logBubble.MessageId;
+                _activeActivityLogs[key] = logBubble.MessageId;
             }
 
             logBubble.ActivityLogEntries.Add(new ActivityLogEntry(content, DateTime.UtcNow));
@@ -177,7 +189,7 @@ public void SetProcessing(bool isProcessing)
         if (isProcessing)
         {
             _currentThinkingMessage = null;
-            _activeActivityLogId = null;
+            _activeActivityLogs.Clear();
         }
         NotifyStateChanged();
     }
@@ -197,6 +209,9 @@ public void AddError(string message)
         NotifyStateChanged();
     }
 
+    private static string ActivityLogKey(MessageCategory category, string? agentName)
+        => $"{category}:{agentName ?? ""}";
+
     private void NotifyStateChanged() => OnStateChanged?.Invoke();
 }
 

src/RockBot.UserProxy.Blazor/wwwroot/css/app.css

@@ -342,6 +342,12 @@ body.dark-mode .btn-feedback:hover:not(:disabled) {
     flex: 1;
 }
 
+.activity-log-count {
+    flex-shrink: 0;
+    font-size: 0.75rem;
+    color: #9ca3af;
+}
+
 .activity-log-entries {
     margin-top: 0.5rem;
     padding-top: 0.5rem;
@@ -491,6 +497,10 @@ body.dark-mode .entry-time {
     color: #6b7280;
 }
 
+body.dark-mode .activity-log-count {
+    color: #6b7280;
+}
+
 /* ── Dark mode: collapsible bubbles ──────────────────────────────────── */
 
 body.dark-mode .collapsible-bubble {