feat: collapsible message bubbles with per-tool activity logging

src/RockBot.A2A/A2ATaskErrorHandler.cs

@@ -81,6 +81,13 @@ await conversationMemory.AddTurnAsync(
 
         try
         {
+            using var progressCtx = ToolProgressNotifier.SetContext(new ToolProgressContext
+            {
+                SessionId = pending.PrimarySessionId,
+                AgentName = agent.Name,
+                ReplyTo = UserProxyTopics.UserResponse
+            });
+
             var finalContent = await agentLoopRunner.RunAsync(
                 chatMessages, chatOptions, pending.PrimarySessionId,
                 enableFollowUp: false, cancellationToken: ct);

src/RockBot.A2A/A2ATaskResultHandler.cs

@@ -28,7 +28,7 @@
     ToolGuideTools toolGuideTools,
     IConversationMemory conversationMemory,
     A2ATaskTracker tracker,
     ModelBehavior modelBehavior,
     ILogger<A2ATaskResultHandler> logger) : IMessageHandler<AgentTaskResult>
 {
     public async Task HandleAsync(AgentTaskResult result, MessageHandlerContext context)
@@ -151,6 +151,13 @@
 
         try
         {
+            using var progressCtx = ToolProgressNotifier.SetContext(new ToolProgressContext
+            {
+                SessionId = rawSessionId,
+                AgentName = agent.Name,
+                ReplyTo = UserProxyTopics.UserResponse
+            });
+
             var finalContent = await agentLoopRunner.RunAsync(
                 chatMessages, chatOptions, rawSessionId,
                 enableFollowUp: false, cancellationToken: ct);

src/RockBot.A2A/A2ATaskStatusHandler.cs

@@ -100,6 +100,13 @@ await conversationMemory.AddTurnAsync(
 
         try
         {
+            using var progressCtx = ToolProgressNotifier.SetContext(new ToolProgressContext
+            {
+                SessionId = pending.PrimarySessionId,
+                AgentName = agent.Name,
+                ReplyTo = UserProxyTopics.UserResponse
+            });
+
             var finalContent = await agentLoopRunner.RunAsync(
                 chatMessages, chatOptions, pending.PrimarySessionId,
                 enableFollowUp: false, cancellationToken: ct);

src/RockBot.Agent/ScheduledTaskHandler.cs

@@ -93,12 +93,21 @@ public async Task HandleAsync(ScheduledTaskMessage message, MessageHandlerContex
             return;
         }
 
+        var replySessionId = message.IsSystemTask ? "scheduled-system" : "scheduled";
+
         string finalText;
         try
         {
             // Use slot.Token so a new user message can preempt this task cleanly.
             await using (slot)
             {
+                using var progressCtx = ToolProgressNotifier.SetContext(new ToolProgressContext
+                {
+                    SessionId = replySessionId,
+                    AgentName = agent.Name,
+                    ReplyTo = UserProxyTopics.UserResponse
+                });
+
                 finalText = await agentLoopRunner.RunAsync(
                     chatMessages, chatOptions, sessionId: sessionId,
                     enableFollowUp: false, cancellationToken: slot.Token);
@@ -133,7 +142,7 @@ public async Task HandleAsync(ScheduledTaskMessage message, MessageHandlerContex
         var reply = new AgentReply
         {
             Content = finalText,
-            SessionId = "scheduled",
+            SessionId = replySessionId,
             AgentName = agent.Name,
             IsFinal = true
         };

src/RockBot.Agent/UserMessageHandler.cs

@@ -364,6 +364,14 @@ private async Task NativeLlmLoopAsync(
 
             logger.LogInformation("Native LLM loop started for session {SessionId}", sessionId);
 
+            using var progressCtx = ToolProgressNotifier.SetContext(new ToolProgressContext
+            {
+                SessionId = sessionId,
+                AgentName = agent.Name,
+                CorrelationId = correlationId,
+                ReplyTo = replyTo
+            });
+
             var lastProgressAt = DateTimeOffset.UtcNow;
 
             var text = await agentLoopRunner.RunAsync(
@@ -468,6 +476,14 @@ private async Task BackgroundToolLoopAsync(
 
             logger.LogInformation("Background tool loop started for session {SessionId}", sessionId);
 
+            using var progressCtx = ToolProgressNotifier.SetContext(new ToolProgressContext
+            {
+                SessionId = sessionId,
+                AgentName = agent.Name,
+                CorrelationId = correlationId,
+                ReplyTo = replyTo
+            });
+
             var lastProgressAt = DateTimeOffset.UtcNow;
 
             var finalContent = await agentLoopRunner.RunAsync(

src/RockBot.Host.Abstractions/ScheduledTask.cs

@@ -12,10 +12,15 @@ namespace RockBot.Host;
 /// When true the task is automatically cancelled after it fires once.
 /// Use this for one-time reminders and deferred actions.
 /// </param>
+/// <param name="IsSystemTask">
+/// When true the task is a system-internal background task (e.g. heartbeat patrol)
+/// whose results are collapsed in the UI. User-created tasks default to false.
+/// </param>
 public sealed record ScheduledTask(
     string Name,
     string CronExpression,
     string Description,
     DateTimeOffset CreatedAt,
     DateTimeOffset? LastFiredAt = null,
-    bool RunOnce = false);
+    bool RunOnce = false,
+    bool IsSystemTask = false);

src/RockBot.Host.Abstractions/ScheduledTaskMessage.cs

@@ -5,4 +5,4 @@ namespace RockBot.Host;
 /// </summary>
 /// <param name="TaskName">Name of the scheduled task that fired.</param>
 /// <param name="Description">Task description — the agent's instructions for this run.</param>
-public sealed record ScheduledTaskMessage(string TaskName, string Description);
+public sealed record ScheduledTaskMessage(string TaskName, string Description, bool IsSystemTask = false);

src/RockBot.Host/HeartbeatBootstrapService.cs

@@ -35,7 +35,8 @@ await scheduler.ScheduleAsync(new ScheduledTask(
             CronExpression: options.Value.CronExpression,
             Description: "Run the heartbeat patrol: check calendar, email, active plans, and scheduled task health.",
             CreatedAt: patrol?.CreatedAt ?? DateTimeOffset.UtcNow,
-            RunOnce: false), ct);
+            RunOnce: false,
+            IsSystemTask: true), ct);
 
         var action = patrol is null ? "Registered" : "Updated";
         logger.LogInformation("{Action} heartbeat patrol (cron: {Cron})", action, options.Value.CronExpression);

src/RockBot.Host/SchedulerService.cs

@@ -196,7 +196,7 @@ private async Task FireTaskAsync(ScheduledTask task)
 
         try
         {
-            var message = new ScheduledTaskMessage(task.Name, task.Description);
+            var message = new ScheduledTaskMessage(task.Name, task.Description, task.IsSystemTask);
             var envelope = message.ToEnvelope(source: _identity.Name);
             await _pipeline.DispatchAsync(envelope, _cts.Token);
         }

src/RockBot.Host/ServiceCollectionExtensions.cs

@@ -30,6 +30,7 @@ public static IServiceCollection AddRockBotHost(
         builder.Build();
 
         services.AddTransient<ILlmClient, LlmClient>();
+        services.AddSingleton<IToolProgressNotifier, ToolProgressNotifier>();
         services.AddTransient<AgentLoopRunner>();
         services.AddScoped<AgentContextBuilder>();
         services.AddSingleton<SessionStartTracker>();

src/RockBot.Host/ToolProgressNotifier.cs

@@ -0,0 +1,94 @@
+using Microsoft.Extensions.Logging;
+using RockBot.Messaging;
+using RockBot.UserProxy;
+
+namespace RockBot.Host;
+
+/// <summary>
+/// Ambient context that carries session routing info for tool-call progress messages.
+/// Each handler sets this via <see cref="ToolProgressNotifier.SetContext"/> before calling
+/// <see cref="AgentLoopRunner.RunAsync"/> so the notifier knows where to route progress.
+/// </summary>
+public sealed class ToolProgressContext
+{
+    public required string SessionId { get; init; }
+    public required string AgentName { get; init; }
+    public string? CorrelationId { get; init; }
+    public required string ReplyTo { get; init; }
+}
+
+/// <summary>
+/// Publishes per-tool-call progress messages to the message bus so the Blazor UI can
+/// display a step-by-step activity log. Uses <see cref="AsyncLocal{T}"/> to read the
+/// session routing context set by each handler.
+/// </summary>
+public sealed class ToolProgressNotifier(
+    IMessagePublisher publisher,
+    ILogger<ToolProgressNotifier> logger) : IToolProgressNotifier
+{
+    private static readonly AsyncLocal<ToolProgressContext?> _context = new();
+
+    /// <summary>
+    /// Sets the ambient context for the current async flow. Call this before
+    /// <see cref="AgentLoopRunner.RunAsync"/> so tool-call progress is routed correctly.
+    /// Returns an <see cref="IDisposable"/> that clears the context on dispose.
+    /// </summary>
+    public static IDisposable SetContext(ToolProgressContext context)
+    {
+        _context.Value = context;
+        return new ContextScope();
+    }
+
+    public async Task OnToolInvokingAsync(string toolName, string? argsSummary, CancellationToken ct)
+    {
+        var ctx = _context.Value;
+        if (ctx is null) return;
+
+        var content = string.IsNullOrEmpty(argsSummary)
+            ? $"Calling {toolName}…"
+            : $"Calling {argsSummary}…";
+
+        await PublishProgressAsync(ctx, content, ct);
+    }
+
+    public async Task OnToolInvokedAsync(string toolName, string? resultSummary, CancellationToken ct)
+    {
+        var ctx = _context.Value;
+        if (ctx is null) return;
+
+        var content = string.IsNullOrEmpty(resultSummary)
+            ? $"{toolName} completed"
+            : $"{toolName} \u2192 {resultSummary}";
+
+        await PublishProgressAsync(ctx, content, ct);
+    }
+
+    private async Task PublishProgressAsync(ToolProgressContext ctx, string content, CancellationToken ct)
+    {
+        var reply = new AgentReply
+        {
+            Content = content,
+            SessionId = ctx.SessionId,
+            AgentName = ctx.AgentName,
+            IsFinal = false
+        };
+
+        var envelope = reply.ToEnvelope<AgentReply>(
+            source: ctx.AgentName,
+            correlationId: ctx.CorrelationId);
+
+        try
+        {
+            await publisher.PublishAsync(ctx.ReplyTo, envelope, ct);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            logger.LogDebug(ex, "Failed to publish tool progress for {Tool}", content);
+        }
+    }
+
+    private sealed class ContextScope : IDisposable
+    {
+        public void Dispose() => _context.Value = null;
+    }
+}

src/RockBot.Subagent/SubagentResultHandler.cs

@@ -113,6 +113,13 @@ await conversationMemory.AddTurnAsync(
 
         try
         {
+            using var progressCtx = ToolProgressNotifier.SetContext(new ToolProgressContext
+            {
+                SessionId = message.PrimarySessionId,
+                AgentName = agent.Name,
+                ReplyTo = UserProxyTopics.UserResponse
+            });
+
             var finalContent = await agentLoopRunner.RunAsync(
                 chatMessages, chatOptions, message.PrimarySessionId,
                 enableFollowUp: false, cancellationToken: ct);

src/RockBot.Subagent/SubagentRunner.cs

@@ -7,6 +7,7 @@
 using RockBot.Messaging;
 using RockBot.Skills;
 using RockBot.Tools;
+using RockBot.UserProxy;
 
 namespace RockBot.Subagent;
 
@@ -153,6 +154,13 @@ public async Task RunAsync(
 
         try
         {
+            using var progressCtx = ToolProgressNotifier.SetContext(new ToolProgressContext
+            {
+                SessionId = primarySessionId,
+                AgentName = $"subagent-{taskId}",
+                ReplyTo = UserProxy.UserProxyTopics.UserResponse
+            });
+
             finalOutput = await agentLoopRunner.RunAsync(
                 chatMessages, chatOptions, subagentSessionId,
                 tier: tier, enableFollowUp: false, enableCompletionEval: false,