diff --git a/DESIGN.md b/DESIGN.md
index d6e905f6b..10e4bef78 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -12,6 +12,16 @@ reimplementing it in this repo.
 The shell has exactly one nav surface: the sidebar. There is no second nav
 column and no collapse affordance — it is always present, at a fixed width.
 
+Conversation rows keep a fixed avatar footprint and two compact text lines:
+the name with its timestamp aligned on the right, then the latest message
+preview. Selection uses a quiet neutral fill; the name stays in the normal
+foreground color. While an agent works, a thin orange orbit surrounds the
+avatar, including when that conversation is selected. A completed, unread
+agent reply replaces the orbit with a small green check labeled "Reply
+ready". Opening the conversation clears that check; idle, read, failed,
+and cancelled turns show no completion badge. Reduced motion keeps the
+working indicator as a static orange arc.
+
 Top to bottom:
 
 1. **Brand row** — logo mark and a "New workbench" button (`+`) that
diff --git a/apps/web/src/app.css b/apps/web/src/app.css
index 2fd9883ad..be59b278d 100644
--- a/apps/web/src/app.css
+++ b/apps/web/src/app.css
@@ -1464,100 +1464,100 @@ select:disabled,
   color: var(--shell-panel-faint);
 }
 
-/* Mock .ch rows in the sidebar: pad 0.32/0.42, square. */
 .shell-ch-row {
   display: grid;
-  grid-template-columns: auto 1fr auto;
-  gap: 0.55rem;
-  align-items: center;
+  grid-template-columns: 2rem minmax(0, 1fr) auto;
+  column-gap: 0.65rem;
+  align-items: start;
   width: 100%;
-  padding: 0.32rem 0.42rem;
-  border-radius: 0;
-  color: var(--muted-foreground, var(--ui-fg-muted));
+  min-height: 3.75rem;
+  padding: 0.65rem 0.6rem;
+  border-radius: var(--radius);
+  color: var(--foreground);
   text-align: left;
   border: 0;
   background: transparent;
   cursor: pointer;
-  transition:
-    background 120ms ease,
-    color 120ms ease;
+  transition: background var(--duration-micro) var(--ease-out);
 }
 
 .shell-ch-row:hover {
-  background: color-mix(in srgb, var(--foreground) 5%, transparent);
-  color: var(--foreground, var(--ui-fg));
+  background: color-mix(in srgb, var(--foreground) 4%, transparent);
 }
 
-/* Brand rule: grey is for text/structure, not container fills — the active
-   row stays on ground and reads through a 2px orange left edge instead of a
-   band. */
 .shell-ch-row[aria-current="true"],
 .shell-ch-row[data-active="true"] {
-  background: var(--background);
-  color: var(--shell-accent);
-  box-shadow: inset 2px 0 0 0 var(--shell-accent);
+  background: color-mix(in srgb, var(--foreground) 6%, transparent);
 }
 
 .shell-ch-row[aria-current="true"] .shell-ch-name,
