diff --git a/src/browser/components/ChatPane/ChatPane.tsx b/src/browser/components/ChatPane/ChatPane.tsx
index 15d19a2aa7..107bfde516 100644
--- a/src/browser/components/ChatPane/ChatPane.tsx
+++ b/src/browser/components/ChatPane/ChatPane.tsx
@@ -1239,11 +1239,19 @@ const ChatPaneContent: React.FC<ChatPaneContentProps> = (props) => {
                         ? (workBundleOverride ?? workBundle.defaultExpanded)
                         : false;
 
-                      if (workBundle?.position === "member") {
+                      const keepCollapsedWorkBundleMemberVisible =
+                        msg.type === "user" ||
+                        (msg.type === "assistant" &&
+                          (msg.isSideAnswer === true || workBundle?.position === "final"));
+                      if (
+                        (workBundle?.position === "member" || workBundle?.position === "final") &&
+                        (isWorkBundleExpanded || !keepCollapsedWorkBundleMemberVisible)
+                      ) {
                         return null;
                       }
 
                       const renderWorkBundle = workBundle?.position === "head";
+                      const renderMessageBeforeWorkBundle = renderWorkBundle && msg.type === "user";
                       const renderMessageAfterWorkBundle = !renderWorkBundle;
                       const operationalBundle = workBundle
                         ? undefined
@@ -1269,6 +1277,10 @@ const ChatPaneContent: React.FC<ChatPaneContentProps> = (props) => {
 
                       return (
                         <React.Fragment key={`${workspaceId}:${msg.id}`}>
+                          {renderMessageBeforeWorkBundle &&
+                            renderMessageAtIndex(msg, index, {
+                              key: `${workspaceId}:${msg.id}:message`,
+                            })}
                           {renderWorkBundle && workBundle && (
                             <WorkBundleMessage
                               item={workBundle}
@@ -1309,23 +1321,20 @@ const ChatPaneContent: React.FC<ChatPaneContentProps> = (props) => {
                                   key={`${workspaceId}:${workBundle.key}:${entry.message.id}`}
                                 >
                                   {renderNestedBundle && nestedOperationalBundle && (
-                                    <div className="ml-4">
-                                      <OperationalBundleMessage
-                                        item={nestedOperationalBundle}
-                                        expanded={isNestedExpanded}
-                                        onToggle={() =>
-                                          setOperationalBundleExpanded(
-                                            nestedOperationalBundle.key,
-                                            !isNestedExpanded
-                                          )
-                                        }
-                                      />
-                                    </div>
+                                    <OperationalBundleMessage
+                                      item={nestedOperationalBundle}
+                                      expanded={isNestedExpanded}
+                                      onToggle={() =>
+                                        setOperationalBundleExpanded(
+                                          nestedOperationalBundle.key,
+                                          !isNestedExpanded
+                                        )
+                                      }
+                                    />
                                   )}
                                   {renderNestedMessage &&
                                     renderMessageAtIndex(entry.message, entry.originalIndex, {
                                       key: `${workspaceId}:${workBundle.key}:${entry.message.id}:message`,
-                                      className: nestedOperationalBundle ? "ml-8" : "ml-4",
                                     })}
                                 </React.Fragment>
                               );
diff --git a/src/browser/features/Messages/TranscriptDensity.stories.tsx b/src/browser/features/Messages/TranscriptDensity.stories.tsx
index a5cb139106..6eda817ae9 100644
--- a/src/browser/features/Messages/TranscriptDensity.stories.tsx
+++ b/src/browser/features/Messages/TranscriptDensity.stories.tsx
@@ -36,45 +36,69 @@ function setupTranscriptDensityStory(density: TranscriptDensity) {
       createAssistantMessage("density-assistant-1", "I'll gather context first.", {
         historySequence: 2,
         timestamp: STABLE_TIMESTAMP - 55_000,
+        partial: true,
         reasoning:
           "Need to inspect auth code, search related validation guidance, and then make a minimal patch.",
         toolCalls: [
           createFileReadTool("density-read-1", "src/auth.ts", "export function verify() {}"),
           createWebSearchTool("density-search-1", "JWT validation best practices", 3),
           createAgentSkillReadTool("density-skill-1", "react-effects", { scope: "global" }),
-          createBashTool("density-rg-1", 'rg "verify" src', "src/auth.ts:1:verify"),
-          {
-            type: "text",
-            text: "I found the relevant code and will patch it.",
-            timestamp: STABLE_TIMESTAMP - 35_000,
-          },
-          createFileEditTool(
-            "density-edit-1",
-            "src/auth.ts",
-            [
-              "--- src/auth.ts",
-              "+++ src/auth.ts",
-              "@@ -1,3 +1,4 @@",
-              "+import { timingSafeEqual } from 'crypto';",
-              " export function verify() {}",
-            ].join("\n")
+          createGenericTool(
+            "density-question-1",
+            "ask_user_question",
+            { question: "Any additional validation needed?" },
+            { answer: "Please validate with typecheck too" }
           ),
-          createBashTool(
-            "density-test-1",
-            "make test",
-            "42 tests passed",
-            0,
-            30,
-            500,
-            "Running tests"
-          ),
-          {
-            type: "text",
-            text: "Implemented the auth audit fix and validated it.",
-            timestamp: STABLE_TIMESTAMP - 15_000,
-          },
         ],
       }),
+      createUserMessage("density-user-2", "Please validate with typecheck too", {
+        historySequence: 3,
+        timestamp: STABLE_TIMESTAMP - 40_000,
+      }),
+      createAssistantMessage(
+        "density-assistant-2",
+        "I found the relevant code and will patch it.",
+        {
+          historySequence: 4,
+          timestamp: STABLE_TIMESTAMP - 35_000,
+          toolCalls: [
+            createFileEditTool(
+              "density-edit-1",
+              "src/auth.ts",
+              [
+                "--- src/auth.ts",
+                "+++ src/auth.ts",
+                "@@ -1,3 +1,4 @@",
+                "+import { timingSafeEqual } from 'crypto';",
+                " export function verify() {}",
+              ].join("\n")
+            ),
+            createBashTool(
+              "density-test-1",
+              "make test",
+              "42 tests passed",
+              0,
+              30,
+              500,
+              "Running tests"
+            ),
+            createBashTool(
+              "density-fail-1",
+              "make typecheck",
+              "Type error in src/auth.ts",
+              1,
+              30,
+              500,
+              "Failing validation"
+            ),
+            {
+              type: "text",
+              text: "Implemented the auth audit fix and validated it.",
+              timestamp: STABLE_TIMESTAMP - 15_000,
+            },
+          ],
+        }
+      ),
     ],
   });
 }
@@ -129,15 +153,16 @@ export const HyperActiveExpandedBundle: AppStory = {
       setup={() => {
         collapseLeftSidebar();
         setDensity("hyper");
+        const activeStartedAt = Date.now() - 39_000;
         return setupSimpleChatStory({
           messages: [
             createUserMessage("active-user-1", "Inspect the repository", {
               historySequence: 1,
-              timestamp: STABLE_TIMESTAMP - 40_000,
+              timestamp: activeStartedAt - 5_000,
             }),
             createAssistantMessage("active-assistant-1", "I'll read the key files now.", {
               historySequence: 2,
-              timestamp: STABLE_TIMESTAMP - 35_000,
+              timestamp: activeStartedAt,
               toolCalls: [
                 createPendingTool("active-read-1", "file_read", { path: "src/App.tsx" }),
                 createPendingTool("active-search-1", "web_search", {
diff --git a/src/browser/features/Messages/WorkBundleMessage.test.tsx b/src/browser/features/Messages/WorkBundleMessage.test.tsx
index 0ebcb84917..17a3d11512 100644
--- a/src/browser/features/Messages/WorkBundleMessage.test.tsx
+++ b/src/browser/features/Messages/WorkBundleMessage.test.tsx
@@ -14,7 +14,9 @@ const item: WorkBundleInfo = {
   position: "head",
   headIndex: 1,
   entries: [],
+  startedAtMs: 0,
   durationMs: 180_000,
+  state: "settled",
   defaultExpanded: false,
 };
 
@@ -46,6 +48,24 @@ describe("WorkBundleMessage", () => {
     expect(view.getByRole("button", { expanded: true })).toBeDefined();
   });
 
+  test("renders active working label with elapsed duration", () => {
+    const view = render(
+      <WorkBundleMessage
+        item={{
+          ...item,
+          state: "active",
+          startedAtMs: Date.now() - 35_000,
+          durationMs: undefined,
+          defaultExpanded: true,
+        }}
+        expanded
+        onToggle={() => undefined}
+      />
+    );
+
+    expect(view.getByText(/Working for \d+s\.\.\./)).toBeDefined();
+  });
+
   test("renders fallback label without duration", () => {
     const view = render(
       <WorkBundleMessage
diff --git a/src/browser/features/Messages/WorkBundleMessage.tsx b/src/browser/features/Messages/WorkBundleMessage.tsx
index 5cafe22098..1e33492ed9 100644
--- a/src/browser/features/Messages/WorkBundleMessage.tsx
+++ b/src/browser/features/Messages/WorkBundleMessage.tsx
@@ -4,6 +4,22 @@ import { cn } from "@/common/lib/utils";
 import { ExpandIcon } from "@/browser/features/Tools/Shared/ToolPrimitives";
 import type { WorkBundleInfo } from "@/browser/utils/messages/transcriptRenderProjection";
 
+function useActiveNowMs(isActive: boolean): number {
+  const [nowMs, setNowMs] = React.useState(() => Date.now());
+
+  React.useEffect(() => {
+    if (!isActive) {
+      return;
+    }
+
+    setNowMs(Date.now());
+    const intervalId = window.setInterval(() => setNowMs(Date.now()), 1_000);
+    return () => window.clearInterval(intervalId);
+  }, [isActive]);
+
+  return nowMs;
+}
+
 interface WorkBundleMessageProps {
   item: WorkBundleInfo;
   expanded: boolean;
@@ -11,9 +27,20 @@ interface WorkBundleMessageProps {
 }
 
 export function WorkBundleMessage(props: WorkBundleMessageProps): React.ReactElement {
-  const duration = props.item.durationMs;
-  const label =
-    duration === undefined ? "Worked" : `Worked for ${formatDuration(duration, "precise")}`;
+  const isActive = props.item.state === "active";
+  const nowMs = useActiveNowMs(isActive && props.item.startedAtMs !== undefined);
+  const duration = isActive
+    ? props.item.startedAtMs === undefined
+      ? undefined
+      : Math.max(0, nowMs - props.item.startedAtMs)
+    : props.item.durationMs;
+  const label = isActive
+    ? duration === undefined
+      ? "Working..."
+      : `Working for ${formatDuration(duration, "precise")}...`
+    : duration === undefined
+      ? "Worked"
+      : `Worked for ${formatDuration(duration, "precise")}`;
 
   return (
     <button
@@ -26,7 +53,7 @@ export function WorkBundleMessage(props: WorkBundleMessageProps): React.ReactEle
       aria-expanded={props.expanded}
       onClick={props.onToggle}
     >
-      <span className="min-w-0 truncate">{label}</span>
+      <span className="counter-nums min-w-0 truncate">{label}</span>
       <ExpandIcon expanded={props.expanded} className="text-muted shrink-0">
         ▶
       </ExpandIcon>
diff --git a/src/browser/utils/messages/transcriptRenderProjection.test.ts b/src/browser/utils/messages/transcriptRenderProjection.test.ts
index 1d1e3f0494..85c3dfdcef 100644
--- a/src/browser/utils/messages/transcriptRenderProjection.test.ts
+++ b/src/browser/utils/messages/transcriptRenderProjection.test.ts
@@ -75,6 +75,7 @@ function assistant(
     isLastPartOfMessage: overrides.isLastPartOfMessage,
     isCompacted: overrides.isCompacted ?? false,
     isIdleCompacted: overrides.isIdleCompacted ?? false,
+    isSideAnswer: overrides.isSideAnswer,
     timestamp: overrides.timestamp,
   };
 }
@@ -165,19 +166,20 @@ describe("work bundle coalescing", () => {
 
     const infos = computeWorkBundleInfos(messages);
 
-    expect(infos[0]).toBeUndefined();
-    expect(infos[1]).toMatchObject({
+    expect(infos[0]).toMatchObject({
       key: "work:think-1",
       position: "head",
-      headIndex: 1,
+      headIndex: 0,
       durationMs: 180_000,
       defaultExpanded: false,
       entries: [
         { message: messages[1], originalIndex: 1 },
         { message: messages[2], originalIndex: 2 },
         { message: messages[3], originalIndex: 3 },
+        { message: messages[4], originalIndex: 4 },
       ],
     });
+    expect(infos[1]).toMatchObject({ key: "work:think-1", position: "member" });
     expect(infos[2]).toMatchObject({ key: "work:think-1", position: "member" });
     expect(infos[3]).toMatchObject({ key: "work:think-1", position: "member" });
     expect(infos[4]).toMatchObject({ key: "work:think-1", position: "final" });
@@ -205,7 +207,7 @@ describe("work bundle coalescing", () => {
     const workInfos = computeWorkBundleInfos(messages);
     const operationalInfos = computeOperationalBundleInfos(messages, { isTurnActive: false });
 
-    expect(workInfos[0]?.entries.map((entry) => entry.originalIndex)).toEqual([0, 1, 2, 3]);
+    expect(workInfos[0]?.entries.map((entry) => entry.originalIndex)).toEqual([0, 1, 2, 3, 4]);
     expect(operationalInfos[2]).toMatchObject({
       position: "head",
       headIndex: 2,
@@ -217,19 +219,255 @@ describe("work bundle coalescing", () => {
     });
   });
 
-  test("leaves active work visible", () => {
+  test("spans steering user messages until the turn final assistant row", () => {
     const messages = [
-      reasoning({ id: "think-1", historyId: "history-a1" }),
-      tool({ id: "read-1", historyId: "history-a1", status: "executing" }),
+      user("u1"),
+      tool({
+        id: "read-1",
+        historyId: "history-a1",
+        isPartial: true,
+        status: "executing",
+        timestamp: 1_000,
+      }),
+      user("steer-1"),
+      tool({ id: "bash-1", historyId: "history-a1", toolName: "bash", timestamp: 31_000 }),
+      assistant("final-1", { historyId: "history-a1", timestamp: 61_000 }),
+    ];
+
+    const infos = computeWorkBundleInfos(messages);
+
+    expect(infos[0]).toMatchObject({
+      key: "work:read-1",
+      position: "head",
+      headIndex: 0,
+      durationMs: 60_000,
+      entries: [
+        { message: messages[1], originalIndex: 1 },
+        { message: messages[2], originalIndex: 2 },
+        { message: messages[3], originalIndex: 3 },
+        { message: messages[4], originalIndex: 4 },
+      ],
+    });
+    expect(infos[1]).toMatchObject({ key: "work:read-1", position: "member" });
+    expect(infos[2]).toMatchObject({ key: "work:read-1", position: "member" });
+    expect(infos[3]).toMatchObject({ key: "work:read-1", position: "member" });
+    expect(infos[4]).toMatchObject({ key: "work:read-1", position: "final" });
+  });
+
+  test("keeps side-question answers visible while bundling surrounding agent work", () => {
+    const messages = [
+      user("u1"),
+      tool({ id: "read-1", historyId: "history-a1" }),
+      user("side-question-1"),
+      assistant("side-answer-1", { isSideAnswer: true }),
+      tool({ id: "bash-1", historyId: "history-a1", toolName: "bash" }),
       assistant("final-1", { historyId: "history-a1" }),
     ];
 
     const infos = computeWorkBundleInfos(messages);
 
+    expect(infos[0]).toMatchObject({
+      key: "work:read-1",
+      headIndex: 0,
+      entries: [
+        { message: messages[1], originalIndex: 1 },
+        { message: messages[2], originalIndex: 2 },
+        { message: messages[3], originalIndex: 3 },
+        { message: messages[4], originalIndex: 4 },
+        { message: messages[5], originalIndex: 5 },
+      ],
+    });
+    expect(infos[1]).toMatchObject({ key: "work:read-1", position: "member" });
+    expect(infos[2]).toMatchObject({ key: "work:read-1", position: "member" });
+    expect(infos[3]).toMatchObject({ key: "work:read-1", position: "member" });
+    expect(infos[4]).toMatchObject({ key: "work:read-1", position: "member" });
+    expect(infos[5]).toMatchObject({ key: "work:read-1", position: "final" });
+  });
+
+  test("does not start a work bundle at a side-question answer", () => {
+    const messages = [
+      user("u1"),
+      assistant("side-answer-1", { isSideAnswer: true }),
+      tool({ id: "bash-1", historyId: "history-a1", toolName: "bash" }),
+      assistant("final-1", { historyId: "history-a1" }),
+    ];
+
+    const infos = computeWorkBundleInfos(messages);
+
+    expect(infos[0]).toBeUndefined();
+    expect(infos[1]).toBeUndefined();
+    expect(infos[2]).toMatchObject({
+      key: "work:bash-1",
+      entries: [
+        { message: messages[2], originalIndex: 2 },
+        { message: messages[3], originalIndex: 3 },
+      ],
+    });
+    expect(infos[3]).toMatchObject({ key: "work:bash-1", position: "final" });
+  });
+
+  test("does not finalize work bundles before the first operation", () => {
+    const messages = [
+      user("u1"),
+      assistant("draft-1", { historyId: "history-a1", content: "I'll inspect first." }),
+      tool({ id: "read-1", historyId: "history-a1" }),
+    ];
+
+    const infos = computeWorkBundleInfos(messages);
+
     expect(infos.every((info) => info === undefined)).toBe(true);
   });
 
-  test("keeps non-success tools visible before a final assistant row", () => {
+  test("does not merge completed partial tools into a tool-using next prompt", () => {
+    const messages = [
+      user("u1"),
+      tool({ id: "read-1", historyId: "history-a1", isPartial: true, status: "completed" }),
+      user("u2"),
+      tool({ id: "bash-1", historyId: "history-a2", toolName: "bash" }),
+      assistant("final-2", { historyId: "history-a2" }),
+    ];
+
+    const infos = computeWorkBundleInfos(messages);
+
+    expect(infos[0]).toBeUndefined();
+    expect(infos[1]).toBeUndefined();
+    expect(infos[2]).toMatchObject({ key: "work:bash-1", position: "head", headIndex: 2 });
+    expect(infos[3]).toMatchObject({ key: "work:bash-1", position: "member" });
+    expect(infos[4]).toMatchObject({ key: "work:bash-1", position: "final" });
+  });
+
+  test("does not merge interrupted partial tools into a text-only next prompt", () => {
+    const messages = [
+      user("u1"),
+      tool({ id: "read-1", historyId: "history-a1", isPartial: true }),
+      user("u2"),
+      assistant("answer-2", { historyId: "history-a2" }),
+    ];
+
+    const infos = computeWorkBundleInfos(messages);
+
+    expect(infos.every((info) => info === undefined)).toBe(true);
+  });
+
+  test("does not merge mixed partial tool and text interruptions across the next user prompt", () => {
+    const messages = [
+      user("u1"),
+      tool({ id: "read-1", historyId: "history-a1", isPartial: true }),
+      assistant("draft-1", { historyId: "history-a1", isPartial: true }),
+      user("u2"),
+      tool({ id: "bash-1", historyId: "history-a2", toolName: "bash" }),
+      assistant("final-2", { historyId: "history-a2" }),
+    ];
+
+    const infos = computeWorkBundleInfos(messages);
+
+    expect(infos[0]).toBeUndefined();
+    expect(infos[1]).toBeUndefined();
+    expect(infos[2]).toBeUndefined();
+    expect(infos[3]).toMatchObject({ key: "work:bash-1", position: "head", headIndex: 3 });
+    expect(infos[4]).toMatchObject({ key: "work:bash-1", position: "member" });
+    expect(infos[5]).toMatchObject({ key: "work:bash-1", position: "final" });
+  });
+
+  test("does not merge partial text-only interruptions across the next user prompt", () => {
+    const messages = [
+      user("u1"),
+      reasoning({ id: "think-1", historyId: "history-a1", isPartial: true }),
+      assistant("draft-1", { historyId: "history-a1", isPartial: true }),
+      user("u2"),
+      tool({ id: "bash-1", historyId: "history-a2", toolName: "bash" }),
+      assistant("final-2", { historyId: "history-a2" }),
+    ];
+
+    const infos = computeWorkBundleInfos(messages);
+
+    expect(infos[0]).toBeUndefined();
+    expect(infos[1]).toBeUndefined();
+    expect(infos[2]).toBeUndefined();
+    expect(infos[3]).toMatchObject({ key: "work:bash-1", position: "head", headIndex: 3 });
+    expect(infos[4]).toMatchObject({ key: "work:bash-1", position: "member" });
+    expect(infos[5]).toMatchObject({ key: "work:bash-1", position: "final" });
+  });
+
+  test("does not merge interrupted work across the next user prompt", () => {
+    const messages = [
+      user("u1"),
+      tool({ id: "interrupted-1", historyId: "history-a1", status: "interrupted" }),
+      user("u2"),
+      tool({ id: "bash-1", historyId: "history-a2", toolName: "bash" }),
+      assistant("final-2", { historyId: "history-a2" }),
+    ];
+
+    const infos = computeWorkBundleInfos(messages);
+
+    expect(infos[1]).toBeUndefined();
+    expect(infos[2]).toMatchObject({ key: "work:bash-1", position: "head", headIndex: 2 });
+    expect(infos[3]).toMatchObject({
+      key: "work:bash-1",
+      entries: [
+        { message: messages[3], originalIndex: 3 },
+        { message: messages[4], originalIndex: 4 },
+      ],
+    });
+    expect(infos[4]).toMatchObject({ key: "work:bash-1", position: "final" });
+  });
+
+  test("does not merge completed turns across the next user message", () => {
+    const messages = [
+      user("u1"),
+      tool({ id: "read-1", historyId: "history-a1" }),
+      assistant("final-1", { historyId: "history-a1" }),
+      user("u2"),
+      tool({ id: "bash-1", historyId: "history-a2", toolName: "bash" }),
+      assistant("final-2", { historyId: "history-a2" }),
+    ];
+
+    const infos = computeWorkBundleInfos(messages);
+
+    expect(infos[0]).toMatchObject({
+      key: "work:read-1",
+      position: "head",
+      entries: [
+        { message: messages[1], originalIndex: 1 },
+        { message: messages[2], originalIndex: 2 },
+      ],
+    });
+    expect(infos[2]).toMatchObject({ key: "work:read-1", position: "final" });
+    expect(infos[3]).toMatchObject({ key: "work:bash-1", position: "head" });
+    expect(infos[4]).toMatchObject({
+      key: "work:bash-1",
+      entries: [
+        { message: messages[4], originalIndex: 4 },
+        { message: messages[5], originalIndex: 5 },
+      ],
+    });
+    expect(infos[5]).toMatchObject({ key: "work:bash-1", position: "final" });
+  });
+
+  test("wraps active work in an expanded working bundle", () => {
+    const messages = [
+      user("u1"),
+      assistant("draft-1", { historyId: "history-a1" }),
+      tool({ id: "read-1", historyId: "history-a1", status: "executing" }),
+    ];
+
+    const infos = computeWorkBundleInfos(messages);
+
+    expect(infos[0]).toMatchObject({
+      key: "work:draft-1",
+      position: "head",
+      state: "active",
+      defaultExpanded: true,
+      entries: [
+        { message: messages[1], originalIndex: 1 },
+        { message: messages[2], originalIndex: 2 },
+      ],
+    });
+    expect(infos[1]).toMatchObject({ key: "work:draft-1", position: "member" });
+    expect(infos[2]).toMatchObject({ key: "work:draft-1", position: "member" });
+  });
+
+  test("collapses non-success tools before a final assistant row", () => {
     const historyId = "history-a1";
     const failedSearch = tool({
       id: "search-1",
@@ -274,7 +512,23 @@ describe("work bundle coalescing", () => {
 
     const infos = computeWorkBundleInfos(messages);
 
-    expect(infos.every((info) => info === undefined)).toBe(true);
+    expect(infos[0]).toMatchObject({
+      key: "work:search-1",
+      position: "head",
+      entries: [
+        { message: failedSearch, originalIndex: 0 },
+        { message: failedBash, originalIndex: 1 },
+        { message: interruptedRead, originalIndex: 2 },
+        { message: redactedRead, originalIndex: 3 },
+        { message: partialRead, originalIndex: 4 },
+        { message: messages[5], originalIndex: 5 },
+      ],
+    });
+    expect(infos[1]).toMatchObject({ key: "work:search-1", position: "member" });
+    expect(infos[2]).toMatchObject({ key: "work:search-1", position: "member" });
+    expect(infos[3]).toMatchObject({ key: "work:search-1", position: "member" });
+    expect(infos[4]).toMatchObject({ key: "work:search-1", position: "member" });
+    expect(infos[5]).toMatchObject({ key: "work:search-1", position: "final" });
   });
 
   test("keeps visible artifacts and stream errors out of work bundles", () => {
@@ -342,6 +596,28 @@ describe("operational bundle coalescing", () => {
     expect(infos[4]).toMatchObject({ position: "head" });
   });
 
+  test("assistant rows split non-success operational bundles", () => {
+    const first = tool({ id: "bash-1", toolName: "bash", status: "failed" });
+    const middle = assistant("a1");
+    const second = tool({ id: "bash-2", toolName: "bash", status: "failed" });
+
+    const infos = computeOperationalBundleInfos([first, middle, second], {
+      isTurnActive: false,
+    });
+
+    expect(infos[0]).toMatchObject({
+      key: "bundle:bash-1",
+      position: "head",
+      entries: [{ message: first, originalIndex: 0 }],
+    });
+    expect(infos[1]).toBeUndefined();
+    expect(infos[2]).toMatchObject({
+      key: "bundle:bash-2",
+      position: "head",
+      entries: [{ message: second, originalIndex: 2 }],
+    });
+  });
+
   test("leaves reasoning-only turns visible", () => {
     const message = reasoning({ id: "think-only", isOnlyMessageContent: true });
 
@@ -368,7 +644,7 @@ describe("operational bundle coalescing", () => {
     expect(reasoningThenTool[0]?.summary.title).toBe("Ran 2 operations");
   });
 
-  test("leaves non-success tools visible", () => {
+  test("groups non-success tools into operational bundles", () => {
     const failedSearch = tool({
       id: "search-1",
       toolName: "web_search",
@@ -402,7 +678,27 @@ describe("operational bundle coalescing", () => {
       { isTurnActive: false }
     );
 
-    expect(infos.every((info) => info === undefined)).toBe(true);
+    expect(infos[0]).toMatchObject({
+      key: "bundle:search-1",
+      position: "head",
+      state: "settled",
+      defaultExpanded: false,
+      entries: [
+        { message: failedSearch, originalIndex: 0 },
+        { message: failedBash, originalIndex: 1 },
+        { message: interruptedRead, originalIndex: 2 },
+        { message: redactedRead, originalIndex: 3 },
+        { message: partialRead, originalIndex: 4 },
+      ],
+      summary: {
+        title: "Ran 5 operations",
+        details: "1 search · 1 shell command · 3 reads",
+      },
+    });
+    expect(infos[1]).toMatchObject({ key: "bundle:search-1", position: "member" });
+    expect(infos[2]).toMatchObject({ key: "bundle:search-1", position: "member" });
+    expect(infos[3]).toMatchObject({ key: "bundle:search-1", position: "member" });
+    expect(infos[4]).toMatchObject({ key: "bundle:search-1", position: "member" });
   });
 
   test("active and just-settled tail bundles stay expanded until a visible event or turn end", () => {
diff --git a/src/browser/utils/messages/transcriptRenderProjection.ts b/src/browser/utils/messages/transcriptRenderProjection.ts
index 42c7a5584c..49283ad90a 100644
--- a/src/browser/utils/messages/transcriptRenderProjection.ts
+++ b/src/browser/utils/messages/transcriptRenderProjection.ts
@@ -35,7 +35,9 @@ export interface WorkBundleInfo {
   /** Render slot where the work-bundle header is placed. */
   headIndex: number;
   entries: readonly WorkBundleEntry[];
+  startedAtMs?: number;
   durationMs?: number;
+  state: "active" | "settled";
   defaultExpanded: boolean;
 }
 
@@ -116,56 +118,59 @@ export function computeWorkBundleInfos(
   let index = 0;
 
   while (index < messages.length) {
-    const historyId = getWorkBundleHistoryId(messages[index]);
-    if (historyId === undefined) {
+    const span = findWorkBundleSpan(messages, index);
+    if (span === undefined) {
       index += 1;
       continue;
     }
 
-    const startIndex = index;
-    while (getWorkBundleHistoryId(messages[index + 1]) === historyId) {
-      index += 1;
-    }
-
-    const finalIndex = index;
-    index += 1;
-
-    if (finalIndex <= startIndex) {
-      continue;
-    }
-
-    if (messages[finalIndex]?.type !== "assistant") {
-      continue;
-    }
-
     const entries: WorkBundleEntry[] = [];
-    for (let entryIndex = startIndex; entryIndex < finalIndex; entryIndex++) {
+    for (let entryIndex = span.firstEntryIndex; entryIndex <= span.finalIndex; entryIndex++) {
       entries.push({ message: messages[entryIndex], originalIndex: entryIndex });
     }
 
-    const groupMessages = [...entries.map((entry) => entry.message), messages[finalIndex]];
-    if (groupMessages.some(isActiveWorkBundleMessage)) {
+    const finalMessage = messages[span.finalIndex];
+    if (span.state === "settled" && finalMessage?.type !== "assistant") {
+      index = span.finalIndex + 1;
       continue;
     }
 
     const frozenEntries = Object.freeze(entries);
-    const first = entries[0].message;
+    const firstAgentMessage = frozenEntries.find((entry) =>
+      isWorkBundleAgentMessage(entry.message)
+    );
+    if (firstAgentMessage === undefined) {
+      index = span.finalIndex + 1;
+      continue;
+    }
+
     const info: WorkBundleInfo = {
-      key: `work:${first.id}`,
+      key: `work:${firstAgentMessage.message.id}`,
       position: "head",
-      headIndex: startIndex,
+      headIndex: span.headIndex,
       entries: frozenEntries,
-      durationMs: computeWorkBundleDurationMs(frozenEntries, messages[finalIndex]),
-      defaultExpanded: false,
+      startedAtMs: getMessageTimestamp(frozenEntries[0].message),
+      durationMs:
+        span.state === "active"
+          ? undefined
+          : computeWorkBundleDurationMs(frozenEntries, finalMessage),
+      state: span.state,
+      defaultExpanded: span.state === "active",
     };
 
+    infos[span.headIndex] = info;
     for (const entry of entries) {
       infos[entry.originalIndex] = {
         ...info,
-        position: entry.originalIndex === startIndex ? "head" : "member",
+        position:
+          entry.originalIndex === span.headIndex
+            ? "head"
+            : span.state === "settled" && entry.originalIndex === span.finalIndex
+              ? "final"
+              : "member",
       };
     }
-    infos[finalIndex] = { ...info, position: "final" };
+    index = span.finalIndex + 1;
   }
 
   return infos;
@@ -241,16 +246,194 @@ export function computeOperationalBundleInfos(
   return infos;
 }
 
-function getWorkBundleHistoryId(message: DisplayedMessage | undefined): string | undefined {
-  switch (message?.type) {
-    case "assistant":
-    case "reasoning":
-      return message.historyId;
-    case "tool":
-      return isBundleableToolMessage(message) ? message.historyId : undefined;
-    default:
-      return undefined;
+interface WorkBundleSpan {
+  headIndex: number;
+  firstEntryIndex: number;
+  finalIndex: number;
+  state: "active" | "settled";
+}
+
+function findWorkBundleSpan(
+  messages: DisplayedMessage[],
+  index: number
+): WorkBundleSpan | undefined {
+  const message = messages[index];
+  const firstEntryIndex = message?.type === "user" ? index + 1 : index;
+  const firstEntry = messages[firstEntryIndex];
+  if (getWorkBundleAgentHistoryId(firstEntry) === undefined) {
+    return undefined;
+  }
+
+  const finalIndex = findWorkBundleFinalIndex(messages, firstEntryIndex);
+  if (finalIndex === undefined) {
+    return undefined;
   }
+
+  return {
+    headIndex: message?.type === "user" ? index : firstEntryIndex,
+    firstEntryIndex,
+    ...finalIndex,
+  };
+}
+
+function findWorkBundleFinalIndex(
+  messages: DisplayedMessage[],
+  startIndex: number
+): Pick<WorkBundleSpan, "finalIndex" | "state"> | undefined {
+  const firstHistoryId = getWorkBundleAgentHistoryId(messages[startIndex]);
+  if (firstHistoryId === undefined) {
+    return undefined;
+  }
+
+  const historyIds = new Set<string>([firstHistoryId]);
+  let canCrossVisibleConversation = false;
+  let sawVisibleConversationSinceLastAgent = false;
+  let sawAnyOperationalMessage = false;
+  let sawOperationalMessage = false;
+  let sawActiveMessage = false;
+  let lastAgentIndex = startIndex;
+  let finalIndex: number | undefined;
+
+  for (let index = startIndex; index < messages.length; index++) {
+    const message = messages[index];
+    if (!isWorkBundleTimelineMessage(message)) {
+      break;
+    }
+
+    if (isWorkBundleVisibleConversationMessage(message)) {
+      if (finalIndex !== undefined) {
+        break;
+      }
+      if (message.type === "assistant" || isSideQuestionStart(messages, index)) {
+        continue;
+      }
+      if (!canCrossVisibleConversation) {
+        break;
+      }
+      if (!hasFutureWorkBundleAgentMessage(messages, index + 1)) {
+        break;
+      }
+      sawVisibleConversationSinceLastAgent = true;
+      sawOperationalMessage = false;
+      sawActiveMessage = false;
+      canCrossVisibleConversation = false;
+      continue;
+    }
+
+    const messageHistoryId = getWorkBundleAgentHistoryId(message);
+    if (messageHistoryId === undefined) {
+      break;
+    }
+    if (!historyIds.has(messageHistoryId)) {
+      if (!sawVisibleConversationSinceLastAgent) {
+        break;
+      }
+      historyIds.add(messageHistoryId);
+    }
+    sawVisibleConversationSinceLastAgent = false;
+    lastAgentIndex = index;
+    if (isActiveWorkBundleMessage(message)) {
+      sawActiveMessage = true;
+    }
+
+    if (isWorkBundleOperationalMessage(message)) {
+      sawAnyOperationalMessage = true;
+      sawOperationalMessage = true;
+    }
+    canCrossVisibleConversation = canContinueWorkBundleAcrossConversation(message);
+
+    if (message.type !== "assistant" || message.isPartial || !sawOperationalMessage) {
+      continue;
+    }
+
+    finalIndex = index;
+    canCrossVisibleConversation = false;
+  }
+
+  if (!sawAnyOperationalMessage) {
+    return undefined;
+  }
+  if (finalIndex !== undefined && finalIndex >= startIndex) {
+    return { finalIndex, state: "settled" };
+  }
+  if (sawActiveMessage && lastAgentIndex >= startIndex) {
+    return { finalIndex: lastAgentIndex, state: "active" };
+  }
+
+  return undefined;
+}
+
+function isSideQuestionStart(messages: DisplayedMessage[], index: number): boolean {
+  const next = messages[index + 1];
+  return (
+    messages[index]?.type === "user" && next?.type === "assistant" && next.isSideAnswer === true
+  );
+}
+
+function hasFutureWorkBundleAgentMessage(
+  messages: DisplayedMessage[],
+  startIndex: number
+): boolean {
+  for (let index = startIndex; index < messages.length; index++) {
+    const message = messages[index];
+    if (!isWorkBundleTimelineMessage(message)) {
+      return false;
+    }
+    if (isWorkBundleVisibleConversationMessage(message)) {
+      continue;
+    }
+
+    return getWorkBundleAgentHistoryId(message) !== undefined;
+  }
+
+  return false;
+}
+
+function canContinueWorkBundleAcrossConversation(message: DisplayedMessage): boolean {
+  // Only partial tool rows prove the agent was still doing operational work when
+  // the user spoke. Partial reasoning/text alone can also be an interrupted turn;
+  // do not anchor the next prompt under that old turn's work bundle.
+  return (
+    message.type === "tool" &&
+    message.isPartial === true &&
+    (message.status === "pending" ||
+      message.status === "executing" ||
+      message.toolName === "ask_user_question")
+  );
+}
+
+function getWorkBundleAgentHistoryId(message: DisplayedMessage | undefined): string | undefined {
+  if (!isWorkBundleAgentMessage(message) || isWorkBundleVisibleConversationMessage(message)) {
+    return undefined;
+  }
+  return message.historyId;
+}
+
+function isWorkBundleTimelineMessage(
+  message: DisplayedMessage | undefined
+): message is DisplayedMessage & { type: "assistant" | "reasoning" | "tool" | "user" } {
+  return (
+    message?.type === "assistant" ||
+    message?.type === "reasoning" ||
+    message?.type === "tool" ||
+    message?.type === "user"
+  );
+}
+
+function isWorkBundleAgentMessage(
+  message: DisplayedMessage | undefined
+): message is DisplayedMessage & { type: "assistant" | "reasoning" | "tool" } {
+  return message?.type === "assistant" || message?.type === "reasoning" || message?.type === "tool";
+}
+
+function isWorkBundleVisibleConversationMessage(message: DisplayedMessage | undefined): boolean {
+  return (
+    message?.type === "user" || (message?.type === "assistant" && message.isSideAnswer === true)
+  );
+}
+
+function isWorkBundleOperationalMessage(message: DisplayedMessage | undefined): boolean {
+  return message?.type === "reasoning" || message?.type === "tool";
 }
 
 function isActiveWorkBundleMessage(message: DisplayedMessage): boolean {
@@ -323,15 +506,6 @@ export function summarizeOperationalBundle(
   };
 }
 
-function isBundleableToolMessage(message: DisplayedMessage & { type: "tool" }): boolean {
-  if (message.isPartial) {
-    return false;
-  }
-  return (
-    message.status === "completed" || message.status === "pending" || message.status === "executing"
-  );
-}
-
 function isEmptyCompletedWebSearch(message: OperationalBundleMemberMessage): boolean {
   return (
     message.type === "tool" &&
@@ -366,7 +540,7 @@ function isOperationalBundleMemberMessage(
     return message.isOnlyMessageContent !== true;
   }
   if (message?.type === "tool") {
-    return isBundleableToolMessage(message);
+    return true;
   }
   return false;
 }
diff --git a/tests/ui/chat/transcriptDensity.test.ts b/tests/ui/chat/transcriptDensity.test.ts
new file mode 100644
index 0000000000..d1b1a2ced9
--- /dev/null
+++ b/tests/ui/chat/transcriptDensity.test.ts
@@ -0,0 +1,182 @@
+import "../dom";
+import { fireEvent, waitFor } from "@testing-library/react";
+import { updatePersistedState } from "@/browser/hooks/usePersistedState";
+import { TRANSCRIPT_DENSITY_KEY, type TranscriptDensity } from "@/common/constants/storage";
+import { setupSimpleChatStory } from "@/browser/stories/helpers/chatSetup";
+import { createWorkspace } from "@/browser/stories/mocks/workspaces";
+import { createAssistantMessage, createUserMessage } from "@/browser/stories/mocks/messages";
+import {
+  createAgentSkillReadTool,
+  createBashTool,
+  createFileReadTool,
+  createGenericTool,
+  createWebSearchTool,
+} from "@/browser/stories/mocks/tools";
+import { installDom } from "../dom";
+import { cleanupView, setupWorkspaceView } from "../helpers";
+import { renderApp } from "../renderReviewPanel";
+
+function queryButtons(container: HTMLElement, testId: string): HTMLButtonElement[] {
+  const HTMLButton = container.ownerDocument.defaultView?.HTMLButtonElement;
+  if (!HTMLButton) {
+    throw new Error("Expected test DOM to provide HTMLButtonElement");
+  }
+  return Array.from(container.querySelectorAll(`[data-testid="${testId}"]`)).flatMap((element) => {
+    if (element instanceof HTMLButton) {
+      return [element];
+    }
+    const button = element.querySelector("button");
+    return button ? [button] : [];
+  });
+}
+
+function queryButton(container: HTMLElement, testId: string): HTMLButtonElement | null {
+  const element = container.querySelector(`[data-testid="${testId}"]`);
+  const HTMLButton = container.ownerDocument.defaultView?.HTMLButtonElement;
+  if (!HTMLButton) {
+    throw new Error("Expected test DOM to provide HTMLButtonElement");
+  }
+  return element instanceof HTMLButton ? element : (element?.querySelector("button") ?? null);
+}
+
+function expectTextOrder(container: HTMLElement, ...orderedText: string[]): void {
+  const text = container.textContent ?? "";
+  let previousIndex = -1;
+  for (const expected of orderedText) {
+    const index = text.indexOf(expected);
+    if (index === -1) {
+      throw new Error(`Expected transcript text to contain "${expected}"`);
+    }
+    expect(index).toBeGreaterThan(previousIndex);
+    previousIndex = index;
+  }
+}
+
+describe("Hyper transcript density", () => {
+  test("expands work bundles and nested operational bundles through the app render path", async () => {
+    const cleanupDom = installDom();
+    updatePersistedState<TranscriptDensity>(TRANSCRIPT_DENSITY_KEY, "hyper");
+
+    const metadata = createWorkspace({
+      id: "ws-density",
+      name: "feature",
+      projectName: "my-app",
+      projectPath: "/home/user/projects/my-app",
+    });
+    const client = setupSimpleChatStory({
+      workspaceId: metadata.id,
+      workspaceName: metadata.name,
+      projectName: metadata.projectName,
+      projectPath: metadata.projectPath,
+      messages: [
+        createUserMessage("density-user-1", "Audit the auth module", {
+          historySequence: 1,
+          timestamp: 0,
+        }),
+        createAssistantMessage("density-assistant-1", "I'll gather context first.", {
+          historySequence: 2,
+          timestamp: 1_000,
+          partial: true,
+          reasoning: "Need to inspect auth code before changing it.",
+          toolCalls: [
+            createFileReadTool("density-read-1", "src/auth.ts", "export function verify() {}"),
+            createWebSearchTool("density-search-1", "JWT validation best practices", 1),
+            createAgentSkillReadTool("density-skill-1", "react-effects", { scope: "global" }),
+            createGenericTool(
+              "density-question-1",
+              "ask_user_question",
+              { question: "Any additional validation needed?" },
+              { answer: "Please validate with typecheck too" }
+            ),
+          ],
+        }),
+        createUserMessage("density-user-2", "Please validate with typecheck too", {
+          historySequence: 3,
+          timestamp: 11_000,
+        }),
+        createAssistantMessage("density-assistant-2", "I'll patch and validate now.", {
+          historySequence: 4,
+          timestamp: 21_000,
+          toolCalls: [
+            createBashTool(
+              "density-fail-1",
+              "make typecheck",
+              "Type error in src/auth.ts",
+              1,
+              30,
+              500,
+              "Failing validation"
+            ),
+            { type: "text", text: "Implemented the auth audit fix." },
+          ],
+        }),
+      ],
+    });
+    const view = renderApp({ apiClient: client, metadata });
+
+    try {
+      await setupWorkspaceView(view, metadata, metadata.id);
+
+      const workButton = await waitFor(() => {
+        const button = queryButton(view.container, "work-bundle");
+        if (!button) {
+          throw new Error("Work bundle button not found");
+        }
+        return button;
+      });
+      expect(workButton.getAttribute("aria-expanded")).toBe("false");
+      expect(view.container.textContent).toContain("Please validate with typecheck too");
+      expect(view.container.textContent).not.toContain("make typecheck");
+      expect(view.container.textContent).toContain("Implemented the auth audit fix.");
+      expect(view.container.textContent).not.toContain("I'll patch and validate now.");
+      expect(view.container.textContent).not.toContain("I'll gather context first.");
+      expectTextOrder(
+        view.container,
+        "Audit the auth module",
+        "Worked for",
+        "Please validate with typecheck too",
+        "Implemented the auth audit fix."
+      );
+      fireEvent.click(workButton);
+
+      const firstOperationalButton = await waitFor(() => {
+        const button = queryButton(view.container, "operational-bundle");
+        if (!button) {
+          throw new Error("Operational bundle button not found");
+        }
+        return button;
+      });
+      expect(firstOperationalButton.textContent).toContain("Ran 5 operations");
+      expect(view.container.textContent).toContain("Please validate with typecheck too");
+      expect(view.container.textContent).not.toContain("make typecheck");
+      expectTextOrder(
+        view.container,
+        "I'll gather context first.",
+        "Please validate with typecheck too",
+        "I'll patch and validate now."
+      );
+      fireEvent.click(firstOperationalButton);
+
+      await waitFor(() => {
+        expect(view.container.textContent).toContain("src/auth.ts");
+      });
+
+      const failedOperationalButton = await waitFor(() => {
+        const button = queryButtons(view.container, "operational-bundle").find((candidate) =>
+          candidate.textContent?.includes("Ran 1 shell command")
+        );
+        if (!button) {
+          throw new Error("Failed operational bundle button not found");
+        }
+        return button;
+      });
+      fireEvent.click(failedOperationalButton);
+
+      await waitFor(() => {
+        expect(view.container.textContent).toContain("make typecheck");
+      });
+    } finally {
+      await cleanupView(view, cleanupDom);
+    }
+  }, 30_000);
+});
diff --git a/tests/ui/chat/transcriptDensity.test.tsx b/tests/ui/chat/transcriptDensity.test.tsx
deleted file mode 100644
index 68e5e39859..0000000000
--- a/tests/ui/chat/transcriptDensity.test.tsx
+++ /dev/null
@@ -1,87 +0,0 @@
-import "../dom";
-import { fireEvent, waitFor } from "@testing-library/react";
-import { updatePersistedState } from "@/browser/hooks/usePersistedState";
-import { TRANSCRIPT_DENSITY_KEY, type TranscriptDensity } from "@/common/constants/storage";
-import { setupSimpleChatStory } from "@/browser/stories/helpers/chatSetup";
-import { createWorkspace } from "@/browser/stories/mocks/workspaces";
-import { createAssistantMessage, createUserMessage } from "@/browser/stories/mocks/messages";
-import {
-  createAgentSkillReadTool,
-  createBashTool,
-  createFileReadTool,
-  createWebSearchTool,
-} from "@/browser/stories/mocks/tools";
-import { installDom } from "../dom";
-import { cleanupView, setupWorkspaceView } from "../helpers";
-import { renderApp } from "../renderReviewPanel";
-
-function queryButton(container: HTMLElement, testId: string): HTMLButtonElement | null {
-  const element = container.querySelector(`[data-testid="${testId}"]`);
-  return element instanceof HTMLButtonElement
-    ? element
-    : (element?.querySelector("button") ?? null);
-}
-
-describe("Hyper transcript density", () => {
-  test("expands work bundles and nested operational bundles through the app render path", async () => {
-    const cleanupDom = installDom();
-    updatePersistedState<TranscriptDensity>(TRANSCRIPT_DENSITY_KEY, "hyper");
-
-    const metadata = createWorkspace({
-      id: "ws-density",
-      name: "feature",
-      projectName: "my-app",
-      projectPath: "/home/user/projects/my-app",
-    });
-    const client = setupSimpleChatStory({
-      workspaceId: metadata.id,
-      workspaceName: metadata.name,
-      projectName: metadata.projectName,
-      projectPath: metadata.projectPath,
-      messages: [
-        createUserMessage("density-user-1", "Audit the auth module", { historySequence: 1 }),
-        createAssistantMessage("density-assistant-1", "I'll gather context first.", {
-          historySequence: 2,
-          reasoning: "Need to inspect auth code before changing it.",
-          toolCalls: [
-            createFileReadTool("density-read-1", "src/auth.ts", "export function verify() {}"),
-            createWebSearchTool("density-search-1", "JWT validation best practices", 1),
-            createAgentSkillReadTool("density-skill-1", "react-effects", { scope: "global" }),
-            createBashTool("density-rg-1", 'rg "verify" src', "src/auth.ts:1:verify"),
-            { type: "text", text: "Implemented the auth audit fix." },
-          ],
-        }),
-      ],
-    });
-    const view = renderApp({ apiClient: client, metadata });
-
-    try {
-      await setupWorkspaceView(view, metadata, metadata.id);
-
-      const workButton = await waitFor(() => {
-        const button = queryButton(view.container, "work-bundle");
-        if (!button) {
-          throw new Error("Work bundle button not found");
-        }
-        return button;
-      });
-      expect(workButton.getAttribute("aria-expanded")).toBe("false");
-      fireEvent.click(workButton);
-
-      const operationalButton = await waitFor(() => {
-        const button = queryButton(view.container, "operational-bundle");
-        if (!button) {
-          throw new Error("Operational bundle button not found");
-        }
-        return button;
-      });
-      fireEvent.click(operationalButton);
-
-      await waitFor(() => {
-        expect(view.container.textContent).toContain("src/auth.ts");
-      });
-    } finally {
-      await cleanupView(view, cleanupDom);
-    }
-  }, 30_000);
-});