diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
index fbbbdd82b..250917d6e 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
@@ -1,7 +1,7 @@
 /* @vitest-environment jsdom */
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
 import { MemoryRouter, useLocation } from "react-router-dom";
 import type {
   AgentChatApprovalDecision,
@@ -66,6 +66,7 @@ import {
   deriveTurnModelState,
   findAnchoredChatEventIndex,
   formatElapsedSeconds,
+  ChatInfoHostContext,
   getTranscriptCollapseCacheKeysForTests,
   reconcileMeasuredScrollTop,
   resetTranscriptCollapseCacheForTests,
@@ -119,6 +120,7 @@ function renderMessageList(
     assistantLabel?: string;
     initialState?: Record<string, unknown>;
     showStreamingIndicator?: boolean;
+    sessionEnded?: boolean;
     sessionId?: string | null;
     transcriptCollapseCacheKey?: string | null;
     laneId?: string | null;
@@ -146,6 +148,7 @@ function renderMessageList(
         events={events}
         assistantLabel={options?.assistantLabel}
         showStreamingIndicator={options?.showStreamingIndicator}
+        sessionEnded={options?.sessionEnded}
         sessionId={options?.sessionId}
         transcriptCollapseCacheKey={options?.transcriptCollapseCacheKey}
         laneId={options?.laneId}
@@ -3171,6 +3174,155 @@ describe("AgentChatMessageList transcript rendering", () => {
     expect(transcriptOnly.container.textContent).not.toContain("Running command");
   });
 
+  it("keeps the elapsed timer ticking when the first tool call wraps the status line in a button", () => {
+    // The status line renders bare while a turn has no tool activity and moves
+    // inside an expander <button> the moment the first tool entry lands. That
+    // swap remounts the timer <span>, so a timer that captured the element once
+    // would keep writing into the detached node and freeze on screen at "0s"
+    // while "taking longer than usual" still appears — the reported bug.
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-03-17T10:00:00.000Z"));
+    try {
+      const before: AgentChatEventEnvelope[] = [
+        {
+          sessionId: "session-1",
+          timestamp: "2026-03-17T10:00:00.000Z",
+          sequence: 1,
+          event: { type: "user_message", text: "go", turnId: "turn-1" },
+        },
+        {
+          sessionId: "session-1",
+          timestamp: "2026-03-17T10:00:00.000Z",
+          sequence: 2,
+          event: { type: "text", text: "Let me check that.", itemId: "text-1", turnId: "turn-1" },
+        },
+      ];
+      const after: AgentChatEventEnvelope[] = [
+        ...before,
+        {
+          sessionId: "session-1",
+          timestamp: "2026-03-17T10:00:05.000Z",
+          sequence: 3,
+          event: {
+            type: "command",
+            command: "npm test",
+            cwd: "/repo",
+            output: "",
+            itemId: "cmd-1",
+            turnId: "turn-1",
+            status: "completed",
+            exitCode: 0,
+          },
+        },
+      ];
+
+      const view = renderMessageList(before, { showStreamingIndicator: true });
+      act(() => { vi.advanceTimersByTime(5_000); });
+      expect(view.container.textContent).toContain("working for 5s");
+
+      view.rerender(
+        <MemoryRouter initialEntries={[{ pathname: "/" }]}>
+          <AgentChatMessageList events={after} showStreamingIndicator />
+          <LocationProbe />
+        </MemoryRouter>,
+      );
+      // The expander button is now present, so the status line remounted.
+      expect(screen.getByRole("button", { name: /activity from the active turn/i })).toBeTruthy();
+
+      act(() => { vi.advanceTimersByTime(5_000); });
+      expect(view.container.textContent).toContain("working for 10s");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("renders a running background job as one line, with no dead open affordance", () => {
+    const runningJob: AgentChatEventEnvelope[] = [
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:00.000Z",
+        event: {
+          type: "scheduled_work_update",
+          id: "background:bg-1",
+          kind: "background_task",
+          status: "running",
+          title: "cd /repo && npm install",
+          sourceTaskId: "bg-1",
+        },
+      },
+    ];
+
+    // No host is listening for `ade:chat:open-info` (PersonalChatsPage is one),
+    // so the affordance must not render at all — a button that silently does
+    // nothing is worse than an absent one.
+    const withoutHost = renderMessageList(runningJob);
+    const line = withoutHost.container.querySelector("[data-background-job]")!;
+    expect(line).toBeTruthy();
+    expect(line.getAttribute("data-background-job-status")).toBe("running");
+    expect(line.textContent).toContain("npm install");
+    expect(withoutHost.container.querySelector("[data-background-job] button")).toBeNull();
+    // Windows parity: bare ⚙/✓/✗ codepoints resolve to Segoe UI Emoji there,
+    // rendering as heavier colour glyphs off the baseline of the rule line.
+    // Status is carried by a Phosphor <svg>, never a text codepoint.
+    expect(line.textContent).not.toMatch(/[⚙✓✗]/);
+    expect(line.querySelector("svg")).toBeTruthy();
+    cleanup();
+
+    // Inside a host that owns the actions pane, the affordance appears and works.
+    const withHost = render(
+      <MemoryRouter initialEntries={[{ pathname: "/" }]}>
+        <ChatInfoHostContext.Provider value={true}>
+          <AgentChatMessageList events={runningJob} />
+        </ChatInfoHostContext.Provider>
+      </MemoryRouter>,
+    );
+    const openButton = withHost.container.querySelector("[data-background-job] button")!;
+    expect(openButton).toBeTruthy();
+
+    const openInfo = vi.fn();
+    window.addEventListener("ade:chat:open-info", openInfo);
+    try {
+      fireEvent.click(openButton);
+      expect(openInfo).toHaveBeenCalledTimes(1);
+    } finally {
+      window.removeEventListener("ade:chat:open-info", openInfo);
+    }
+  });
+
+  it("does not tick a background job that never finished in an ended session", () => {
+    // An archived chat whose job never got a terminal update stays `running`
+    // forever. Reporting "1440h" is arithmetically right and useless; the row
+    // shows no duration at all rather than asserting a number nobody should act
+    // on.
+    const endedJob: AgentChatEventEnvelope[] = [
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:00.000Z",
+        event: {
+          type: "scheduled_work_update",
+          id: "background:bg-1",
+          kind: "background_task",
+          status: "running",
+          title: "cd /repo && npm run dev",
+          sourceTaskId: "bg-1",
+        },
+      },
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:01.000Z",
+        event: { type: "done", turnId: "turn-1", status: "completed" },
+      },
+    ];
+
+    const rendered = renderMessageList(endedJob, { sessionEnded: true });
+    const line = rendered.container.querySelector("[data-background-job]")!;
+    expect(line).toBeTruthy();
+    expect(line.getAttribute("data-background-job-status")).toBe("running");
+    expect(line.textContent).toContain("npm run dev");
+    // No elapsed at all — not a frozen one, and not a ticking one.
+    expect(line.textContent).not.toMatch(/\d+\s*(s|m|h|d)\b/);
+  });
+
   it("keeps narration and file changes inline while completed tool activity moves behind the status line", () => {
     const rendered = renderMessageList([
       {
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
index 549ab5d5e..9dd71a5fc 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
@@ -96,7 +96,7 @@ import {
   shouldCollapseUserMessageText,
   summarizeDiffStats,
   summarizeInlineText,
-  type BackgroundFinishChipRenderEvent,
+  type BackgroundJobLineRenderEvent,
   type ChatActivityBundleEvent,
   type ChatActivityBundleItem,
   type CollapseTranscriptResult,
@@ -109,7 +109,7 @@ import {
   type ChatTranscriptRenderEnvelope as TranscriptRenderEnvelope,
   type ChatWorkLogEntry,
 } from "./chatTranscriptRows";
-import { BackgroundFinishChip, SubagentResultCard, SubagentSpawnCard, SubagentStoppedGroupCard } from "./SubagentActivityCards";
+import { BackgroundJobLine, SubagentResultCard, SubagentSpawnCard, SubagentStoppedGroupCard } from "./SubagentActivityCards";
 import { AdeCard } from "./AdeCard";
 import { navigateToSpawnedChat } from "./spawnNavigation";
 import { ChatUserMinimap } from "./ChatUserMinimap";
@@ -957,7 +957,7 @@ type RenderEnvelope = {
   | SubagentSpawnAnchorRenderEvent
   | SubagentResultCardRenderEvent
   | SubagentStoppedGroupEvent
-  | BackgroundFinishChipRenderEvent
+  | BackgroundJobLineRenderEvent
   | ScheduledWakeDividerRenderEvent
   | SpawnWakeDividerRenderEvent;
 };
@@ -1408,6 +1408,23 @@ function openChatInfoFromActivity(sessionId: string | null | undefined, taskId:
   }
 }
 
+/**
+ * True inside a host that owns a chat actions pane and listens for
+ * `ade:chat:open-info` — i.e. `AgentChatPane`, which provides it.
+ * `PersonalChatsPage` mounts the same transcript with no actions pane and
+ * therefore leaves it false, so an affordance that opens that pane never
+ * renders as a button that silently does nothing.
+ *
+ * Deliberately a context and NOT a module-level "is any host alive" registry:
+ * `App` renders every `ProjectSurface` and only toggles `active`, so each
+ * `AgentChatPane` stays MOUNTED while Personal Chats is open. A global count
+ * would read true on exactly the surface that has no pane, and clicking would
+ * dispatch to a hidden pane that drops the event on the `sessionId` guard —
+ * recreating the dead affordance this is meant to prevent. Only the owning
+ * subtree can answer this question.
+ */
+export const ChatInfoHostContext = React.createContext(false);
+
 function activityBundleDedupeKey(item: ChatActivityBundleItem): string {
   const event = item.event;
   if (event.type === "scheduled_work_update") {
@@ -1965,16 +1982,32 @@ function WorkingIndicator({
   onRevealChatTerminal?: (terminal: { terminalId: string; ptyId: string; label: string }) => void;
   sessionId?: string | null;
 }) {
-  const timerRef = useRef<HTMLSpanElement>(null);
+  const timerRef = useRef<HTMLSpanElement | null>(null);
+  const startMsRef = useRef<number | null>(null);
   const [longRunning, setLongRunning] = useState(false);
   const [activityOpen, setActivityOpen] = useState(false);
   const hasToolActivity = toolEntries.length > 0;
+  // The status line swaps between a bare <span> and an expander <button> the
+  // moment the turn's first tool entry lands, which makes React unmount and
+  // remount the timer element. Painting through a *callback* ref (rather than
+  // an element captured once when the ticker started) reattaches the counter to
+  // whichever node is currently mounted and repaints it in the same commit, so
+  // the swap can't strand the ticker on a detached node — the bug that froze
+  // the display at "0s" while "taking longer than usual" still appeared.
+  const attachTimer = useCallback((el: HTMLSpanElement | null) => {
+    timerRef.current = el;
+    if (!el) return;
+    const startMs = startMsRef.current ?? startedAt ?? Date.now();
+    el.textContent = formatElapsedSeconds((Date.now() - startMs) / 1000);
+  }, [startedAt]);
   useEffect(() => {
     const startMs = startedAt ?? Date.now();
-    const el = timerRef.current;
+    startMsRef.current = startMs;
     let handle = 0;
     const tick = () => {
       const elapsedSec = Math.max(0, Math.floor((Date.now() - startMs) / 1000));
+      // Re-read the ref every tick — see attachTimer above.
+      const el = timerRef.current;
       if (el) el.textContent = formatElapsedSeconds(elapsedSec);
       setLongRunning(elapsedSec >= LONG_RUNNING_TURN_SECONDS);
       handle = window.setTimeout(tick, 1000);
@@ -1988,7 +2021,7 @@ function WorkingIndicator({
       <span className="min-w-0 truncate font-medium text-fg/55">{activity ?? "Working"}</span>
       <span className="shrink-0 text-fg/28" aria-hidden>·</span>
       <span className="shrink-0 text-fg/38">
-        working for <span ref={timerRef} className="tabular-nums">0s</span>
+        working for <span ref={attachTimer} className="tabular-nums">0s</span>
       </span>
       {longRunning ? (
         <>
@@ -2667,6 +2700,8 @@ function renderEvent(
     assistantTurnCopy?: { text: string } | null;
     /** Interrupt-receipt identities whose queued messages already ran → collapse. */
     staleInterruptReceipts?: Set<string>;
+    /** True when a host is listening for `ade:chat:open-info` (see the registry). */
+    chatInfoHostAvailable?: boolean;
     /** Cancel an ADE-owned queued message by uuid (stop-receipt affordance). */
     onCancelQueuedMessage?: (uuid: string) => void;
     onRestoreCancelledQueue?: (recoveryId: string) => Promise<boolean>;
@@ -3106,9 +3141,22 @@ function renderEvent(
     );
   }
 
-  /* ── Background command finish chip ── */
-  if (event.type === "background_finish_chip") {
-    return <BackgroundFinishChip event={event} />;
+  /* ── Background command one-liner (live from spawn through finish) ── */
+  if (event.type === "background_job_line") {
+    return (
+      <BackgroundJobLine
+        event={event}
+        sessionEnded={options?.sessionEnded}
+        // Same channel the sibling subagent card uses two branches up: the pane
+        // already listens for `ade:chat:open-info` and opens the agents tab,
+        // where background jobs live. A null taskId opens the tab without
+        // selecting an agent. Omitted entirely on a host with no actions pane,
+        // so the affordance never renders as a button that does nothing.
+        onOpenBackgroundJobs={options?.chatInfoHostAvailable
+          ? () => openChatInfoFromActivity(options?.sessionId, null)
+          : undefined}
+      />
+    );
   }
 
   /* ── Structured Question ── */
@@ -4613,6 +4661,7 @@ const EventRow = React.memo(function EventRow({
   const workLogAnimate = Boolean(turnActive)
     && !sessionEnded
     && Boolean(isLatestWorkLog);
+  const chatInfoHostAvailable = React.useContext(ChatInfoHostContext);
   return (
     <div
       data-chat-anchored-row={anchored ? "true" : undefined}
@@ -4689,6 +4738,7 @@ const EventRow = React.memo(function EventRow({
             sessionId,
             runtimeName,
             onRevealChatTerminal,
+            chatInfoHostAvailable,
             onRewindFiles,
             turnDiffSummaries,
             mosaic,
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
index e36d89074..f7d8fc59c 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
@@ -116,6 +116,7 @@ import { getSharedRuntimeCatalog } from "../shared/ModelPicker/runtimeCatalogCac
 import { familiesFromStatus } from "../shared/ModelPicker/useProviderAuthStatus";
 import {
   AgentChatMessageList,
+  ChatInfoHostContext,
   type MosaicRenderContext,
 } from "./AgentChatMessageList";
 import {
@@ -12954,79 +12955,84 @@ export function AgentChatPane({
                         ))}
                       </div>
                     ) : null}
-                    <AgentChatMessageList
-                      key={subagentView ? `subagent-${subagentView.taskId}` : renderedSessionId ?? "chat-draft"}
-                      events={subagentView ? subagentEventsForDisplay : selectedEventsForDisplay}
-                      showStreamingIndicator={subagentView
-                        ? subagentTranscriptLoading || subagentViewSnapshot?.status === "running"
-                        : turnActive && selectedSession?.status !== "ended"}
-                      sessionTurnActive={turnActive}
-                      sessionEnded={selectedSession?.status === "ended"}
-                      className="min-h-0 border-0"
-                      surfaceMode={surfaceMode}
-                      surfaceProfile={surfaceProfile}
-                      assistantLabel={assistantLabel}
-                      hasOlderHistory={Boolean(
-                        !subagentView
-                        && renderedSessionId
-                        && (olderHistoryCursorBySession[renderedSessionId] ?? 0) > 0,
-                      )}
-                      loadingOlderHistory={Boolean(
-                        !subagentView
-                        && renderedSessionId
-                        && olderHistoryLoadingBySession[renderedSessionId],
-                      )}
-                      olderHistoryError={
-                        !subagentView && renderedSessionId
-                          ? olderHistoryErrorBySession[renderedSessionId] ?? null
-                          : null
-                      }
-                      onLoadOlderHistory={
-                        !subagentView && renderedSessionId
-                          ? () => {
-                              void loadOlderHistory(renderedSessionId, renderedChatRuntimePin);
-                            }
-                          : undefined
-                      }
-                      onRetryOlderHistory={
-                        !subagentView && renderedSessionId
-                          ? () => {
-                              void loadOlderHistory(renderedSessionId, renderedChatRuntimePin, { interactive: true });
-                            }
-                          : undefined
-                      }
-                      onReturnToLatest={
-                        !subagentView && renderedSessionId
-                          ? () => returnHistoryToLatest(renderedSessionId, renderedChatRuntimePin)
-                          : undefined
-                      }
-                      respondingApprovalIds={respondingApprovalIds}
-                      pendingApprovalIds={pendingApprovalIds}
-                      laneId={laneId}
-                      sessionId={renderedSessionId}
-                      transcriptCollapseCacheKey={subagentView
-                        ? `subagent:${renderedSessionId ?? "chat-draft"}:${subagentView.taskId}`
-                        : undefined}
-                      onInsertDraft={insertComposerDraft}
-                      onRevealChatTerminal={revealChatTerminal}
-                      turnDiffSummaries={selectedTurnDiffSummaries}
-                      onRewindFiles={selectedSession?.provider === "claude" || selectedSession?.provider === "codex" ? rewindFilesFromMessage : undefined}
-                      onCancelQueuedMessage={!subagentView && selectedSessionId ? cancelQueuedMessageFromReceipt : undefined}
-                      onRestoreCancelledQueue={!subagentView && selectedSessionId ? restoreCancelledQueue : undefined}
-                      onApproval={handleListApproval}
-                      onCodexRecovery={handleListCodexRecovery}
-                      onRecoverContinuity={recoverContinuity}
-                      onRunUnprocessedMessage={handleRunUnprocessedMessage}
-                      onEditUnprocessedMessage={handleEditUnprocessedMessage}
-                      onDismissUnprocessedMessage={handleDismissUnprocessedMessage}
-                      onRetryProviderFailure={handleListRetryProviderFailure}
-                      onChooseProviderFailureModel={handleListChooseProviderFailureModel}
-                      mosaic={subagentView ? undefined : mosaicContext}
-                      scrollToRowKeyRequest={subagentView ? null : wakeJumpRequest}
-                      proofArtifacts={subagentView ? EMPTY_PROOF_ARTIFACTS : computerUseSnapshot?.artifacts ?? EMPTY_PROOF_ARTIFACTS}
-                      allowLocalProofArtifactProtocol={!isRemoteProject}
-                      onOpenProofDrawer={subagentView ? undefined : openProofDrawer}
-                    />
+                    {/* This host owns the chat actions pane and listens for
+                        `ade:chat:open-info`, so transcript affordances that open it
+                        may render here. PersonalChatsPage provides no such context. */}
+                    <ChatInfoHostContext.Provider value={true}>
+                      <AgentChatMessageList
+                        key={subagentView ? `subagent-${subagentView.taskId}` : renderedSessionId ?? "chat-draft"}
+                        events={subagentView ? subagentEventsForDisplay : selectedEventsForDisplay}
+                        showStreamingIndicator={subagentView
+                          ? subagentTranscriptLoading || subagentViewSnapshot?.status === "running"
+                          : turnActive && selectedSession?.status !== "ended"}
+                        sessionTurnActive={turnActive}
+                        sessionEnded={selectedSession?.status === "ended"}
+                        className="min-h-0 border-0"
+                        surfaceMode={surfaceMode}
+                        surfaceProfile={surfaceProfile}
+                        assistantLabel={assistantLabel}
+                        hasOlderHistory={Boolean(
+                          !subagentView
+                          && renderedSessionId
+                          && (olderHistoryCursorBySession[renderedSessionId] ?? 0) > 0,
+                        )}
+                        loadingOlderHistory={Boolean(
+                          !subagentView
+                          && renderedSessionId
+                          && olderHistoryLoadingBySession[renderedSessionId],
+                        )}
+                        olderHistoryError={
+                          !subagentView && renderedSessionId
+                            ? olderHistoryErrorBySession[renderedSessionId] ?? null
+                            : null
+                        }
+                        onLoadOlderHistory={
+                          !subagentView && renderedSessionId
+                            ? () => {
+                                void loadOlderHistory(renderedSessionId, renderedChatRuntimePin);
+                              }
+                            : undefined
+                        }
+                        onRetryOlderHistory={
+                          !subagentView && renderedSessionId
+                            ? () => {
+                                void loadOlderHistory(renderedSessionId, renderedChatRuntimePin, { interactive: true });
+                              }
+                            : undefined
+                        }
+                        onReturnToLatest={
+                          !subagentView && renderedSessionId
+                            ? () => returnHistoryToLatest(renderedSessionId, renderedChatRuntimePin)
+                            : undefined
+                        }
+                        respondingApprovalIds={respondingApprovalIds}
+                        pendingApprovalIds={pendingApprovalIds}
+                        laneId={laneId}
+                        sessionId={renderedSessionId}
+                        transcriptCollapseCacheKey={subagentView
+                          ? `subagent:${renderedSessionId ?? "chat-draft"}:${subagentView.taskId}`
+                          : undefined}
+                        onInsertDraft={insertComposerDraft}
+                        onRevealChatTerminal={revealChatTerminal}
+                        turnDiffSummaries={selectedTurnDiffSummaries}
+                        onRewindFiles={selectedSession?.provider === "claude" || selectedSession?.provider === "codex" ? rewindFilesFromMessage : undefined}
+                        onCancelQueuedMessage={!subagentView && selectedSessionId ? cancelQueuedMessageFromReceipt : undefined}
+                        onRestoreCancelledQueue={!subagentView && selectedSessionId ? restoreCancelledQueue : undefined}
+                        onApproval={handleListApproval}
+                        onCodexRecovery={handleListCodexRecovery}
+                        onRecoverContinuity={recoverContinuity}
+                        onRunUnprocessedMessage={handleRunUnprocessedMessage}
+                        onEditUnprocessedMessage={handleEditUnprocessedMessage}
+                        onDismissUnprocessedMessage={handleDismissUnprocessedMessage}
+                        onRetryProviderFailure={handleListRetryProviderFailure}
+                        onChooseProviderFailureModel={handleListChooseProviderFailureModel}
+                        mosaic={subagentView ? undefined : mosaicContext}
+                        scrollToRowKeyRequest={subagentView ? null : wakeJumpRequest}
+                        proofArtifacts={subagentView ? EMPTY_PROOF_ARTIFACTS : computerUseSnapshot?.artifacts ?? EMPTY_PROOF_ARTIFACTS}
+                        allowLocalProofArtifactProtocol={!isRemoteProject}
+                        onOpenProofDrawer={subagentView ? undefined : openProofDrawer}
+                      />
+                    </ChatInfoHostContext.Provider>
                     {sessionDelta ? (
                       <div className="flex items-center gap-3 border-t border-white/[0.05] px-4 py-2 font-mono text-[11px]">
                         <span className="text-emerald-400/75">+{sessionDelta.insertions}</span>
diff --git a/apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx b/apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx
index 1cffd1766..dfb999157 100644
--- a/apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx
+++ b/apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx
@@ -1,5 +1,5 @@
 import { useEffect, useState } from "react";
-import { ArrowDown, ArrowUp, CaretDown, CaretRight, Stop } from "@phosphor-icons/react";
+import { ArrowDown, ArrowUp, CaretDown, CaretRight, Check, Gear, Stop, X } from "@phosphor-icons/react";
 import { cn } from "../ui/cn";
 import { formatSubagentDurationMs } from "../../lib/format";
 import { ChatSubagentGlyph, chatSubagentColor } from "./chatSubagentIdentity";
@@ -17,7 +17,7 @@ import {
 } from "./chatCardPrimitives";
 import { formatContextTokens } from "./usage/contextUsageModel";
 import type {
-  BackgroundFinishChipRenderEvent,
+  BackgroundJobLineRenderEvent,
   SubagentResultCardRenderEvent,
   SubagentSpawnAnchorRenderEvent,
   SubagentStoppedGroupEvent,
@@ -54,13 +54,37 @@ export function spawnTypeAccent(
 // Two rows per real subagent — a spawn card anchored where it started, and a
 // result card at the settle position. Both inherit the chat accent
 // (`--chat-accent`) and mirror the calm styling idiom of AgentCliAuthCard
-// (soft-tinted card, no red error blocks). Background shell commands render a
-// single compact finish chip instead of cards.
+// (soft-tinted card, no red error blocks). Background shell commands get no
+// cards at all — just the single `BackgroundJobLine` one-liner below.
 
-function liveElapsedText(startedAt: string, nowMs: number): string | null {
-  const start = Date.parse(startedAt);
-  if (!Number.isFinite(start)) return null;
-  return formatSubagentDurationMs(Math.max(0, nowMs - start));
+/**
+ * Live elapsed since a start timestamp, ticking once a second while `running`.
+ * Shared by the spawn card and the background-job line — the one live-duration
+ * ticker in this file.
+ *
+ * Anchored to the real start timestamp rather than to mount time, so scrolling
+ * the row out of the virtualizer and back keeps the true elapsed instead of
+ * restarting from zero. Same shape as `useElapsedLabel` in `SessionStatusLabel`
+ * — a state tick on a leaf that renders one line, so the per-second re-render
+ * never reaches the memoized transcript rows around it. (`WorkingIndicator`'s
+ * ticker is deliberately NOT this: it mutates `textContent` through a ref to
+ * avoid a per-second commit on the message list itself.)
+ *
+ * Returns null for an absent or unparseable timestamp so callers render no
+ * duration rather than `NaN`.
+ */
+function useLiveDurationMs(startedAt: string | null, running: boolean): number | null {
+  const startMs = startedAt ? Date.parse(startedAt) : Number.NaN;
+  const anchored = Number.isFinite(startMs) ? startMs : null;
+  const [nowMs, setNowMs] = useState(() => Date.now());
+  useEffect(() => {
+    if (!running || anchored == null) return undefined;
+    setNowMs(Date.now());
+    const id = window.setInterval(() => setNowMs(Date.now()), 1_000);
+    return () => window.clearInterval(id);
+  }, [running, anchored]);
+  if (anchored == null) return null;
+  return Math.max(0, nowMs - anchored);
 }
 
 function glyphStatusFor(status: SubagentSpawnAnchorRenderEvent["status"]): ChatSubagentSnapshot["status"] {
@@ -85,16 +109,11 @@ export function SubagentSpawnCard({
   laneId?: string | null;
 }) {
   const isRunning = event.status === "running";
-  const [nowMs, setNowMs] = useState(() => Date.now());
-  useEffect(() => {
-    if (!isRunning) return;
-    const intervalId = window.setInterval(() => setNowMs(Date.now()), 1000);
-    return () => window.clearInterval(intervalId);
-  }, [isRunning]);
+  const liveMs = useLiveDurationMs(event.startedAt, isRunning);
 
   const color = chatSubagentColor(event.agentKey);
   const elapsed = isRunning
-    ? liveElapsedText(event.startedAt, nowMs)
+    ? formatSubagentDurationMs(liveMs)
     : formatSubagentDurationMs(
         event.endedAt ? Math.max(0, Date.parse(event.endedAt) - Date.parse(event.startedAt)) : null,
       );
@@ -366,34 +385,92 @@ export function SubagentResultCard({
 }
 
 /**
- * Compact single-line finish chip for a backgrounded shell command:
- * `✓ background command finished · exit <code?> · <duration>` (✗ variant for
- * failure/stopped). Calm styling, never a red error block.
+ * The whole in-thread presence of a backgrounded shell command: one quiet
+ * centered rule-line, in the same idiom as the scheduled-wake and spawn-return
+ * dividers — deliberately NOT a card. Background jobs are frequent and rarely
+ * the point of the turn, so they get a line, not a block.
+ *
+ * Running:  `⚙ Background · npm install · 47s        [open]`
+ * Finished: `✓ Background · npm install · exit 0 · 4m [open]`
+ *
+ * (`formatSubagentDurationMs` is lossy above a minute — `4m`, not `4m 11s`.)
+ *
+ * `open` reveals the chat actions pane, which is where a background job's full
+ * state and output already live — the line points at it rather than duplicating
+ * it inline.
  */
-export function BackgroundFinishChip({ event }: { event: BackgroundFinishChipRenderEvent }) {
+export function BackgroundJobLine({
+  event,
+  sessionEnded = false,
+  onOpenBackgroundJobs,
+}: {
+  event: BackgroundJobLineRenderEvent;
+  /**
+   * Freezes the ticker. A job whose terminal update was never written (app
+   * killed mid-run, provider crash) stays `running` in the transcript forever;
+   * without this, reopening that dead chat months later renders a live counter
+   * ticking up from a session that ended long ago — and holds an interval open
+   * for as long as the row is mounted.
+   */
+  sessionEnded?: boolean;
+  onOpenBackgroundJobs?: () => void;
+}) {
+  const running = event.status === "running";
+  // A frozen counter is still a wrong counter: an archived job that never got a
+  // terminal update would otherwise read "1440h" — accurate arithmetic, useless
+  // claim. Drop the duration entirely rather than assert a number nobody should
+  // read.
+  const stale = running && sessionEnded;
+  const liveMs = useLiveDurationMs(event.startedAt, running && !sessionEnded);
   const ok = event.status === "completed";
-  const duration = formatSubagentDurationMs(event.durationMs);
+  const duration = formatSubagentDurationMs(running ? (stale ? null : liveMs) : event.durationMs);
   const parts = [
-    "background command finished",
-    typeof event.exitCode === "number" ? `exit ${event.exitCode}` : null,
+    event.label,
+    !running && typeof event.exitCode === "number" ? `exit ${event.exitCode}` : null,
     duration,
+    !running && !ok ? event.status : null,
   ].filter((part): part is string => Boolean(part));
 
+  const skin = running
+    ? { tone: "text-sky-200/60", rule: "bg-sky-200/[0.09]" }
+    : ok
+      ? { tone: "text-fg/45", rule: "bg-white/[0.06]" }
+      : { tone: "text-amber-100/70", rule: "bg-amber-200/[0.10]" };
+
   return (
     <div
       className={cn(
-        "inline-flex max-w-[var(--chat-content-width,52rem)] items-center gap-2 overflow-hidden rounded-md border px-2.5 py-1 font-mono text-[length:calc(var(--chat-font-size)*10/14)]",
-        ok
-          ? "border-white/[0.07] bg-white/[0.025] text-fg/55"
-          : "border-amber-300/14 bg-amber-300/[0.05] text-amber-100/75",
+        "my-2 flex items-center gap-2 font-sans text-[length:calc(var(--chat-font-size)*10.5/14)]",
+        skin.tone,
       )}
-      title={event.label}
+      data-background-job={event.agentKey}
+      data-background-job-status={event.status}
     >
-      <span aria-hidden className="shrink-0">{ok ? "✓" : "✗"}</span>
-      <span className="min-w-0 truncate">
-        {parts.join(" · ")}
-        {event.label ? <span className="ml-2 text-fg/38">· {event.label}</span> : null}
+      <span className={cn("h-px flex-1", skin.rule)} />
+      <span className="inline-flex min-w-0 shrink items-center gap-1.5" title={event.label}>
+        {/* Phosphor rather than raw codepoints: bare ⚙/✓/✗ resolve to Segoe UI
+            Emoji on Windows, rendering as heavier colour glyphs that sit off
+            the baseline of a 10.5px rule line. */}
+        {running
+          ? <Gear size={10} weight="bold" aria-hidden className="shrink-0" />
+          : ok
+            ? <Check size={10} weight="bold" aria-hidden className="shrink-0" />
+            : <X size={10} weight="bold" aria-hidden className="shrink-0" />}
+        <span className="min-w-0 truncate">
+          Background · {parts.join(" · ")}
+        </span>
       </span>
+      {onOpenBackgroundJobs ? (
+        <button
+          type="button"
+          onClick={onOpenBackgroundJobs}
+          className="inline-flex shrink-0 cursor-pointer items-center gap-0.5 rounded-full px-1.5 py-0.5 text-current opacity-70 transition-opacity hover:opacity-100 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-sky-300/40"
+          title="Show background jobs in the chat actions pane"
+        >
+          open<CaretRight size={9} weight="bold" aria-hidden />
+        </button>
+      ) : null}
+      <span className={cn("h-px flex-1", skin.rule)} />
     </div>
   );
 }
diff --git a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
index 3d32aeba2..008cfcced 100644
--- a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
+++ b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
@@ -2466,6 +2466,40 @@ describe("subagent two-row rendering", () => {
         status: "failed",
         summary: "tests failed",
       }),
+      // Both background-job producers, so `background_job_line`'s context cache
+      // (`backgroundJobRowIndexByKey`) and the `backgroundLineOpened` latch are
+      // covered by the parity guarantee too — they are rebuilt from the event
+      // stream on a full recompute and must not diverge from the incremental
+      // path's carried state.
+      env("2026-06-01T10:00:08.000Z", {
+        type: "scheduled_work_update",
+        id: "background:bg-live",
+        kind: "background_task",
+        status: "running",
+        title: "cd /repo && npm run dev",
+        sourceTaskId: "bg-live",
+      }),
+      env("2026-06-01T10:00:09.000Z", {
+        type: "subagent_started",
+        taskId: "bg-legacy",
+        taskType: "background",
+        description: "cd /repo && npm install",
+      }),
+      env("2026-06-01T10:00:10.000Z", {
+        type: "scheduled_work_update",
+        id: "background:bg-live",
+        kind: "background_task",
+        status: "completed",
+        title: "cd /repo && npm run dev",
+        sourceTaskId: "bg-live",
+      }),
+      env("2026-06-01T10:00:11.000Z", {
+        type: "subagent_result",
+        taskId: "bg-legacy",
+        taskType: "background",
+        status: "completed",
+        summary: "exited 0",
+      }),
     ];
 
     const full = collapseChatTranscriptEvents(stream);
@@ -2584,7 +2618,7 @@ describe("subagent two-row rendering", () => {
     expect(incremental.rows).toEqual(full);
   });
 
-  it("renders old-style background shell subagent events as one finish chip, no cards", () => {
+  it("renders old-style background shell subagent events as one job line, no cards", () => {
     const rows = collapseChatTranscriptEvents([
       env("2026-06-01T10:00:00.000Z", {
         type: "subagent_started",
@@ -2607,13 +2641,123 @@ describe("subagent two-row rendering", () => {
     ]);
 
     expect(rows).toHaveLength(1);
-    if (rows[0]!.event.type !== "background_finish_chip") throw new Error("Expected finish chip");
+    if (rows[0]!.event.type !== "background_job_line") throw new Error("Expected background job line");
     expect(rows[0]!.event.status).toBe("completed");
     expect(rows[0]!.event.label).toBe("npm run dev");
     expect(rows[0]!.key).toBe("background-chip:bg-1");
   });
 
-  it("dedupes a double background result into one finish chip", () => {
+  it("shows a background job in the thread while it is still running", () => {
+    // Regression: the line used to be pushed only on the terminal event, so a
+    // long background job left the thread completely silent while the sidebar
+    // flipped to a duration-less "Working" — together they read as a hung turn.
+    const rows = collapseChatTranscriptEvents([
+      env("2026-06-01T10:00:00.000Z", {
+        type: "subagent_started",
+        taskId: "bg-1",
+        taskType: "background",
+        description: "cd /repo && npm install",
+      }),
+    ]);
+
+    expect(rows).toHaveLength(1);
+    if (rows[0]!.event.type !== "background_job_line") throw new Error("Expected background job line");
+    expect(rows[0]!.event.status).toBe("running");
+    expect(rows[0]!.event.label).toBe("npm install");
+    expect(rows[0]!.key).toBe("background-chip:bg-1");
+  });
+
+  it("mutates the running background line in place instead of adding a finish row", () => {
+    const rows = collapseChatTranscriptEvents([
+      env("2026-06-01T10:00:00.000Z", {
+        type: "subagent_started",
+        taskId: "bg-1",
+        taskType: "background",
+        description: "cd /repo && npm install",
+      }),
+      env("2026-06-01T10:00:01.000Z", {
+        type: "subagent_progress",
+        taskId: "bg-1",
+        summary: "resolving packages",
+      }),
+      env("2026-06-01T10:00:30.000Z", {
+        type: "subagent_result",
+        taskId: "bg-1",
+        taskType: "background",
+        status: "completed",
+        summary: "exited 0",
+      }),
+    ]);
+
+    // One row for the job's whole life — spawn, progress, and finish all land
+    // on the same key, so a turn that starts several jobs cannot stack rows.
+    expect(rows).toHaveLength(1);
+    const settled = rows[0]!.event;
+    if (settled.type !== "background_job_line") throw new Error("Expected background job line");
+    if (settled.status === "running") throw new Error("Expected a settled job line");
+    expect(settled.status).toBe("completed");
+    expect(settled.durationMs).toBe(30_000);
+    expect(rows[0]!.key).toBe("background-chip:bg-1");
+  });
+
+  it("does not reopen a settled background line when a late progress tick arrives", () => {
+    // Providers do emit a trailing progress notification after a job already
+    // settled. Rewriting the row back to `running` would drop its exit code and
+    // duration and restart a ticker that then never stops.
+    const rows = collapseChatTranscriptEvents([
+      env("2026-06-01T10:00:00.000Z", {
+        type: "subagent_started",
+        taskId: "bg-1",
+        taskType: "background",
+        description: "cd /repo && npm install",
+      }),
+      env("2026-06-01T10:00:30.000Z", {
+        type: "subagent_result",
+        taskId: "bg-1",
+        taskType: "background",
+        status: "completed",
+        summary: "exited 0",
+      }),
+      env("2026-06-01T10:00:31.000Z", {
+        type: "subagent_progress",
+        taskId: "bg-1",
+        summary: "late tick",
+      }),
+    ]);
+
+    expect(rows).toHaveLength(1);
+    const settled = rows[0]!.event;
+    if (settled.type !== "background_job_line") throw new Error("Expected background job line");
+    expect(settled.status).toBe("completed");
+  });
+
+  it("keeps a background job as one line when a late agentType would reclassify it", () => {
+    // `preferredSubagentAgentType` upgrades "background" to a real agent type,
+    // which used to flip the classification mid-flight: the running one-liner
+    // was stranded forever AND a full subagent result card was pushed for the
+    // same task.
+    const rows = collapseChatTranscriptEvents([
+      env("2026-06-01T10:00:00.000Z", {
+        type: "subagent_started",
+        taskId: "bg-1",
+        taskType: "background",
+        description: "cd /repo && npm install",
+      }),
+      env("2026-06-01T10:00:30.000Z", {
+        type: "subagent_result",
+        taskId: "bg-1",
+        taskType: "background",
+        agentType: "Explore",
+        status: "completed",
+        summary: "exited 0",
+      }),
+    ]);
+
+    expect(rows).toHaveLength(1);
+    expect(rows[0]!.event.type).toBe("background_job_line");
+  });
+
+  it("dedupes a double background result into one job line", () => {
     const rows = collapseChatTranscriptEvents([
       env("2026-06-01T10:00:00.000Z", {
         type: "subagent_started",
@@ -2638,18 +2782,25 @@ describe("subagent two-row rendering", () => {
     ]);
 
     expect(rows).toHaveLength(1);
-    if (rows[0]!.event.type !== "background_finish_chip") throw new Error("Expected finish chip");
+    if (rows[0]!.event.type !== "background_job_line") throw new Error("Expected background job line");
     expect(rows[0]!.event.status).toBe("failed");
   });
 
-  it("drops background_task scheduled_work_update from the in-thread transcript", () => {
+  it("renders the LIVE background_task scheduled_work stream as the job line", () => {
+    // This is the only shape a running app actually emits for a backgrounded
+    // shell: `emitClaudeBackgroundTaskUpdate` fires a background_task
+    // scheduled_work_update on spawn and on exit, and deliberately emits NO
+    // subagent lifecycle events for these tasks. It used to be dropped outright,
+    // so the in-thread row existed only for legacy replayed transcripts and
+    // never appeared for a job you actually started.
     const rows = collapseChatTranscriptEvents([
       env("2026-06-01T10:00:00.000Z", {
         type: "scheduled_work_update",
-        id: "bg-task-1",
+        id: "background:bg-task-1",
         kind: "background_task",
         status: "running",
         title: "cd /repo && npm run dev",
+        sourceTaskId: "bg-task-1",
       }),
       env("2026-06-01T10:00:01.000Z", {
         type: "scheduled_work_update",
@@ -2660,10 +2811,115 @@ describe("subagent two-row rendering", () => {
       }),
     ]);
 
-    // background_task produces no thread row; the cron survives.
+    expect(rows).toHaveLength(2);
+    const job = rows[0]!.event;
+    if (job.type !== "background_job_line") throw new Error("Expected background job line");
+    expect(job.status).toBe("running");
+    expect(job.label).toBe("npm run dev");
+    // Same key space as the legacy subagent producer, so a transcript carrying
+    // both shapes for one task still renders exactly one row.
+    expect(rows[0]!.key).toBe("background-chip:bg-task-1");
+    // Other scheduled kinds are untouched.
+    if (rows[1]!.event.type !== "scheduled_work_update") throw new Error("Expected scheduled_work_update");
+    expect(rows[1]!.event.kind).toBe("cron");
+  });
+
+  it("never renders a job line for a real subagent reported through the background stream", () => {
+    // `applyClaudeBackgroundTasksLevel` gates only on task_type, so an agent
+    // that reports none reaches the background emitter. Without the identity
+    // guard the agent got its spawn/result cards AND a job line wedged between
+    // them. Both orderings are covered — the stream is unspecified.
+    const scheduledFirst = collapseChatTranscriptEvents([
+      env("2026-06-01T10:00:00.000Z", {
+        type: "scheduled_work_update",
+        id: "background:agent-1",
+        kind: "background_task",
+        status: "running",
+        title: "Investigate route tree",
+        sourceTaskId: "agent-1",
+      }),
+      env("2026-06-01T10:00:01.000Z", {
+        type: "subagent_started",
+        taskId: "agent-1",
+        agentType: "Explore",
+        description: "Investigate route tree",
+      }),
+    ]);
+    expect(scheduledFirst.map((row) => row.event.type)).toEqual(["subagent_spawn_anchor"]);
+
+    const lifecycleFirst = collapseChatTranscriptEvents([
+      env("2026-06-01T10:00:00.000Z", {
+        type: "subagent_started",
+        taskId: "agent-1",
+        agentType: "Explore",
+        description: "Investigate route tree",
+      }),
+      env("2026-06-01T10:00:01.000Z", {
+        type: "scheduled_work_update",
+        id: "background:agent-1",
+        kind: "background_task",
+        status: "running",
+        title: "Investigate route tree",
+        sourceTaskId: "agent-1",
+      }),
+    ]);
+    expect(lifecycleFirst.map((row) => row.event.type)).toEqual(["subagent_spawn_anchor"]);
+  });
+
+  it("drops the job line when a real subagent's ONLY lifecycle event is its result", () => {
+    // Reachable from a truncated or replayed transcript: history paging can
+    // drop `subagent_started` while the scheduled-work update survives. The
+    // guard used to live only on the spawn path, so this ordering left the job
+    // line in the transcript beside the agent's card pair.
+    const rows = collapseChatTranscriptEvents([
+      env("2026-06-01T10:00:00.000Z", {
+        type: "scheduled_work_update",
+        id: "background:agent-1",
+        kind: "background_task",
+        status: "running",
+        title: "Investigate route tree",
+        sourceTaskId: "agent-1",
+      }),
+      env("2026-06-01T10:00:30.000Z", {
+        type: "subagent_result",
+        taskId: "agent-1",
+        agentType: "Explore",
+        status: "completed",
+        summary: "found it",
+      }),
+    ]);
+
+    expect(rows.map((row) => row.event.type)).not.toContain("background_job_line");
+    expect(rows.map((row) => row.event.type)).toEqual(["subagent_result_card"]);
+  });
+
+  it("settles the live background job line in place with a measured duration", () => {
+    const rows = collapseChatTranscriptEvents([
+      env("2026-06-01T10:00:00.000Z", {
+        type: "scheduled_work_update",
+        id: "background:bg-task-1",
+        kind: "background_task",
+        status: "running",
+        title: "cd /repo && npm test",
+        sourceTaskId: "bg-task-1",
+      }),
+      env("2026-06-01T10:02:00.000Z", {
+        type: "scheduled_work_update",
+        id: "background:bg-task-1",
+        kind: "background_task",
+        status: "failed",
+        title: "cd /repo && npm test",
+        sourceTaskId: "bg-task-1",
+      }),
+    ]);
+
     expect(rows).toHaveLength(1);
-    if (rows[0]!.event.type !== "scheduled_work_update") throw new Error("Expected scheduled_work_update");
-    expect(rows[0]!.event.kind).toBe("cron");
+    const settled = rows[0]!.event;
+    if (settled.type !== "background_job_line") throw new Error("Expected background job line");
+    if (settled.status === "running") throw new Error("Expected a settled job line");
+    expect(settled.status).toBe("failed");
+    // Measured from the row's own first sighting, not from the terminal event.
+    expect(settled.durationMs).toBe(120_000);
   });
 
   it("derives a wake divider before every unattended scheduled turn", () => {
diff --git a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts
index 0c03dd73b..d194b5d88 100644
--- a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts
+++ b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts
@@ -3,9 +3,10 @@ import {
   mergeReasoningTextFragments,
   type ActivityPhaseMergeMeta,
 } from "../../../shared/chatActivityPhase";
-import type { AgentChatEvent, AgentChatEventEnvelope, AgentChatSpawnKind, CodexWebSearchResult } from "../../../shared/types";
+import type { AgentChatEvent, AgentChatEventEnvelope, AgentChatScheduledWorkStatus, AgentChatSpawnKind, CodexWebSearchResult } from "../../../shared/types";
 import {
   isBackgroundShellCommand,
+  isRealSubagent,
   longerSubagentText,
   normalizeSubagentLifecycleEvent,
   preferSubagentSummary,
@@ -202,19 +203,46 @@ export type SubagentStoppedGroupEvent = {
 };
 
 /**
- * Compact finish chip for a backgrounded shell command (no spawn/result cards).
- * Row key: `background-chip:${agentKey}`.
+ * The whole in-thread presence of a backgrounded shell command: ONE quiet
+ * one-liner, pushed where the job started and mutated in place through to its
+ * terminal state (no spawn/result cards, and never a second row).
+ *
+ * It used to be a finish-only chip, so a job that ran for minutes left the
+ * thread completely silent while the sidebar flipped to a duration-less
+ * "Working" — the two together read as a stalled turn. Showing the line from
+ * the start costs no extra rows (the terminal update reuses this one) and gives
+ * the run somewhere to point at.
+ *
+ * TWO producers feed this one row type, and they must land on the SAME key or a
+ * mixed transcript renders the job twice:
+ *   - the live Claude runtime, which reports background shells as
+ *     `scheduled_work_update {kind:"background_task"}` (see
+ *     `emitClaudeBackgroundTaskUpdate`) — this is the only producer a running
+ *     app actually emits;
+ *   - legacy `subagent_*` lifecycle events carrying `taskType: background`,
+ *     which is all that older persisted transcripts contain.
+ *
+ * Row key: `background-chip:${agentKey}` — unchanged from the finish-chip era on
+ * purpose; the virtualizer's measuredHeights are keyed by it.
+ *
+ * Modelled as a union so "running ⇒ no outcome yet" is enforced by the type
+ * rather than by a comment on four independently-nullable fields.
  */
-export type BackgroundFinishChipRenderEvent = {
-  type: "background_finish_chip";
+export type BackgroundJobLineRenderEvent = {
+  type: "background_job_line";
   agentKey: string;
   label: string;
-  status: SubagentCardTerminalStatus;
-  exitCode: number | null;
-  durationMs: number | null;
   startedAt: string | null;
-  endedAt: string;
-};
+} & (
+  | { status: "running" }
+  | {
+      status: SubagentCardTerminalStatus;
+      /** Null when the producer reports no exit code (the live runtime does not). */
+      exitCode: number | null;
+      /** Wall-clock between the job's first and last row update. */
+      durationMs: number | null;
+    }
+);
 
 export type ScheduledWakeDividerRenderEvent = {
   type: "scheduled_wake_divider";
@@ -248,7 +276,7 @@ export type ChatTranscriptRenderEvent =
   | WorkLogRenderEvent
   | SubagentSpawnAnchorRenderEvent
   | SubagentResultCardRenderEvent
-  | BackgroundFinishChipRenderEvent
+  | BackgroundJobLineRenderEvent
   | ScheduledWakeDividerRenderEvent
   | SpawnWakeDividerRenderEvent;
 
@@ -274,8 +302,10 @@ type TodoUpdateTranscriptEvent = Extract<AgentChatEvent, { type: "todo_update" }
 /**
  * Live per-subagent state threaded through the collapse pass. `rowIndex` lets an
  * appended progress/result event index back into the rows array and mutate the
- * anchor in place. Subagent lifecycle handling never splices rows; transcript
- * retractions repair every stored position after removing a text row.
+ * anchor in place. Subagent lifecycle handling splices exactly one kind of row —
+ * a stale background-job line the scheduled-work producer opened for what turns
+ * out to be a real subagent; transcript retractions remove text rows. Both
+ * repair every stored position afterwards.
  */
 type SubagentAnchorState = {
   agentKey: string;
@@ -291,7 +321,14 @@ type SubagentAnchorState = {
   /** Index of the result-card row once the agent ends (null until then). */
   resultRowIndex: number | null;
   /** Index of the background finish-chip row (null unless a background shell). */
-  chipRowIndex: number | null;
+  /**
+   * Latched once this task has opened a background-job line. Classification is
+   * derived per event and can legitimately FLIP: a late `agentType` upgrades
+   * `background` to a real subagent type, which would otherwise strand the
+   * running one-liner forever AND push a full result card for the same task.
+   * Once the line exists, the task stays a background job.
+   */
+  backgroundLineOpened: boolean;
   description: string | null;
   agentType: string | null;
   taskType: string | null;
@@ -344,6 +381,12 @@ type CollapseTranscriptContext = {
    * the update — the same discipline as the subagent spawn anchor above.
    */
   adeCardRowIndexById: Map<string, number>;
+  /**
+   * `background_job_line` rows keyed by their row key. Keyed by row key rather
+   * than task id because two different producers (live scheduled-work updates
+   * and legacy subagent lifecycle events) upsert into the same key space.
+   */
+  backgroundJobRowIndexByKey: Map<string, number>;
 };
 
 export function createCollapseTranscriptContext(): CollapseTranscriptContext {
@@ -357,6 +400,7 @@ export function createCollapseTranscriptContext(): CollapseTranscriptContext {
     recoveryRowIndexByTurn: new Map(),
     stalledRowIndexByTurn: new Map(),
     adeCardRowIndexById: new Map(),
+    backgroundJobRowIndexByKey: new Map(),
   };
 }
 
@@ -965,7 +1009,7 @@ function backgroundChipKey(agentKey: string): string {
   return `background-chip:${agentKey}`;
 }
 
-type SubagentRowPosition = "rowIndex" | "resultRowIndex" | "chipRowIndex";
+type SubagentRowPosition = "rowIndex" | "resultRowIndex";
 
 function resolveSubagentRowPosition(
   rows: ChatTranscriptRenderEnvelope[],
@@ -991,7 +1035,7 @@ function repairSubagentRowPositionsAfterSplice(
   removedIndex: number,
 ): void {
   for (const state of new Set(context.subagentAnchors.values())) {
-    for (const position of ["rowIndex", "resultRowIndex", "chipRowIndex"] as const) {
+    for (const position of ["rowIndex", "resultRowIndex"] as const) {
       const storedIndex = state[position];
       if (storedIndex === removedIndex) state[position] = null;
       else if (storedIndex != null && storedIndex > removedIndex) state[position] = storedIndex - 1;
@@ -1010,6 +1054,7 @@ function repairIndexedTranscriptRowsAfterSplice(
     context.recoveryRowIndexByTurn,
     context.stalledRowIndexByTurn,
     context.adeCardRowIndexById,
+    context.backgroundJobRowIndexByKey,
   ]) {
     for (const [key, storedIndex] of rowIndexes) {
       if (storedIndex === removedIndex) rowIndexes.delete(key);
@@ -1025,13 +1070,13 @@ function repairIndexedTranscriptRowsAfterSplice(
  * appends without a context, and it guarantees a `cardId` can never mint two
  * rows sharing one React key. Both agree because only one row ever holds a key.
  */
-function resolveAdeCardRowIndex(
+function resolveKeyedRowIndex(
   rows: ChatTranscriptRenderEnvelope[],
-  context: CollapseTranscriptContext | undefined,
-  cardId: string,
+  rowIndexes: Map<string, number> | undefined,
+  lookupKey: string,
   expectedKey: string,
 ): number | null {
-  const stored = context?.adeCardRowIndexById.get(cardId);
+  const stored = rowIndexes?.get(lookupKey);
   if (stored != null && rows[stored]?.key === expectedKey) return stored;
   for (let index = rows.length - 1; index >= 0; index -= 1) {
     if (rows[index]?.key === expectedKey) return index;
@@ -1039,6 +1084,15 @@ function resolveAdeCardRowIndex(
   return null;
 }
 
+function resolveAdeCardRowIndex(
+  rows: ChatTranscriptRenderEnvelope[],
+  context: CollapseTranscriptContext | undefined,
+  cardId: string,
+  expectedKey: string,
+): number | null {
+  return resolveKeyedRowIndex(rows, context?.adeCardRowIndexById, cardId, expectedKey);
+}
+
 type AdeCardEvent = Extract<AgentChatEvent, { type: "ade_card" }>;
 
 /**
@@ -1116,6 +1170,120 @@ function backgroundExitCode(event: NormalizedSubagentLifecycleEvent): number | n
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
+/**
+ * Human label for a background job's one-liner. `backgroundCommandLabel` strips
+ * the shell noise (`cd /repo && …`) down to the part worth reading; the raw
+ * command and description are the fallbacks, in that order.
+ */
+function backgroundJobLabel(state: SubagentAnchorState): string {
+  return backgroundCommandLabel(state.command ?? state.description ?? "")
+    || state.command
+    || state.description
+    || "Background command";
+}
+
+/**
+ * Row position of an existing background-job line, keyed by its own row key.
+ */
+function resolveBackgroundJobRowIndex(
+  rows: ChatTranscriptRenderEnvelope[],
+  context: CollapseTranscriptContext | undefined,
+  expectedKey: string,
+): number | null {
+  return resolveKeyedRowIndex(rows, context?.backgroundJobRowIndexByKey, expectedKey, expectedKey);
+}
+
+/**
+ * Drop a background-job line that a later event proved was never a background
+ * job at all — see the real-subagent guard in the `background_task` handler.
+ */
+function removeBackgroundJobLine(
+  rows: ChatTranscriptRenderEnvelope[],
+  context: CollapseTranscriptContext,
+  expectedKey: string,
+): void {
+  const rowIndex = resolveBackgroundJobRowIndex(rows, context, expectedKey);
+  if (rowIndex == null) return;
+  rows.splice(rowIndex, 1);
+  repairIndexedTranscriptRowsAfterSplice(context, rowIndex);
+}
+
+/**
+ * Push the job's one-liner, or mutate the existing one in place — a NEW object
+ * under the SAME row key, matching how the spawn anchor updates. Keeping one
+ * row for the job's whole life is what stops a busy turn from stacking a
+ * running row and a finished row for every background command it starts, and is
+ * what lets the live and legacy producers converge on one row.
+ *
+ * A terminal row is never reopened. Providers do emit a trailing progress tick
+ * after a job has already settled, and rewriting the row back to `running`
+ * would drop its exit code and duration and restart a ticker that then never
+ * stops.
+ */
+function upsertBackgroundJobLine(
+  rows: ChatTranscriptRenderEnvelope[],
+  context: CollapseTranscriptContext | undefined,
+  expectedKey: string,
+  timestamp: string,
+  event: BackgroundJobLineRenderEvent,
+): void {
+  const rowIndex = resolveBackgroundJobRowIndex(rows, context, expectedKey);
+  if (rowIndex == null) {
+    context?.backgroundJobRowIndexByKey.set(expectedKey, rows.length);
+    rows.push({ key: expectedKey, timestamp, event });
+    return;
+  }
+  const existing = rows[rowIndex]!.event;
+  if (existing.type === "background_job_line" && existing.status !== "running") {
+    if (event.status === "running") return;
+  }
+  context?.backgroundJobRowIndexByKey.set(expectedKey, rowIndex);
+  rows[rowIndex] = { key: expectedKey, timestamp, event };
+}
+
+/**
+ * The job's start anchor: whatever the row already recorded, so a terminal
+ * update computes its duration from the first sighting rather than from itself.
+ */
+function backgroundJobStartedAt(
+  rows: ChatTranscriptRenderEnvelope[],
+  rowIndex: number | null,
+  fallback: string,
+): string {
+  if (rowIndex == null) return fallback;
+  const existing = rows[rowIndex]?.event;
+  if (existing?.type !== "background_job_line") return fallback;
+  return existing.startedAt ?? fallback;
+}
+
+/**
+ * Scheduled-work status → the job line's status. `paused` has no meaning for a
+ * background shell (nothing pauses one) and is treated as still running rather
+ * than inventing a terminal outcome the runtime never reported.
+ */
+function backgroundJobStatusFromScheduledWork(
+  status: AgentChatScheduledWorkStatus,
+): SubagentCardStatus {
+  // Enumerated rather than defaulted: a terminal status added to
+  // AgentChatScheduledWorkStatus later must fail the build here instead of
+  // silently rendering as a job that never finishes.
+  switch (status) {
+    case "completed":
+      return "completed";
+    case "stopped":
+    case "cancelled":
+      return "stopped";
+    case "failed":
+    case "missed":
+      return "failed";
+    case "scheduled":
+    case "paused":
+    case "running":
+    case "fired":
+      return "running";
+  }
+}
+
 // Best-effort parent label from the anchors map — the parent's description or
 // agentType. Null when the parent isn't (yet) in the map; renders nothing.
 function resolveParentLabel(
@@ -1203,9 +1371,11 @@ function classificationInput(state: SubagentAnchorState) {
  * Handle one of the three subagent lifecycle events. Returns true if the event
  * was consumed (caller should stop). Mutates rows and context in place.
  *
- * INVARIANT: this never SPLICES rows — only pushes at the tail or replaces an
- * existing row by its stored index. Every replacement verifies the stable key
- * and repairs a stale position before mutating.
+ * INVARIANT: the ONLY splice is the stale background-job-line drop below, which
+ * repairs every stored position through `repairIndexedTranscriptRowsAfterSplice`.
+ * Card rows are never spliced — only pushed at the tail or replaced by their
+ * stored index, and every replacement verifies the stable key and repairs a
+ * stale position before mutating.
  */
 function handleSubagentLifecycleEvent(
   rows: ChatTranscriptRenderEnvelope[],
@@ -1239,7 +1409,7 @@ function handleSubagentLifecycleEvent(
       renderKeyBase: agentKey,
       rowIndex: null,
       resultRowIndex: null,
-      chipRowIndex: null,
+      backgroundLineOpened: false,
       description: null,
       agentType: null,
       taskType: null,
@@ -1267,10 +1437,51 @@ function handleSubagentLifecycleEvent(
   }
 
   enrichSubagentStateFromEvent(state, event);
-  const backgroundShell = isBackgroundShellCommand(classificationInput(state));
+  const backgroundShell = state.backgroundLineOpened
+    || isBackgroundShellCommand(classificationInput(state));
+
+  // The counterpart to the real-subagent guard in the `background_task` handler:
+  // scheduled-work and lifecycle ordering is unspecified, so the job line may
+  // already exist by the time this task proves itself a real subagent. Drop it
+  // before any card lands, or the agent renders as a job line AND a card pair.
+  //
+  // Hoisted above the event-type split deliberately: a truncated or replayed
+  // transcript can deliver `subagent_result` as a task's ONLY lifecycle event,
+  // which never passes through the spawn branch.
+  //
+  // Note the two guards are counterparts, NOT complements: that one requires
+  // `isRealSubagent`, this one only requires "not proven a background shell".
+  // A task with neither `taskType` nor `agentType` satisfies neither, so it can
+  // still have its line re-created by a later scheduled-work update. That gap is
+  // unreachable today — the runtime emits no lifecycle events for background
+  // tasks — so both sides are deliberately left as they are rather than flipped
+  // blind to a predicate the tests do not pin.
+  if (!backgroundShell) {
+    for (const identity of [state.renderKeyBase, agentKey, taskId]) {
+      if (identity) removeBackgroundJobLine(rows, context, backgroundChipKey(identity));
+    }
+  }
 
   if (event.type === "subagent_started" || event.type === "subagent_progress") {
-    if (backgroundShell) return true; // background shell → chip only, no cards
+    // Background shell → the single one-liner, never spawn/result cards. Pushed
+    // on the first lifecycle event so the run is visible while it runs; the
+    // terminal event below mutates this same row rather than adding another.
+    // A progress tick that arrives AFTER the job settled is ignored rather than
+    // reopening the finished row (`upsertBackgroundJobLine` enforces the same
+    // rule for the live producer).
+    if (backgroundShell) {
+      if (state.endedAt == null) {
+        state.backgroundLineOpened = true;
+        upsertBackgroundJobLine(rows, context, backgroundChipKey(state.renderKeyBase), timestamp, {
+          type: "background_job_line",
+          agentKey: state.renderKeyBase,
+          label: backgroundJobLabel(state),
+          status: "running",
+          startedAt: state.startedAt,
+        });
+      }
+      return true;
+    }
     if (state.rowIndex == null) {
       // First lifecycle → push the spawn anchor and record its index.
       state.status = "running";
@@ -1312,29 +1523,17 @@ function handleSubagentLifecycleEvent(
   const terminalStatus = event.status;
 
   if (backgroundShell) {
-    const label = backgroundCommandLabel(state.command ?? state.description ?? "")
-      || state.command
-      || state.description
-      || "Background command";
     state.endedAt = timestamp;
-    const chipEvent: BackgroundFinishChipRenderEvent = {
-      type: "background_finish_chip",
+    state.backgroundLineOpened = true;
+    upsertBackgroundJobLine(rows, context, backgroundChipKey(state.renderKeyBase), timestamp, {
+      type: "background_job_line",
       agentKey: state.renderKeyBase,
-      label,
+      label: backgroundJobLabel(state),
       status: terminalStatus,
       exitCode: backgroundExitCode(event),
       durationMs: durationMsBetween(state.startedAt, timestamp),
       startedAt: state.startedAt,
-      endedAt: timestamp,
-    };
-    if (state.chipRowIndex == null) {
-      state.chipRowIndex = rows.length;
-      rows.push({ key: backgroundChipKey(state.renderKeyBase), timestamp, event: chipEvent });
-    } else {
-      const expectedKey = backgroundChipKey(state.renderKeyBase);
-      const rowIndex = resolveSubagentRowPosition(rows, state, "chipRowIndex", expectedKey);
-      if (rowIndex != null) rows[rowIndex] = { key: expectedKey, timestamp, event: chipEvent };
-    }
+    });
     return true;
   }
 
@@ -1859,14 +2058,60 @@ export function appendCollapsedChatTranscriptEvent(
     }
   }
 
-  // `background_task` scheduled work is owned by the actions pane — never render
-  // an in-thread row for it. Other scheduled kinds keep their current behavior.
+  // `background_task` scheduled work IS how the live Claude runtime reports a
+  // backgrounded shell command — `emitClaudeBackgroundTaskUpdate` fires one of
+  // these on spawn and one on exit, and deliberately emits no subagent
+  // lifecycle events for these tasks at all. This used to be dropped outright
+  // ("the actions pane owns it"), which left a running job with no in-thread
+  // presence whatsoever while the sidebar flipped to a bare "Working" — the two
+  // together read as a hung turn. It now drives the same single one-liner the
+  // legacy subagent path produces, on the same row key, so a transcript holding
+  // both shapes still renders exactly one row per job.
+  //
+  // Other scheduled kinds (wakeup/cron/loop) keep their existing behavior.
   if (event.type === "scheduled_work_update" && event.kind === "background_task") {
+    const taskKey = event.sourceTaskId?.trim() || event.id;
+    if (!taskKey) return;
+    // A REAL subagent can also be reported through this stream: the level-set
+    // path (`applyClaudeBackgroundTasksLevel`) gates only on task_type, so an
+    // agent that reports none falls through to the background emitter. Without
+    // this guard the agent gets its spawn/result card pair AND a job line
+    // wedged between them. The identity filter matches the one
+    // `deriveBackgroundItems` and the iOS timeline already apply.
+    const anchor = context?.subagentAnchors.get(taskKey);
+    if (anchor && isRealSubagent(classificationInput(anchor))) return;
+    const expectedKey = backgroundChipKey(taskKey);
+    const rowIndex = resolveBackgroundJobRowIndex(rows, context, expectedKey);
+    const startedAt = backgroundJobStartedAt(rows, rowIndex, envelope.timestamp);
+    const status = backgroundJobStatusFromScheduledWork(event.status);
+    const label = backgroundCommandLabel(event.title ?? "")
+      || event.title
+      || "Background command";
+    upsertBackgroundJobLine(
+      rows,
+      context,
+      expectedKey,
+      envelope.timestamp,
+      status === "running"
+        ? { type: "background_job_line", agentKey: taskKey, label, startedAt, status }
+        : {
+            type: "background_job_line",
+            agentKey: taskKey,
+            label,
+            startedAt,
+            status,
+            // The scheduled-work wire format carries no exit code; duration is
+            // measured from the row's own first sighting instead of trusting
+            // the free-text summary the emitter composes.
+            exitCode: null,
+            durationMs: durationMsBetween(startedAt, envelope.timestamp),
+          },
+    );
     return;
   }
 
-  // Subagent lifecycle → two-row spawn/result cards (or a single finish chip for
-  // background shell commands). Normalize canonical dotted events first, then
+  // Subagent lifecycle → two-row spawn/result cards (or a single live one-liner
+  // for background shell commands). Normalize canonical dotted events first, then
   // fold every lifecycle event into the anchor state (handled BEFORE the generic
   // passthrough so no raw subagent_* row ever reaches the activity bundler).
   if (event.type === "codex_image_generation" || event.type === "codex_image_view") {
@@ -2278,9 +2523,10 @@ export function groupConsecutiveWorkLogRows(
 }
 
 function isActivityBundleSourceEvent(event: ChatTranscriptRenderEvent): event is ChatActivityBundleItem["event"] {
-  // Subagent lifecycle events now render as dedicated spawn/result/chip rows and
-  // never reach here. `background_task` scheduled work is dropped in the collapse
-  // pass (the actions pane owns it); other scheduled kinds keep bundling.
+  // Subagent lifecycle events now render as dedicated spawn/result/job-line rows
+  // and never reach here. `background_task` scheduled work is consumed by the
+  // collapse pass into a `background_job_line`; other scheduled kinds keep
+  // bundling.
   return event.type === "todo_update"
     || (event.type === "scheduled_work_update" && event.kind !== "background_task");
 }
diff --git a/apps/desktop/src/renderer/components/personalChats/PersonalChatsPage.test.tsx b/apps/desktop/src/renderer/components/personalChats/PersonalChatsPage.test.tsx
index 293fdda43..98464ca8f 100644
--- a/apps/desktop/src/renderer/components/personalChats/PersonalChatsPage.test.tsx
+++ b/apps/desktop/src/renderer/components/personalChats/PersonalChatsPage.test.tsx
@@ -47,6 +47,7 @@ vi.mock("../shared/ModelPicker/ReasoningEffortPicker", () => ({
 type MessageListHarnessProps = {
   events: AgentChatEventEnvelope[];
   sessionId?: string | null;
+  sessionEnded?: boolean;
   hasOlderHistory?: boolean;
   loadingOlderHistory?: boolean;
   olderHistoryError?: string | null;
@@ -71,6 +72,7 @@ vi.mock("../chat/AgentChatMessageList", () => ({
         data-has-older={props.hasOlderHistory ? "true" : "false"}
         data-loading-older={props.loadingOlderHistory ? "true" : "false"}
         data-older-error={props.olderHistoryError ?? ""}
+        data-session-ended={props.sessionEnded ? "true" : "false"}
       >
         <button
           type="button"
@@ -265,6 +267,36 @@ describe("PersonalChatsPage", () => {
     expect(textarea.closest("[data-composer-variant]")?.getAttribute("data-composer-variant")).toBe("docked");
   });
 
+  it("tells the transcript when an ended chat is ended", async () => {
+    // Rows that hold a live clock -- a background job left `running` by a
+    // restart -- freeze on an ended session. That only works if the host says
+    // the session ended; this one used to derive turnActive and nothing else,
+    // so an archived personal chat counted up forever.
+    state.sessions = [makeSession({ title: "Archived chat", status: "ended" })];
+    state.historyEvents = [
+      { sessionId: "s1", timestamp: new Date().toISOString(), sequence: 1, event: { type: "assistant", text: "hi" } },
+    ];
+    await renderPage();
+
+    fireEvent.click(await screen.findByText("Archived chat"));
+
+    const list = await screen.findByTestId("message-list");
+    expect(list.getAttribute("data-session-ended")).toBe("true");
+  });
+
+  it("leaves a live chat unmarked so its tickers keep running", async () => {
+    state.sessions = [makeSession({ title: "Live chat", status: "active" })];
+    state.historyEvents = [
+      { sessionId: "s1", timestamp: new Date().toISOString(), sequence: 1, event: { type: "assistant", text: "hi" } },
+    ];
+    await renderPage();
+
+    fireEvent.click(await screen.findByText("Live chat"));
+
+    const list = await screen.findByTestId("message-list");
+    expect(list.getAttribute("data-session-ended")).toBe("false");
+  });
+
   it("pages through empty cursor windows and prepends older transcript events", async () => {
     const newer = makeHistoryEvent({
       sequence: 2,
diff --git a/apps/desktop/src/renderer/components/personalChats/PersonalChatsPage.tsx b/apps/desktop/src/renderer/components/personalChats/PersonalChatsPage.tsx
index b2f85deb5..8c8076201 100644
--- a/apps/desktop/src/renderer/components/personalChats/PersonalChatsPage.tsx
+++ b/apps/desktop/src/renderer/components/personalChats/PersonalChatsPage.tsx
@@ -827,6 +827,11 @@ export function PersonalChatsPage({ standalone = false }: { standalone?: boolean
                     key={selectedId}
                     events={selectedEvents}
                     showStreamingIndicator={turnActive}
+                    // Same derivation as AgentChatPane. Rows that tick a live
+                    // clock (a background job stuck `running` after a restart)
+                    // must freeze on an ended chat here too, or an archived
+                    // personal chat counts up forever.
+                    sessionEnded={selectedSession?.status === "ended"}
                     laneId={null}
                     sessionId={selectedId}
                     assistantLabel={selectedSession ? sessionTitle(selectedSession) : "ADE"}
diff --git a/apps/desktop/src/renderer/components/terminals/SessionCard.test.tsx b/apps/desktop/src/renderer/components/terminals/SessionCard.test.tsx
index 5954cc4c2..f1064da08 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionCard.test.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionCard.test.tsx
@@ -1041,13 +1041,46 @@ describe("SessionCard status vocabulary", () => {
     expect(status.textContent).not.toContain("12m");
   });
 
-  it("shows Working when the foreground turn is idle but background work remains", () => {
+  it("names background work and times it when the foreground turn is idle", () => {
+    // Regression: this row used to read as a bare "Working" with no duration,
+    // which is indistinguishable from a live turn that has stalled — it claimed
+    // the model was thinking when the turn had already ended, and gave no
+    // elapsed to judge it by.
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-05-23T10:00:45.000Z"));
+    try {
+      const { container } = render(
+        <SessionCard
+          session={makeSession({
+            toolType: "claude-chat",
+            runtimeState: "idle",
+            lastActivityAt: "2026-05-23T10:00:00.000Z",
+            activeBackgroundTaskCount: 1,
+          })}
+          lane={lane}
+          isSelected={false}
+          onSelect={vi.fn()}
+          onContextMenu={vi.fn()}
+        />,
+      );
+
+      const status = container.querySelector("[data-session-status]")!;
+      expect(status.getAttribute("data-session-status")).toBe("Background work");
+      expect(status.getAttribute("data-session-tone")).toBe("blue");
+      expect(status.textContent).toContain("Background work");
+      expect(status.textContent).toContain("45s");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("counts concurrent background jobs in the status label", () => {
     const { container } = render(
       <SessionCard
         session={makeSession({
           toolType: "claude-chat",
           runtimeState: "idle",
-          activeBackgroundTaskCount: 1,
+          activeBackgroundTaskCount: 3,
         })}
         lane={lane}
         isSelected={false}
@@ -1057,9 +1090,7 @@ describe("SessionCard status vocabulary", () => {
     );
 
     const status = container.querySelector("[data-session-status]")!;
-    expect(status.getAttribute("data-session-status")).toBe("Working");
-    expect(status.getAttribute("data-session-tone")).toBe("blue");
-    expect(status.textContent).toBe("Working");
+    expect(status.getAttribute("data-session-status")).toBe("Background work ×3");
   });
 
   it("shows a compact Waiting countdown only after the foreground turn is idle", () => {
diff --git a/apps/desktop/src/renderer/lib/terminalAttention.test.ts b/apps/desktop/src/renderer/lib/terminalAttention.test.ts
index a54afeb8f..f1bcafb3f 100644
--- a/apps/desktop/src/renderer/lib/terminalAttention.test.ts
+++ b/apps/desktop/src/renderer/lib/terminalAttention.test.ts
@@ -279,7 +279,7 @@ describe("terminalAttention", () => {
       expect(idle?.tone).toBe("emerald");
     });
 
-    it("keeps an idle chat Working while authoritative background tasks remain", () => {
+    it("names and times background work on an idle chat, and outranks a pending wake", () => {
       const presentation = sessionStatusDisplay({
         status: "running",
         runtimeState: "idle",
@@ -290,12 +290,15 @@ describe("terminalAttention", () => {
         nowMs: Date.parse("2026-08-01T10:00:00.000Z"),
       });
 
+      // Not a bare "Working": the foreground turn has ENDED, so claiming the
+      // model is working — with no duration to judge it by — reads exactly like
+      // a turn that has hung. Name the state and show how long it has run.
       expect(presentation).toMatchObject({
-        label: "Working",
+        label: "Background work ×2",
         tone: "blue",
         glyph: "working",
       });
-      expect(presentation?.showsElapsed).toBe(false);
+      expect(presentation?.showsElapsed).toBe(true);
     });
 
     it("shows Waiting only for an idle chat with a valid future wake", () => {
diff --git a/apps/desktop/src/shared/sessionStatusPresentation.ts b/apps/desktop/src/shared/sessionStatusPresentation.ts
index 89d5d6fe7..a9f386bab 100644
--- a/apps/desktop/src/shared/sessionStatusPresentation.ts
+++ b/apps/desktop/src/shared/sessionStatusPresentation.ts
@@ -169,15 +169,24 @@ export function sessionStatusPresentation(
     };
   }
 
-  if (
-    (phase === "ready" || phase === "idle")
-    && (activity.activeBackgroundTaskCount ?? 0) > 0
-  ) {
+  // The turn is over but a backgrounded job outlives it. This previously read
+  // as a bare "Working" with no duration, which is indistinguishable from a
+  // live turn that has stalled — the row claimed the model was thinking when it
+  // had already finished, and offered no elapsed to judge it by. Name the state
+  // for what it is and let the row show its elapsed.
+  //
+  // That elapsed is time since the session's last activity (the caller supplies
+  // the anchor — see `SessionStatusSlot`), NOT the job's own runtime, which is
+  // not in the session summary. It is a proxy: a job launched early in a long
+  // turn reads ~0s at turn end. `showsElapsed` also re-enables the breathing
+  // animation, which is intended — background work genuinely is a live state.
+  const backgroundJobCount = activity.activeBackgroundTaskCount ?? 0;
+  if ((phase === "ready" || phase === "idle") && backgroundJobCount > 0) {
     return {
-      label: "Working",
+      label: backgroundJobCount > 1 ? `Background work ×${backgroundJobCount}` : "Background work",
       tone: "blue",
       glyph: "working",
-      showsElapsed: false,
+      showsElapsed: true,
       prominent: false,
     };
   }
diff --git a/apps/ios/ADE/Views/Work/WorkTimelineHelpers.swift b/apps/ios/ADE/Views/Work/WorkTimelineHelpers.swift
index 0579d6a39..64f79aeba 100644
--- a/apps/ios/ADE/Views/Work/WorkTimelineHelpers.swift
+++ b/apps/ios/ADE/Views/Work/WorkTimelineHelpers.swift
@@ -2842,8 +2842,19 @@ private func eventCard(
       return nil
     case .scheduledWorkUpdate(_, let kind, let status, _, let title, let summary, let prompt, let reason, let cron, let nextRunAt, _, _, _, _, _, _, _, let turnId, let error):
       // Background shell commands are owned by the Chat Info pane's Background
-      // section (and a compact timeline finish chip). Mirrors desktop, which
-      // stops rendering an inline scheduled-work card for background_task.
+      // section (and a compact timeline finish chip).
+      //
+      // KNOWN DIVERGENCE — desktop no longer drops these. It folds the
+      // background_task stream into a single live `background_job_line` in the
+      // thread (see `chatTranscriptRows.ts`), anchored at the job's first
+      // sighting and mutated in place at exit. Because the live Claude runtime
+      // reports a backgrounded shell ONLY through this stream — never as
+      // subagent lifecycle events — a running job currently has no mobile
+      // timeline presence at all; only legacy `subagent_*` transcripts produce
+      // the iOS finish chip.
+      //
+      // This is unported work, not a deliberate platform difference. Porting it
+      // needs a machine that can compile and run the iOS target.
       guard kind.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() != "background_task" else {
         return nil
       }
diff --git a/docs/features/chat/README.md b/docs/features/chat/README.md
index 598c93f15..f6560f020 100644
--- a/docs/features/chat/README.md
+++ b/docs/features/chat/README.md
@@ -76,7 +76,7 @@ for its separate RPC, sync, storage, and UI contracts.
 | `apps/desktop/src/main/services/opencode/openCodeInventory.ts` | OpenCode provider/model probe. Now classifies model variants into `reasoningTiers` + `serviceTiers` (alias map covering `minimal`/`mini`/`med`/`xhigh`/`extra-high`), reads `capabilities` (tools/vision/reasoning) into descriptor capabilities, and tracks both `modelIds` (connected providers only) and `catalogModelIds` (the full browseable catalog). Anthropic rows normalize generic `opus` to Opus 5 with its `high` default reasoning effort and Fast capability; retired Sonnet 4.6 / basic Opus 4.7 ids still resolve to Sonnet 5 / Opus 4.8 so runtime catalogs cannot reintroduce removed picker rows. `OpenCodeProviderInfo.availableModelCount` exposes the connected count separately from `modelCount`. **Cross-launch persistence:** `persistOpenCodeInventory(projectRoot, providers)` writes each successful probe's provider list (keyed by project root, with `savedAt`) to `opencode-inventory-cache.json` under Electron `userData` (override via `ADE_OPENCODE_INVENTORY_CACHE_FILE`); on a cold start the Settings page reloads that persisted list flagged stale (`opencodeProvidersStale`) so the ~160-provider chip cloud renders immediately instead of blanking until the first live probe (stale-while-revalidate). Writes are best-effort and never break the probe. |
 | `apps/desktop/src/main/services/opencode/openCodeAuthService.ts` | Drives the managed OpenCode server's auth API for subscription connect + API-key seeding, reusing the shared inventory server lease (never spawning its own process). `listAuthMethods` reads `GET /provider/auth`; `startOAuth` authorizes (`POST /provider/{id}/oauth/authorize`), opens the returned URL, and polls `provider.list().connected` every 2s until connected or a 5-min timeout, re-probing inventory on success; `cancelOAuth` stops the poller; `setProviderKey` does `PUT /auth/{id}` and mirrors the key into ADE's `apiKeyStore` so it is re-injected on future launches. One flow per `providerId` at a time (a new start supersedes the prior). Transitions are published through `addOpenCodeOAuthStatusListener` (`pending`/`connected`/`cancelled`/`timeout`/`failed`), a multi-sink fan-out so the same event reaches desktop windows and the remote/web runtime event buffer. Seeded credentials land in ADE's isolated managed OpenCode dir (XDG roots under `userData/opencode-runtime/xdg-v*`), never the user's `~/.local/share/opencode`. |
 | `apps/desktop/src/shared/chatTranscript.ts` | Pure JSON-lines parser for `AgentChatEventEnvelope` values. Used by both the main process and the renderer. |
-| `apps/desktop/src/shared/chatSubagents.ts` | Cross-target subagent helpers: `normalizeSubagentLifecycleEvent` (canonicalizes legacy `subagent_*` and dotted `subagent.*` envelopes), the stable `groupPaneSectionItems` partition and pane caps, `buildSubagentPaneRows`, tagged pane click targets, `buildSubagentTranscriptEvents`, `isLifecycleEventForSnapshot`, plus the `latestPlan` derivation. The partition keeps source order, forces pinned rows into the active cap, and excludes visually cleared Completed ids. It also owns the shared subagent-vs-background classification (`isBackgroundShellCommand`, `isRealSubagent`, `isNonAgentTaskRun`, `subagentAgentKey`) — `isNonAgentTaskRun` flags a `task_type` `other` run with no agent metadata (a plain Claude Code task, not a subagent) so both the idle-turn and foreground paths keep it out of the roster. Claude's raw `local_bash` kind is normalized only after explicit background evidence (`background_tasks_changed`, `is_backgrounded`, or `run_in_background`) because foreground Bash emits the same kind. The file also owns summary-quality helpers and `deriveSubagentTimelineRows` → `SubagentTimelineRow` (`spawn` / `result` / `background_chip`). Desktop consumes the partition directly; ADE Code consumes the expanded row model; iOS mirrors the same predicates and caps. |
+| `apps/desktop/src/shared/chatSubagents.ts` | Cross-target subagent helpers: `normalizeSubagentLifecycleEvent` (canonicalizes legacy `subagent_*` and dotted `subagent.*` envelopes), the stable `groupPaneSectionItems` partition and pane caps, `buildSubagentPaneRows`, tagged pane click targets, `buildSubagentTranscriptEvents`, `isLifecycleEventForSnapshot`, plus the `latestPlan` derivation. The partition keeps source order, forces pinned rows into the active cap, and excludes visually cleared Completed ids. It also owns the shared subagent-vs-background classification (`isBackgroundShellCommand`, `isRealSubagent`, `isNonAgentTaskRun`, `subagentAgentKey`) — `isNonAgentTaskRun` flags a `task_type` `other` run with no agent metadata (a plain Claude Code task, not a subagent) so both the idle-turn and foreground paths keep it out of the roster. Claude's raw `local_bash` kind is normalized only after explicit background evidence (`background_tasks_changed`, `is_backgrounded`, or `run_in_background`) because foreground Bash emits the same kind. The file also owns summary-quality helpers and `deriveSubagentTimelineRows` → `SubagentTimelineRow` (`spawn` / `result` / `background_chip`) — the portable timeline shape iOS mirrors, not what the desktop transcript renders; that pipeline is `chatTranscriptRows.ts`. Desktop consumes the partition directly; ADE Code consumes the expanded row model; iOS mirrors the same predicates and caps. |
 | `apps/desktop/src/shared/chatScheduledWork.ts` | Cross-target scheduled-work validation and derivation. `resolveScheduledWorkTiming` accepts exactly one timing form: five-field brain-local cron, offset-qualified absolute `runAt`, or relative `delaySeconds`; it rejects ambiguous, past, non-integer, and unrepresentable schedules before persistence. The rest of the module folds `scheduled_work_update` envelopes into stable snapshots for Claude wakeups, cron tasks, `/loop`, remote triggers, and background work, then merges the transcript projection with the KV-backed management snapshot from `AgentChatSessionSummary.scheduledWork`. The merge removes stale active durable transcript rows that no longer exist in the management store, preserves provider-only/non-durable activity for display, and marks only ADE-managed rows as cancellable. It also partitions rows by surface: `deriveScheduleItems` returns schedule kinds (`wakeup` / `cron` / `loop` / `remote_trigger`) while `deriveBackgroundItems` returns `background_task` rows that do not duplicate a real subagent with the same `sourceTaskId`. A parent turn's terminal event does not coerce surviving background work to stopped; only an explicit work terminal state or runtime teardown does. `isEarlierBackgroundItem`, `isFiredOneShotWakeup`, and `isEarlierScheduleItem` define the shared Earlier membership mirrored by ADE Code and iOS. |
 | `apps/desktop/src/main/services/chat/claudeWorkflowProgress.ts` | Defensive normalizer for the Claude Agent SDK's undocumented `workflow_progress` snapshot on `system:task_progress` (Workflow orchestration runs). Parses phases + per-agent entries (caps counts, clips previews, drops malformed entries, unknown states degrade to queued/running; unparseable snapshots return undefined so the generic task rendering is untouched), then `planClaudeWorkflowAgentTransitions` diffs each cumulative tick against per-task emit state to fan out `subagent_started/progress/result` events under a stable `<taskId>::a<index>` identity with the emitted agentId latched at first emission. Consumed by `agentChatService`'s `task_progress`/`task_notification` handlers and the interrupt path (which close still-running agents as `stopped`). |
 | `apps/desktop/src/shared/chatMosaic.ts` | Mosaic v1 — agent-emitted interactive cards. Strict versioned (`"v":1`) parser for ```` ```mosaic ```` fence bodies (`parseMosaicCard`: unknown version/element types, duplicate ids, or malformed JSON → null → callers render the plain fence), submission serializer (`serializeMosaicSubmission`: readable lines + machine JSON, sent through the normal `agentChat.send` path with `displayText`), and `summarizeMosaicCard` for the TUI's one-line summary. Data only — no expressions, no eval, no host actions. Schema documented for agents in the `ade-mosaic` Agent Skill (`apps/desktop/resources/agent-skills/ade-mosaic/SKILL.md`). |
@@ -91,12 +91,12 @@ for its separate RPC, sync, storage, and UI contracts.
 | `apps/desktop/src/renderer/lib/draftLaunchJobs.ts` | Shared renderer helper for Work draft-launch job DTOs and pruning. Owns `NativeControlState`, `DraftLaunchSnapshot`, `PreparedDraftLaunch`, `DraftLaunchJobStatus`, `DraftLaunchJob`, `isDraftLaunchJobTerminal`, `isDraftLaunchJobStale`, and `pruneDraftLaunchJobs`; active jobs are kept ahead of terminal rows, with terminal rows filling the remaining retained slots and at least one terminal row retained alongside active jobs. Also owns the launch durability constants/helpers: `DRAFT_LAUNCH_TIMEOUT_MS` (90 s) + `withDraftLaunchTimeout(promise, label)` (rejects a launch step whose runtime call never settles; the underlying IPC is not cancellable, so on timeout it keeps running detached and the timeout only unwedges the renderer-side job) and `LAUNCH_PROJECT_CHANGED_MESSAGE` (the legacy/unpinned abort error used only when no originating project binding is available and the active project drifts mid-launch). |
 | `apps/desktop/src/renderer/lib/handoffLaunchJobs.ts` | Shared renderer helper for in-flight chat handoff placeholders. Defines the handoff job DTO, scope keying, mode-aware status labels (`preparing-summary` for brief, `forking-history` for fork), search matching, the stable placeholder id used by the Work session sidebar, and `handoffJobLikelyMaterialized` — the ADE-122 dedupe that hides a placeholder as soon as a matching real session row (same lane + tool type, started at/after the job began) is visible, so an in-flight handoff never reads as two new sessions with one vanishing. |
 | `apps/desktop/src/renderer/state/appStore.ts` | Shared renderer state store. Besides project/lane/work selection, it persists user preferences such as `launchPromptClipboardEnabled`, `launchPromptClipboardNoticeEnabled`, and the default-on `promptStashButtonEnabled`, mirrors them into per-project stores, and owns `draftLaunchJobsByScope` (+ `setDraftLaunchJobs`) for Work draft launch status strips plus `handoffLaunchJobsByScope` (+ `setHandoffLaunchJobs`) for Work sidebar handoff placeholders. These live in the **root** store (not the per-project store) on purpose: in-flight launches must survive a remote project switch that destroys the originating per-project store; `AgentChatPane` reads them via `useRootAppStore` / `rootAppStoreApi.getState()`. |
-| `apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx` | Virtualized transcript renderer. Coalesces resize / measurement updates and, while sticky-to-bottom is active, follows height changes across multiple animation frames so streamed output and late row measurements do not leave the user above the newest message. Programmatic scroll writes are tracked by target scroll position, not a stale counter, so browser-coalesced scroll events do not swallow the next real user gesture. Workspace paths in Markdown links and inline code render with an explicit file glyph/click treatment and navigate with a relative path + lane id; `FilesTab` resolves that target against the active runtime's workspace roster, so the same click opens the correct file for local and remote-bound desktop projects without treating a remote path as a local OS file. Activity bundles fold todo/scheduled updates and placeholder subagent updates into compact rows, dedupe placeholder subagent parents once the concrete child id is known, and open Chat Info / subagent detail instead of duplicating the drawer roster inline; real subagents instead render as inline `SubagentSpawnCard` / `SubagentResultCard` rows anchored where they started and settled (background shell commands collapse to a single `BackgroundFinishChip`), with jump-to-result / jump-to-start affordances that reuse the stable-row scroll machinery; a run of two or more interrupt-stopped subagents folds into one calm `SubagentStoppedGroupCard` instead of a wall of identical stopped cards. Synthetic scheduled turns render an amber `Woke on schedule` divider with fire time, reason, and late marker; the existing stable-row scroll machinery accepts jump requests from the while-you-were-away strip. Completed-turn dividers bucket chat-owned proof by capture timestamp, expose a collapsed `N proof` chip, and expand the filmstrip directly beneath the producing turn; there is no proof footer pinned to the tail. Codex goal lifecycle events render as compact user-facing rows (`Goal set`, `Goal paused`, `Goal cleared`) instead of raw JSON-RPC/status wording. Codex runtime notices (`codex_safety_buffering`, `codex_moderation_metadata`, `codex_sleep`, `codex_thread_deleted`) render as small transcript chips. `codex_turn_stalled` renders a live recovery card: Wait re-arms the watchdog, Nudge sends a status steer, Retry interrupts and replays work in the same thread, and Resume restarts app-server, resumes the thread, and retries. Handoff brief user messages with `metadata.hideFullPrompt` show only their `displayText` breadcrumb and do not expose or copy the internal prompt body. History seeded into a forked chat (envelopes tagged `providerOrigin: "handoff_fork"`) renders under a single `Forked from the previous chat — full history above` divider pinned to the first live row after the seeded tail, rather than a per-row marker. Error events whose `errorInfo.agentCli.category` is `"unauthenticated"` render as the calm `AgentCliAuthCard` (raw 401 behind a `Details` disclosure) rather than the red error block, so a recoverable logout reads as a re-login prompt, not a crash. |
+| `apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx` | Virtualized transcript renderer. Coalesces resize / measurement updates and, while sticky-to-bottom is active, follows height changes across multiple animation frames so streamed output and late row measurements do not leave the user above the newest message. Programmatic scroll writes are tracked by target scroll position, not a stale counter, so browser-coalesced scroll events do not swallow the next real user gesture. Workspace paths in Markdown links and inline code render with an explicit file glyph/click treatment and navigate with a relative path + lane id; `FilesTab` resolves that target against the active runtime's workspace roster, so the same click opens the correct file for local and remote-bound desktop projects without treating a remote path as a local OS file. Activity bundles fold todo/scheduled updates and placeholder subagent updates into compact rows, dedupe placeholder subagent parents once the concrete child id is known, and open Chat Info / subagent detail instead of duplicating the drawer roster inline; real subagents instead render as inline `SubagentSpawnCard` / `SubagentResultCard` rows anchored where they started and settled (a backgrounded shell command instead gets a single `BackgroundJobLine` that covers its whole life), with jump-to-result / jump-to-start affordances that reuse the stable-row scroll machinery; a run of two or more interrupt-stopped subagents folds into one calm `SubagentStoppedGroupCard` instead of a wall of identical stopped cards. Synthetic scheduled turns render an amber `Woke on schedule` divider with fire time, reason, and late marker; the existing stable-row scroll machinery accepts jump requests from the while-you-were-away strip. Completed-turn dividers bucket chat-owned proof by capture timestamp, expose a collapsed `N proof` chip, and expand the filmstrip directly beneath the producing turn; there is no proof footer pinned to the tail. Codex goal lifecycle events render as compact user-facing rows (`Goal set`, `Goal paused`, `Goal cleared`) instead of raw JSON-RPC/status wording. Codex runtime notices (`codex_safety_buffering`, `codex_moderation_metadata`, `codex_sleep`, `codex_thread_deleted`) render as small transcript chips. `codex_turn_stalled` renders a live recovery card: Wait re-arms the watchdog, Nudge sends a status steer, Retry interrupts and replays work in the same thread, and Resume restarts app-server, resumes the thread, and retries. Handoff brief user messages with `metadata.hideFullPrompt` show only their `displayText` breadcrumb and do not expose or copy the internal prompt body. History seeded into a forked chat (envelopes tagged `providerOrigin: "handoff_fork"`) renders under a single `Forked from the previous chat — full history above` divider pinned to the first live row after the seeded tail, rather than a per-row marker. Error events whose `errorInfo.agentCli.category` is `"unauthenticated"` render as the calm `AgentCliAuthCard` (raw 401 behind a `Details` disclosure) rather than the red error block, so a recoverable logout reads as a re-login prompt, not a crash. The live turn's `working for <elapsed>` counter is painted imperatively through a callback ref that survives the status line's mid-turn remount (see [composer-and-ui.md](composer-and-ui.md)). It also owns `ChatInfoHostContext`: `AgentChatPane` provides it because it owns the chat actions pane and listens for `ade:chat:open-info`; `PersonalChatsPage` does not, so transcript affordances that reveal that pane render only where dispatching would actually do something. Scoping is per-subtree by necessity — hidden `ProjectSurface`s stay mounted, so a module-level registry would report a host on the one surface that lacks one. |
 | `apps/desktop/src/renderer/components/chat/chatHistoryWindow.ts` | Shared bounded-history policy for project and personal desktop chats: canonical event identity, byte estimates and resident caps, page-seam merging, strict cursor advancement, bounded continuation through empty physical pages, and stale-request predicates. Snapshot cursor reconciliation preserves a known exhausted head only when the authoritative refresh overlaps the current window and retains its oldest event; replacement snapshots and cap eviction re-arm paging. |
 | `apps/desktop/src/renderer/components/chat/chatAppearance.ts` | Chat density/font geometry plus the single responsive transcript width contract. `--chat-content-width` is `min(100%, clamp(720px, 62vw, 1180px))`; `--chat-column` aliases it so prose, composer, cards, pills, plans, file changes, and floating-pane reserve math share one viewport-scaling measure. |
 | `apps/desktop/src/renderer/components/chat/chatCardPrimitives.tsx` | Shared transcript-card vocabulary: one `[16px glyph | flexible content | auto meta]` grid, line/inset/bordered/rail/plain skins, status tones, chips/meters/detail rows/diff stats, human-readable agent identity and schedule formatting, and the collapsible proof filmstrip. Passing one-line facts use a hairline row; live/detail-bearing rows use inset chrome; failures use an amber rail rather than a red block. |
 | `apps/desktop/src/renderer/components/chat/AdeCard.tsx` | Provider-independent `ade_card` renderer built only from the shared primitives. Shape follows state rather than variant: terminal success is one line, live work adds progress, failures show only warning rows, unknown variants fall back to text + deeplink, and degraded re-emits preserve prior detail as stale rather than blanking it. |
-| `apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx` | Inline subagent transcript cards mounted by `AgentChatMessageList` from the render events `chatTranscriptRows.ts` derives. `SubagentSpawnCard` anchors where the agent started (identicon/colour from `chatSubagentIdentity`, task title, agent-type/background chips, a single live `running · <activity> · <N> tools · <elapsed>` line that ticks each second, and a `jump to result` link once the agent ends); `SubagentResultCard` renders at the settle position (status + duration, ~2-line report preview, View transcript, `jump to start`, warm amber tones for stopped/failed instead of red error blocks); `BackgroundFinishChip` is the one-line finish chip for backgrounded shell commands; `SubagentStoppedGroupCard` collapses a run of interrupt-stopped subagents into one amber "N agents stopped when you interrupted" line that expands to a per-agent list with `jump to start` links. All inherit `--chat-accent`. |
+| `apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx` | Inline subagent transcript cards mounted by `AgentChatMessageList` from the render events `chatTranscriptRows.ts` derives. `SubagentSpawnCard` anchors where the agent started (identicon/colour from `chatSubagentIdentity`, task title, agent-type/background chips, a single live `running · <activity> · <N> tools · <elapsed>` line that ticks each second, and a `jump to result` link once the agent ends); `SubagentResultCard` renders at the settle position (status + duration, ~2-line report preview, View transcript, `jump to start`, warm amber tones for stopped/failed instead of red error blocks); `BackgroundJobLine` is the whole in-thread presence of a backgrounded shell command — one quiet centered rule-line in the scheduled-wake/spawn-return divider idiom (deliberately not a card), pushed when the job starts with a live ticking elapsed and mutated in place to `✓/✗ · exit <code> · <duration>` when it exits, with an `open` affordance that dispatches `ade:chat:open-info` to reveal the actions pane's agents tab where the job's full state lives — omitted entirely on a host that registers no chat-info listener, so it is never a button that does nothing. Its ticker is the file's one shared `useLiveDurationMs` hook (also driving the spawn card), anchored to the real start timestamp so scrolling the row out of the virtualizer and back keeps the true elapsed; it freezes on an ended session, and a job still marked `running` there drops its duration entirely rather than assert an elapsed nobody should read. Status glyphs are Phosphor components, not bare `⚙`/`✓`/`✗` codepoints, which Windows resolves to off-baseline emoji; `SubagentStoppedGroupCard` collapses a run of interrupt-stopped subagents into one amber "N agents stopped when you interrupted" line that expands to a per-agent list with `jump to start` links. All inherit `--chat-accent`. |
 | `apps/desktop/src/renderer/components/chat/spawnNavigation.ts` | One canonical `navigateToSpawnedChat(sessionId, laneId?)` helper that dispatches the `ade:work:select-session` window event (behind a try/catch, no-op on a falsy id). Every spawn surface routes through it: the inline `SubagentSpawnCard`, `spawn_wake_divider` and `spawn_completed` completion rows, spawned-chat rows in `ChatSubagentsPanel`, the `AgentChatPane` parent-thread breadcrumb, and the `SessionCard` lineage glyph. `TerminalsPage` resolves an omitted lane from the loaded session list before focusing the target, so cross-lane jumps land on the correct lane. |
 | `apps/desktop/src/renderer/components/chat/ChatActionsDrawerPanel.tsx`, `ChatSourcesPanel.tsx`, `chatSources.ts` | Codex Chat Actions source inventory. Sources is the first available tab and derives a deduplicated list of attachments/files, web searches/results, MCP apps/tools, and external resource URLs from the current transcript. HTTP(S) rows open in ADE's built-in browser; internal `node_repl` plumbing and unsafe protocols are excluded. |
 | `apps/desktop/src/renderer/components/chat/ChatGitToolbar.tsx` | Git / PR quick-action toolbar above the composer. If the lane already has a linked PR, the PR button opens or toggles that PR; otherwise it routes to the PR workspace with a create-PR handoff (`create=1&sourceLaneId=<lane>&target=primary`). When the chat PR pane or compact PR menu opens, it asks `prReadCache.refreshLinkedPrCoalesced` for a targeted `prs.refresh({ prIds })` so the badge picks up merged/closed/check transitions without broad GitHub polling. An unmapped lane PR (a `github_pr_projections`-derived summary with `pr.unmapped === true` and a synthetic `gh:` id) has no DB row to refresh or fetch checks for, so both the live refresh and `getChecks` are skipped for it. The toolbar is a **status strip only** — the manual PR-sync (↻) control lives in the PR pane's title bar, so surfaces that render the toolbar without a PR pane heal through reconcile-on-focus and `prs-updated` instead. It takes an optional `runtimePin`: a lane's PR row lives in its own machine's database, so a chat on another machine reads and subscribes through that machine's runtime rather than showing the bare create-PR button for a session that already has one. Effects key on the pin's `key`, not the object, which is rebuilt on every cross-machine merge. Under a pin the unpinned `diff.getChanges` status read is skipped and PR *creation* is withheld — see [Pull requests](../pull-requests/README.md#which-machine-answers-a-pr-read). |
@@ -120,7 +120,7 @@ for its separate RPC, sync, storage, and UI contracts.
 | `apps/desktop/src/renderer/components/chat/ChatSurfaceShell.tsx` | Shell that wraps every chat surface (desktop pane, mobile lane, CTO chat) with a unified header/footer slot and `--chat-accent` CSS variable. Supports a `layoutVariant="mobile"` mode that the iOS companion mirrors. |
 | `apps/desktop/src/renderer/components/chat/chatSurfaceTheme.ts` | Chat chrome tokens. Exports `PROVIDER_CHAT_ACCENTS` (claude → amber, codex → warm white, cursor → violet, opencode → blue, etc.) and `providerChatAccent(provider)`. iOS mirrors this table in `ADEDesignSystem.swift`. |
 | `apps/desktop/src/renderer/components/chat/AskQuestionComposer.tsx` | The ask-question surface, anchored **in the composer** — it replaces the textarea inside the same prompt-box frame while a question blocks (there is no longer a separate `AgentQuestionModal`, no `InlineQuestionRequestCard`, and no question-kind `pendingBanner`). Header is the provider mark + a kind-derived verb (`{Provider} asks` / `{Provider} · Plan ready` via `pendingInputHeaderLabel`) plus a dot rail for paged sets, a minimize `⌄`, and a decline `×`; body shows the question's `header` kicker then the question text once; options render as a one-column ledger with radio/checkbox a11y roles and a flush-right `✓`; option previews render through `QuestionOptionPreview` — a column-preserving monospace `<pre>` for wireframes/ASCII (detected via `looksLikeWireframe`) and the code-fence-aware `ChatMarkdown` for prose — inside a natural-height, capped option region, disclosed by an explicit click rather than hover. Only genuinely long option content scrolls; header, note row, and footer stay pinned. Chrome inherits `--chat-accent` (per-provider), used in exactly two places plus one structural hairline. Keyboard: `1-9` pick, `↵` next/send, `←→` page, `esc` decline. Selecting marks and never submits; a pick and a typed note both travel (see `shared/pendingInputAnswers.ts`). Nothing is preselected. `QuestionReceipts.tsx` renders the transcript record: an "awaiting you" row while open, a one-line expandable receipt once resolved. |
-| `apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts` | Two-layer event-to-row pipeline (render events + grouped envelopes) that powers the message list. It threads per-subagent anchor state through the collapse pass to emit identity-keyed `subagent_spawn_anchor` / `subagent_result_card` / `background_finish_chip` render events (keys `subagent-spawn:` / `subagent-result:` / `background-chip:<agentKey>`), mutating anchors in place as progress/result events arrive and repairing row positions when a `transcript_retraction` splices a row out — so the virtualizer's measured heights survive rebind. It derives a `scheduled_wake_divider` immediately before every synthetic `user_message` carrying `metadata.scheduledWake` and a `spawn_wake_divider` before completion deliveries carrying `metadata.spawnCompletion`; the latter renders as **Subagent returned** whether the completion steered an active turn or woke an idle chat. It also diffs `todo_update` snapshots per turn so only changed tasks render, normalizes dotted `subagent.*` lifecycle events into the legacy renderer shape while providers migrate, and falls back to a full collapse when incremental append would miss todo state. A second-layer grouping pass (`groupStoppedSubagentResultCards`) folds a run of two or more consecutive interrupt-stopped `subagent_result_card` rows into one `subagent_stopped_group` event; completed/failed cards and a lone stopped card stay individual. |
+| `apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts` | Two-layer event-to-row pipeline (render events + grouped envelopes) that powers the message list. It threads per-subagent anchor state through the collapse pass to emit identity-keyed `subagent_spawn_anchor` / `subagent_result_card` / `background_job_line` render events (keys `subagent-spawn:` / `subagent-result:` / `background-chip:<agentKey>`), mutating anchors in place as progress/result events arrive and repairing row positions when a `transcript_retraction` splices a row out — so the virtualizer's measured heights survive rebind. `background_job_line` is upserted by two producers on one shared key space — the live runtime's `scheduled_work_update {kind:"background_task"}` and legacy `subagent_*` events carrying `taskType: background` — so a transcript holding both shapes still renders exactly one row per job; a settled row is never reopened by a late progress tick, a task that has opened a job line stays a background job even if a late `agentType` would reclassify it, and a real subagent reported through the background stream has its job line spliced out before its spawn anchor lands. It derives a `scheduled_wake_divider` immediately before every synthetic `user_message` carrying `metadata.scheduledWake` and a `spawn_wake_divider` before completion deliveries carrying `metadata.spawnCompletion`; the latter renders as **Subagent returned** whether the completion steered an active turn or woke an idle chat. It also diffs `todo_update` snapshots per turn so only changed tasks render, normalizes dotted `subagent.*` lifecycle events into the legacy renderer shape while providers migrate, and falls back to a full collapse when incremental append would miss todo state. A second-layer grouping pass (`groupStoppedSubagentResultCards`) folds a run of two or more consecutive interrupt-stopped `subagent_result_card` rows into one `subagent_stopped_group` event; completed/failed cards and a lone stopped card stay individual. |
 | `apps/desktop/src/main/services/ai/tools/` | Tool tiers consumed by the service when it provisions a Claude/Codex/OpenCode runtime (see [Tool System](tool-system.md)). |
 | `apps/desktop/src/main/services/ipc/registerIpc.ts` | Validates chat IPC args, exposes `agentChat.*` handlers (including scheduled-work create, list, per-job cancel, and per-chat pause), persists/retrieves parallel launch recovery state in `kv`, and refreshes the runtime scheduler after the global AI config pause changes. |
 | `apps/desktop/src/shared/ipc.ts` | `ade.agentChat.*` IPC channel constants. |
diff --git a/docs/features/chat/composer-and-ui.md b/docs/features/chat/composer-and-ui.md
index 300207270..933a18fe1 100644
--- a/docs/features/chat/composer-and-ui.md
+++ b/docs/features/chat/composer-and-ui.md
@@ -18,7 +18,7 @@ subagents, computer use). The pane derives all visible state from the
 | `apps/desktop/src/renderer/lib/handoffLaunchJobs.ts` | Pure helper for handoff placeholder DTOs, scope keys, stable placeholder ids, status labels, and search matching. `AgentChatPane` writes these jobs into the root store while `TerminalsPage` passes matching jobs into the Work session sidebar. The local handoff surface offers a brief summarized handoff or a full-history fork whenever the source provider is fork-capable (`providerSupportsHandoffFork`: Claude, Codex, OpenCode, Droid); Cursor is brief-only. Fork keeps the new chat on the same provider and lane while allowing the target model to change; Claude forks the SDK session pointer, Codex the app-server thread (`thread/fork`), OpenCode `session.fork`, and Droid `forkSession()`. |
 | `apps/desktop/src/renderer/lib/aiDiscoveryCache.ts` | Runtime-binding-scoped AI integration-status and provider-model cache shared across renderer surfaces. Local and remote checkouts with the same project identity cannot share model/auth state. `getAiStatusCached` uses a 10-second freshness window and deduplicates concurrent `ade.ai.getStatus` requests; cache update/invalidation events let open ModelPickers react without polling or mounting their own background refresh loops. |
 | `CrossMachineHandoffModal.tsx`, `crossMachineHandoffPresentation.tsx` | Modal state and user flow for **Send to machine**. It verifies a local source lane, follows live remote connection snapshots, lets the user pick brief or full-history fork (fork defaults on for fork-capable providers and constrains the model picker to the same provider), lets the user set the destination chat's model, reasoning effort, fast mode, and permission mode with the same shared pills the composer uses, handles existing-project versus confirmed-clone setup, offers a destination-run fast-forward when the target lane is clean and strictly behind the source commit, decodes destination responses at the renderer boundary, pins acceptance to the reviewed route kind, and exposes retryable source-marker failures after destination success. Source blockers render through `BlockedReasons` / `BlockedActionButton` instead of silently disabling Continue. The pure half — stage/mode types, `SourceCheck`, branch/route/repo-readiness copy, permission tone and icon maps, send-step labels, `CheckRow` — lives in `crossMachineHandoffPresentation.tsx` so it is assertable without mounting the stateful modal. Once destination acceptance is dispatched, a runtime timeout or connection interruption produces an amber unknown-outcome notice: the destination chat may still appear, the user should check that machine before retrying, and the modal never reports a truthful cancellation that the runtime did not perform. A fork that the destination can't accept (older ADE with no `forkHandoffSupport`, oversize history, or an unforkable provider file) surfaces a plain reason and a one-click **send as brief** that re-runs prepare + preflight; the insecure-route consent line is fork-aware (a fork discloses that the full history is sent exactly as recorded, a brief that only the summary is sent). |
-| `AgentChatMessageList.tsx` | Virtualized message list. The virtualizer is **hand-rolled**, not `@tanstack/react-virtual`: a `measuredHeights` row-key → height `Map` feeds top/bottom spacer divs around the rendered window, and each rendered row is wrapped in `MeasuredEventRow`, whose `ResizeObserver` reports its real height through `handleMeasure` → `reconcileMeasuredScrollTop` so a height correction above the viewport does not shift what the reader is looking at. Renders transcript rows and turn dividers, including a `Woke on schedule` divider before every synthetic scheduled turn and inline `SubagentSpawnCard` / `SubagentResultCard` / `BackgroundFinishChip` rows (from `SubagentActivityCards.tsx`) for real subagents and backgrounded shell commands, and accepts stable row-key jump requests from the while-you-were-away strip and the spawn/result jump affordances. Keeps sticky-bottom sessions pinned across streamed row growth and late virtual-height measurements. A Claude `queue_recovery: available` row renders one eight-second Undo card; later `restored`/`expired` rows settle the same recovery id so history replay cannot show a stale action. The last text block of a multi-block assistant turn exposes Copy turn, which joins only that turn's assistant text blocks with blank lines; legacy rows without a turn id and single-block turns keep only the normal block copy. Plan-approval rows with non-empty body text render a scrollable markdown block (capped at `360px`) beneath the header so the user can review plan content inline. Codex goal lifecycle rows use user-facing text such as `Goal set`, `Goal paused`, and `Goal cleared`. A stalled Codex turn renders a clickable Wait / Nudge / Retry / Resume recovery card wired to `agentChat.recoverCodexTurn`; terminal provider capacity/usage-limit errors render `ProviderFailureRecoveryCard` with same-thread retry and model-selection actions. User messages marked `metadata.hideFullPrompt` render and copy only their `displayText`, keeping internal handoff briefs out of the visible transcript details, and a handoff-brief user row shows a small brief chip. When a fork seeds pre-fork history into the new chat, the envelopes carry the `handoff_fork` provider origin and the list draws a single `Forked from the previous chat — full history above` divider (`computeForkHistoryDividerRowKey` pins it to the first live row after the seeded history) instead of one marker per seeded row. |
+| `AgentChatMessageList.tsx` | Virtualized message list. The virtualizer is **hand-rolled**, not `@tanstack/react-virtual`: a `measuredHeights` row-key → height `Map` feeds top/bottom spacer divs around the rendered window, and each rendered row is wrapped in `MeasuredEventRow`, whose `ResizeObserver` reports its real height through `handleMeasure` → `reconcileMeasuredScrollTop` so a height correction above the viewport does not shift what the reader is looking at. Renders transcript rows and turn dividers, including a `Woke on schedule` divider before every synthetic scheduled turn and inline `SubagentSpawnCard` / `SubagentResultCard` / `BackgroundJobLine` rows (from `SubagentActivityCards.tsx`) for real subagents and backgrounded shell commands, and accepts stable row-key jump requests from the while-you-were-away strip and the spawn/result jump affordances. Keeps sticky-bottom sessions pinned across streamed row growth and late virtual-height measurements. A Claude `queue_recovery: available` row renders one eight-second Undo card; later `restored`/`expired` rows settle the same recovery id so history replay cannot show a stale action. The last text block of a multi-block assistant turn exposes Copy turn, which joins only that turn's assistant text blocks with blank lines; legacy rows without a turn id and single-block turns keep only the normal block copy. Plan-approval rows with non-empty body text render a scrollable markdown block (capped at `360px`) beneath the header so the user can review plan content inline. Codex goal lifecycle rows use user-facing text such as `Goal set`, `Goal paused`, and `Goal cleared`. A stalled Codex turn renders a clickable Wait / Nudge / Retry / Resume recovery card wired to `agentChat.recoverCodexTurn`; terminal provider capacity/usage-limit errors render `ProviderFailureRecoveryCard` with same-thread retry and model-selection actions. User messages marked `metadata.hideFullPrompt` render and copy only their `displayText`, keeping internal handoff briefs out of the visible transcript details, and a handoff-brief user row shows a small brief chip. When a fork seeds pre-fork history into the new chat, the envelopes carry the `handoff_fork` provider origin and the list draws a single `Forked from the previous chat — full history above` divider (`computeForkHistoryDividerRowKey` pins it to the first live row after the seeded history) instead of one marker per seeded row. `WorkingIndicator` is the in-flight turn's status line — `<activity> · working for <elapsed>`, plus a `taking longer than usual` marker past `LONG_RUNNING_TURN_SECONDS`. Its elapsed is written imperatively (`textContent` on a ref) rather than through state, so the once-per-second tick never commits a render on the message list. The line swaps a bare `<span>` for an expander `<button>` the instant the turn's first tool entry arrives, which remounts the timer node, so the ref is a **callback** ref: it repaints the counter in the same commit it attaches, and the ticker re-reads the ref every tick. An element captured once when the ticker started would be detached by that swap and the display would sit frozen at `0s` while the long-running marker still appeared. `ChatInfoHostContext` also lives here — a boolean context reporting whether the *owning host* listens for `ade:chat:open-info`. `AgentChatPane` provides `true` (it owns the chat actions pane); `PersonalChatsPage` mounts the same transcript without it, so the `BackgroundJobLine` `open` button is absent there rather than dispatching into nothing. It must stay a context rather than a module-level registry: `App` renders every `ProjectSurface` and only toggles `active`, so each `AgentChatPane` stays mounted while Personal Chats is open, and a global "is any host alive" flag would read true on exactly the surface that has no pane. |
 | `AgentChatComposer.tsx`, `ComposerPromptStash.tsx`, `ComposerSmartLinkMenu.tsx`, `smartLinkChipMark.ts` | Text input, attachments, model selector, compact title-only permission controls (per-provider `PermissionModePickerOption` tables fed into the shared `components/shared/PermissionModePicker`, which the composer owns the option data for but not the control), slash commands, desktop prompt stashes, smart-link chips (`smartLinkChipMark.ts` returns the inline `currentColor` SVG brand mark each chip renders), pending-input answering (including Codex MCP form/URL elicitations), voice-dictation target registration, and parallel model-slot controls. A running chat's toolbar also shows a read-only amber tower plus the owning machine name beside the model and thinking controls; it identifies where the chat executes and directs moves to Chat actions → Handoff → Continue on another machine. A draft omits that label because its launch shelf owns the machine choice. `ComposerPromptStash` keeps its command surface mounted when the Appearance preference hides the bookmark, so Cmd/Ctrl+S remains available, but the visible bookmark stays out of the toolbar while both the composer and stash list are empty. Its menu is rendered in a viewport-clamped body portal with a bounded, scrolling list so composer overflow and short windows cannot crop it. A save first copies up to ten attached images into the owning project runtime, commits the text plus image references, then clears only the unchanged composer snapshot; restore reapplies both text and images before consuming the stash. The list renders an image thumbnail when the active runtime owns the bytes. On another synced runtime, the row retains its text and image count, labels the images as living on another machine, and refuses restore until the composer is connected to the origin runtime. Machine-bound context and non-image files are not stashed. Completed URLs are non-editable inline chips whose `data-composer-chip-text` preserves the literal URL during serialization; clicking or keyboard-activating a chip opens the Copy link / Remove link menu, and character deletion removes the whole URL token. Every chip also carries a kind-naming `data-composer-chip` attribute, and a scoped `selectionchange` effect marks intersecting chips with `data-composer-chip-selected` so the native selection paints continuously across them (overlay styling lives in `apps/desktop/src/renderer/index.css`). During an active Claude turn, its split Send control selects without dispatching among inline, after-turn, and interrupt delivery; the primary button and Enter execute the selected mode. A separate Claude split Stop control selects **Stop & clear queue** or **Stop only**, persists that choice per chat, and dismisses its custom popover immediately after selection. Staged rows expose send-during-turn, interrupt, cancel, and Edit-back-to-composer actions. It forwards one-shot open requests to the shared ModelPicker so transcript recovery cards can open model selection without synthetic DOM events; the picker acknowledges each request so remounts do not reopen it. Launch-prompt clipboard reminder text is controlled by `launchPromptClipboardNoticeEnabled`, separate from the `launchPromptClipboardEnabled` copy behavior. For orchestration model-selection pending inputs it decodes the agent briefing metadata (`workDescription`, `filesHint`, `dependsOn`) before rendering the selection card. |
 | `apps/desktop/src/main/services/chat/promptStashService.ts` | Runtime-backed prompt-stash persistence. Exact prompt text, up to ten image references, their origin sync-site id, provider/model labels, and creation time are stored in the PK-only, CRR-compatible `prompt_stashes` table; newest-first retention is capped at 20 entries. Text and metadata converge across runtimes. HTTP(S) image references remain portable, while local-image bytes stay on the originating runtime: off-origin readers receive the image count but no absolute paths and cannot consume the stash. Origin-owned image files referenced by live stashes are protected from the normal seven-day temporary-attachment cleanup. |
 | `ProviderFailureRecoveryCard.tsx` | Friendly recovery surface for terminal provider capacity and usage-limit failures. Shows human-readable error identity and guidance, then offers **Retry turn** and **Choose model** only after the failed turn has released the composer. |
@@ -925,12 +925,14 @@ timeline and resolves the backing Claude session pointer when opening the
 dedicated child transcript. A user's mid-turn steer always carries
 `parent_tool_use_id: null`, so it remains addressed to the parent agent.
 The same lifecycle events also render inline in the transcript as
-identity-anchored spawn/result cards (background shells collapse to a
-single finish chip) via `deriveSubagentTimelineRows()`
-(`shared/chatSubagents.ts`), so the panel is a live roster and the
-transcript keeps a durable per-agent boundary; iOS mirrors both the
-timeline rows and the unified Subagents/Background/Schedule Chat Info
-sheet.
+identity-anchored spawn/result cards, so the panel is a live roster and the
+transcript keeps a durable per-agent boundary. The desktop transcript derives
+those rows in `chatTranscriptRows.ts` (a backgrounded shell command gets a
+single `background_job_line` there instead of cards);
+`deriveSubagentTimelineRows()` in `shared/chatSubagents.ts` is the portable
+spawn / result / `background_chip` shape iOS mirrors in
+`buildWorkSubagentTimelineRows`, and it still models a background shell as one
+settle-position chip rather than a live line.
 
 Claude wakeups, cron tasks, `/loop`, remote triggers, and background work
 are folded by `deriveScheduledWorkSnapshots()` into rows with kind,
diff --git a/docs/features/chat/transcript-and-turns.md b/docs/features/chat/transcript-and-turns.md
index f388ed30f..5e10df0d5 100644
--- a/docs/features/chat/transcript-and-turns.md
+++ b/docs/features/chat/transcript-and-turns.md
@@ -145,7 +145,7 @@ Two helpers summarise a parsed stream:
 | `activity` | Ephemeral UI hint (thinking, searching, running_command). Hidden from the transcript. |
 | `todo_update` | Task-list snapshot; consumed by `ChatTasksPanel`. |
 | `subagent_started` / `subagent_progress` / `subagent_result` | Legacy Claude background subagent lifecycle. Each envelope carries `taskId`, `parentToolUseId`, `description`, and optional `agentId`, `parentAgentId`, `agentType`, and `providerSessionId`; Claude start rows bind the native child to the owning Claude session so transcript drill-in never mistakes the ADE chat id for a provider session id. For Claude / ade-code `agentType` is the Task tool's `subagent_type` (stashed at the `tool_use` boundary and joined on `parentToolUseId`); for Codex parallel agents it is a per-turn `Agent #N` label assigned at first announcement and the raw threadId is mirrored as `agentId`; for OpenCode subagents `agentType` is omitted so the row falls back to the `description` (taken from `session.title`). Codex app-server `subAgentActivity` items also flow into these rows and may carry `label`, `model`, and `reasoningEffort` for richer roster labels. Claude SDK runs also stash `taskType` (`subagent` / `background` / `local_workflow` / `cron` / `other`) and `workflowName` at spawn so the renderer can label rows by workflow without re-deriving them per event; ambient/housekeeping tasks (the SDK's `skip_transcript=true` flag — e.g. session-title generation) and plain Claude Code task runs (`task_type` `other` with no agent metadata, e.g. "Re-run affected test files") are both tracked only for cleanup and filtered out symmetrically across spawn, progress, and completion notifications so the subagent panel never flashes them, while a backgrounded `Bash` shell (`task_type` `local_bash`/`background`) is routed to the background pane rather than the roster. Every `subagent_result` is gated on a recorded `subagent_started` (`emittedSubagentStartIds`), so an interrupt cannot emit a phantom stopped card for a subagent that never announced; terminal events clear both the taskId and agentId aliases. The service also emits canonical `subagent.started` / `subagent.progress` / `subagent.completed` rows from `runtimeEvents.ts` so all runtimes can converge on the same envelope. Two additional producers fan into the same three event types: **Claude Workflow runs** — the SDK's undocumented `workflow_progress` snapshot on `system:task_progress` is normalized by `claudeWorkflowProgress.ts` (defensive: malformed entries dropped, previews clipped, counts capped, unknown states degrade to queued/running; an unparseable snapshot leaves the generic task rendering untouched) and diffed per tick into started/progress/result transitions under a stable `<taskId>::a<index>` / latched-agentId identity, so each workflow agent renders as its own row with phase, tokens, and duration, reconnects upsert instead of duplicating, and agents left running when the workflow ends are closed out as `stopped`; and **child chat spawns** — a session created with `orchestrationParentSessionId` outside an orchestration run (e.g. `ade chat create` from a tracked agent shell) emits synthetic `subagent_started`/`subagent_result` events keyed `chat:<childSessionId>` into the parent so the child lists in the parent's subagents panel, its first finished turn reporting completed/failed/stopped. |
-| `scheduled_work_update` | Scheduled/background-work lifecycle snapshot. ADE emits it for provider-neutral action schedules and Claude `ScheduleWakeup`, `CronCreate`, `CronDelete`, `/loop`/hook snapshots, remote triggers, cron/background task lifecycle messages, and durable scheduler transitions. It carries `kind` (`wakeup`, `cron`, `loop`, `remote_trigger`, `background_task`), `status` (`scheduled`, `paused`, `running`, `fired`, `missed`, `completed`, `cancelled`, `failed`, `stopped`), provenance ids, optional cron/prompt/reason/timestamps, `firedAt`, `late`, and `durable`; `shared/chatScheduledWork.ts` folds it into active/history Chat Info rows on desktop, ADE Code, and iOS. Parent turn completion does not imply background completion, and `background_task` snapshots whose `sourceTaskId` belongs to a real subagent are omitted from the Background roster to avoid duplicate Agent rows. One-shots progress through `scheduled` -> `fired` -> `completed`; crons record the fire and return to `scheduled` with `lastRunAt` plus their next occurrence. |
+| `scheduled_work_update` | Scheduled/background-work lifecycle snapshot. ADE emits it for provider-neutral action schedules and Claude `ScheduleWakeup`, `CronCreate`, `CronDelete`, `/loop`/hook snapshots, remote triggers, cron/background task lifecycle messages, and durable scheduler transitions. It carries `kind` (`wakeup`, `cron`, `loop`, `remote_trigger`, `background_task`), `status` (`scheduled`, `paused`, `running`, `fired`, `missed`, `completed`, `cancelled`, `failed`, `stopped`), provenance ids, optional cron/prompt/reason/timestamps, `firedAt`, `late`, and `durable`; `shared/chatScheduledWork.ts` folds it into active/history Chat Info rows on desktop, ADE Code, and iOS. `background_task` is additionally how the live Claude runtime reports a backgrounded shell command — it emits no subagent lifecycle events for one — so on desktop those snapshots also drive the in-thread `background_job_line`; other kinds bundle as activity. Parent turn completion does not imply background completion, and `background_task` snapshots whose `sourceTaskId` belongs to a real subagent are omitted from the Background roster (and from the job line) to avoid duplicate Agent rows. One-shots progress through `scheduled` -> `fired` -> `completed`; crons record the fire and return to `scheduled` with `lastRunAt` plus their next occurrence. |
 | `tool_use_start` / `tool_use_complete` / `tool_use_summary` | Claude SDK tool lifecycle tracking (see [Claude tool-use tracking](#claude-tool-use-tracking)). |
 | `step_boundary` | Workflow step boundary marker. |
 | `system_notice` | Non-transcript chrome: auth errors, rate limits, and file persistence hints. Special-cased renders: the "Promoted to Cursor Cloud" pill, and the `status:"subagent_spawned"` chip (emitted into the parent when a child chat session is created with a parent lineage; `detail.spawnedSession` carries the child sessionId/laneId/title and the chip deep-links via `ade:work:select-session`; the TUI shows the message line; iOS renders it through its existing system_notice mapping). |
@@ -242,12 +242,45 @@ implements a two-layer transform:
      stable render rows — a `subagent_spawn_anchor` at the start
      position (mutated in place as progress arrives) and a
      `subagent_result_card` at the settle position — while backgrounded
-     shell commands collapse to a single `background_finish_chip`. The
+     shell commands collapse to a single `background_job_line`, pushed on
+     the job's first sighting (so a running job is visible in the thread)
+     and mutated in place through to its terminal state, which is never
+     reopened by a late progress tick. Two producers feed that one row and
+     share its key space: the LIVE runtime, which reports background
+     shells only as `scheduled_work_update {kind:"background_task"}`
+     (`emitClaudeBackgroundTaskUpdate` — it emits no subagent lifecycle
+     events for them at all), and legacy `subagent_*` events carrying
+     `taskType: background`, which is all older persisted transcripts
+     hold. Other scheduled kinds are unaffected. Classification can
+     legitimately flip mid-task, so both directions are guarded: once a
+     task has opened a job line it stays a background job (a late
+     `agentType` cannot strand the running line and push a card pair for
+     the same task), and a task that proves itself a real subagent has
+     its job line spliced out before the spawn anchor lands — the
+     level-set path gates only on task type, so an agent that reports
+     none falls through to the background emitter and would otherwise
+     render as a line *and* a card pair. The
      anchor keys (`subagent-spawn:` / `subagent-result:` /
-     `background-chip:<agentKey>`) never change on rebind so the
+     `background-chip:<agentKey>`, the last kept from the finish-chip era
+     on purpose) never change on rebind so the
      virtualizer's measured heights survive; a `transcript_retraction`
-     splice repairs each stored row index. Raw lifecycle events are then
-     hidden.
+     splice repairs each stored row index, including the
+     `backgroundJobRowIndexByKey` map that resolves job lines. Raw
+     lifecycle events are then hidden.
+
+     `BackgroundJobLine` renders that row as a quiet centered rule-line
+     in the same idiom as the scheduled-wake and spawn-return dividers —
+     deliberately not a card, because background jobs are frequent and
+     rarely the point of the turn. Running reads
+     `⚙ Background · <command> · <elapsed>` with a once-per-second
+     ticker anchored to the real start timestamp; a terminal update
+     rewrites the same row to `✓/✗ · exit <code> · <duration>`. The
+     scheduled-work wire format carries no exit code, so a job reported
+     only through the live producer shows a duration measured from its
+     own first sighting and no exit. An `open` affordance dispatches
+     `ade:chat:open-info` to reveal the chat actions pane, where the
+     job's full state and output already live, and is omitted where no
+     host registered a listener for that event.
    - `ade_card` collapses per `cardId` into ONE permanent chronological row
      keyed `ade-card:<cardId>`. A repeat emit mutates that row in place — a new
      object under the same key, merged over the previous payload, so an update
diff --git a/docs/features/sync-and-multi-device/ios-companion.md b/docs/features/sync-and-multi-device/ios-companion.md
index 9ca67d327..ef8da423c 100644
--- a/docs/features/sync-and-multi-device/ios-companion.md
+++ b/docs/features/sync-and-multi-device/ios-companion.md
@@ -2687,7 +2687,18 @@ different machine's cached limits.
   and one result row per real subagent anchored where it started and
   ended, and a single finish chip for backgrounded shell commands —
   mirroring `deriveSubagentTimelineRows` in `chatSubagents.ts` so a
-  subagent never repaints per tick. `WorkChatRichCardViews` renders those
+  subagent never repaints per tick.
+- **Known divergence — a running background job has no mobile presence.**
+  Desktop folds `scheduled_work_update {kind: "background_task"}` into a
+  single live in-thread `background_job_line` (`chatTranscriptRows.ts`),
+  anchored at the job's first sighting and mutated in place at exit. iOS
+  still drops that event from the timeline
+  (`WorkTimelineHelpers.swift`). Because the live Claude runtime reports
+  a backgrounded shell *only* through that stream — never as subagent
+  lifecycle events — the mobile timeline shows nothing at all while a
+  background job runs; only legacy `subagent_*` transcripts produce the
+  finish chip above. This is unported work, not a platform decision.
+  `WorkChatRichCardViews` renders those
   rows plus the unified Chat Info sheet, whose ordered Subagents /
   Background / Schedule sections mirror the desktop Chat Info pane —
   including the same active caps (12 / 8 / 10), the single **Completed**
diff --git a/docs/features/terminals-and-sessions/README.md b/docs/features/terminals-and-sessions/README.md
index d2d759621..624302c23 100644
--- a/docs/features/terminals-and-sessions/README.md
+++ b/docs/features/terminals-and-sessions/README.md
@@ -317,6 +317,11 @@ Shared types and IPC:
   and Activity surfaces and mirrored by iOS widgets/Activity drawer. Blue means
   work in flight, amber is reserved exclusively for `Needs you`, emerald is a
   clean unseen outcome, red is failure, and neutral is true but non-actionable.
+  An idle or ready session that still has live background jobs is named for what
+  it is — **Background work**, or **Background work ×N** — rather than reusing
+  the bare **Working** of a live turn, and it sets `showsElapsed`, so the row
+  carries a duration instead of an unfalsifiable claim that the model is still
+  thinking.
   It also owns the short working-duration formatter; renderer icon components
   map its dependency-free glyph ids to platform symbols.
 - `apps/desktop/src/renderer/lib/sessionSnooze.ts` — the desktop half of snooze
diff --git a/docs/features/terminals-and-sessions/ui-surfaces.md b/docs/features/terminals-and-sessions/ui-surfaces.md
index a46449fe3..9c4555a01 100644
--- a/docs/features/terminals-and-sessions/ui-surfaces.md
+++ b/docs/features/terminals-and-sessions/ui-surfaces.md
@@ -297,13 +297,20 @@ words, glyphs, tone, prominence, and elapsed-time behavior through
 `shared/sessionStatusPresentation.ts`. An active ADE chat in its authoritative
 plan interaction mode reads **Planning** in violet; other active turns retain
 **Working**. Once the foreground turn is idle, provider-reported background
-tasks keep the row at **Working**, while an armed `nextWakeAt` reads neutral
-**Waiting** with a compact countdown. These contextual labels do not change the
+tasks read blue **Background work** (**Background work ×N** when several are
+live), while an armed `nextWakeAt` reads neutral
+**Waiting** with a compact countdown. Naming that state rather than reusing
+**Working** matters because the turn has already ended: a duration-less
+"Working" on a finished turn is indistinguishable from one that has hung.
+These contextual labels do not change the
 canonical lifecycle, filing bucket, filters, or attention count, and CLI output
 is never scraped to infer plan mode. Working/Planning elapsed time ticks from
 the active chat's immutable `currentTurnStartedAt`, so streamed activity cannot
-reset it; legacy chat rows without that anchor, plus CLI and Stale durations,
-use last activity. Waiting refreshes on a quiet 30-second cadence. On row hover or
+reset it; legacy chat rows without that anchor, plus Background work, CLI, and
+Stale durations, use last activity. That makes the Background work elapsed a
+proxy, not the job's own runtime — the session summary does not carry per-job
+start times, so a job launched early in a long turn reads near zero the moment
+the turn ends. Waiting refreshes on a quiet 30-second cadence. On row hover or
 keyboard focus the status swaps, without reflow, for `SessionSnoozeControl` and
 the context-appropriate Settle or Un-settle action. An open snooze menu pins the
 action slot visible. A row whose snooze ended early shows the shared Woke
@@ -328,7 +335,7 @@ context menu, lowers opacity, and renders a centered spinner/status overlay.
 This is used while the card's owning lane is being deleted.
 
 Selected and hovered rows spend the reserved background surface; multi-select
-adds a subtle ring. Non-prominent states (working, starting, stale, stopped,
+adds a subtle ring. Non-prominent states (working, background work, starting, stale, stopped,
 ended, snoozed, and settled) recede until hovered, while Needs you, Done, and
 Failed keep full weight. Only canonical `needs_you` contributes to the Work-tab
 highlight, notifications, and Dock badge. `useAppWideSessionAttention` owns