fix: completed messages skip live streaming-stats subscription

Codex P1 on PR #3219: every TypewriterMarkdown instance was subscribing
to useWorkspaceStreamingStats(workspaceId) regardless of streaming
state. Long transcripts of completed assistant messages then re-rendered
on every stream-delta of the new live message, undoing part of the
cascade-rerender fix.

Subscribe to the real workspace key only while the message is actively
streaming; completed messages subscribe to the empty-string sentinel
which is never bumped. Hook still runs unconditionally per rules of
hooks — only the key changes.

Author: ammar-agent

src/browser/features/Messages/TypewriterMarkdown.test.tsx

@@ -1,5 +1,6 @@
 import type { UseSmoothStreamingTextOptions } from "@/browser/hooks/useSmoothStreamingText";
 import { useSmoothStreamingText as importedUseSmoothStreamingText } from "@/browser/hooks/useSmoothStreamingText";
+import { useWorkspaceStreamingStats as importedUseWorkspaceStreamingStats } from "@/browser/stores/WorkspaceStore";
 import { afterAll, afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 import { cleanup, render } from "@testing-library/react";
 import { GlobalWindow } from "happy-dom";
@@ -8,6 +9,7 @@ import { TypewriterMarkdown } from "./TypewriterMarkdown";
 
 const actualMarkdownCore = ImportedMarkdownCore;
 const actualUseSmoothStreamingText = importedUseSmoothStreamingText;
+const actualUseWorkspaceStreamingStats = importedUseWorkspaceStreamingStats;
 
 const mockUseSmoothStreamingText = mock(
   (options: UseSmoothStreamingTextOptions): { visibleText: string; isCaughtUp: boolean } => ({
@@ -16,6 +18,8 @@ const mockUseSmoothStreamingText = mock(
   })
 );
 
+const mockUseWorkspaceStreamingStats = mock((_workspaceId: string) => null);
+
 function MarkdownCoreStub(props: { content: string }) {
   return <div data-testid="markdown-core">{props.content}</div>;
 }
@@ -29,6 +33,9 @@ async function installTypewriterMarkdownModuleMocks() {
   await mock.module("@/browser/hooks/useSmoothStreamingText", () => ({
     useSmoothStreamingText: mockUseSmoothStreamingText,
   }));
+  await mock.module("@/browser/stores/WorkspaceStore", () => ({
+    useWorkspaceStreamingStats: mockUseWorkspaceStreamingStats,
+  }));
 }
 
 async function restoreTypewriterMarkdownModuleMocks() {
@@ -40,6 +47,9 @@ async function restoreTypewriterMarkdownModuleMocks() {
   await mock.module("@/browser/hooks/useSmoothStreamingText", () => ({
     useSmoothStreamingText: actualUseSmoothStreamingText,
   }));
+  await mock.module("@/browser/stores/WorkspaceStore", () => ({
+    useWorkspaceStreamingStats: actualUseWorkspaceStreamingStats,
+  }));
 }
 
 describe("TypewriterMarkdown", () => {
@@ -59,6 +69,7 @@ describe("TypewriterMarkdown", () => {
     globalThis.document = globalThis.window.document;
     await installTypewriterMarkdownModuleMocks();
     mockUseSmoothStreamingText.mockClear();
+    mockUseWorkspaceStreamingStats.mockClear();
   });
 
   afterEach(async () => {
@@ -108,4 +119,38 @@ describe("TypewriterMarkdown", () => {
       expect.objectContaining({ bypassSmoothing: true })
     );
   });
+
+  // Regression: completed historical messages must not subscribe to live
+  // streaming stats for their workspace, otherwise every assistant message in a
+  // long transcript re-renders on every stream-delta of an active stream and
+  // re-introduces the cascade jitter this PR is supposed to eliminate.
+  test("completed messages subscribe with empty key (no live-stats updates)", () => {
+    render(
+      <TypewriterMarkdown
+        content="Historical reply"
+        isComplete={true}
+        streamKey="msg-old"
+        streamSource="live"
+        workspaceId="ws-active"
+      />
+    );
+
+    // Hook still runs (rules of hooks), but the key must be the no-op sentinel.
+    expect(mockUseWorkspaceStreamingStats).toHaveBeenCalledWith("");
+    expect(mockUseWorkspaceStreamingStats).not.toHaveBeenCalledWith("ws-active");
+  });
+
+  test("streaming messages subscribe with the real workspace key", () => {
+    render(
+      <TypewriterMarkdown
+        content="Streaming reply"
+        isComplete={false}
+        streamKey="msg-live"
+        streamSource="live"
+        workspaceId="ws-active"
+      />
+    );
+
+    expect(mockUseWorkspaceStreamingStats).toHaveBeenCalledWith("ws-active");
+  });
 });

src/browser/features/Messages/TypewriterMarkdown.tsx

@@ -46,9 +46,15 @@ export const TypewriterMarkdown: React.FC<TypewriterMarkdownProps> = ({
   // Read the live model emission rate (chars/sec) for the active stream of this
   // workspace. The hook subscribes to its own MapStore so per-delta updates
   // re-render this component WITHOUT cascading through the parent — see
-  // useWorkspaceStreamingStats. Hooks must run unconditionally; pass an empty
-  // string when no workspace is provided so the subscription is a stable no-op.
-  const streamingStats = useWorkspaceStreamingStats(workspaceId ?? "");
+  // useWorkspaceStreamingStats.
+  //
+  // Subscribe to the real workspace key ONLY while this message is actively
+  // streaming. Completed historical messages subscribe to the stable empty-key
+  // sentinel, which is never bumped — so a long transcript of finished
+  // assistant messages does not re-render on every delta of a new stream.
+  // (Hooks must run unconditionally; we toggle the key, not the call site.)
+  const subscriptionKey = isStreaming && workspaceId ? workspaceId : "";
+  const streamingStats = useWorkspaceStreamingStats(subscriptionKey);
   const liveCharsPerSec = isStreaming && workspaceId ? (streamingStats?.charsPerSec ?? 0) : 0;
 
   // Two-clock streaming: ingestion (content) vs presentation (visibleText).