-.shell-ch-row[data-active="true"] .shell-ch-name {
+.shell-ch-row[data-unread="true"] .shell-ch-name {
   font-weight: 650;
 }
 
-/* A 5% foreground tint is a much quieter cue on a near-black row than the
-   same percentage on a near-white one perceptually, so dark mode's hover
-   gets a stronger mix to read at the same visible weight. */
-.dark .shell-ch-row:hover {
-  background: color-mix(in srgb, var(--foreground) 9%, transparent);
-}
-
-.shell-ch-stack {
-  display: flex;
-  width: 1.35rem;
-  height: 1.4rem;
+.shell-ch-avatar {
   position: relative;
-  flex-shrink: 0;
+  display: grid;
+  place-items: center;
+  width: 2rem;
+  height: 2rem;
+  align-self: center;
 }
 
-.shell-ch-stack span {
-  position: absolute;
-  width: 1.2rem;
-  height: 1.2rem;
-  border-radius: 50%;
-  border: 1.5px solid var(--background);
+.shell-ch-initial {
   display: grid;
   place-items: center;
-  font-size: 0.55rem;
-  font-weight: 700;
-  /* --muted sits within ~1.2:1 of --background in dark (near-black on
-     pure black), leaving the chip indistinguishable from the page. A
-     foreground tint reads at the same visible strength in both themes
-     since the page it's mixed against is pure white/black either way. */
+  width: 1.5rem;
+  height: 1.5rem;
+  border-radius: 50%;
   background: color-mix(in srgb, var(--foreground) 10%, transparent);
-  color: var(--foreground);
+  font-size: 0.75rem;
+  font-weight: 650;
 }
 
-.shell-ch-stack span:nth-child(1) {
-  left: 0;
-  top: 0.2rem;
-  z-index: 3;
+.shell-ch-orbit {
+  position: absolute;
+  inset: 0;
+  border: 1.5px solid transparent;
+  border-top-color: var(--primary);
+  border-right-color: var(--primary);
+  border-bottom-color: var(--primary);
+  border-radius: 50%;
+  animation: shell-ch-orbit 1.4s linear infinite;
 }
 
-.shell-ch-stack span:nth-child(2) {
-  left: 0.45rem;
-  top: 0.2rem;
-  z-index: 2;
-  background: color-mix(in srgb, var(--foreground) 16%, transparent);
+@keyframes shell-ch-orbit {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+.shell-ch-completion {
+  position: absolute;
+  right: -0.05rem;
+  bottom: -0.05rem;
+  display: grid;
+  place-items: center;
+  width: 0.85rem;
+  height: 0.85rem;
+  border: 2px solid var(--background);
+  border-radius: 50%;
+  background: var(--ok);
+  color: var(--background);
 }
 
-.shell-ch-stack span:nth-child(3) {
-  left: 0.9rem;
-  top: 0.2rem;
-  z-index: 1;
+.shell-ch-completion svg {
+  width: 0.6rem;
+  height: 0.6rem;
 }
 
-.shell-ch-stack span[data-agent="true"] {
-  background: var(--primary);
-  color: var(--primary-foreground);
+@media (prefers-reduced-motion: reduce) {
+  .shell-ch-orbit {
+    animation: none;
+  }
+  .shell-ch-row {
+    transition: none;
+  }
 }
 
 /* Agent-DM identity avatar: zero radius per brand rule, distinct from the
@@ -1606,7 +1606,7 @@ select:disabled,
 }
 
 .shell-ch-name {
-  font-weight: 580;
+  font-weight: 550;
   font-size: 0.86rem;
   overflow: hidden;
   text-overflow: ellipsis;
@@ -1622,27 +1622,9 @@ select:disabled,
   color: var(--muted-foreground, var(--ui-fg-muted));
 }
 
-.shell-ch-live {
-  width: 0.4rem;
-  height: 0.4rem;
-  border-radius: 0;
-  background: var(--ok);
-  flex-shrink: 0;
-  animation: shell-ch-pulse 2s ease infinite;
-}
-
-@keyframes shell-ch-pulse {
-  0%,
-  100% {
-    box-shadow: 0 0 0 0 color-mix(in srgb, var(--ok) 40%, transparent);
-  }
-  50% {
-    box-shadow: 0 0 0 4px transparent;
-  }
-}
-
 .shell-ch-right {
   display: flex;
+  min-width: 1.6rem;
   flex-direction: row;
   align-items: center;
   gap: 0.35rem;
@@ -1650,6 +1632,8 @@ select:disabled,
 }
 
 .shell-ch-time {
+  line-height: 1.3rem;
+  white-space: nowrap;
   font-size: 0.66rem;
   color: var(--muted-foreground, var(--ui-fg-muted));
 }
@@ -1658,6 +1642,7 @@ select:disabled,
    workbench's message preview, or an unreachable agent's join caption. */
 .shell-ch-preview {
   display: block;
+  margin-top: 0.15rem;
   font-size: 0.72rem;
   color: var(--muted-foreground, var(--ui-fg-muted));
   overflow: hidden;
@@ -1666,9 +1651,9 @@ select:disabled,
 }
 
 .shell-ch-row-wrap {
+  position: relative;
   display: flex;
   align-items: stretch;
-  gap: 0.15rem;
   width: 100%;
 }
 
@@ -1678,17 +1663,26 @@ select:disabled,
 }
 
 .shell-ch-row-menu {
+  position: absolute;
+  top: 0.5rem;
+  right: 0.6rem;
   opacity: 0;
-  flex-shrink: 0;
-  align-self: center;
   transition: opacity 120ms ease;
 }
 
 .shell-ch-row-wrap:hover .shell-ch-row-menu,
-.shell-ch-row-wrap:focus-within .shell-ch-row-menu {
+.shell-ch-row-wrap:focus-within .shell-ch-row-menu,
+.shell-ch-row-wrap:has([aria-expanded="true"]) .shell-ch-row-menu,
+.shell-ch-row-menu .chat-sidebar-row-menu-trigger {
   opacity: 1;
 }
 
+.shell-ch-row-wrap:hover .shell-ch-time,
+.shell-ch-row-wrap:focus-within .shell-ch-time,
+.shell-ch-row-wrap:has([aria-expanded="true"]) .shell-ch-time {
+  visibility: hidden;
+}
+
 /* Mock v2 .search: 2rem, square, on the ground — shared by every band. */
 .shell-panel-search {
   display: flex;
diff --git a/apps/web/src/shell/workbench-list.test.ts b/apps/web/src/shell/workbench-list.test.ts
index 463bdb6e0..6c42751be 100644
--- a/apps/web/src/shell/workbench-list.test.ts
+++ b/apps/web/src/shell/workbench-list.test.ts
@@ -49,14 +49,23 @@ describe("renamePayload", () => {
 });
 
 describe("workbenchRowSignals", () => {
+  test("opening clears a ready reply but keeps an active orbit", () => {
+    expect(
+      workbenchRowSignals(workbench({ live: "reply-ready" }), true).live,
+    ).toBe("idle");
+    expect(workbenchRowSignals(workbench({ live: "working" }), true).live).toBe(
+      "working",
+    );
+  });
+
   test("passes through only the signals the platform actually sent", () => {
     expect(workbenchRowSignals(workbench(), false)).toEqual({});
     const signals = workbenchRowSignals(
-      workbench({ unreadCount: 3, live: true, sharedLabel: "Acme" }),
+      workbench({ unreadCount: 3, live: "working", sharedLabel: "Acme" }),
       false,
     );
     expect(signals.unread).toBe(3);
-    expect(signals.live).toBe(true);
+    expect(signals.live).toBe("working");
     expect(signals.sharedLabel).toBe("Acme");
   });
 
diff --git a/apps/web/src/shell/workbench-list.tsx b/apps/web/src/shell/workbench-list.tsx
index 0491101b2..3d482d8e8 100644
--- a/apps/web/src/shell/workbench-list.tsx
+++ b/apps/web/src/shell/workbench-list.tsx
@@ -26,6 +26,7 @@ import type { Workbench } from "@corbits/chat-ui";
 import { useQueryClient } from "@tanstack/react-query";
 import {
   ChatCircle,
+  Check,
   DotsThree,
   Hash,
   MagnifyingGlass,
@@ -102,7 +103,7 @@ export function renamePayload(
  */
 export type WorkbenchRowSignals = {
   readonly sharedLabel?: string;
-  readonly live?: boolean;
+  readonly live?: Workbench["live"];
   readonly time?: string;
   readonly unread?: number;
 };
@@ -125,7 +126,14 @@ export function workbenchRowSignals(
     ...(workbench.sharedLabel !== undefined
       ? { sharedLabel: workbench.sharedLabel }
       : {}),
-    ...(workbench.live !== undefined ? { live: workbench.live } : {}),
+    ...(workbench.live !== undefined
+      ? {
+          live:
+            isOpen && workbench.live === "reply-ready"
+              ? "idle"
+              : workbench.live,
+        }
+      : {}),
     ...(workbench.lastActivityAt !== undefined
       ? { time: formatRelativeTime(workbench.lastActivityAt) }
       : {}),
@@ -299,6 +307,12 @@ function WorkbenchRow({
     displayWorkbenchTitle(title, workbench.id) || CHAT_STRINGS.unnamedWorkbench;
   const { sharedLabel, live, time, unread } = signals;
   const hasUnread = typeof unread === "number" && unread > 0;
+  const liveLabel =
+    live === "working"
+      ? "Agent working"
+      : live === "reply-ready"
+        ? "Reply ready"
+        : "";
 
   return (
     <div
@@ -312,25 +326,37 @@ function WorkbenchRow({
         className="shell-ch-row"
         aria-current={active ? "true" : undefined}
         data-active={active ? "true" : undefined}
+        data-unread={hasUnread ? "true" : undefined}
         onClick={onSelect}
       >
-        {/* The workbench's own initial for multi-party channels, or
-            the Corbit avatar for agent DM conversations. */}
-        <span className="shell-ch-stack" aria-hidden="true">
+        <span className="shell-ch-avatar" data-live={live}>
           {workbench.kind === "chat" ? (
-            <span
-              data-agent="true"
-              className="!overflow-hidden !border-[1.5px] !border-background !bg-transparent !p-0"
-            >
-              <CorbitAvatar
-                size="sm"
-                ariaLabel={displayTitle}
-                className="!static !size-full"
-              />
+            <span aria-hidden="true">
+              <CorbitAvatar size="sm" ariaLabel={displayTitle} />
             </span>
           ) : (
-            <span>{displayTitle.slice(0, 1).toUpperCase()}</span>
+            <span className="shell-ch-initial" aria-hidden="true">
+              {displayTitle.slice(0, 1).toUpperCase()}
+            </span>
           )}
+          {live === "working" ? (
+            <span
+              className="shell-ch-orbit"
+              aria-hidden="true"
+              title="Agent working"
+            />
+          ) : live === "reply-ready" ? (
+            <span
+              className="shell-ch-completion"
+              aria-hidden="true"
+              title="Reply ready"
+            >
+              <Check aria-hidden="true" />
+            </span>
+          ) : null}
+          <span className="sr-only" aria-live="polite" aria-atomic="true">
+            {liveLabel}
+          </span>
         </span>
         <span className="shell-ch-meta">
           <span className="shell-ch-name-row">
@@ -346,10 +372,6 @@ function WorkbenchRow({
                 shared
               </Badge>
             ) : null}
-            {/* Live pulse only when no unread badge. */}
-            {live === true && !hasUnread ? (
-              <span className="shell-ch-live" title="Active" />
-            ) : null}
           </span>
           {workbench.preview !== undefined && workbench.preview !== "" ? (
             <span className="shell-ch-preview">{workbench.preview}</span>
@@ -359,7 +381,11 @@ function WorkbenchRow({
           {time !== undefined && time !== "" ? (
             <span className="shell-ch-time">{time}</span>
           ) : null}
-          {hasUnread ? <Badge tone="accent">{unread}</Badge> : null}
+          {hasUnread && live !== "reply-ready" ? (
+            <Badge tone="accent" className="shell-ch-unread-badge">
+              {unread}
+            </Badge>
+          ) : null}
         </span>
       </button>
       <div className="shell-ch-row-menu">
diff --git a/apps/web/test/workbench-list.test.tsx b/apps/web/test/workbench-list.test.tsx
index 0dbbe8d05..e8d85745f 100644
--- a/apps/web/test/workbench-list.test.tsx
+++ b/apps/web/test/workbench-list.test.tsx
@@ -209,3 +209,57 @@ describe("WorkbenchList — pin visibility and order (CL-6657)", () => {
     expect(wraps[3]?.querySelector(".shell-ch-pin")).toBeNull();
   });
 });
+
+describe("WorkbenchList avatar activity", () => {
+  for (const activity of ["working", "reply-ready", "idle"] as const) {
+    test(`renders ${activity} without changing the message preview`, async () => {
+      stubFetch({
+        chats: [
+          {
+            id: "ch_myra",
+            title: "Myra",
+            kind: "chat",
+            pinned: false,
+            participants: [],
+            live: activity,
+            unreadCount: 1,
+            preview: "Here is the revised draft.",
+            lastActivityAt: new Date().toISOString(),
+          },
+        ],
+      });
+      const el = await mount();
+      const avatar = el.querySelector(".shell-ch-avatar");
+      const corbit = avatar?.querySelector('[data-corbit="true"]');
+      expect(corbit).not.toBeNull();
+      expect(corbit?.parentElement?.getAttribute("aria-hidden")).toBe("true");
+      expect(el.querySelector(".shell-ch-preview")?.textContent).toBe(
+        "Here is the revised draft.",
+      );
+      expect(el.querySelector(".shell-ch-live")).toBeNull();
+      expect(avatar?.querySelector('[aria-live="polite"]')?.textContent).toBe(
+        activity === "working"
+          ? "Agent working"
+          : activity === "reply-ready"
+            ? "Reply ready"
+            : "",
+      );
+      if (activity === "working") {
+        expect(avatar?.querySelector(".shell-ch-orbit")).not.toBeNull();
+      } else {
+        expect(avatar?.querySelector(".shell-ch-orbit")).toBeNull();
+      }
+      if (activity === "reply-ready") {
+        expect(avatar?.querySelector(".shell-ch-completion")).not.toBeNull();
+      } else {
+        expect(avatar?.querySelector(".shell-ch-completion")).toBeNull();
+      }
+      const unreadBadge = el.querySelector(".shell-ch-unread-badge");
+      if (activity === "reply-ready") {
+        expect(unreadBadge).toBeNull();
+      } else {
+        expect(unreadBadge?.textContent).toBe("1");
+      }
+    });
+  }
+});
diff --git a/packages/chat-ui/src/api.ts b/packages/chat-ui/src/api.ts
index 0dff65cd8..511a578a7 100644
--- a/packages/chat-ui/src/api.ts
+++ b/packages/chat-ui/src/api.ts
@@ -62,7 +62,7 @@ const WorkbenchWire = type({
   // the honest "nothing unread" answer once a mailbox is resolved.
   "unreadCount?": "number",
   "lastActivityAt?": "string",
-  "live?": "boolean",
+  "live?": "'idle' | 'working' | 'reply-ready'",
   // A bounded, text-only snippet of the newest message (see
   // `packages/chat/src/codec.ts`'s `extractTextPreview`) — absent, never
   // an empty string, when there is no message yet or it carries no text
diff --git a/packages/chat-ui/src/workbench-timeline-view.ts b/packages/chat-ui/src/workbench-timeline-view.ts
index d3f0dc464..c30ff08b8 100644
--- a/packages/chat-ui/src/workbench-timeline-view.ts
+++ b/packages/chat-ui/src/workbench-timeline-view.ts
@@ -8,7 +8,9 @@
 // here is also what stops the two hooks depending on each other.
 
 import { useEffect, useMemo } from "react";
-import { putReadState } from "./api";
+import { reportError } from "@corbits/error-sink";
+import { useQueryClient } from "@tanstack/react-query";
+import { putReadState, workbenchesQueryKeyPrefix } from "./api";
 import type { MessageItem } from "./api";
 import { selectThreadFeed, threadAffordanceMeta } from "./thread-feed";
 import type { ThreadAffordanceMeta } from "./timeline";
@@ -51,6 +53,7 @@ export function useWorkbenchTimelineView(args: {
   readonly navigation: ThreadNavigation;
 }): WorkbenchTimelineView {
   const { tenantId, activeWorkbenchId, feed, navigation } = args;
+  const queryClient = useQueryClient();
   const { loadedMessages, rootThreadId, threads, feedStatus } = feed;
   const { openThreadId, openThread, pendingParentMessageId } = navigation;
 
@@ -87,13 +90,26 @@ export function useWorkbenchTimelineView(args: {
     void putReadState(tenantId, activeWorkbenchId, {
       lastSeenCreatedAt: last.createdAt,
       lastSeenId: last.id,
-    }).catch(() => undefined);
+    })
+      .then(() =>
+        queryClient.invalidateQueries({
+          queryKey: workbenchesQueryKeyPrefix(tenantId),
+        }),
+      )
+      .catch((error: unknown) => {
+        reportError(error, {
+          operation: "chat.markRead",
+          tenantId,
+          roomId: activeWorkbenchId,
+        });
+      });
   }, [
     tenantId,
     activeWorkbenchId,
     openThreadId,
     pendingParentMessageId,
     feedItems,
+    queryClient,
   ]);
 
   return {
diff --git a/packages/chat/src/agent-turns.ts b/packages/chat/src/agent-turns.ts
index c1a861871..fdbd5bfc2 100644
--- a/packages/chat/src/agent-turns.ts
+++ b/packages/chat/src/agent-turns.ts
@@ -15,7 +15,7 @@ import {
   AGENT_RUNTIME_SECTION_ID,
   agentRuntimeTurnRunId,
 } from "@corbits/agent-runtime";
-import { and, desc, eq, lt, sql } from "drizzle-orm";
+import { and, asc, desc, eq, inArray, lt, sql } from "drizzle-orm";
 
 import { agentTurns } from "./schema";
 import type { ChatDb } from "./store";
@@ -163,6 +163,10 @@ export interface AgentTurnStore {
     },
     signal?: AbortSignal,
   ): Promise<void>;
+  listWorkbenchTurns(input: {
+    readonly tenantId: string;
+    readonly workbenchIds: readonly string[];
+  }): Promise<readonly AgentTurn[]>;
   listTurns(input: {
     readonly tenantId: string;
     readonly workbenchId: string;
@@ -419,6 +423,28 @@ export function createInMemoryAgentTurnStore(
         .sort(compareTurnsNewestFirst)[0];
     },
 
+    async listWorkbenchTurns(input) {
+      expireStaleTurns();
+      const workbenchIds = new Set(input.workbenchIds);
+      const ordered = [...rows.values()]
+        .filter(
+          (turn) =>
+            turn.tenantId === input.tenantId &&
+            workbenchIds.has(turn.workbenchId),
+        )
+        .sort(
+          (a, b) =>
+            Number(b.status === "running") - Number(a.status === "running") ||
+            compareTurnsNewestFirst(a, b),
+        );
+      const byWorkbench = new Map<string, AgentTurn>();
+      for (const turn of ordered) {
+        if (!byWorkbench.has(turn.workbenchId))
+          byWorkbench.set(turn.workbenchId, turn);
+      }
+      return [...byWorkbench.values()];
+    },
+
     async findRunningTurns(input) {
       expireStaleTurns();
       return [...rows.values()].filter(
@@ -670,6 +696,27 @@ export function createDrizzleAgentTurnStore<
       return resolveTurnByChildRun(input);
     },
 
+    async listWorkbenchTurns(input) {
+      if (input.workbenchIds.length === 0) return [];
+      await expireStaleTurns({ tenantId: input.tenantId });
+      const rows = await db
+        .selectDistinctOn([agentTurns.workbenchId])
+        .from(agentTurns)
+        .where(
+          and(
+            eq(agentTurns.tenantId, input.tenantId),
+            inArray(agentTurns.workbenchId, [...input.workbenchIds]),
+          ),
+        )
+        .orderBy(
+          asc(agentTurns.workbenchId),
+          desc(sql`${agentTurns.status} = 'running'`),
+          desc(agentTurns.startedAt),
+          desc(agentTurns.occurrence),
+        );
+      return rows.map((row) => toAgentTurn(row));
+    },
+
     async findRunningTurns(input) {
       await expireStaleTurns(input);
       const rows = await db
diff --git a/packages/chat/src/room-messages.ts b/packages/chat/src/room-messages.ts
index ef76bb79b..58d96f5ab 100644
--- a/packages/chat/src/room-messages.ts
+++ b/packages/chat/src/room-messages.ts
@@ -96,6 +96,10 @@ export interface RoomMessageStore {
     input: PostRoomMessageInput & { readonly id: string },
   ): Promise<RoomMessage>;
   listMessages(input: ListRoomMessagesInput): Promise<ListedRoomMessages>;
+  getMessages(input: {
+    readonly tenantId: string;
+    readonly messageIds: readonly string[];
+  }): Promise<readonly RoomMessage[]>;
   getMessage(input: {
     readonly tenantId: string;
     readonly workbenchId: string;
@@ -432,6 +436,20 @@ export function createDrizzleRoomMessageStore(
       return pageOf(rows.map((row) => toRoomMessage(row as MessageRow)));
     },
 
+    async getMessages(input) {
+      if (input.messageIds.length === 0) return [];
+      const rows = await db
+        .select()
+        .from(workbenchMessages)
+        .where(
+          and(
+            eq(workbenchMessages.tenantId, input.tenantId),
+            inArray(workbenchMessages.id, [...input.messageIds]),
+          ),
+        );
+      return rows.map(toRoomMessage);
+    },
+
     async getMessage(input) {
       const [row] = await db
         .select()
@@ -655,6 +673,15 @@ export function createInMemoryRoomMessageStore(): RoomMessageStore {
       );
     },
 
+    async getMessages(input) {
+      const messageIds = new Set(input.messageIds);
+      return [...byWorkbench.entries()].flatMap(([key, messages]) =>
+        key.startsWith(`${input.tenantId}:`)
+          ? messages.filter((message) => messageIds.has(message.id))
+          : [],
+      );
+    },
+
     async getMessage(input) {
       const messages =
         byWorkbench.get(keyOf(input.tenantId, input.workbenchId)) ?? [];
diff --git a/packages/chat/src/routes.ts b/packages/chat/src/routes.ts
index 8bf057502..92c1cd595 100644
--- a/packages/chat/src/routes.ts
+++ b/packages/chat/src/routes.ts
@@ -64,7 +64,7 @@ import {
   validateSettingsPatch,
   visibilityOf,
 } from "./workbench-settings";
-import { isRecentlyActive } from "./workbench-activity";
+import { listWorkbenchLiveState } from "./workbench-reply-activity";
 import { postRoomMessage, type RoomMessageStore } from "./room-messages";
 import { WorkbenchOnboardingStep } from "./blocks";
 import type { ConnectGithubBlockData } from "./blocks";
@@ -1444,7 +1444,7 @@ export function createChatRoutes(deps: CreateChatRoutesDeps): Hono<TenantEnv> {
         rows.map((row) => deps.tenancy.getWorkbenchTenancy(row.workbenchId)),
       );
 
-      // Row signals (unread badge, live dot, relative time) in two bulk
+      // Message signals (unread count, preview, relative time) in two bulk
       // calls covering every row — never one per workbench. The caller's
       // own read cursors come from `workbench_read_state`, the activity
       // from the timeline itself.
@@ -1470,6 +1470,14 @@ export function createChatRoutes(deps: CreateChatRoutesDeps): Hono<TenantEnv> {
         }),
       });
 
+      const liveState = await listWorkbenchLiveState({
+        tenantId: tenant.id,
+        workbenchIds: rows.map((row) => row.workbenchId),
+        readCursors: cursorByWorkbenchId,
+        agentTurns: deps.agentTurns,
+        roomMessages: deps.roomMessages,
+      });
+
       const ownItems = rows.map((row, index) => {
         const link = links[index];
         const view =
@@ -1477,13 +1485,19 @@ export function createChatRoutes(deps: CreateChatRoutesDeps): Hono<TenantEnv> {
             ? withTenancy(workbenchView(row), link)
             : { ...workbenchView(row), tenancy: null, legacy: true };
         const activity = activityByWorkbenchId[row.workbenchId];
-        if (activity === undefined) return view;
-        const withUnread = { ...view, unreadCount: activity.unreadCount };
+        const withLiveState = {
+          ...view,
+          live: liveState.get(row.workbenchId),
+        };
+        if (activity === undefined) return withLiveState;
+        const withUnread = {
+          ...withLiveState,
+          unreadCount: activity.unreadCount,
+        };
         if (activity.lastActivityAt === undefined) return withUnread;
         const withActivity = {
           ...withUnread,
           lastActivityAt: activity.lastActivityAt,
-          live: isRecentlyActive(activity.lastActivityAt),
         };
         return activity.preview === undefined
           ? withActivity
@@ -1539,6 +1553,7 @@ export function createChatRoutes(deps: CreateChatRoutesDeps): Hono<TenantEnv> {
                   tenancy: null,
                   legacy: false,
                   sharedLabel,
+                  live: "idle",
                 });
               }
               return items;
diff --git a/packages/chat/src/workbench-activity.test.ts b/packages/chat/src/workbench-activity.test.ts
deleted file mode 100644
index a2cbcc727..000000000
--- a/packages/chat/src/workbench-activity.test.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  isRecentlyActive,
-  LIVE_ACTIVITY_WINDOW_MS,
-} from "./workbench-activity";
-
-describe("isRecentlyActive", () => {
-  test("true right at the edge of the window", () => {
-    const now = new Date("2026-01-01T00:10:00.000Z");
-    const lastActivityAt = new Date(
-      now.getTime() - LIVE_ACTIVITY_WINDOW_MS,
-    ).toISOString();
-    expect(isRecentlyActive(lastActivityAt, now)).toBe(true);
-  });
-
-  test("false one millisecond past the window", () => {
-    const now = new Date("2026-01-01T00:10:00.000Z");
-    const lastActivityAt = new Date(
-      now.getTime() - LIVE_ACTIVITY_WINDOW_MS - 1,
-    ).toISOString();
-    expect(isRecentlyActive(lastActivityAt, now)).toBe(false);
-  });
-});
diff --git a/packages/chat/src/workbench-activity.ts b/packages/chat/src/workbench-activity.ts
deleted file mode 100644
index aa4347ed3..000000000
--- a/packages/chat/src/workbench-activity.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-// Whether a workbench row should read as "live", kept apart from the
-// activity query itself (see `listActivity` in `./room-messages.ts`) so
-// the recency rule is testable without a database.
-
-/** A workbench counts as "live" when its newest message landed within
- * this window of now — no fake presence, just recency. */
-export const LIVE_ACTIVITY_WINDOW_MS = 5 * 60 * 1000;
-
-export function isRecentlyActive(
-  lastActivityAt: string,
-  now: Date = new Date(),
-): boolean {
-  return now.getTime() - Date.parse(lastActivityAt) <= LIVE_ACTIVITY_WINDOW_MS;
-}
diff --git a/packages/chat/src/workbench-reply-activity.ts b/packages/chat/src/workbench-reply-activity.ts
new file mode 100644
index 000000000..5762ca729
--- /dev/null
+++ b/packages/chat/src/workbench-reply-activity.ts
@@ -0,0 +1,46 @@
+import type { AgentTurnStore } from "./agent-turns";
+import type { RoomMessageStore } from "./room-messages";
+
+export type WorkbenchLiveState = "idle" | "working" | "reply-ready";
+
+export async function listWorkbenchLiveState(input: {
+  readonly tenantId: string;
+  readonly workbenchIds: readonly string[];
+  readonly readCursors: ReadonlyMap<string, string>;
+  readonly agentTurns: AgentTurnStore | undefined;
+  readonly roomMessages: RoomMessageStore;
+}): Promise<ReadonlyMap<string, WorkbenchLiveState>> {
+  const live = new Map<string, WorkbenchLiveState>(
+    input.workbenchIds.map((id) => [id, "idle"]),
+  );
+  if (input.agentTurns === undefined) return live;
+  const turns = await input.agentTurns.listWorkbenchTurns(input);
+  const replies = await input.roomMessages.getMessages({
+    tenantId: input.tenantId,
+    messageIds: turns.flatMap((turn) =>
+      turn.status === "completed" && turn.replyMessageId !== null
+        ? [turn.replyMessageId]
+        : [],
+    ),
+  });
+  const byId = new Map(replies.map((reply) => [reply.id, reply]));
+  for (const turn of turns) {
+    if (turn.status === "running") {
+      live.set(turn.workbenchId, "working");
+      continue;
+    }
+    if (turn.status !== "completed" || turn.replyMessageId === null) continue;
+    const reply = byId.get(turn.replyMessageId);
+    const cursor = input.readCursors.get(turn.workbenchId);
+    if (
+      reply !== undefined &&
+      reply.workbenchId === turn.workbenchId &&
+      reply.senderPrincipalId === null &&
+      reply.sender.address === turn.agentAddress &&
+      (cursor === undefined || reply.createdAt > cursor)
+    ) {
+      live.set(turn.workbenchId, "reply-ready");
+    }
+  }
+  return live;
+}
diff --git a/packages/chat/test/agent-turns.drizzle.test.ts b/packages/chat/test/agent-turns.drizzle.test.ts
index 3682c2cc1..ed96215f3 100644
--- a/packages/chat/test/agent-turns.drizzle.test.ts
+++ b/packages/chat/test/agent-turns.drizzle.test.ts
@@ -19,6 +19,8 @@ import {
   createDrizzleAgentTurnStore,
 } from "../src/agent-turns";
 import { applyChatMigrations } from "../src/migrations";
+import { createDrizzleRoomMessageStore } from "../src/room-messages";
+import { listWorkbenchLiveState } from "../src/workbench-reply-activity";
 import { dbGate } from "../../../scripts/e2e/db-gate";
 
 function scratchUrlFor(e2eUrl: string): string {
@@ -242,4 +244,91 @@ describeIfDb("createDrizzleAgentTurnStore", () => {
       await sql.end();
     }
   });
+  test("bulk sidebar projection preserves running precedence, reply ownership and read state", async () => {
+    const sql = postgres(scratchUrl, { max: 1, onnotice: () => undefined });
+    try {
+      let now = Date.now();
+      const agentTurns = createDrizzleAgentTurnStore(drizzle(sql), {
+        now: () => now,
+      });
+      const roomMessages = createDrizzleRoomMessageStore(drizzle(sql));
+      const workbenchId = "run_sidebar";
+      const agentAddress = "sidebar@acme.example";
+      const readCursors = new Map<string, string>();
+      const input = {
+        tenantId: TENANT,
+        workbenchId,
+        agentAddress,
+        requestMessageIds: ["sidebar_request"],
+      };
+      const activity = async () =>
+        (
+          await listWorkbenchLiveState({
+            tenantId: TENANT,
+            workbenchIds: [workbenchId],
+            readCursors,
+            agentTurns,
+            roomMessages,
+          })
+        ).get(workbenchId);
+      const older = await agentTurns.startTurn({
+        ...input,
+        agentAddress: "older@acme.example",
+      });
+      const turn = await agentTurns.startTurn(input);
+      const reply = await roomMessages.insertMessage({
+        tenantId: TENANT,
+        workbenchId,
+        id: "sidebar_reply",
+        sender: { name: "Myra", address: agentAddress },
+        parts: [{ kind: "text", text: "The draft is ready." }],
+      });
+      await agentTurns.finishTurn({
+        tenantId: TENANT,
+        turnId: turn.id,
+        status: "completed",
+        replyMessageId: reply.id,
+      });
+      expect(await activity()).toBe("working");
+      await agentTurns.finishTurn({
+        tenantId: TENANT,
+        turnId: older.id,
+        status: "cancelled",
+      });
+      expect(await activity()).toBe("reply-ready");
+      readCursors.set(workbenchId, reply.createdAt);
+      expect(await activity()).toBe("idle");
+      const next = await agentTurns.startTurn(input);
+      await agentTurns.finishTurn({
+        tenantId: TENANT,
+        turnId: next.id,
+        status: "failed",
+      });
+      readCursors.clear();
+      expect(await activity()).toBe("idle");
+      await agentTurns.startTurn(input);
+      now = Date.now() + AGENT_TURN_STALE_MS + 60_000;
+      expect(await activity()).toBe("idle");
+      expect(
+        await agentTurns.listWorkbenchTurns({
+          tenantId: "other_tenant",
+          workbenchIds: [workbenchId],
+        }),
+      ).toEqual([]);
+      expect(
+        await agentTurns.listWorkbenchTurns({
+          tenantId: TENANT,
+          workbenchIds: [],
+        }),
+      ).toEqual([]);
+      expect(
+        await roomMessages.getMessages({
+          tenantId: "other_tenant",
+          messageIds: [reply.id],
+        }),
+      ).toEqual([]);
+    } finally {
+      await sql.end();
+    }
+  });
 });
diff --git a/packages/chat/test/chat-orchestrator.test.ts b/packages/chat/test/chat-orchestrator.test.ts
index b883d5a75..da0b97d2c 100644
--- a/packages/chat/test/chat-orchestrator.test.ts
+++ b/packages/chat/test/chat-orchestrator.test.ts
@@ -71,6 +71,7 @@ function fakeRoom(options?: { failPostOnCall: number }) {
     },
     listMessages: store.listMessages,
     getMessage: store.getMessage,
+    getMessages: store.getMessages,
     stampMailMessageId: store.stampMailMessageId,
     findByMailMessageId: store.findByMailMessageId,
     listActivity: store.listActivity,
diff --git a/packages/chat/test/routes.test.ts b/packages/chat/test/routes.test.ts
index 5b3d6c73a..1f08f6055 100644
--- a/packages/chat/test/routes.test.ts
+++ b/packages/chat/test/routes.test.ts
@@ -1609,7 +1609,7 @@ describe("GET /workbenches", () => {
       items: {
         unreadCount?: number;
         lastActivityAt?: string;
-        live?: boolean;
+        live?: string;
       }[];
     };
 
@@ -1618,7 +1618,7 @@ describe("GET /workbenches", () => {
     expect(body.items).toHaveLength(1);
     expect(body.items[0]?.unreadCount).toBeUndefined();
     expect(body.items[0]?.lastActivityAt).toBeUndefined();
-    expect(body.items[0]?.live).toBeUndefined();
+    expect(body.items[0]?.live).toBe("idle");
   });
 
   test("counts messages sent since the caller's own read cursor as unread", async () => {
@@ -1641,13 +1641,13 @@ describe("GET /workbenches", () => {
         id: string;
         unreadCount?: number;
         lastActivityAt?: string;
-        live?: boolean;
+        live?: string;
       }[];
     };
     const bobRow = bobList.items.find((item) => item.id === workbench.id);
     expect(bobRow?.unreadCount).toBe(2);
     expect(bobRow?.lastActivityAt).toBeDefined();
-    expect(bobRow?.live).toBe(true);
+    expect(bobRow?.live).toBe("idle");
   });
 
   test("carries a bounded text preview of the newest message", async () => {
diff --git a/packages/chat/test/workbench-reply-activity.test.ts b/packages/chat/test/workbench-reply-activity.test.ts
new file mode 100644
index 000000000..e7366d718
--- /dev/null
+++ b/packages/chat/test/workbench-reply-activity.test.ts
@@ -0,0 +1,210 @@
+import { describe, expect, test } from "bun:test";
+import {
+  createInMemoryAgentTurnStore,
+  AGENT_TURN_STALE_MS,
+} from "../src/agent-turns";
+import { createInMemoryRoomMessageStore } from "../src/room-messages";
+import { listWorkbenchLiveState } from "../src/workbench-reply-activity";
+import { createChatRoutes } from "../src/routes";
+import { buildDeps, createWorkbench, mountAs, TENANT } from "./test-support";
+
+function fixture() {
+  let now = Date.now();
+  const agentTurns = createInMemoryAgentTurnStore({ now: () => now });
+  const roomMessages = createInMemoryRoomMessageStore();
+  const readCursors = new Map<string, string>();
+  const start = {
+    tenantId: TENANT.id,
+    workbenchId: "wb_1",
+    agentAddress: "agent@acme.example",
+    requestMessageIds: ["request_1"],
+  };
+  const activity = () =>
+    listWorkbenchLiveState({
+      tenantId: TENANT.id,
+      workbenchIds: ["wb_1"],
+      readCursors,
+      agentTurns,
+      roomMessages,
+    });
+  async function reply(
+    overrides: {
+      senderPrincipalId?: string;
+      workbenchId?: string;
+      tenantId?: string;
+      address?: string;
+    } = {},
+  ) {
+    return roomMessages.insertMessage({
+      tenantId: overrides.tenantId ?? TENANT.id,
+      workbenchId: overrides.workbenchId ?? "wb_1",
+      id: "reply_1",
+      sender: {
+        name: "Myra",
+        address: overrides.address ?? start.agentAddress,
+      },
+      parts: [{ kind: "text", text: "Here is the revised draft." }],
+      ...(overrides.senderPrincipalId !== undefined
+        ? { senderPrincipalId: overrides.senderPrincipalId }
+        : {}),
+    });
+  }
+  return {
+    agentTurns,
+    roomMessages,
+    start,
+    readCursors,
+    activity,
+    reply,
+    advance: (ms: number) => {
+      now += ms;
+    },
+  };
+}
+
+describe("sidebar reply activity", () => {
+  test("working becomes reply ready only when its actual reply exists, then clears at the read cursor", async () => {
+    const f = fixture();
+    expect((await f.activity()).get("wb_1")).toBe("idle");
+    const turn = await f.agentTurns.startTurn(f.start);
+    expect((await f.activity()).get("wb_1")).toBe("working");
+    await f.agentTurns.finishTurn({
+      tenantId: TENANT.id,
+      turnId: turn.id,
+      status: "completed",
+      replyMessageId: "reply_1",
+    });
+    expect((await f.activity()).get("wb_1")).toBe("idle");
+    const reply = await f.reply();
+    expect((await f.activity()).get("wb_1")).toBe("reply-ready");
+    f.readCursors.set("wb_1", reply.createdAt);
+    expect((await f.activity()).get("wb_1")).toBe("idle");
+  });
+
+  for (const status of ["failed", "cancelled"] as const) {
+    test(`a newer ${status} turn suppresses an older unread completion`, async () => {
+      const f = fixture();
+      const first = await f.agentTurns.startTurn(f.start);
+      await f.reply();
+      await f.agentTurns.finishTurn({
+        tenantId: TENANT.id,
+        turnId: first.id,
+        status: "completed",
+        replyMessageId: "reply_1",
+      });
+      const second = await f.agentTurns.startTurn(f.start);
+      expect((await f.activity()).get("wb_1")).toBe("working");
+      await f.agentTurns.finishTurn({
+        tenantId: TENANT.id,
+        turnId: second.id,
+        status,
+      });
+      expect((await f.activity()).get("wb_1")).toBe("idle");
+    });
+  }
+
+  test("an older running agent takes precedence over a newer completed agent", async () => {
+    const f = fixture();
+    await f.agentTurns.startTurn({
+      ...f.start,
+      agentAddress: "other@acme.example",
+    });
+    f.advance(1);
+    const turn = await f.agentTurns.startTurn(f.start);
+    await f.reply();
+    await f.agentTurns.finishTurn({
+      tenantId: TENANT.id,
+      turnId: turn.id,
+      status: "completed",
+      replyMessageId: "reply_1",
+    });
+    expect((await f.activity()).get("wb_1")).toBe("working");
+  });
+
+  test("stale, other-tenant and unlisted running turns cannot keep the orbit active", async () => {
+    const f = fixture();
+    await f.agentTurns.startTurn(f.start);
+    f.advance(AGENT_TURN_STALE_MS + 1);
+    await f.agentTurns.startTurn({ ...f.start, tenantId: "other" });
+    await f.agentTurns.startTurn({ ...f.start, workbenchId: "other" });
+    expect((await f.activity()).get("wb_1")).toBe("idle");
+  });
+
+  for (const invalid of [
+    { senderPrincipalId: "human" },
+    { address: "system" },
+    { workbenchId: "other" },
+    { tenantId: "other" },
+  ]) {
+    test(`never treats an unrelated reply as completion: ${JSON.stringify(invalid)}`, async () => {
+      const f = fixture();
+      const turn = await f.agentTurns.startTurn(f.start);
+      await f.reply(invalid);
+      await f.agentTurns.finishTurn({
+        tenantId: TENANT.id,
+        turnId: turn.id,
+        status: "completed",
+        replyMessageId: "reply_1",
+      });
+      expect((await f.activity()).get("wb_1")).toBe("idle");
+    });
+  }
+
+  test("ordinary unread messages without an agent turn have no completion indicator", async () => {
+    const f = fixture();
+    await f.reply({ senderPrincipalId: "human" });
+    expect((await f.activity()).get("wb_1")).toBe("idle");
+  });
+
+  test("the list route projects activity for the caller and clears it after reading", async () => {
+    const f = fixture();
+    const deps = buildDeps({
+      agentTurns: f.agentTurns,
+      roomMessages: f.roomMessages,
+    });
+    const app = mountAs(createChatRoutes(deps), "prn_alice");
+    const { body: workbench } = await createWorkbench(app, {
+      kind: "workbench",
+      name: "Myra",
+    });
+    const turn = await f.agentTurns.startTurn({
+      ...f.start,
+      workbenchId: workbench.id,
+    });
+    const readList = async () =>
+      (await app.request("/workbenches?kind=workbench")).json();
+    expect(await readList()).toEqual({
+      items: [expect.objectContaining({ id: workbench.id, live: "working" })],
+    });
+    const reply = await f.reply({ workbenchId: workbench.id });
+    await f.agentTurns.finishTurn({
+      tenantId: TENANT.id,
+      turnId: turn.id,
+      status: "completed",
+      replyMessageId: reply.id,
+    });
+    expect(await readList()).toEqual({
+      items: [
+        expect.objectContaining({
+          live: "reply-ready",
+          preview: "Here is the revised draft.",
+        }),
+      ],
+    });
+    const response = await app.request(
+      `/workbenches/${workbench.id}/read-state`,
+      {
+        method: "PUT",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          lastSeenCreatedAt: reply.createdAt,
+          lastSeenId: reply.id,
+        }),
+      },
+    );
+    expect(response.status).toBe(200);
+    expect(await readList()).toEqual({
+      items: [expect.objectContaining({ live: "idle" })],
+    });
+  });
+});