🤖 fix: stop compaction state leaking into continue streams (#2894)

## Summary

Fix the streaming indicator so the follow-up continue turn after
compaction is treated as a normal stream instead of incorrectly showing
the compacting state.

## Background

The browser-side stream aggregator was inferring `isCompacting` from the
latest `/compact` user message whenever `stream-start.mode` was not
explicitly `compact`. That fallback predates this PR (introduced in
`ba125e654ae` / retained in `0b947aa6aa`), and it let the continue
stream inherit stale compaction state even though the backend already
emits the authoritative `stream-start.agentId` (`compact` for
compaction, normal agent IDs for follow-up turns).

The bug showed up recently because the newer activity-snapshot/catch-up
path from `ba2b7b32911` can keep stale aggregator state visible for
longer, but the root cause was the older compaction inference fallback.

## Implementation

- prefer `stream-start.agentId == "compact"` as the primary compaction
signal in `StreamingMessageAggregator.handleStreamStart`
- only consult historical `/compact` request metadata for legacy
stream-start events that do not include `agentId`
- stop reusing an older compaction request once a compaction boundary
summary has already landed
- add regression coverage for both modern and legacy continue-stream
cases

## Validation

- `bun test
src/browser/utils/messages/StreamingMessageAggregator.test.ts`
- `make static-check`

## Risks

Low. The change is narrowly scoped to compaction stream classification
in the browser aggregator and preserves the existing fallback for older
replayed stream-start events.

---

_Generated with `mux` • Model: `openai:gpt-5.4` • Thinking: `xhigh` •
Cost: `unknown`_

<!-- mux-attribution: model=openai:gpt-5.4 thinking=xhigh costs=unknown
-->

Author: ammar-agent

src/browser/utils/messages/StreamingMessageAggregator.test.ts

@@ -1831,6 +1831,83 @@ describe("StreamingMessageAggregator", () => {
 
       expect(aggregator.isCompacting()).toBe(true);
     });
+    test("does not treat non-compact agent streams as compacting even when the latest user message is /compact", () => {
+      const aggregator = new StreamingMessageAggregator(TEST_CREATED_AT);
+
+      const compactionRequestMessage = {
+        id: "msg1",
+        role: "user" as const,
+        parts: [{ type: "text" as const, text: "/compact" }],
+        metadata: {
+          historySequence: 1,
+          timestamp: Date.now(),
+          muxMetadata: {
+            type: "compaction-request" as const,
+            rawCommand: "/compact",
+            parsed: { model: "anthropic:claude-3-5-haiku-20241022" },
+          },
+        },
+      };
+
+      aggregator.loadHistoricalMessages([compactionRequestMessage], true);
+
+      aggregator.handleStreamStart({
+        type: "stream-start",
+        workspaceId: "test-workspace",
+        messageId: "continue-stream",
+        historySequence: 2,
+        model: "anthropic:claude-3-5-haiku-20241022",
+        startTime: Date.now(),
+        agentId: "exec",
+        mode: "exec",
+      });
+
+      expect(aggregator.isCompacting()).toBe(false);
+    });
+
+    test("does not reuse a completed compaction request when older stream-start events omit agentId", () => {
+      const aggregator = new StreamingMessageAggregator(TEST_CREATED_AT);
+
+      const compactionRequestMessage = {
+        id: "msg1",
+        role: "user" as const,
+        parts: [{ type: "text" as const, text: "/compact" }],
+        metadata: {
+          historySequence: 1,
+          timestamp: Date.now(),
+          muxMetadata: {
+            type: "compaction-request" as const,
+            rawCommand: "/compact",
+            parsed: { model: "anthropic:claude-3-5-haiku-20241022" },
+          },
+        },
+      };
+      const compactionSummaryMessage = createMuxMessage(
+        "summary-1",
+        "assistant",
+        "Compacted summary",
+        {
+          historySequence: 2,
+          timestamp: Date.now(),
+          compactionBoundary: true,
+          muxMetadata: { type: "compaction-summary" },
+        }
+      );
+
+      aggregator.loadHistoricalMessages([compactionRequestMessage, compactionSummaryMessage], true);
+
+      aggregator.handleStreamStart({
+        type: "stream-start",
+        workspaceId: "test-workspace",
+        messageId: "continue-stream",
+        historySequence: 3,
+        model: "anthropic:claude-3-5-haiku-20241022",
+        startTime: Date.now(),
+        mode: "exec",
+      });
+
+      expect(aggregator.isCompacting()).toBe(false);
+    });
   });
 
   describe("pending stream model", () => {

src/browser/utils/messages/StreamingMessageAggregator.ts

@@ -1115,25 +1115,50 @@ export class StreamingMessageAggregator {
     return this.pendingStreamModel;
   }
 
-  private getLatestCompactionRequest(): CompactionRequestData | null {
-    if (this.pendingCompactionRequest) {
-      return this.pendingCompactionRequest;
-    }
-
+  private getLatestHistoricalCompactionRequest(): CompactionRequestData | null {
+    let sawCompletedCompaction = false;
     const messages = this.getAllMessages();
     for (let i = messages.length - 1; i >= 0; i--) {
       const message = messages[i];
+      if (message.role === "assistant" && this.isCompactionBoundarySummaryMessage(message)) {
+        // A completed summary closes the earlier /compact request, so later auto-continue
+        // streams must not inherit a stale "compacting" UI state from that older turn.
+        sawCompletedCompaction = true;
+        continue;
+      }
       if (message.role !== "user") continue;
       const muxMetadata = message.metadata?.muxMetadata;
       if (muxMetadata?.type === "compaction-request") {
-        return muxMetadata.parsed;
+        return sawCompletedCompaction ? null : muxMetadata.parsed;
       }
       return null;
     }
 
     return null;
   }
 
+  private getLatestUnresolvedCompactionRequest(): CompactionRequestData | null {
+    return this.pendingCompactionRequest ?? this.getLatestHistoricalCompactionRequest();
+  }
+
+  private resolveStreamStartCompaction(data: StreamStartEvent): {
+    isCompacting: boolean;
+    hasCompactionContinue: boolean;
+  } {
+    // Keep stream classification separate from stream context construction so
+    // continue turns after /compact do not inherit stale UI state from history.
+    const streamSignalsCompaction = data.agentId === "compact" || data.mode === "compact";
+    if (!streamSignalsCompaction && data.agentId != null) {
+      return { isCompacting: false, hasCompactionContinue: false };
+    }
+
+    const compactionRequest = this.getLatestUnresolvedCompactionRequest();
+    return {
+      isCompacting: streamSignalsCompaction || compactionRequest !== null,
+      hasCompactionContinue: Boolean(compactionRequest?.followUpContent),
+    };
+  }
+
   private setPendingStreamStartTime(time: number | null): void {
     this.pendingStreamStartTime = time;
     if (time === null) {
@@ -1454,14 +1479,7 @@ export class StreamingMessageAggregator {
 
   // Unified event handlers that encapsulate all complex logic
   handleStreamStart(data: StreamStartEvent): void {
-    // Detect compaction via stream mode (most authoritative).
-    // For backwards compat (older stream-start events without mode), fall back to the
-    // triggering compaction request metadata (pending or last user message).
-    const compactionRequest = this.getLatestCompactionRequest();
-    const isCompacting = data.mode === "compact" || compactionRequest !== null;
-
-    // Capture compaction-continue metadata before clearing pending request state.
-    const hasCompactionContinue = Boolean(compactionRequest?.followUpContent);
+    const { isCompacting, hasCompactionContinue } = this.resolveStreamStartCompaction(data);
 
     // Clear pending stream start timestamp - stream has started
     this.setPendingStreamStartTime(null);