From 99c92f46f7305968b6963accce5312cc6c9f854c Mon Sep 17 00:00:00 2001
From: Dean Stratakos <29683763+dastratakos@users.noreply.github.com>
Date: Sun, 18 Oct 2026 16:25:57 +0000
Subject: [PATCH 1/2] feat(ui,host,desktop): mark Inbox items read and unread

An unread Inbox item, one changed since the reader last read it or marked
unread, wears the blue dot in a gutter before its tile, its title in the
semibold weight and its preview in the body's ink. Opening an item marks
it read, once each time it is shown. A row offers Mark as read / Mark as
unread (MailOpen / Mail) over its time while hovered or focused, and as
the first item of its right-click menu, beside U; a plain U toggles the
chosen item; the view's menu gains Mark all as read, which clears the
dots alone. A mark flips the dot at once and is let go where the service
refuses it. The Factory's rows and summary wear the attention mark for
what waits, so blue means unread everywhere.

The host gains two acts over the service's read state:
codingAgents.inboxReadState ({ itemId, unread }) and
codingAgents.inboxReadAll ({ workspaceId? }). ListRow gains
LIST_ROW_ACTIONS.HOVER, and its unread look is the semibold title and
the description in the body's ink.

Co-authored-by: luke-agent[bot] <339870089+luke-agent[bot]@users.noreply.github.com>
---
 .../renderer/desktop/desktop-factory.test.ts  |  23 +-
 .../src/renderer/desktop/desktop-factory.tsx  |  14 +-
 .../src/renderer/desktop/desktop-home.test.ts |   4 +-
 .../renderer/desktop/desktop-inbox.test.ts    | 211 +++++++++++++++++-
 .../src/renderer/desktop/desktop-inbox.tsx    |  19 +-
 .../renderer/desktop/desktop-tasks.test.ts    |  40 ++++
 .../src/renderer/desktop/desktop-tasks.tsx    |  16 +-
 apps/desktop/src/renderer/styles/desktop.css  |  46 ++--
 .../desktop/src/renderer/tasks/inbox-list.tsx | 122 ++++++++--
 .../src/renderer/tasks/inbox-model.test.ts    |  27 +++
 .../desktop/src/renderer/tasks/inbox-model.ts |  42 ++++
 .../renderer/tasks/use-inbox-read-marks.ts    | 134 +++++++++++
 ...codingAgentInboxReadStateParamsSchema.json |  17 ++
 packages/features/src/coding-agent-view.ts    |   8 +
 .../features/src/hosted-wire-schemas.test.ts  |   1 +
 packages/gateway/src/protocol.ts              |   4 +
 .../src/act-router/coding-agent-acts.test.ts  |  61 +++++
 .../host/src/act-router/coding-agent-acts.ts  |  20 ++
 packages/host/src/acts.ts                     |  22 ++
 .../host/src/compose-coding-agents.test.ts    |  33 +++
 packages/host/src/compose-coding-agents.ts    |  29 +++
 packages/host/src/host-operator.ts            |  28 +++
 packages/settings/src/shortcuts.ts            |   6 +
 .../ui/src/components/list-row/list-row.css   |  46 +++-
 .../ui/src/components/list-row/list-row.tsx   |  23 +-
 25 files changed, 927 insertions(+), 69 deletions(-)
 create mode 100644 apps/desktop/src/renderer/tasks/use-inbox-read-marks.ts
 create mode 100644 packages/features/fixtures/json-schema/coding-agent-view-codingAgentInboxReadStateParamsSchema.json

diff --git a/apps/desktop/src/renderer/desktop/desktop-factory.test.ts b/apps/desktop/src/renderer/desktop/desktop-factory.test.ts
index a51bc296d2..cc935e0eed 100644
--- a/apps/desktop/src/renderer/desktop/desktop-factory.test.ts
+++ b/apps/desktop/src/renderer/desktop/desktop-factory.test.ts
@@ -173,6 +173,23 @@ function mount(listed: readonly TaskSummary[], overrides: Partial<TasksControl>
   return { page: container, opened, redraw, rerender };
 }
 
+/**
+ * Whether a row waits on the developer, as it reads: ` (waits)` where its
+ * name stands in the unread weight and the attention mark before its time
+ * says "Needs you", none where neither, and ` (?)` where only one stands
+ * or it wears the blue dot that now means unread, so a half-drawn mark fails
+ * every listing.
+ */
+function waitsOf(row: Element): string {
+  const weight = row.getAttribute("data-unread") === "true";
+  const mark =
+    row.querySelector(".sidebar-task-time .attention-mark") !== null &&
+    row.querySelector(".sidebar-task-time .visually-hidden")?.textContent === "Needs you";
+  if (row.querySelector(".inbox-row-unread, .inbox-row-dot") !== null) return " (?)";
+  if (weight && mark) return " (waits)";
+  return weight || mark ? " (?)" : "";
+}
+
 /** A station's rows as a reader scans them: each row's words and task, and whether it waits on the developer. */
 function rows(page: HTMLElement, step: string): string[] {
   const region = page.querySelector(`section[data-step="${step}"]`);
@@ -180,7 +197,7 @@ function rows(page: HTMLElement, step: string): string[] {
   return [...region.querySelectorAll(".sidebar-task")].map((row) => {
     const words = row.querySelector(".sidebar-task-name")?.textContent;
     const context = row.querySelector(".home-row-context")?.textContent;
-    const waits = row.getAttribute("data-unread") === "true" ? " (waits)" : "";
+    const waits = waitsOf(row);
     return `${words}${context === undefined ? "" : ` · ${context}`}${waits}`;
   });
 }
@@ -213,6 +230,10 @@ test("each plan stands in its station, and what waits on the developer leads the
     page.querySelector(".factory-summary")?.textContent,
     "2 need you·1 agent working·0 shipped today",
   );
+  assert.ok(
+    page.querySelector(".factory-needs .attention-mark"),
+    "what needs you is counted beside the attention mark",
+  );
   // A draft with no agents stands nowhere; Talk holds only the task on a call.
   assert.deepEqual(rows(page, "talk"), []);
   assert.equal(
diff --git a/apps/desktop/src/renderer/desktop/desktop-factory.tsx b/apps/desktop/src/renderer/desktop/desktop-factory.tsx
index 33d39b834d..dfc3efc999 100644
--- a/apps/desktop/src/renderer/desktop/desktop-factory.tsx
+++ b/apps/desktop/src/renderer/desktop/desktop-factory.tsx
@@ -36,6 +36,7 @@ import {
 import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { ACTOR_SIZE, ActorMark, CreatorHeard } from "../actor-ref";
 import { useAppCommand } from "../app-commands";
+import { AttentionMark } from "../attention-mark";
 import { LINK_COPY, useCopyToast } from "../copy-feedback";
 import { agentPlace, LinkWorkspaceProvider, useCopyLinkItem } from "../copy-link-item";
 import { ExperimentTag, SendFeedbackButton } from "../experiment-marks";
@@ -345,13 +346,14 @@ function FactoryRow({
             <span className="sidebar-task-time">
               {actor === undefined ? null : <ActorMark actor={actor} size={ACTOR_SIZE.MARK} />}
               {end}
+              {waiting ? (
+                <span className="inbox-row-attention">
+                  <AttentionMark />
+                  <span className="visually-hidden">{NEEDS_YOU.LABEL}</span>
+                </span>
+              ) : null}
               <RelativeTime at={at} now={now} hint={false} />
             </span>
-            {waiting ? (
-              <span className="inbox-row-dot">
-                <span className="visually-hidden">{NEEDS_YOU.LABEL}</span>
-              </span>
-            ) : null}
           </span>
         </button>
       </Tooltip>
@@ -680,7 +682,7 @@ function Summary({ board }: { board: FactoryBoard }): React.JSX.Element {
         </Text>
       ) : (
         <span className="factory-needs">
-          <span className="inbox-row-dot factory-head-dot" aria-hidden="true" />
+          <AttentionMark />
           <Text as={TEXT_ELEMENT.SPAN} variant={TEXT_VARIANT.LABEL}>
             {`${waiting} ${waiting === 1 ? NEEDS_YOU.COUNT.one : NEEDS_YOU.COUNT.many}`}
           </Text>
diff --git a/apps/desktop/src/renderer/desktop/desktop-home.test.ts b/apps/desktop/src/renderer/desktop/desktop-home.test.ts
index b294d02505..1fe718fa7a 100644
--- a/apps/desktop/src/renderer/desktop/desktop-home.test.ts
+++ b/apps/desktop/src/renderer/desktop/desktop-home.test.ts
@@ -310,7 +310,7 @@ test("a waiting item's row opens the Inbox on its item, a recent plan opens the
   assert.equal(opened.newTasks, 1);
 });
 
-test("a waiting item's row on Home reads as the Inbox's own: what it asks under its title, its plan and the attention mark before its time, and no blue dot", async () => {
+test("a waiting item's row on Home reads as the Inbox's own: what it asks under its title, its plan and the attention mark before its time, and no unread dot on an item read", async () => {
   const { page } = mount();
   await settle();
 
@@ -324,7 +324,7 @@ test("a waiting item's row on Home reads as the Inbox's own: what it asks under
   const head = row.querySelector(".luke-list-row-head");
   assert.equal(head?.querySelector(".home-row-context")?.textContent, "Teammate invitations");
   assert.ok(head?.querySelector(".attention-mark"), "it needs the reader");
-  assert.equal(row.querySelector(".inbox-row-dot"), null);
+  assert.equal(row.querySelector(".inbox-row-unread"), null, "a read item wears no unread dot");
 });
 
 test("the waiting items stand under the Inbox's name, the place a press on one opens", async () => {
diff --git a/apps/desktop/src/renderer/desktop/desktop-inbox.test.ts b/apps/desktop/src/renderer/desktop/desktop-inbox.test.ts
index 77cbf98b5e..36156f6d31 100644
--- a/apps/desktop/src/renderer/desktop/desktop-inbox.test.ts
+++ b/apps/desktop/src/renderer/desktop/desktop-inbox.test.ts
@@ -205,6 +205,10 @@ let copied: string[] = [];
 let pageAgents = new Map<string, CodingAgentSummary>();
 /** The reads of an item's images, each held until the test lands it with a PNG's first bytes. */
 let imageReads: (() => void)[] = [];
+/** Every read mark the Inbox sent, in order: `read:<item>`, `unread:<item>`, or `all:<workspace>`. */
+let readMarks: string[] = [];
+/** Whether the service refuses a read mark, as one for an item it no longer holds. */
+let readMarkRefused = false;
 
 // Landed before any box renders, as the panel lands it after its first paint.
 beforeAll(() => Effect.runPromise(editorBundleLanded));
@@ -234,6 +238,8 @@ beforeEach(() => {
   fakeAppPlatform({ ...QUIET_PANEL, ...copyingInto(copied), ...DESKTOP_LINKS });
   pageAgents = new Map();
   imageReads = [];
+  readMarks = [];
+  readMarkRefused = false;
   fakeAppBridge({
     act: (request: Act) => {
       const done = (value: CodingAgentListAnswer | CodingAgentInboxAnswerView) =>
@@ -282,6 +288,20 @@ beforeEach(() => {
       if (request.kind === ACT_KIND.AUTOMATIONS_LIST) {
         return Promise.resolve({ status: ACT_OUTCOME_STATUS.DONE, value: { automations } });
       }
+      if (request.kind === ACT_KIND.CODING_AGENTS_INBOX_READ_STATE) {
+        const { itemId, unread } = request.payload;
+        readMarks.push(`${unread ? "unread" : "read"}:${itemId}`);
+        return Promise.resolve({
+          status: ACT_OUTCOME_STATUS.DONE,
+          value: readMarkRefused
+            ? { failure: CODING_AGENT_CALL_FAILURE.NOT_FOUND }
+            : { id: itemId, unread },
+        });
+      }
+      if (request.kind === ACT_KIND.CODING_AGENTS_INBOX_READ_ALL) {
+        readMarks.push(`all:${request.payload.workspaceId ?? "every workspace"}`);
+        return Promise.resolve({ status: ACT_OUTCOME_STATUS.DONE, value: { marked: 2 } });
+      }
       if (request.kind === ACT_KIND.CODING_AGENTS_INBOX_ATTACHMENT) {
         return new Promise((resolve) =>
           imageReads.push(() =>
@@ -407,14 +427,14 @@ const ROW_TITLE = ".luke-list-row-title";
 /**
  * What marks a row as needing the developer: `*` where it wears the
  * attention mark and says "Needs you" beside it, nothing where it does
- * neither, and `?` where it does one alone or wears the blue dot that
- * meant it before, so a half-drawn or stale mark fails every listing.
+ * neither, and `?` where it does one alone, so a half-drawn mark fails
+ * every listing.
  */
 function needsYouMark(row: HTMLElement): string {
   const mark = row.querySelector(".luke-list-row-meta .attention-mark") !== null;
-  const said =
-    row.querySelector(".luke-list-row-meta .visually-hidden")?.textContent === "Needs you";
-  if (row.querySelector(".inbox-row-dot") !== null) return "?";
+  const said = [...row.querySelectorAll(".luke-list-row-meta .visually-hidden")].some(
+    (each) => each.textContent === "Needs you",
+  );
   if (mark && said) return "*";
   return mark || said ? "?" : "";
 }
@@ -3218,7 +3238,7 @@ test("the attention mark stands before the time on the reader's own open item al
       mark: meta?.querySelector(".attention-mark") !== null,
       face: meta?.querySelector<HTMLElement>(".actor-mark")?.dataset.kind,
       said: meta?.querySelector(".visually-hidden")?.textContent,
-      dot: row.querySelector(".inbox-row-dot") !== null,
+      dot: row.querySelector(".inbox-row-unread") !== null,
       unread: row.closest("li")?.dataset.unread === "true",
     };
   };
@@ -3251,3 +3271,182 @@ test("the attention mark stands before the time on the reader's own open item al
     "▸ *Expire after 7 days?",
   ]);
 });
+
+/** Whether a row reads as unread: its blue dot, its title in the unread weight, and "Unread" said to a reader, each `?` where only some stand. */
+function unreadOf(page: HTMLElement, title: string): boolean | "?" {
+  const row = rowNamed(page, title);
+  const marks = [
+    row.querySelector(".inbox-row-gutter .inbox-row-unread") !== null,
+    row.closest("li")?.dataset.unread === "true",
+    [...row.querySelectorAll(".luke-list-row-meta .visually-hidden")].some(
+      (each) => each.textContent === "Unread",
+    ),
+  ];
+  if (marks.every(Boolean)) return true;
+  return marks.some(Boolean) ? "?" : false;
+}
+
+/** The mark a row's hover offers over its time. */
+function hoverMark(page: HTMLElement, title: string): HTMLButtonElement {
+  const li = rowNamed(page, title).closest("li");
+  const press = li?.querySelector<HTMLButtonElement>(".luke-list-row-actions button");
+  assert.ok(press, `${title}'s row offers a mark over its time`);
+  return press;
+}
+
+/** A row's right-click menu as it reads: each item's words, its key where it names one, a rule between groups. */
+function rowMenu(page: HTMLElement, title: string): string[] {
+  act(() => {
+    rowNamed(page, title).dispatchEvent(
+      new MouseEvent("contextmenu", { bubbles: true, cancelable: true }),
+    );
+  });
+  return menuWords();
+}
+
+/** The menu open now as it reads: each item's words, its key where it names one, and a rule between its groups. */
+function menuWords(): string[] {
+  const menu = [...document.querySelectorAll('[role="menu"]')].at(-1);
+  assert.ok(menu, "a menu is open");
+  return [...menu.querySelectorAll('[role^="menuitem"], .luke-menu-rule')].map((each) =>
+    each.classList.contains("luke-menu-rule") ? "—" : (each.textContent ?? ""),
+  );
+}
+
+/** The menu item whose words start with `label`, in the menu open now. */
+function menuItem(label: string): HTMLElement {
+  const item = [...document.querySelectorAll<HTMLElement>('[role="menuitem"]')].find((each) =>
+    each.textContent?.startsWith(label),
+  );
+  assert.ok(item, `the menu offers ${label}`);
+  return item;
+}
+
+/** The workspace the marking tests list, whose Mark all as read names it. */
+const ACME: Workspace = {
+  id: "workspace-acme",
+  name: "Acme",
+  slug: "acme",
+  role: WORKSPACE_ROLE.MEMBER,
+  github: null,
+};
+
+test("an unread item wears the blue dot in its row's gutter, its title in the unread weight, and says Unread to a reader; opening it marks it read at once, the item standing chosen first among them", async () => {
+  inboxes.set(BILLING.id, [
+    { ...THRESHOLD, unread: true },
+    { ...RETRY, unread: true },
+  ]);
+  inboxes.set(INVITES.id, [{ ...EXPIRY, unread: true }]);
+  const { page } = mount();
+  await settle();
+  // The item standing chosen is shown, and so opened, as the Inbox opens.
+  assert.deepEqual(readMarks, [`read:${THRESHOLD.id}`]);
+  assert.equal(unreadOf(page, "Alert at 80%?"), false);
+  assert.equal(unreadOf(page, "Expire after 7 days?"), true);
+  assert.equal(unreadOf(page, "How is a failed email retried?"), true);
+
+  act(() => rowNamed(page, "Expire after 7 days?").click());
+  await settle();
+  assert.deepEqual(readMarks, [`read:${THRESHOLD.id}`, `read:${EXPIRY.id}`]);
+  assert.equal(unreadOf(page, "Expire after 7 days?"), false);
+  assert.equal(unreadOf(page, "How is a failed email retried?"), true);
+});
+
+test("a row's mark over its time, the first item of its menu, and U each mark an item read or unread: Mark as unread on a read item, Mark as read on an unread one, U the chosen item, and the menu names U above Copy link", async () => {
+  listedWorkspace = ACME;
+  const keys = standKeymap();
+  const { page } = mount();
+  await settle();
+  const retry = "How is a failed email retried?";
+  assert.equal(hoverMark(page, retry).getAttribute("aria-label"), "Mark as unread");
+  act(() => hoverMark(page, retry).click());
+  await settle();
+  assert.equal(unreadOf(page, retry), true);
+  assert.equal(hoverMark(page, retry).getAttribute("aria-label"), "Mark as read");
+  assert.equal(
+    page.querySelector('[aria-current="page"] .luke-list-row-title')?.textContent,
+    "Alert at 80%?",
+    "a press on the mark opens nothing",
+  );
+
+  assert.deepEqual(rowMenu(page, retry), ["Mark as readU", "—", "Copy link"]);
+  act(() => menuItem("Mark as read").click());
+  await settle();
+  assert.equal(unreadOf(page, retry), false);
+
+  pressKey("u");
+  await settle();
+  assert.equal(unreadOf(page, "Alert at 80%?"), true, "U marks the chosen item unread");
+  pressKey("u");
+  await settle();
+  assert.equal(unreadOf(page, "Alert at 80%?"), false, "and U again marks it read");
+  assert.deepEqual(readMarks, [
+    `unread:${RETRY.id}`,
+    `read:${RETRY.id}`,
+    `unread:${THRESHOLD.id}`,
+    `read:${THRESHOLD.id}`,
+  ]);
+  act(() => keys.unmount());
+});
+
+test("an item marked unread while it is shown stays unread until it is opened again, as a mail app keeps it", async () => {
+  const keys = standKeymap();
+  const { page } = mount();
+  await settle();
+  pressKey("u");
+  await settle();
+  assert.equal(unreadOf(page, "Alert at 80%?"), true);
+  act(() => rowNamed(page, "Expire after 7 days?").click());
+  await settle();
+  assert.equal(unreadOf(page, "Alert at 80%?"), true, "leaving it leaves it unread");
+  act(() => rowNamed(page, "Alert at 80%?").click());
+  await settle();
+  assert.equal(unreadOf(page, "Alert at 80%?"), false, "opening it again reads it");
+  assert.deepEqual(readMarks, [`unread:${THRESHOLD.id}`, `read:${THRESHOLD.id}`]);
+  act(() => keys.unmount());
+});
+
+test("a mark the service refuses is let go, and the dot stands as the reads hold it", async () => {
+  readMarkRefused = true;
+  const { page } = mount();
+  await settle();
+  act(() => hoverMark(page, "How is a failed email retried?").click());
+  await settle();
+  assert.deepEqual(readMarks, [`unread:${RETRY.id}`]);
+  assert.equal(unreadOf(page, "How is a failed email retried?"), false);
+});
+
+test("Mark all as read in the view's menu, under the groupings, marks every unread item of the listed workspace read and clears the dots alone, the attention marks standing; with nothing unread it stands disabled", async () => {
+  listedWorkspace = ACME;
+  inboxes.set(BILLING.id, [THRESHOLD, { ...RETRY, unread: true }]);
+  inboxes.set(INVITES.id, [{ ...EXPIRY, unread: true }]);
+  const { page } = mount();
+  await settle();
+  const openOptions = () => {
+    const options = page.querySelector<HTMLButtonElement>('button[aria-label="View options"]');
+    assert.ok(options, "the head offers the view's menu");
+    act(() => options.click());
+    return menuWords();
+  };
+  assert.deepEqual(openOptions(), [
+    "Group by task",
+    "Group by person",
+    "Newest first",
+    "—",
+    "Mark all as read",
+  ]);
+  act(() => menuItem("Mark all as read").click());
+  await settle();
+  assert.deepEqual(readMarks, ["all:workspace-acme"]);
+  assert.equal(unreadOf(page, "Expire after 7 days?"), false);
+  assert.equal(unreadOf(page, "How is a failed email retried?"), false);
+  assert.deepEqual(listed(page), [
+    "# Billing usage alerts",
+    "How is a failed email retried?",
+    "▸ *Alert at 80%?",
+    "# Invites",
+    "*Expire after 7 days?",
+  ]);
+  openOptions();
+  assert.equal(menuItem("Mark all as read").matches(":disabled"), true);
+});
diff --git a/apps/desktop/src/renderer/desktop/desktop-inbox.tsx b/apps/desktop/src/renderer/desktop/desktop-inbox.tsx
index 45b323fe00..1a0a85bb8b 100644
--- a/apps/desktop/src/renderer/desktop/desktop-inbox.tsx
+++ b/apps/desktop/src/renderer/desktop/desktop-inbox.tsx
@@ -25,6 +25,7 @@ import { INBOX_COLUMNS, useInboxColumns } from "../tasks/inbox-columns";
 import { InboxList, InboxListSkeleton, ItemMark, NeedsYouEmpty } from "../tasks/inbox-list";
 import {
   anyNeedsYou,
+  anyUnread,
   firstChoice,
   INBOX_HOLDER,
   type InboxGroup,
@@ -50,6 +51,7 @@ import { useMinute } from "../tasks/task-time";
 import { TOOL_TARGET, type ToolTarget } from "../tasks/tool-call-model";
 import { type CodingAgentsControl, useCodingAgents } from "../tasks/use-coding-agents";
 import { useInboxItems } from "../tasks/use-inbox-items";
+import { useInboxReadMarks, useReadOnOpen } from "../tasks/use-inbox-read-marks";
 import { type OpenHere, OpenHereProvider, useOpenLink } from "../tasks/use-open-link";
 import { PULL_REQUEST_VIEW, type SidePanelControl } from "../tasks/use-side-panel";
 import { useTaskInbox } from "../tasks/use-task-inbox";
@@ -276,10 +278,11 @@ export function DesktopInbox({ tasks }: { tasks: TasksControl }): React.JSX.Elem
           },
         ]
       : [];
-  const entries = [
+  const marks = useInboxReadMarks({ act, workspaceId: tasks.workspace?.id });
+  const entries = marks.over([
     ...taskEntries,
     ...tasklessGroups([...tasks.inboxTaskless, ...settledAgent], tasklessRead, tasks.workspace?.id),
-  ];
+  ]);
   const filter = {
     grouping: choices.grouping,
     waitingOnly: choices.waitingOnly,
@@ -358,6 +361,13 @@ export function DesktopInbox({ tasks }: { tasks: TasksControl }): React.JSX.Elem
     choose(listed);
     columns.onOpen(listed.item.id);
   };
+  const { onMark: markItem } = marks;
+  useReadOnOpen({
+    shown: tasks.shown && columns.shown !== INBOX_COLUMNS.LIST ? chosen?.item : undefined,
+    chosen: chosen?.item,
+    active: tasks.shown,
+    onMark: markItem,
+  });
   const pager = useInboxPager(steps, list, chosen?.item.id, choose, {
     shown: tasks.shown,
     folded: folds.folded,
@@ -472,6 +482,10 @@ export function DesktopInbox({ tasks }: { tasks: TasksControl }): React.JSX.Elem
                     needsYou: choices,
                     view: { choices, folds },
                     waiting: anyNeedsYou(entries, tasks.me),
+                    readAll: {
+                      unread: anyUnread(entries),
+                      onMarkAll: () => marks.onMarkAll(entries.flatMap(({ items }) => items)),
+                    },
                   }}
                   models={named.models}
                   readerId={tasks.me}
@@ -487,6 +501,7 @@ export function DesktopInbox({ tasks }: { tasks: TasksControl }): React.JSX.Elem
                     />
                   }
                   onChoose={open}
+                  onMark={(listed, unread) => markItem(listed.item, unread)}
                 />
                 {chosen === undefined ? (
                   <section
diff --git a/apps/desktop/src/renderer/desktop/desktop-tasks.test.ts b/apps/desktop/src/renderer/desktop/desktop-tasks.test.ts
index 892b9c76ae..6f1ab5cfe3 100644
--- a/apps/desktop/src/renderer/desktop/desktop-tasks.test.ts
+++ b/apps/desktop/src/renderer/desktop/desktop-tasks.test.ts
@@ -835,3 +835,43 @@ test("with Chat off for the account, a Chat tab kept on the task's strip draws n
   act(() => off.root.unmount());
   off.container.remove();
 });
+
+test("a plan's own Inbox marks the item it shows read as it opens it, and its rows offer to mark an item read or unread as the window's Inbox does", async () => {
+  const marked: string[] = [];
+  fakeAppBridge({
+    act: (request: Act) => {
+      if (request.kind === ACT_KIND.CODING_AGENTS_INBOX_READ_STATE) {
+        const { itemId, unread } = request.payload;
+        marked.push(`${unread ? "unread" : "read"}:${itemId}`);
+        return Promise.resolve({ status: ACT_OUTCOME_STATUS.DONE, value: { id: itemId, unread } });
+      }
+      return Promise.resolve({ status: ACT_OUTCOME_STATUS.REFUSED, reason: "Not in this test." });
+    },
+  });
+  const SHIP = {
+    ...approvalItem("a1b2c3d4-0000-4000-8000-0000000000a1", "Ship it?", 2),
+    unread: true,
+  };
+  const ROLL = {
+    ...approvalItem("a1b2c3d4-0000-4000-8000-0000000000a2", "Roll back?", 1),
+    unread: true,
+  };
+  const inbox = await narrowTaskInbox([SHIP, ROLL], false, 1400);
+  await act(async () => {
+    for (let tick = 0; tick < 8; tick += 1) await Promise.resolve();
+  });
+  assert.equal(inbox.title(), "Ship it?");
+  assert.deepEqual(marked, [`read:${SHIP.id}`]);
+  const dot = (title: string) =>
+    inbox.row(title)?.querySelector(".inbox-row-gutter .inbox-row-unread") !== null;
+  assert.deepEqual([dot("Ship it?"), dot("Roll back?")], [false, true]);
+  const mark = inbox
+    .row("Roll back?")
+    ?.closest("li")
+    ?.querySelector<HTMLButtonElement>('.luke-list-row-actions button[aria-label="Mark as read"]');
+  assert.ok(mark, "an unread row offers Mark as read over its time");
+  await act(async () => mark.click());
+  assert.deepEqual(marked, [`read:${SHIP.id}`, `read:${ROLL.id}`]);
+  assert.equal(dot("Roll back?"), false);
+  inbox.unmount();
+});
diff --git a/apps/desktop/src/renderer/desktop/desktop-tasks.tsx b/apps/desktop/src/renderer/desktop/desktop-tasks.tsx
index 2f37a33467..c8740ac7cf 100644
--- a/apps/desktop/src/renderer/desktop/desktop-tasks.tsx
+++ b/apps/desktop/src/renderer/desktop/desktop-tasks.tsx
@@ -60,6 +60,7 @@ import { useMinute } from "../tasks/task-time";
 import { CallBar } from "../tasks/tasks-parts";
 import { TerminalCommands, useOpenTerminal } from "../tasks/terminal-commands";
 import { TOOL_TARGET, type ToolTarget } from "../tasks/tool-call-model";
+import { useInboxReadMarks, useReadOnOpen } from "../tasks/use-inbox-read-marks";
 import { MAIN_TAB, type MainTab } from "../tasks/use-main-tabs";
 import { OpenHereProvider, openPullRequestsHere, useOpenLink } from "../tasks/use-open-link";
 import { PULL_REQUEST_VIEW, SIDE_PANEL_TAB } from "../tasks/use-side-panel";
@@ -218,8 +219,12 @@ function TaskInboxTab({
   const now = useMinute();
   const [asked, setAsked] = useState<string | undefined>(undefined);
   const needsYou = useTaskInboxWaitingOnly();
-  const items = [...inbox.board.open, ...inbox.board.settled];
-  const groups = [{ holder: taskHolder(task), items }];
+  const { act } = useAct();
+  const marks = useInboxReadMarks({ act, workspaceId: task.workspaceId });
+  const groups = marks.over([
+    { holder: taskHolder(task), items: [...inbox.board.open, ...inbox.board.settled] },
+  ]);
+  const items = groups.flatMap((group) => group.items);
   const filter = {
     grouping: INBOX_GROUPING.NEWEST,
     waitingOnly: needsYou.waitingOnly,
@@ -242,6 +247,12 @@ function TaskInboxTab({
     choose(listed);
     columns.onOpen(listed.item.id);
   };
+  useReadOnOpen({
+    shown: shown && columns.shown !== INBOX_COLUMNS.LIST ? chosen?.item : undefined,
+    chosen: chosen?.item,
+    active: shown,
+    onMark: marks.onMark,
+  });
   // Note that the column is hidden, though drawn, while the side panel fills the window.
   const pager = useInboxPager(steps, list, chosen?.item.id, choose, {
     shown,
@@ -297,6 +308,7 @@ function TaskInboxTab({
           ) : null
         }
         onChoose={open}
+        onMark={(listed, unread) => marks.onMark(listed.item, unread)}
       />
       {chosen === undefined ? (
         <section
diff --git a/apps/desktop/src/renderer/styles/desktop.css b/apps/desktop/src/renderer/styles/desktop.css
index 329d6c06f9..f907b2872f 100644
--- a/apps/desktop/src/renderer/styles/desktop.css
+++ b/apps/desktop/src/renderer/styles/desktop.css
@@ -1015,9 +1015,9 @@ ul.actor-stack {
    they last looked at it on this Mac, a tab that something arrived on while
    another was chosen, and a Factory row that waits on them, reads in the
    heavier weight and the primary ink until they look, as a chat app's
-   channels do. Only what waits on them, the Factory's row, also wears the
-   blue dot (`.inbox-row-dot`); an Inbox item that needs them wears the
-   attention mark instead (`.inbox-row-attention`). In the sidebar, where a read name is in the
+   channels do. What waits on them also wears the attention mark
+   (`.inbox-row-attention`); an unread Inbox item wears the blue dot
+   (`.inbox-row-unread`). In the sidebar, where a read name is in the
    quieter ink, the ink carries half the step, so a semibold is enough. */
 .sidebar-task[data-unread="true"] .sidebar-task-name,
 .tab[data-unread="true"] .tab-label {
@@ -3804,30 +3804,25 @@ button.integration-tool-head:hover,
   flex: none;
 }
 
-/* An item that needs the developer wears a mail app's unread dot in the system
-   blue, beside its title's unread weight; an answered one wears neither. The
-   dot is the window's one mark for what waits on the developer, as a plan or
-   a tab with something unseen on it is unread, not waiting. The dots stand
-   in a column of their own past the times, kept on every row, so the times
-   line up whether a row wears one or not. */
-.inbox-row {
-  --inbox-dot: 7px;
-}
+/* An unread Inbox item wears a mail app's blue dot in a gutter before its
+   tile (`inbox-list.tsx`); the gutter stands on every row, so the tiles
+   line up whether a row wears the dot or not. */
+.inbox-row-gutter {
+  display: inline-flex;
+  width: var(--inbox-unread-dot);
+  flex: none;
+  align-items: center;
+  justify-content: center;
+  margin-inline-end: var(--luke-space-6);
 
-.inbox-row .sidebar-task-line {
-  position: relative;
-  padding-right: calc(var(--inbox-dot) + var(--luke-space-6));
+  --inbox-unread-dot: 7px;
 }
 
-.inbox-row-dot {
-  position: absolute;
-  top: 50%;
-  right: 0;
-  width: var(--inbox-dot);
-  height: var(--inbox-dot);
+.inbox-row-unread {
+  width: var(--inbox-unread-dot);
+  height: var(--inbox-unread-dot);
   border-radius: 50%;
   background: var(--luke-color-accent);
-  transform: translateY(-50%);
 }
 
 /* An Inbox item that needs the developer wears the attention mark before
@@ -4360,13 +4355,6 @@ button.integration-tool-head:hover,
   flex: 1;
 }
 
-.factory-head-dot {
-  --inbox-dot: 7px;
-  position: static;
-  flex: none;
-  transform: none;
-}
-
 /* A station with nothing in it says so in one quiet line. */
 .factory-step > p.luke-text {
   padding: var(--luke-space-2) var(--row-inset) var(--luke-space-6);
diff --git a/apps/desktop/src/renderer/tasks/inbox-list.tsx b/apps/desktop/src/renderer/tasks/inbox-list.tsx
index 122351ac78..3701619c6f 100644
--- a/apps/desktop/src/renderer/tasks/inbox-list.tsx
+++ b/apps/desktop/src/renderer/tasks/inbox-list.tsx
@@ -1,10 +1,13 @@
 import { INBOX_STATUS, type InboxItem } from "@luke/features/inbox-wire";
 import { LINK_PLACE } from "@luke/features/luke-link";
 import type { CatalogModel } from "@luke/features/models-wire";
+import { APP_COMMAND } from "@luke/settings/shortcuts";
 import {
+  BUTTON_SIZE,
   DocumentIcon,
   EmptyState,
   IconButton,
+  LIST_ROW_ACTIONS,
   LIST_ROW_CURRENT,
   LIST_ROW_META,
   ListRow,
@@ -23,8 +26,11 @@ import {
 } from "@luke/ui/actor-model";
 import {
   ArrowDownNarrowWideIcon,
+  CheckCheckIcon,
   FactoryIcon,
   InboxIcon,
+  MailIcon,
+  MailOpenIcon,
   SlidersHorizontalIcon,
   UsersIcon,
 } from "lucide-react";
@@ -65,11 +71,13 @@ import {
   type InboxPersonGroup,
   type InboxStarter,
   inboxPreview,
+  isUnread,
   NEEDS_YOU,
   needsReader,
   readersItem,
 } from "./inbox-model";
 import { RelativeTime } from "./relative-time";
+import { markReadItem } from "./task-menu-items";
 import { useMinute } from "./task-time";
 import { cardTitle } from "./tool-call-model";
 
@@ -96,7 +104,11 @@ import { cardTitle } from "./tool-call-model";
  * (`attention-mark.tsx`), in either grouping and filtered or not; a
  * teammate's open item waits on the teammate, whose face stands in that
  * place, and any member may still answer it; an answered one wears
- * neither. A folded task
+ * neither. Apart from whether it waits, an item is unread where it changed
+ * since the developer last read it, or they marked it so: the blue dot in
+ * a gutter before its tile, its title in the unread weight; opening it
+ * reads it, and its row, its menu, U, and Mark all as read in the view's
+ * menu mark it read or unread (`use-inbox-read-marks.ts`). A folded task
  * counts what in it needs the developer, at rest, and says nothing where
  * none does. The head names the Inbox and, at its right, offers two
  * buttons: Needs you, pressed while the list holds only what needs the
@@ -105,7 +117,8 @@ import { cardTitle } from "./tool-call-model";
  * needs the developer, filtered out or not, its pressed fill alone saying the filter
  * is on and its tooltip what a press does; and one whose menu says
  * how the list groups its items, by plan, by person, or newest first, the
- * choice checked; both are kept across launches. Grouped by person, each
+ * choice checked, and under them Mark all as read, which clears the dots
+ * alone; both choices are kept across launches. Grouped by person, each
  * person's items stand under their face, the reader's own first as You, and
  * a row names its plan where it wears no face, since the header says whose
  * it is. Where Needs you leaves out every
@@ -123,6 +136,12 @@ import { cardTitle } from "./tool-call-model";
 /** What an item's row's right-click menu is called. */
 const ITEM_ACTIONS = "Inbox item actions";
 
+/** What an unread row says to a reader, its dot being drawn for the eye alone. */
+const UNREAD = "Unread";
+
+/** What the view's menu offers to clear every dot with. */
+const MARK_ALL_READ = "Mark all as read";
+
 /** What the head's menu button is called. */
 const VIEW_OPTIONS = "View options";
 
@@ -237,7 +256,15 @@ export function ItemMark({
  * the attention mark before its time, and a teammate's item their face
  * there where `face` allows it, the mark of their open item being theirs to
  * wear. The title hangs in the window's pill, since a narrow list cuts it
- * short. The home page's Inbox
+ * short. An unread item, changed since the developer last read it or marked
+ * unread, wears the blue dot in a gutter before its tile, its title in the
+ * unread weight and its preview in the body's ink; the gutter stands on
+ * every row, so the tiles line up whether a row wears a dot or not. Where
+ * the list hands down `onMark`, the row offers to mark it read or unread:
+ * a press over its time while the pointer rests on it or it holds the
+ * keyboard, the time and its marks stepping aside, and the first item of
+ * its right-click menu, which names the key that does the same to the
+ * chosen item (`APP_COMMAND.TOGGLE_INBOX_ITEM_READ`). The home page's Inbox
  * names the item's plan at the row's end, in `context`, since its rows stand
  * under no plan's header, as a person's group does. Its right-click offers
  * Copy link, the item's link under the task or the agent that holds it, where
@@ -253,6 +280,7 @@ export function InboxItemRow({
   face = true,
   ref,
   onChoose,
+  onMark,
 }: {
   listed: InboxListed;
   chosen: boolean;
@@ -266,8 +294,11 @@ export function InboxItemRow({
   /** Handed the row's press, by which the list finds the row of an item. */
   ref?: React.RefCallback<HTMLElement> | undefined;
   onChoose: (listed: InboxListed) => void;
+  /** Marks the item read or unread; none where the row offers no mark. */
+  onMark?: ((listed: InboxListed, unread: boolean) => void) | undefined;
 }): React.JSX.Element {
   const { holder, item } = listed;
+  const unread = isUnread(item);
   const title = cardTitle(item.title);
   const directory = useMemberDirectory();
   const reader = directory.readerId ?? readerId;
@@ -284,6 +315,17 @@ export function InboxItemRow({
       ? { kind: LINK_PLACE.INBOX_ITEM, planId: holder.task.id, itemId: item.id }
       : { kind: LINK_PLACE.INBOX_ITEM, agentId: item.agentId, itemId: item.id },
   );
+  const read =
+    onMark === undefined
+      ? undefined
+      : {
+          ...markReadItem({ unread, onMark: (next) => onMark(listed, next) }),
+          command: APP_COMMAND.TOGGLE_INBOX_ITEM_READ,
+        };
+  const groups = [
+    read === undefined ? [] : [read],
+    copyLink === undefined ? [] : [copyLink],
+  ].filter((group) => group.length > 0);
   const press = useRef<HTMLElement | null>(null);
   const hold = useCallback(
     (element: HTMLElement | null) => {
@@ -297,14 +339,26 @@ export function InboxItemRow({
       <ListRow
         ref={hold}
         leading={
-          <span className="inbox-row-mark">
-            <ItemMark holder={holder} agentId={item.agentId} models={models} readerId={readerId} />
-          </span>
+          <>
+            {/* Note that the gutter stands on every row, so the tiles line up whether a row wears the dot or not. */}
+            <span className="inbox-row-gutter">
+              {unread ? <span className="inbox-row-unread" /> : null}
+            </span>
+            <span className="inbox-row-mark">
+              <ItemMark
+                holder={holder}
+                agentId={item.agentId}
+                models={models}
+                readerId={readerId}
+              />
+            </span>
+          </>
         }
         title={title}
         description={preview}
         meta={
           <span className="home-row-meta">
+            {unread ? <span className="visually-hidden">{UNREAD}</span> : null}
             {context === undefined ? null : <span className="home-row-context">{context}</span>}
             {starter === undefined || !face ? null : (
               <ActorMark actor={starter} size={ACTOR_SIZE.MARK} />
@@ -322,18 +376,27 @@ export function InboxItemRow({
           </span>
         }
         metaAt={LIST_ROW_META.TITLE}
+        actions={
+          read === undefined ? undefined : (
+            <Tooltip label={read.label} command={read.command}>
+              <IconButton
+                icon={unread ? <MailOpenIcon /> : <MailIcon />}
+                label={read.label}
+                size={BUTTON_SIZE.COMPACT}
+                onClick={read.onSelect}
+              />
+            </Tooltip>
+          )
+        }
+        actionsAt={LIST_ROW_ACTIONS.HOVER}
         current={chosen ? LIST_ROW_CURRENT.PAGE : undefined}
+        unread={unread}
         hint={{ Hint: Tooltip, label: title }}
         onPress={() => onChoose(listed)}
-        onContextMenu={copyLink === undefined ? undefined : menu.contextMenu(press)}
+        onContextMenu={groups.length === 0 ? undefined : menu.contextMenu(press)}
       />
-      {menu.drawn === undefined || copyLink === undefined ? null : (
-        <ActionMenu
-          label={ITEM_ACTIONS}
-          menu={menu.drawn}
-          groups={[[copyLink]]}
-          onClose={menu.close}
-        />
+      {menu.drawn === undefined || groups.length === 0 ? null : (
+        <ActionMenu label={ITEM_ACTIONS} menu={menu.drawn} groups={groups} onClose={menu.close} />
       )}
     </>
   );
@@ -433,10 +496,12 @@ function ViewOptions({
   shown,
   grouping,
   onGrouping,
+  readAll,
 }: {
   shown: boolean;
   grouping: InboxGrouping;
   onGrouping: (grouping: InboxGrouping) => void;
+  readAll: InboxReadAll | undefined;
 }): React.JSX.Element {
   const menu = useMenu(shown);
   const choices: MenuAction[] = [
@@ -468,7 +533,21 @@ function ViewOptions({
         <ActionMenu
           label={VIEW_OPTIONS}
           menu={menu.drawn}
-          groups={[choices]}
+          groups={
+            readAll === undefined
+              ? [choices]
+              : [
+                  choices,
+                  [
+                    {
+                      label: MARK_ALL_READ,
+                      icon: <CheckCheckIcon />,
+                      disabled: !readAll.unread,
+                      onSelect: readAll.onMarkAll,
+                    },
+                  ],
+                ]
+          }
           onClose={menu.close}
         />
       )}
@@ -581,6 +660,7 @@ function ListHead({ head }: { head: InboxListHead }): React.JSX.Element {
             shown={shown}
             grouping={view.choices.grouping}
             onGrouping={view.choices.onGrouping}
+            readAll={head.readAll}
           />
         )}
       </div>
@@ -597,6 +677,14 @@ export interface InboxListHead {
   readonly view: { readonly choices: InboxViewChoices; readonly folds: InboxTaskFolds } | undefined;
   /** Whether any item needs the developer, filtered out or not, for Needs you's dot. */
   readonly waiting: boolean;
+  /** Mark all as read, in the view's menu, where the list marks its items. */
+  readonly readAll?: InboxReadAll | undefined;
+}
+
+/** Mark all as read as the view's menu offers it: whether any item is unread, filtered out or not, and the mark. */
+interface InboxReadAll {
+  readonly unread: boolean;
+  readonly onMarkAll: () => void;
 }
 
 /** What the list wears to keep the keyboard: its element, and its handlers for focus arriving and leaving. */
@@ -647,6 +735,7 @@ export function InboxList({
   columns,
   rows,
   onChoose,
+  onMark,
 }: {
   view: InboxListView;
   /** The id of the item the pane shows. */
@@ -663,6 +752,8 @@ export function InboxList({
   /** Where each row's press is kept, by the item it opens. */
   rows: InboxRowPresses;
   onChoose: (listed: InboxListed) => void;
+  /** Marks an item read or unread from its row; none where the rows offer no mark. */
+  onMark?: ((listed: InboxListed, unread: boolean) => void) | undefined;
 }): React.JSX.Element {
   const now = useMinute();
   const { width, onResize } = useInboxListWidth();
@@ -687,6 +778,7 @@ export function InboxList({
       ref={rows.hold(listed.item.id)}
       {...(byPerson ? { context: holderName(listed.holder) } : undefined)}
       onChoose={onChoose}
+      onMark={onMark}
     />
   );
   const needingYou = (items: readonly InboxItem[]) =>
diff --git a/apps/desktop/src/renderer/tasks/inbox-model.test.ts b/apps/desktop/src/renderer/tasks/inbox-model.test.ts
index 8e535cf06f..ef338c609b 100644
--- a/apps/desktop/src/renderer/tasks/inbox-model.test.ts
+++ b/apps/desktop/src/renderer/tasks/inbox-model.test.ts
@@ -31,6 +31,7 @@ import {
   inboxPreview,
   inboxReply,
   inboxSteps,
+  isUnread,
   listedItems,
   nextNeedingYou,
   proposedOptions,
@@ -38,6 +39,7 @@ import {
   settlementOf,
   taskHolder,
   tasklessGroups,
+  withReadMarks,
   withValue,
 } from "./inbox-model";
 
@@ -886,3 +888,28 @@ test("the latest message on an item's thread is its preview, open or settled, le
     "Agent: Backfilled 41,208 rows; staging totals match",
   );
 });
+
+test("a read mark the window made stands over the item as it was marked, and gives way to the reads once the item changes again, as a message landing may make it unread", () => {
+  const holder = taskHolder(BILLING);
+  const unread = item({ id: "h1", unread: true, updatedAt: 2_000 });
+  const read = item({ id: "h2", updatedAt: 2_000 });
+  const marks = new Map([
+    ["h1", { unread: false, updatedAt: 2_000 }],
+    ["h2", { unread: true, updatedAt: 2_000 }],
+  ]);
+  const unreadOf = (groups: ReturnType<typeof withReadMarks>) =>
+    groups.flatMap(({ items }) => items.map((each) => [each.id, isUnread(each)]));
+  assert.deepEqual(unreadOf(withReadMarks([{ holder, items: [unread, read] }], marks)), [
+    ["h1", false],
+    ["h2", true],
+  ]);
+  const changed = { ...unread, updatedAt: 3_000 };
+  assert.deepEqual(unreadOf(withReadMarks([{ holder, items: [changed, read] }], marks)), [
+    ["h1", true],
+    ["h2", true],
+  ]);
+  assert.deepEqual(unreadOf(withReadMarks([{ holder, items: [unread, read] }], new Map())), [
+    ["h1", true],
+    ["h2", false],
+  ]);
+});
diff --git a/apps/desktop/src/renderer/tasks/inbox-model.ts b/apps/desktop/src/renderer/tasks/inbox-model.ts
index 84282725e3..20f088d736 100644
--- a/apps/desktop/src/renderer/tasks/inbox-model.ts
+++ b/apps/desktop/src/renderer/tasks/inbox-model.ts
@@ -784,6 +784,48 @@ export function inboxList(
   return { grouping: INBOX_GROUPING.PERSON, groups: personGroups(items, readerId), readerId };
 }
 
+/** Whether an item is unread for the reader: changed since they last read it, or marked unread; an item from a service before read state reads as read. */
+export function isUnread(item: InboxItem): boolean {
+  return item.unread === true;
+}
+
+/**
+ * A read mark the window made that the reads may not hold yet: whether the
+ * item now reads as unread, and when it last changed as it was marked.
+ */
+export interface InboxReadMark {
+  readonly unread: boolean;
+  readonly updatedAt: number;
+}
+
+/**
+ * The groups with the window's own read marks laid over what the reads
+ * hold, so a dot flips the moment it is marked rather than when the
+ * service's held read next answers. A mark stands only over the item as it
+ * was marked: once the item changes again, a message landing on its thread
+ * say, the reads' word on it stands, since that change may make it unread
+ * again.
+ */
+export function withReadMarks(
+  groups: readonly InboxGroup[],
+  marks: ReadonlyMap<string, InboxReadMark>,
+): readonly InboxGroup[] {
+  if (marks.size === 0) return groups;
+  return groups.map(({ holder, items }) => ({
+    holder,
+    items: items.map((item) => {
+      const mark = marks.get(item.id);
+      if (mark === undefined || mark.updatedAt !== item.updatedAt) return item;
+      return isUnread(item) === mark.unread ? item : { ...item, unread: mark.unread };
+    }),
+  }));
+}
+
+/** Whether any task's item is unread, listed or filtered out. */
+export function anyUnread(tasks: readonly InboxGroup[]): boolean {
+  return tasks.some(({ items }) => items.some(isUnread));
+}
+
 /** Whether any task's item needs the reader, listed or filtered out. */
 export function anyNeedsYou(tasks: readonly InboxGroup[], readerId: string | undefined): boolean {
   return tasks.some(({ items }) => items.some((item) => needsReader(item, readerId)));
diff --git a/apps/desktop/src/renderer/tasks/use-inbox-read-marks.ts b/apps/desktop/src/renderer/tasks/use-inbox-read-marks.ts
new file mode 100644
index 0000000000..22acc45896
--- /dev/null
+++ b/apps/desktop/src/renderer/tasks/use-inbox-read-marks.ts
@@ -0,0 +1,134 @@
+import { CODING_AGENT_CALL_FAILURE } from "@luke/features/coding-agent-view";
+import type { InboxItem } from "@luke/features/inbox-wire";
+import { ACT_KIND } from "@luke/host/acts";
+import { APP_COMMAND } from "@luke/settings/shortcuts";
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { ActHandle } from "../act";
+import { useAppCommand } from "../app-commands";
+import { type InboxGroup, type InboxReadMark, isUnread, withReadMarks } from "./inbox-model";
+
+/**
+ * use-inbox-read-marks.ts -- the Inbox's read and unread marks as one control: an item marked read or unread, or every item marked read, its dot flipping at once.
+ *
+ * A mark goes to the service as an act, which wakes the held reads of the
+ * account on its own, so nothing here reads again; until those reads
+ * answer, the mark is laid over what they hold (`inbox-model.ts`'s
+ * `withReadMarks`), so the dot flips the moment it is pressed. A mark the
+ * service did not take is let go, and the dot stands as the reads hold it.
+ * Marking every item read marks only the items the Inbox lists that are
+ * unread, in the one workspace it lists, as the service marks them; an item
+ * waiting on the developer keeps waiting, since the dots are all it clears.
+ *
+ * Opening an item marks it read, once each time it is shown
+ * (`useReadOnOpen`), so an item the reader marks unread while it is shown
+ * stays unread until they open it again, as a mail app keeps it; and a
+ * plain U marks the chosen item read or unread, as its row's menu says.
+ */
+
+/** What the Inbox's read marks offer: the reads with the marks laid over them, and the marks themselves. */
+export interface InboxReadMarks {
+  /** The groups as the reads hold them, the marks not yet read back laid over them. */
+  readonly over: (groups: readonly InboxGroup[]) => readonly InboxGroup[];
+  /** Marks one item read or unread. */
+  readonly onMark: (item: InboxItem, unread: boolean) => void;
+  /** Marks every item given that is unread as read, as the service marks the listed workspace's. */
+  readonly onMarkAll: (items: readonly InboxItem[]) => void;
+}
+
+/** What a mark the act channel refused hears, as the service not answering. */
+const UNANSWERED = { failure: CODING_AGENT_CALL_FAILURE.UNANSWERED } as const;
+
+/** No marks, one map so a hook that holds none hands down the same one. */
+const NO_MARKS: ReadonlyMap<string, InboxReadMark> = new Map();
+
+/** The Inbox's read marks, sent through `act`, every item marked read in `workspaceId` where the Inbox lists one. */
+export function useInboxReadMarks({
+  act,
+  workspaceId,
+}: {
+  act: ActHandle["act"];
+  workspaceId: string | undefined;
+}): InboxReadMarks {
+  const [marks, setMarks] = useState(NO_MARKS);
+  // Note that a mark is let go only where it still stands as it was made, so a later mark on the same item outlives an earlier one's refusal.
+  const letGo = useCallback((made: ReadonlyMap<string, InboxReadMark>) => {
+    setMarks((held) => {
+      const kept = new Map(held);
+      for (const [itemId, mark] of made) if (kept.get(itemId) === mark) kept.delete(itemId);
+      return kept.size === held.size ? held : kept;
+    });
+  }, []);
+  const lay = useCallback((made: ReadonlyMap<string, InboxReadMark>) => {
+    setMarks((held) => new Map([...held, ...made]));
+  }, []);
+  const onMark = useCallback(
+    (item: InboxItem, unread: boolean) => {
+      const made = new Map([[item.id, { unread, updatedAt: item.updatedAt }]]);
+      lay(made);
+      void act(ACT_KIND.CODING_AGENTS_INBOX_READ_STATE, { itemId: item.id, unread })
+        .catch(() => UNANSWERED)
+        .then((answer) => {
+          if ("failure" in answer) letGo(made);
+        });
+    },
+    [act, lay, letGo],
+  );
+  const onMarkAll = useCallback(
+    (items: readonly InboxItem[]) => {
+      const made = new Map(
+        items
+          .filter(isUnread)
+          .map((item) => [item.id, { unread: false, updatedAt: item.updatedAt }] as const),
+      );
+      if (made.size === 0) return;
+      lay(made);
+      void act(
+        ACT_KIND.CODING_AGENTS_INBOX_READ_ALL,
+        workspaceId === undefined ? {} : { workspaceId },
+      )
+        .catch(() => UNANSWERED)
+        .then((answer) => {
+          if ("failure" in answer) letGo(made);
+        });
+    },
+    [act, workspaceId, lay, letGo],
+  );
+  const over = useCallback(
+    (groups: readonly InboxGroup[]) => withReadMarks(groups, marks),
+    [marks],
+  );
+  return { over, onMark, onMarkAll };
+}
+
+/**
+ * Marks the item an Inbox shows read as it is opened, once each time it is
+ * shown, and offers U, which marks the chosen item read or unread, while
+ * the Inbox stands. `shown` is the item the pane draws, none while the
+ * Inbox is hidden or shows its list alone.
+ */
+export function useReadOnOpen({
+  shown,
+  chosen,
+  active,
+  onMark,
+}: {
+  shown: InboxItem | undefined;
+  chosen: InboxItem | undefined;
+  active: boolean;
+  onMark: (item: InboxItem, unread: boolean) => void;
+}): void {
+  const readOn = useRef<string | undefined>(undefined);
+  useEffect(() => {
+    if (shown === undefined) {
+      readOn.current = undefined;
+      return;
+    }
+    if (readOn.current === shown.id) return;
+    readOn.current = shown.id;
+    if (isUnread(shown)) onMark(shown, false);
+  }, [shown, onMark]);
+  useAppCommand(
+    APP_COMMAND.TOGGLE_INBOX_ITEM_READ,
+    active && chosen !== undefined ? () => onMark(chosen, !isUnread(chosen)) : undefined,
+  );
+}
diff --git a/packages/features/fixtures/json-schema/coding-agent-view-codingAgentInboxReadStateParamsSchema.json b/packages/features/fixtures/json-schema/coding-agent-view-codingAgentInboxReadStateParamsSchema.json
new file mode 100644
index 0000000000..53a4d66f7d
--- /dev/null
+++ b/packages/features/fixtures/json-schema/coding-agent-view-codingAgentInboxReadStateParamsSchema.json
@@ -0,0 +1,17 @@
+{
+  "type": "object",
+  "properties": {
+    "itemId": {
+      "type": "string",
+      "minLength": 1
+    },
+    "unread": {
+      "type": "boolean"
+    }
+  },
+  "required": [
+    "itemId",
+    "unread"
+  ],
+  "additionalProperties": false
+}
diff --git a/packages/features/src/coding-agent-view.ts b/packages/features/src/coding-agent-view.ts
index 4e390120f3..78fc5364d0 100644
--- a/packages/features/src/coding-agent-view.ts
+++ b/packages/features/src/coding-agent-view.ts
@@ -453,6 +453,14 @@ export const codingAgentInboxMessagedViewSchema = EffectSchema.Union([inboxMessa
 
 export type CodingAgentInboxMessagedView = typeof codingAgentInboxMessagedViewSchema.Type;
 
+/** One item marked read or unread for the account, as the window asks it: the item, and whether it is to read as unread. */
+export const codingAgentInboxReadStateParamsSchema = EffectSchema.Struct({
+  itemId: EffectSchema.NonEmptyString,
+  unread: EffectSchema.Boolean,
+});
+
+export type CodingAgentInboxReadStateParams = typeof codingAgentInboxReadStateParamsSchema.Type;
+
 /** One item marked read or unread, as the window hears it: the item's id and its read state for the account, or why there is no answer. */
 export const codingAgentInboxReadStateViewSchema = EffectSchema.Union([
   inboxReadStateSchema,
diff --git a/packages/features/src/hosted-wire-schemas.test.ts b/packages/features/src/hosted-wire-schemas.test.ts
index 25df3d1bf3..40622392b1 100644
--- a/packages/features/src/hosted-wire-schemas.test.ts
+++ b/packages/features/src/hosted-wire-schemas.test.ts
@@ -233,6 +233,7 @@ const EFFECT_MODULE_SCHEMAS = {
     codingAgentInboxAnsweredViewSchema: codingAgentView.codingAgentInboxAnsweredViewSchema,
     codingAgentInboxMessageParamsSchema: codingAgentView.codingAgentInboxMessageParamsSchema,
     codingAgentInboxMessagedViewSchema: codingAgentView.codingAgentInboxMessagedViewSchema,
+    codingAgentInboxReadStateParamsSchema: codingAgentView.codingAgentInboxReadStateParamsSchema,
     codingAgentInboxReadStateViewSchema: codingAgentView.codingAgentInboxReadStateViewSchema,
     codingAgentInboxReadAllViewSchema: codingAgentView.codingAgentInboxReadAllViewSchema,
     codingAgentAccountInboxParamsSchema: codingAgentView.codingAgentAccountInboxParamsSchema,
diff --git a/packages/gateway/src/protocol.ts b/packages/gateway/src/protocol.ts
index f1626ed8b0..faf74383da 100644
--- a/packages/gateway/src/protocol.ts
+++ b/packages/gateway/src/protocol.ts
@@ -195,6 +195,10 @@ export const GATEWAY_METHOD = {
   CODING_AGENTS_INBOX_ANSWER: "codingAgents.inboxAnswer",
   /** One message of the account's on an item's thread, open or settled, under the panel's own key; the item as it then stands, its thread with the message on it, or why there is no answer. */
   CODING_AGENTS_INBOX_MESSAGE: "codingAgents.inboxMessage",
+  /** One item marked read or unread for the account, as the Inbox's dot says it; its read state, or why there is no answer. */
+  CODING_AGENTS_INBOX_READ_STATE: "codingAgents.inboxReadState",
+  /** Every item of the account's Inbox marked read, in one workspace or in all; how many were unread, or why there is no answer. */
+  CODING_AGENTS_INBOX_READ_ALL: "codingAgents.inboxReadAll",
   /** A workspace's chat past a cursor: what a person in it sees of it, held open by the service while nothing moved. */
   CODING_AGENTS_CHAT: "codingAgents.chat",
   /** A write to a workspace's chat as the account's own member: a post, an answer to an ask, a resolve, or how far it has read; what the write came to, or why there is no answer. */
diff --git a/packages/host/src/act-router/coding-agent-acts.test.ts b/packages/host/src/act-router/coding-agent-acts.test.ts
index 6685b583e6..dbfb184fda 100644
--- a/packages/host/src/act-router/coding-agent-acts.test.ts
+++ b/packages/host/src/act-router/coding-agent-acts.test.ts
@@ -310,6 +310,16 @@ function fixture(answered: CodingAgentAgentAnswer = STARTED) {
           asked.push(`message:${itemId}:${text}:${files}:${clientKey}`);
           return { item: ITEM };
         }),
+      codingAgentInboxReadState: ({ itemId, unread }) =>
+        Effect.sync(() => {
+          asked.push(`read-state:${itemId}:${unread}`);
+          return { id: itemId, unread };
+        }),
+      codingAgentInboxReadAll: ({ workspaceId }) =>
+        Effect.sync(() => {
+          asked.push(`read-all:${workspaceId ?? "every workspace"}`);
+          return { marked: 3 };
+        }),
       codingAgentInboxAttachment: ({ itemId, attachmentId }) =>
         Effect.sync(() => {
           asked.push(`attachment:${itemId}:${attachmentId}`);
@@ -609,3 +619,54 @@ it.effect(
       ]);
     }),
 );
+
+it.effect(
+  "a panel marks an inbox item read or unread, or its whole Inbox read in one workspace or all, and hears the read state; the voice window's is refused before it",
+  () =>
+    Effect.gen(function* () {
+      const { router, asked } = fixture();
+      const unread = {
+        kind: ACT_KIND.CODING_AGENTS_INBOX_READ_STATE,
+        payload: { itemId: ITEM.id, unread: true },
+      } as const;
+
+      const refused = yield* router.performAct(unread, VOICE);
+      const marked = yield* router.performAct(unread, PANEL);
+      const read = yield* router.performAct(
+        {
+          kind: ACT_KIND.CODING_AGENTS_INBOX_READ_STATE,
+          payload: { itemId: ITEM.id, unread: false },
+        },
+        PANEL,
+      );
+      const all = yield* router.performAct(
+        { kind: ACT_KIND.CODING_AGENTS_INBOX_READ_ALL, payload: { workspaceId: "workspace-1" } },
+        PANEL,
+      );
+      const everywhere = yield* router.performAct(
+        { kind: ACT_KIND.CODING_AGENTS_INBOX_READ_ALL, payload: {} },
+        PANEL,
+      );
+
+      assert.deepEqual(refused, {
+        status: ACT_OUTCOME_STATUS.REFUSED,
+        reason: ACT[ACT_KIND.CODING_AGENTS_INBOX_READ_STATE].refusal,
+      });
+      assert.deepEqual(marked, {
+        status: ACT_OUTCOME_STATUS.DONE,
+        value: { id: ITEM.id, unread: true },
+      });
+      assert.deepEqual(read, {
+        status: ACT_OUTCOME_STATUS.DONE,
+        value: { id: ITEM.id, unread: false },
+      });
+      assert.deepEqual(all, { status: ACT_OUTCOME_STATUS.DONE, value: { marked: 3 } });
+      assert.deepEqual(everywhere, { status: ACT_OUTCOME_STATUS.DONE, value: { marked: 3 } });
+      assert.deepEqual(asked, [
+        `read-state:${ITEM.id}:true`,
+        `read-state:${ITEM.id}:false`,
+        "read-all:workspace-1",
+        "read-all:every workspace",
+      ]);
+    }),
+);
diff --git a/packages/host/src/act-router/coding-agent-acts.ts b/packages/host/src/act-router/coding-agent-acts.ts
index 590f4f0ced..7a8bee09b4 100644
--- a/packages/host/src/act-router/coding-agent-acts.ts
+++ b/packages/host/src/act-router/coding-agent-acts.ts
@@ -20,6 +20,9 @@ import {
   type CodingAgentInboxMessagedView,
   type CodingAgentInboxMessageParams,
   type CodingAgentInboxParams,
+  type CodingAgentInboxReadAllView,
+  type CodingAgentInboxReadStateParams,
+  type CodingAgentInboxReadStateView,
   type CodingAgentListAnswer,
   type CodingAgentListParams,
   type CodingAgentMessageParams,
@@ -54,6 +57,7 @@ import {
   type ProviderKeySaveParams,
   type ProviderKeysAnswerView,
 } from "@luke/features/coding-agent-view";
+import type { InboxReadAllRequest } from "@luke/features/inbox-wire";
 import type { ModelChoice } from "@luke/features/models-wire";
 import { Effect } from "effect";
 import { ACT, ACT_KIND } from "../acts.js";
@@ -150,6 +154,12 @@ export interface CodingAgentActsDependencies {
     codingAgentInboxMessage(
       params: CodingAgentInboxMessageParams,
     ): Effect.Effect<CodingAgentInboxMessagedView>;
+    codingAgentInboxReadState(
+      params: CodingAgentInboxReadStateParams,
+    ): Effect.Effect<CodingAgentInboxReadStateView>;
+    codingAgentInboxReadAll(
+      params: InboxReadAllRequest,
+    ): Effect.Effect<CodingAgentInboxReadAllView>;
     codingAgentInboxAttachment(
       params: CodingAgentInboxAttachmentParams,
     ): Effect.Effect<CodingAgentInboxAttachmentView>;
@@ -214,6 +224,8 @@ export type CodingAgentActKind =
   | typeof ACT_KIND.CODING_AGENTS_AGENT_INBOX
   | typeof ACT_KIND.CODING_AGENTS_INBOX_ANSWER
   | typeof ACT_KIND.CODING_AGENTS_INBOX_MESSAGE
+  | typeof ACT_KIND.CODING_AGENTS_INBOX_READ_STATE
+  | typeof ACT_KIND.CODING_AGENTS_INBOX_READ_ALL
   | typeof ACT_KIND.CODING_AGENTS_INBOX_ATTACHMENT
   | typeof ACT_KIND.CODING_AGENTS_PICTURE
   | typeof ACT_KIND.CODING_AGENTS_CHAT
@@ -411,6 +423,14 @@ export function codingAgentActRows(
       refuseUnlessPanel(ACT_KIND.CODING_AGENTS_INBOX_MESSAGE, sender);
       return host.codingAgentInboxMessage(params);
     },
+    [ACT_KIND.CODING_AGENTS_INBOX_READ_STATE]: (params, sender) => {
+      refuseUnlessPanel(ACT_KIND.CODING_AGENTS_INBOX_READ_STATE, sender);
+      return host.codingAgentInboxReadState(params);
+    },
+    [ACT_KIND.CODING_AGENTS_INBOX_READ_ALL]: (params, sender) => {
+      refuseUnlessPanel(ACT_KIND.CODING_AGENTS_INBOX_READ_ALL, sender);
+      return host.codingAgentInboxReadAll(params);
+    },
     [ACT_KIND.CODING_AGENTS_INBOX_ATTACHMENT]: (params, sender) => {
       refuseUnlessPanel(ACT_KIND.CODING_AGENTS_INBOX_ATTACHMENT, sender);
       return host.codingAgentInboxAttachment(params);
diff --git a/packages/host/src/acts.ts b/packages/host/src/acts.ts
index bc1c213bdd..dfc8ea8838 100644
--- a/packages/host/src/acts.ts
+++ b/packages/host/src/acts.ts
@@ -27,6 +27,8 @@ import {
   type CodingAgentInboxAnswerView,
   type CodingAgentInboxAttachmentView,
   type CodingAgentInboxMessagedView,
+  type CodingAgentInboxReadAllView,
+  type CodingAgentInboxReadStateView,
   type CodingAgentListAnswer,
   type CodingAgentMessagesAnswerView,
   type CodingAgentModelsAnswer,
@@ -57,6 +59,9 @@ import {
   codingAgentInboxMessagedViewSchema,
   codingAgentInboxMessageParamsSchema,
   codingAgentInboxParamsSchema,
+  codingAgentInboxReadAllViewSchema,
+  codingAgentInboxReadStateParamsSchema,
+  codingAgentInboxReadStateViewSchema,
   codingAgentListAnswerViewSchema,
   codingAgentListParamsSchema,
   codingAgentMessageParamsSchema,
@@ -106,6 +111,7 @@ import {
   type FeedbackSubmission,
   feedbackSubmission,
 } from "@luke/features/feedback";
+import { inboxReadAllRequestSchema } from "@luke/features/inbox-wire";
 import {
   type IntegrationAccountView,
   type IntegrationConnectView,
@@ -530,6 +536,10 @@ export const ACT_KIND = {
   CODING_AGENTS_INBOX_ANSWER: "codingAgents.inboxAnswer",
   /** A message on one item's thread, open or settled, under the panel's own key; it never answers the item. */
   CODING_AGENTS_INBOX_MESSAGE: "codingAgents.inboxMessage",
+  /** One item marked read or unread for the account; it changes neither what the item asks nor whether it waits. */
+  CODING_AGENTS_INBOX_READ_STATE: "codingAgents.inboxReadState",
+  /** Every item of the account's Inbox marked read, in one workspace or in all; the dots alone. */
+  CODING_AGENTS_INBOX_READ_ALL: "codingAgents.inboxReadAll",
   /** One image of an inbox item, fetched by the host under the account, so the window holds no bearer and no address. */
   CODING_AGENTS_INBOX_ATTACHMENT: "codingAgents.inboxAttachment",
   CODING_AGENTS_PICTURE: "codingAgents.picture",
@@ -1474,6 +1484,18 @@ export const ACT = {
     ),
     refusal: "Could not send the message on this system.",
   },
+  [ACT_KIND.CODING_AGENTS_INBOX_READ_STATE]: {
+    payload: actSchema(codingAgentInboxReadStateParamsSchema),
+    result: wireResult<CodingAgentInboxReadStateView>(
+      isReadable(codingAgentInboxReadStateViewSchema),
+    ),
+    refusal: "Could not mark the inbox item on this system.",
+  },
+  [ACT_KIND.CODING_AGENTS_INBOX_READ_ALL]: {
+    payload: actSchema(inboxReadAllRequestSchema),
+    result: wireResult<CodingAgentInboxReadAllView>(isReadable(codingAgentInboxReadAllViewSchema)),
+    refusal: "Could not mark the inbox read on this system.",
+  },
   [ACT_KIND.CODING_AGENTS_INBOX_ATTACHMENT]: {
     payload: actSchema(codingAgentInboxAttachmentParamsSchema),
     result: wireResult<CodingAgentInboxAttachmentView>(
diff --git a/packages/host/src/compose-coding-agents.test.ts b/packages/host/src/compose-coding-agents.test.ts
index f6a8d37a91..0cd8a1fddd 100644
--- a/packages/host/src/compose-coding-agents.test.ts
+++ b/packages/host/src/compose-coding-agents.test.ts
@@ -399,6 +399,21 @@ function fakeService() {
         asked.push(`picture:${agentId}:${pictureId}:${callId ?? ""}`);
         return { contentType: INBOX_IMAGE_TYPE.PNG, base64: "iVBORw0KGgo=" };
       }),
+    markInboxItemRead: (itemId) =>
+      Effect.sync(() => {
+        asked.push(`inbox-read:${itemId}`);
+        return { id: itemId, unread: false };
+      }),
+    markInboxItemUnread: (itemId) =>
+      Effect.sync(() => {
+        asked.push(`inbox-unread:${itemId}`);
+        return { id: itemId, unread: true };
+      }),
+    markInboxRead: (request) =>
+      Effect.sync(() => {
+        asked.push(`inbox-read-all:${request?.workspaceId ?? ""}`);
+        return { marked: 2 };
+      }),
     messageInbox: (itemId, request) =>
       Effect.sync(() => {
         const files = (request.attachments ?? []).map((file) => file.name).join(",");
@@ -675,6 +690,21 @@ it.effect("each method asks the service once and answers what it said, whole", (
         },
       },
     );
+    assert.deepEqual(
+      yield* call(GATEWAY_METHOD.CODING_AGENTS_INBOX_READ_STATE, { itemId: ITEM.id, unread: true }),
+      { id: ITEM.id, unread: true },
+    );
+    assert.deepEqual(
+      yield* call(GATEWAY_METHOD.CODING_AGENTS_INBOX_READ_STATE, {
+        itemId: ITEM.id,
+        unread: false,
+      }),
+      { id: ITEM.id, unread: false },
+    );
+    assert.deepEqual(
+      yield* call(GATEWAY_METHOD.CODING_AGENTS_INBOX_READ_ALL, { workspaceId: WORKSPACE_ID }),
+      { marked: 2 },
+    );
 
     assert.deepEqual(
       yield* call(GATEWAY_METHOD.CODING_AGENTS_ACCOUNT_INBOX, { after: INBOX_CURSOR_START }),
@@ -726,6 +756,9 @@ it.effect("each method asks the service once and answers what it said, whole", (
       `picture:${AGENT_ID}:${PICTURE_ID}:call-worker`,
       `answer:${ITEM.id}:2:${INBOX_REPLY.DECLINED}:Not before the freeze lifts.:answer-1`,
       `inbox-message:${ITEM.id}:Also page on-call.:pager.txt:message-1`,
+      `inbox-unread:${ITEM.id}`,
+      `inbox-read:${ITEM.id}`,
+      `inbox-read-all:${WORKSPACE_ID}`,
       `account-inbox:${INBOX_CURSOR_START}`,
       `chat:${WORKSPACE_ID}:${CHAT_CURSOR_START}`,
       `chat-post:${WORKSPACE_ID}:{"readTo":4}`,
diff --git a/packages/host/src/compose-coding-agents.ts b/packages/host/src/compose-coding-agents.ts
index 44351c3cc4..a77b97ee34 100644
--- a/packages/host/src/compose-coding-agents.ts
+++ b/packages/host/src/compose-coding-agents.ts
@@ -12,6 +12,8 @@ import {
   type CodingAgentInboxAnswerView,
   type CodingAgentInboxAttachmentView,
   type CodingAgentInboxMessagedView,
+  type CodingAgentInboxReadAllView,
+  type CodingAgentInboxReadStateView,
   type CodingAgentListAnswer,
   type CodingAgentMessagesAnswerView,
   type CodingAgentModelsAnswer,
@@ -33,6 +35,7 @@ import {
   codingAgentInboxAttachmentParamsSchema,
   codingAgentInboxMessageParamsSchema,
   codingAgentInboxParamsSchema,
+  codingAgentInboxReadStateParamsSchema,
   codingAgentListParamsSchema,
   codingAgentMessageParamsSchema,
   codingAgentMessagesParamsSchema,
@@ -58,6 +61,7 @@ import {
   providerKeyRemoveParamsSchema,
   providerKeySaveParamsSchema,
 } from "@luke/features/coding-agent-view";
+import { inboxReadAllRequestSchema } from "@luke/features/inbox-wire";
 import { carried, GATEWAY_METHOD, type GatewayMethodTable, invalid } from "@luke/gateway";
 import { unparsedWire } from "@luke/wire";
 import { readEither } from "@luke/wire/effect";
@@ -124,6 +128,9 @@ export type CodingAgentClient = Pick<
   | "inbox"
   | "answerInbox"
   | "messageInbox"
+  | "markInboxItemRead"
+  | "markInboxItemUnread"
+  | "markInboxRead"
   | "accountInbox"
   | "inboxAttachment"
   | "agentPicture"
@@ -519,6 +526,28 @@ function composed(
         const answer = yield* asked(client.messageInbox(itemId, request));
         return carried<CodingAgentInboxMessagedView>(answer);
       }),
+    [GATEWAY_METHOD.CODING_AGENTS_INBOX_READ_STATE]: (params) =>
+      Effect.gen(function* () {
+        const { itemId, unread } = yield* read(
+          codingAgentInboxReadStateParamsSchema,
+          params,
+          "marking an inbox item names the item and whether it reads as unread",
+        );
+        const answer = yield* asked(
+          unread ? client.markInboxItemUnread(itemId) : client.markInboxItemRead(itemId),
+        );
+        return carried<CodingAgentInboxReadStateView>(answer);
+      }),
+    [GATEWAY_METHOD.CODING_AGENTS_INBOX_READ_ALL]: (params) =>
+      Effect.gen(function* () {
+        const request = yield* read(
+          inboxReadAllRequestSchema,
+          params,
+          "marking the inbox read names no more than the workspace it lists",
+        );
+        const answer = yield* asked(client.markInboxRead(request));
+        return carried<CodingAgentInboxReadAllView>(answer);
+      }),
     [GATEWAY_METHOD.CODING_AGENTS_CHAT]: (params) =>
       Effect.gen(function* () {
         const { workspaceId, after } = yield* read(
diff --git a/packages/host/src/host-operator.ts b/packages/host/src/host-operator.ts
index c81717fd14..8f7fe8f57e 100644
--- a/packages/host/src/host-operator.ts
+++ b/packages/host/src/host-operator.ts
@@ -43,6 +43,9 @@ import {
   type CodingAgentInboxMessagedView,
   type CodingAgentInboxMessageParams,
   type CodingAgentInboxParams,
+  type CodingAgentInboxReadAllView,
+  type CodingAgentInboxReadStateParams,
+  type CodingAgentInboxReadStateView,
   type CodingAgentListAnswer,
   type CodingAgentListParams,
   type CodingAgentMessageParams,
@@ -76,6 +79,8 @@ import {
   codingAgentInboxAnswerViewSchema,
   codingAgentInboxAttachmentViewSchema,
   codingAgentInboxMessagedViewSchema,
+  codingAgentInboxReadAllViewSchema,
+  codingAgentInboxReadStateViewSchema,
   codingAgentListAnswerViewSchema,
   codingAgentMessagesAnswerViewSchema,
   codingAgentModelsAnswerSchema,
@@ -108,6 +113,7 @@ import {
   type FactoryWorldView,
   factoryWorldViewSchema,
 } from "@luke/features/factory-world-view";
+import type { InboxReadAllRequest } from "@luke/features/inbox-wire";
 import {
   INTEGRATION_CALL_FAILURE,
   type IntegrationAccountView,
@@ -613,6 +619,12 @@ export interface HostOperator {
   codingAgentInboxMessage(
     params: CodingAgentInboxMessageParams,
   ): Effect.Effect<CodingAgentInboxMessagedView>;
+  /** One item marked read or unread for the account; its read state, or why there is no answer. */
+  codingAgentInboxReadState(
+    params: CodingAgentInboxReadStateParams,
+  ): Effect.Effect<CodingAgentInboxReadStateView>;
+  /** Every item of the account's Inbox marked read, in the one workspace named or in all; how many were unread, or why there is no answer. */
+  codingAgentInboxReadAll(params: InboxReadAllRequest): Effect.Effect<CodingAgentInboxReadAllView>;
   /** What waits on the developer across the account past a cursor, held by the service while nothing changed; or why there is none. */
   codingAgentAccountInbox(
     params: CodingAgentAccountInboxParams,
@@ -1723,6 +1735,22 @@ export function createHostOperator(options: HostOperatorOptions): HostOperator {
         }),
         codingAgentAnswer(codingAgentInboxMessagedViewSchema),
       ),
+    codingAgentInboxReadState: (params) =>
+      Effect.map(
+        client.call(GATEWAY_METHOD.CODING_AGENTS_INBOX_READ_STATE, {
+          itemId: params.itemId,
+          unread: params.unread,
+        }),
+        codingAgentAnswer(codingAgentInboxReadStateViewSchema),
+      ),
+    codingAgentInboxReadAll: (params) =>
+      Effect.map(
+        client.call(
+          GATEWAY_METHOD.CODING_AGENTS_INBOX_READ_ALL,
+          params.workspaceId === undefined ? {} : { workspaceId: params.workspaceId },
+        ),
+        codingAgentAnswer(codingAgentInboxReadAllViewSchema),
+      ),
     codingAgentAccountInbox: (params) =>
       Effect.map(
         client.call(GATEWAY_METHOD.CODING_AGENTS_ACCOUNT_INBOX, { after: params.after }),
diff --git a/packages/settings/src/shortcuts.ts b/packages/settings/src/shortcuts.ts
index 4fc6543966..4f3e6ebe56 100644
--- a/packages/settings/src/shortcuts.ts
+++ b/packages/settings/src/shortcuts.ts
@@ -64,6 +64,7 @@ export const APP_COMMAND = {
   INBOX_LIST: "inbox-list",
   PREVIOUS_INBOX_ITEM: "previous-inbox-item",
   NEXT_INBOX_ITEM: "next-inbox-item",
+  TOGGLE_INBOX_ITEM_READ: "toggle-inbox-item-read",
   EXIT_AGENT_PAGE: "exit-agent-page",
   EXIT_PERSON_PAGE: "exit-person-page",
   FACTORY: "factory",
@@ -414,6 +415,10 @@ export const APP_SHORTCUTS = {
     label: "Next inbox item",
     chord: { key: SHORTCUT_KEY.J, plain: true },
   },
+  [APP_COMMAND.TOGGLE_INBOX_ITEM_READ]: {
+    label: "Mark inbox item as read or unread",
+    chord: { key: SHORTCUT_KEY.U, plain: true },
+  },
   [APP_COMMAND.EXIT_AGENT_PAGE]: {
     label: "Exit agent page",
     chord: { key: SHORTCUT_KEY.ESCAPE, bare: true },
@@ -505,6 +510,7 @@ export const APP_SHORTCUT_GROUPS = [
       APP_COMMAND.INBOX_LIST,
       APP_COMMAND.PREVIOUS_INBOX_ITEM,
       APP_COMMAND.NEXT_INBOX_ITEM,
+      APP_COMMAND.TOGGLE_INBOX_ITEM_READ,
       APP_COMMAND.ISSUES,
       APP_COMMAND.EXIT_ISSUES,
       APP_COMMAND.NEW_ISSUE,
diff --git a/packages/ui/src/components/list-row/list-row.css b/packages/ui/src/components/list-row/list-row.css
index c4e6a65368..52d732a186 100644
--- a/packages/ui/src/components/list-row/list-row.css
+++ b/packages/ui/src/components/list-row/list-row.css
@@ -144,10 +144,14 @@
     font-weight: var(--luke-weight-medium);
   }
 
-  /* What has not been seen reads in the heavier weight until it is, as a
-     mail app's unread rows do. */
+  /* What has not been seen reads in a heavier weight, and its description
+     in the body's ink, until it is, as a mail app's unread threads do. */
   .luke-list-row[data-unread="true"] .luke-list-row-title {
-    font-weight: var(--luke-weight-bold);
+    font-weight: var(--luke-weight-semibold);
+  }
+
+  .luke-list-row[data-unread="true"] .luke-list-row-description {
+    color: var(--luke-color-text);
   }
 
   .luke-list-row-description,
@@ -199,4 +203,40 @@
     gap: var(--luke-space-4);
     padding-inline-end: var(--luke-space-12);
   }
+
+  /* Acts offered to the row in hand stand over its metadata's end, at the
+     title's line where the metadata stands there, and come in while the
+     pointer rests on the row or it holds the keyboard, the metadata
+     stepping aside so nothing moves. The press keeps its end inset, since
+     the acts take no room beside it. */
+  .luke-list-row[data-actions="hover"] {
+    position: relative;
+  }
+
+  .luke-list-row[data-actions="hover"] > .luke-list-row-main {
+    padding-inline-end: var(--luke-space-12);
+  }
+
+  .luke-list-row[data-actions="hover"] > .luke-list-row-actions {
+    position: absolute;
+    inset-block: 0;
+    inset-inline-end: 0;
+    opacity: 0;
+    pointer-events: none;
+    transition: opacity var(--duration-hover) ease;
+  }
+
+  .luke-list-row[data-actions="hover"][data-meta="title"] > .luke-list-row-actions {
+    inset-block: var(--luke-space-8) auto;
+    height: var(--luke-type-label-leading);
+  }
+
+  .luke-list-row[data-actions="hover"]:is(:hover, :has(:focus-visible)) > .luke-list-row-actions {
+    opacity: 1;
+    pointer-events: auto;
+  }
+
+  .luke-list-row[data-actions="hover"]:is(:hover, :has(:focus-visible)) .luke-list-row-meta {
+    visibility: hidden;
+  }
 }
diff --git a/packages/ui/src/components/list-row/list-row.tsx b/packages/ui/src/components/list-row/list-row.tsx
index 98aa26c286..a4fc044f46 100644
--- a/packages/ui/src/components/list-row/list-row.tsx
+++ b/packages/ui/src/components/list-row/list-row.tsx
@@ -37,8 +37,9 @@ import type {
  *
  * The open row is current in one of two ways (`LIST_ROW_CURRENT`): the page
  * shown beside the list, as an Inbox's item is, or the one item chosen in
- * its set. An unread row's title stands in the heavier weight until it is
- * read. A row that opens something may hang the app's hint from its press
+ * its set. An unread row's title stands in the heavier weight, and its
+ * description in the body's ink, until it is read, as a mail app's unread
+ * thread does. A row that opens something may hang the app's hint from its press
  * (`hint`), as a Button's hint hangs: the app's own tooltip, handed the
  * words to raise and the press it wraps, whose pointer and focus handlers
  * land on the press itself.
@@ -46,7 +47,11 @@ import type {
  * A row's metadata stands at its middle, or, in a list read as a mail
  * app's is (`LIST_ROW_META.TITLE`), at the end of its title's line, the
  * description running the row's whole width under both and its leading
- * mark level with the title.
+ * mark level with the title. A row's acts stand beside it, or, in a list
+ * that offers them only to the row in hand (`LIST_ROW_ACTIONS.HOVER`), over
+ * its metadata's end while the pointer rests on it or it holds the
+ * keyboard, the metadata stepping aside as a sidebar row's time does for
+ * Pin and Archive.
  *
  * A list stands plain, its rows apart on the ground, each lit on its own;
  * or as a card (`LIST_VARIANT.CARD`), its rows edge to edge on the card's
@@ -88,6 +93,14 @@ export const LIST_ROW_META = {
 
 export type ListRowMeta = (typeof LIST_ROW_META)[keyof typeof LIST_ROW_META];
 
+/** When a row's acts stand: always, beside it, or over its metadata's end only while the row is in hand. */
+export const LIST_ROW_ACTIONS = {
+  ALWAYS: "always",
+  HOVER: "hover",
+} as const;
+
+export type ListRowActions = (typeof LIST_ROW_ACTIONS)[keyof typeof LIST_ROW_ACTIONS];
+
 /** What a hint hands the press it wraps: when to show and go, and what it says of the press. */
 interface ListRowHintProps {
   "aria-describedby"?: string | undefined;
@@ -137,6 +150,7 @@ export function ListRow({
   meta,
   metaAt = LIST_ROW_META.MIDDLE,
   actions,
+  actionsAt = LIST_ROW_ACTIONS.ALWAYS,
   onPress,
   current,
   unread,
@@ -156,6 +170,8 @@ export function ListRow({
   metaAt?: ListRowMeta;
   /** The row's own acts (an IconButton, a Button), each a control beside the row's press. */
   actions?: ReactNode;
+  /** When the acts stand: always, beside the row, or over its metadata's end while the row is hovered or holds the keyboard. */
+  actionsAt?: ListRowActions;
   /** What pressing the row does; a row without one is not a control. */
   onPress?: (() => void) | undefined;
   /** How the row is the one open now, drawn and announced as current; nothing where it is not. */
@@ -213,6 +229,7 @@ export function ListRow({
       ref={onPress ? undefined : ref}
       className="luke-list-row"
       data-meta={metaAt === LIST_ROW_META.TITLE ? metaAt : undefined}
+      data-actions={actionsAt === LIST_ROW_ACTIONS.HOVER ? actionsAt : undefined}
       data-current={current === undefined ? undefined : "true"}
       data-unread={unread === true ? "true" : undefined}
       onContextMenu={onContextMenu}

From da946edf2e681cc2c2d96312fccebba64548e946 Mon Sep 17 00:00:00 2001
From: Dean Stratakos <29683763+dastratakos@users.noreply.github.com>
Date: Sun, 18 Oct 2026 17:19:00 +0000
Subject: [PATCH 2/2] fix(desktop): read marks give way once the reads catch
 up, go in order, and Mark all as read reads again

A read mark stands over the reads only until they hold the item as it
left it, so another window's later mark is drawn. Marks reach the service
one at a time in the order they were made, an item's latest standing for
its own still waiting, Mark all as read in its turn. Once Mark all as read
is taken, every listed plan and agent is read again, since the write
moves nothing main hears of. U and opening an item stand down while the
side panel holds the keys or fills the window.

Co-authored-by: luke-agent[bot] <339870089+luke-agent[bot]@users.noreply.github.com>
---
 .../renderer/desktop/desktop-inbox.test.ts    |  26 +++
 .../src/renderer/desktop/desktop-inbox.tsx    |  41 +++-
 .../src/renderer/desktop/desktop-tasks.tsx    |  12 +-
 .../renderer/desktop/inbox-side-panel.test.ts |  43 ++++
 .../renderer/tasks/use-inbox-items.test.ts    |  24 +++
 .../src/renderer/tasks/use-inbox-items.ts     |  21 +-
 .../tasks/use-inbox-read-marks.test.ts        | 204 ++++++++++++++++++
 .../renderer/tasks/use-inbox-read-marks.ts    | 118 +++++++---
 .../tasks/use-taskless-inbox-items.ts         |   9 +
 9 files changed, 447 insertions(+), 51 deletions(-)
 create mode 100644 apps/desktop/src/renderer/tasks/use-inbox-read-marks.test.ts

diff --git a/apps/desktop/src/renderer/desktop/desktop-inbox.test.ts b/apps/desktop/src/renderer/desktop/desktop-inbox.test.ts
index 36156f6d31..37a89d4b84 100644
--- a/apps/desktop/src/renderer/desktop/desktop-inbox.test.ts
+++ b/apps/desktop/src/renderer/desktop/desktop-inbox.test.ts
@@ -3450,3 +3450,29 @@ test("Mark all as read in the view's menu, under the groupings, marks every unre
   openOptions();
   assert.equal(menuItem("Mark all as read").matches(":disabled"), true);
 });
+
+test("Mark all as read, once the service took it, reads every listed plan and every agent with no plan again, since the write moves nothing main hears of", async () => {
+  listedWorkspace = ACME;
+  const planReads: string[] = [];
+  startRead = (taskId) => {
+    planReads.push(taskId);
+    return undefined;
+  };
+  inboxes.set(BILLING.id, [THRESHOLD, { ...RETRY, unread: true }]);
+  agentInboxes = new Map([[SWEEP_AGENT, [{ ...QUARANTINE, unread: true }]]]);
+  const { page } = mount([waitingTaskless(QUARANTINE)]);
+  await settle();
+  const plansBefore = planReads.length;
+  const agentsBefore = agentReads.length;
+  const marksBefore = readMarks.length;
+  const options = page.querySelector<HTMLButtonElement>('button[aria-label="View options"]');
+  act(() => options?.click());
+  act(() => menuItem("Mark all as read").click());
+  await settle();
+  assert.deepEqual(readMarks.slice(marksBefore), ["all:workspace-acme"]);
+  assert.deepEqual(
+    [...new Set(planReads.slice(plansBefore))].toSorted(),
+    [BILLING.id, INVITES.id].toSorted(),
+  );
+  assert.deepEqual(agentReads.slice(agentsBefore), [SWEEP_AGENT]);
+});
diff --git a/apps/desktop/src/renderer/desktop/desktop-inbox.tsx b/apps/desktop/src/renderer/desktop/desktop-inbox.tsx
index 1a0a85bb8b..83122a355a 100644
--- a/apps/desktop/src/renderer/desktop/desktop-inbox.tsx
+++ b/apps/desktop/src/renderer/desktop/desktop-inbox.tsx
@@ -278,11 +278,26 @@ export function DesktopInbox({ tasks }: { tasks: TasksControl }): React.JSX.Elem
           },
         ]
       : [];
-  const marks = useInboxReadMarks({ act, workspaceId: tasks.workspace?.id });
-  const entries = marks.over([
-    ...taskEntries,
-    ...tasklessGroups([...tasks.inboxTaskless, ...settledAgent], tasklessRead, tasks.workspace?.id),
-  ]);
+  const { onReread: rereadTasks } = read;
+  const { onReread: rereadTaskless } = taskless;
+  // Note that every item marked read moves nothing main hears of, so the Inbox reads its items again once the service took it.
+  const marks = useInboxReadMarks({
+    act,
+    workspaceId: tasks.workspace?.id,
+    groups: [
+      ...taskEntries,
+      ...tasklessGroups(
+        [...tasks.inboxTaskless, ...settledAgent],
+        tasklessRead,
+        tasks.workspace?.id,
+      ),
+    ],
+    onMarkedAll: () => {
+      rereadTasks();
+      rereadTaskless();
+    },
+  });
+  const entries = marks.groups;
   const filter = {
     grouping: choices.grouping,
     waitingOnly: choices.waitingOnly,
@@ -362,12 +377,6 @@ export function DesktopInbox({ tasks }: { tasks: TasksControl }): React.JSX.Elem
     columns.onOpen(listed.item.id);
   };
   const { onMark: markItem } = marks;
-  useReadOnOpen({
-    shown: tasks.shown && columns.shown !== INBOX_COLUMNS.LIST ? chosen?.item : undefined,
-    chosen: chosen?.item,
-    active: tasks.shown,
-    onMark: markItem,
-  });
   const pager = useInboxPager(steps, list, chosen?.item.id, choose, {
     shown: tasks.shown,
     folded: folds.folded,
@@ -414,6 +423,16 @@ export function DesktopInbox({ tasks }: { tasks: TasksControl }): React.JSX.Elem
   const { onArea, focus } = useColumnFocus();
   // The panel holds the keys while the focus went into it last, or while it fills the window over the Inbox.
   const sideFocused = sidePanel.open && (focus === COLUMN.SIDE || sidePanel.fullScreen);
+  // The item shown is read as it opens, and U marks it, only while the Inbox holds the keys and the panel does not cover it.
+  useReadOnOpen({
+    shown:
+      tasks.shown && !sidePanel.fullScreen && columns.shown !== INBOX_COLUMNS.LIST
+        ? chosen?.item
+        : undefined,
+    chosen: chosen?.item,
+    active: tasks.shown && !sideFocused,
+    onMark: markItem,
+  });
   // The panel stands for the item asked for, by its task, or its agent where it has none (`use-tasks-tab.ts`).
   const panelFor = taskId ?? chosenAgentId;
   const pullRequests = [...named.pullRequests].map(([agentId, opened]) => ({
diff --git a/apps/desktop/src/renderer/desktop/desktop-tasks.tsx b/apps/desktop/src/renderer/desktop/desktop-tasks.tsx
index c8740ac7cf..983e208bcb 100644
--- a/apps/desktop/src/renderer/desktop/desktop-tasks.tsx
+++ b/apps/desktop/src/renderer/desktop/desktop-tasks.tsx
@@ -220,10 +220,14 @@ function TaskInboxTab({
   const [asked, setAsked] = useState<string | undefined>(undefined);
   const needsYou = useTaskInboxWaitingOnly();
   const { act } = useAct();
-  const marks = useInboxReadMarks({ act, workspaceId: task.workspaceId });
-  const groups = marks.over([
-    { holder: taskHolder(task), items: [...inbox.board.open, ...inbox.board.settled] },
-  ]);
+  const marks = useInboxReadMarks({
+    act,
+    workspaceId: task.workspaceId,
+    groups: [{ holder: taskHolder(task), items: [...inbox.board.open, ...inbox.board.settled] }],
+    // Note that a task's own Inbox offers no Mark all as read.
+    onMarkedAll: () => undefined,
+  });
+  const { groups } = marks;
   const items = groups.flatMap((group) => group.items);
   const filter = {
     grouping: INBOX_GROUPING.NEWEST,
diff --git a/apps/desktop/src/renderer/desktop/inbox-side-panel.test.ts b/apps/desktop/src/renderer/desktop/inbox-side-panel.test.ts
index 166e6be7be..382b3b9e4c 100644
--- a/apps/desktop/src/renderer/desktop/inbox-side-panel.test.ts
+++ b/apps/desktop/src/renderer/desktop/inbox-side-panel.test.ts
@@ -31,6 +31,7 @@ import { fakeAppPlatform, QUIET_PANEL } from "#testing/app-platform";
 import { onRegistry } from "#testing/copy-feedback";
 import { markdownHtmlParserLanded } from "#testing/markdown";
 import { tasksControl, waitingOf } from "#testing/tasks-control";
+import { useAppKeymap } from "../app-commands";
 import { OpenLinkProvider } from "../tasks/use-open-link";
 import { useSidePanel } from "../tasks/use-side-panel";
 import type { InboxChoice } from "../tasks/use-tasks-tab";
@@ -114,6 +115,7 @@ let root: Root | undefined;
 
 beforeEach(() => {
   window.localStorage.clear();
+  readMarks = [];
 });
 
 afterEach(() => {
@@ -123,8 +125,17 @@ afterEach(() => {
 });
 
 /** Answers each act as the service would for the plan, its agent, and the pull request it opened. */
+/** Every read mark the Inbox sent, in order. */
+let readMarks: string[] = [];
+
 function answer(request: Act): Promise<ActOutcome> {
   switch (request.kind) {
+    case ACT_KIND.CODING_AGENTS_INBOX_READ_STATE:
+      readMarks.push(`${request.payload.unread ? "unread" : "read"}:${request.payload.itemId}`);
+      return Promise.resolve({
+        status: ACT_OUTCOME_STATUS.DONE,
+        value: { id: request.payload.itemId, unread: request.payload.unread },
+      });
     case ACT_KIND.CODING_AGENTS_INBOX:
       // A read past the cursor is held open while nothing changes, as the service holds it.
       return request.payload.after === "0"
@@ -265,3 +276,35 @@ test("a page the item names whose plan's pages did not answer asks for them agai
   assert.equal(left.rereads, 1);
   assert.equal(left.links.length, 0, "the page is still the panel's to open");
 });
+
+test("U marks the Inbox's item while the Inbox holds the keys, and not while the panel beside it does", async () => {
+  function Keymap() {
+    useAppKeymap(true);
+    return null;
+  }
+  const keys = createRoot(document.body.appendChild(document.createElement("div")));
+  act(() => keys.render(createElement(Keymap)));
+  const { container } = await inbox();
+  const pressU = () =>
+    act(() => {
+      document.body.dispatchEvent(new KeyboardEvent("keydown", { key: "u", bubbles: true }));
+    });
+  pressU();
+  await settle();
+  assert.deepEqual(readMarks, [`unread:${ITEM.id}`], "the Inbox holds the keys");
+
+  await pressChip(container, "invites.ts");
+  const panel = container.querySelector<HTMLElement>(".side-panel");
+  assert.ok(panel, "the panel stands beside the Inbox");
+  act(() => {
+    panel.dispatchEvent(new FocusEvent("focusin", { bubbles: true }));
+  });
+  pressU();
+  await settle();
+  assert.deepEqual(
+    readMarks,
+    [`unread:${ITEM.id}`],
+    "the panel holds the keys, so U is not the Inbox's",
+  );
+  act(() => keys.unmount());
+});
diff --git a/apps/desktop/src/renderer/tasks/use-inbox-items.test.ts b/apps/desktop/src/renderer/tasks/use-inbox-items.test.ts
index f7d71a5767..ccd755afbc 100644
--- a/apps/desktop/src/renderer/tasks/use-inbox-items.test.ts
+++ b/apps/desktop/src/renderer/tasks/use-inbox-items.test.ts
@@ -82,3 +82,27 @@ test("a plan that changed since its items were read is pending until a read of i
   assert.deepEqual([unread, read, control?.pending], [true, false, true]);
   assert.deepEqual(control?.items.get("acme-plan"), []);
 });
+
+test("asked to read again, every listed plan is read anew though main says none changed, its last items standing, and not pending, until the new read lands", async () => {
+  const answers: ((answer: CodingAgentInboxAnswerView) => void)[] = [];
+  const readInbox = (): Promise<CodingAgentInboxAnswerView> =>
+    new Promise((resolve) => answers.push(resolve));
+  let control: InboxItemsControl | undefined;
+  function Probe({ holdings }: { holdings: readonly AppInboxTaskHolding[] }) {
+    control = useInboxItems({ holdings, readInbox });
+    return null;
+  }
+  root = createRoot(document.createElement("div"));
+  act(() => root?.render(createElement(Probe, { holdings: [holding("acme-plan")] })));
+  await act(async () => answers[0]?.({ items: [], cursor: INBOX_CURSOR_START }));
+  await settle();
+  assert.equal(answers.length, 1);
+
+  act(() => control?.onReread());
+  await settle();
+  assert.equal(answers.length, 2, "the plan is read again");
+  assert.deepEqual([control?.pending, control?.items.get("acme-plan")], [false, []]);
+  await act(async () => answers[1]?.({ items: [], cursor: "2" }));
+  await settle();
+  assert.equal(answers.length, 2, "and once");
+});
diff --git a/apps/desktop/src/renderer/tasks/use-inbox-items.ts b/apps/desktop/src/renderer/tasks/use-inbox-items.ts
index dcffbab2c3..60710e9b60 100644
--- a/apps/desktop/src/renderer/tasks/use-inbox-items.ts
+++ b/apps/desktop/src/renderer/tasks/use-inbox-items.ts
@@ -27,6 +27,8 @@ import type { InboxReader } from "./use-task-inbox";
 /** One task's items as last read, and the moment main said its latest item changed when they were asked for. */
 interface Read {
   readonly at: number;
+  /** The re-read it answered, so a read every task is asked again for (`onReread`) is asked once more. */
+  readonly round: number;
   readonly items: readonly InboxItem[];
 }
 
@@ -43,6 +45,8 @@ export interface InboxItemsControl {
   /** The plans whose items are read as of main's latest word of them, or read and listed no more, so an item they do not hold is not theirs. */
   readonly current: ReadonlySet<string>;
   readonly onRetry: () => void;
+  /** Reads every listed task again, as of now, though main says none changed: what a write main does not hear of, every item marked read, needs. */
+  readonly onReread: () => void;
 }
 
 export function useInboxItems(input: {
@@ -54,6 +58,8 @@ export function useInboxItems(input: {
   const [reads, setReads] = useState<ReadonlyMap<string, Read>>(new Map());
   const [failed, setFailed] = useState<ReadonlySet<string>>(new Set());
   const [attempt, setAttempt] = useState(0);
+  // How many times every task was asked to be read again, each read answering for the round it was asked in.
+  const round = useRef(0);
   // The read out for each task, by the moment it asks for, so a task is asked once per change.
   const asking = useRef(new Map<string, number>());
   // The latest moment each task was asked for, so an answer to an earlier ask, landing last, is let go.
@@ -71,9 +77,11 @@ export function useInboxItems(input: {
   // A retry's press asks again of the tasks whose read failed, the ones not yet read.
   useEffect(() => {
     for (const { taskId, updatedAt } of holdings) {
-      if (latest.current.reads.get(taskId)?.at === updatedAt) continue;
+      const read = latest.current.reads.get(taskId);
+      if (read?.at === updatedAt && read.round === round.current) continue;
       if (asking.current.get(taskId) === updatedAt) continue;
       asking.current.set(taskId, updatedAt);
+      const asked = round.current;
       newest.current.set(taskId, Math.max(newest.current.get(taskId) ?? updatedAt, updatedAt));
       latest.current
         .readInbox({ taskId: taskId, after: INBOX_CURSOR_START })
@@ -91,7 +99,9 @@ export function useInboxItems(input: {
             return next;
           });
           if (failure) return;
-          setReads((was) => new Map(was).set(taskId, { at: updatedAt, items: answer.items }));
+          setReads((was) =>
+            new Map(was).set(taskId, { at: updatedAt, round: asked, items: answer.items }),
+          );
         });
     }
   }, [holdings, attempt]);
@@ -100,6 +110,12 @@ export function useInboxItems(input: {
     setFailed(new Set());
     setAttempt((count) => count + 1);
   }, []);
+  // Note that each task's last read stays drawn until the new one lands.
+  const onReread = useCallback(() => {
+    round.current += 1;
+    asking.current.clear();
+    setAttempt((count) => count + 1);
+  }, []);
   const items = useMemo(
     () => new Map([...reads].map(([taskId, read]) => [taskId, read.items])),
     [reads],
@@ -121,5 +137,6 @@ export function useInboxItems(input: {
     pending,
     current,
     onRetry,
+    onReread,
   };
 }
diff --git a/apps/desktop/src/renderer/tasks/use-inbox-read-marks.test.ts b/apps/desktop/src/renderer/tasks/use-inbox-read-marks.test.ts
new file mode 100644
index 0000000000..ccf306ccbf
--- /dev/null
+++ b/apps/desktop/src/renderer/tasks/use-inbox-read-marks.test.ts
@@ -0,0 +1,204 @@
+// @vitest-environment jsdom
+
+import assert from "node:assert/strict";
+import { CODING_AGENT_CALL_FAILURE } from "@luke/features/coding-agent-view";
+import {
+  INBOX_RESPONSE,
+  INBOX_STATUS,
+  INBOX_WIRE_VERSION,
+  type InboxItem,
+} from "@luke/features/inbox-wire";
+import type { TaskSummary } from "@luke/features/task-wire";
+import { ACT_KIND, ACT_OUTCOME_STATUS, type Act, type ActOutcome } from "@luke/host/acts";
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, test } from "vitest";
+import { fakeAppBridge } from "#testing/app-bridge";
+import { useAct } from "../act";
+import { type InboxGroup, isUnread, taskHolder } from "./inbox-model";
+import { type InboxReadMarks, useInboxReadMarks } from "./use-inbox-read-marks";
+
+/**
+ * use-inbox-read-marks.test.ts -- the Inbox's read marks flip a dot at once
+ * and stand only until the reads hold the item as the mark left it, so a
+ * later read, another window's mark among them, is what the row draws; the
+ * marks reach the service one at a time in the order they were made, an
+ * item's latest standing for its own still waiting; and every item marked
+ * read asks the reads again once the service took it. Synthetic plan and
+ * items.
+ */
+
+const TASK: TaskSummary = {
+  id: "7b0f5f3e-2c1d-4c7a-9a55-5e3b6f1d2a10",
+  workspaceId: "workspace-acme",
+  name: "Billing usage alerts",
+  createdAt: 1,
+  updatedAt: 2,
+  repository: "acme/relay",
+};
+
+/** An item of the plan's, open and asking words, read or unread as given. */
+function item(id: string, unread: boolean): InboxItem {
+  return {
+    id,
+    agentId: "8c1a6a4f-3d2e-4d8b-8b66-6f4c7a2e3b21",
+    key: id.slice(-4),
+    revision: 1,
+    version: INBOX_WIRE_VERSION,
+    title: "Alert at 80%?",
+    blocks: [],
+    response: { type: INBOX_RESPONSE.TEXT },
+    needsReply: true,
+    status: INBOX_STATUS.OPEN,
+    postedAt: 1_000,
+    updatedAt: 1_000,
+    unread,
+  };
+}
+
+const X = "a1b2c3d4-0000-4000-8000-000000000001";
+const Y = "a1b2c3d4-0000-4000-8000-000000000002";
+
+/** One write the hook sent, and how to answer it. */
+interface Sent {
+  readonly words: string;
+  readonly answer: (failed?: boolean) => Promise<void>;
+}
+
+let root: Root | undefined;
+
+afterEach(() => {
+  act(() => root?.unmount());
+  root = undefined;
+});
+
+/** The hook over the reads given, every write it sends held until the test answers it; and how to give it newer reads. */
+function marks(first: readonly InboxItem[]) {
+  const sent: Sent[] = [];
+  let rereads = 0;
+  fakeAppBridge({
+    act: (request: Act) =>
+      new Promise<ActOutcome>((resolve) => {
+        const words =
+          request.kind === ACT_KIND.CODING_AGENTS_INBOX_READ_ALL
+            ? `all:${request.payload.workspaceId}`
+            : request.kind === ACT_KIND.CODING_AGENTS_INBOX_READ_STATE
+              ? `${request.payload.unread ? "unread" : "read"}:${request.payload.itemId}`
+              : request.kind;
+        sent.push({
+          words,
+          answer: async (failed = false) => {
+            const value = failed
+              ? { failure: CODING_AGENT_CALL_FAILURE.NOT_FOUND }
+              : request.kind === ACT_KIND.CODING_AGENTS_INBOX_READ_STATE
+                ? { id: request.payload.itemId, unread: request.payload.unread }
+                : { marked: 1 };
+            await act(async () => {
+              resolve({ status: ACT_OUTCOME_STATUS.DONE, value });
+              for (let tick = 0; tick < 8; tick += 1) await Promise.resolve();
+            });
+          },
+        });
+      }),
+  });
+  let control: InboxReadMarks | undefined;
+  function Harness({ groups }: { groups: readonly InboxGroup[] }) {
+    const { act: send } = useAct();
+    control = useInboxReadMarks({
+      act: send,
+      workspaceId: TASK.workspaceId,
+      groups,
+      onMarkedAll: () => {
+        rereads += 1;
+      },
+    });
+    return null;
+  }
+  root = createRoot(document.createElement("div"));
+  const read = (items: readonly InboxItem[]) =>
+    act(() =>
+      root?.render(createElement(Harness, { groups: [{ holder: taskHolder(TASK), items }] })),
+    );
+  read(first);
+  const held = () => control ?? assert.fail("the hook stands");
+  return {
+    sent,
+    read,
+    rereads: () => rereads,
+    /** Each item's dot as the hook draws it. */
+    dots: () =>
+      held().groups.flatMap(({ items }) => items.map((each) => [each.id, isUnread(each)])),
+    mark: (target: InboxItem, unread: boolean) => act(() => held().onMark(target, unread)),
+    markAll: (items: readonly InboxItem[]) => act(() => held().onMarkAll(items)),
+  };
+}
+
+/** Lets the writes queued so far reach the act. */
+async function settle(): Promise<void> {
+  await act(async () => {
+    for (let tick = 0; tick < 8; tick += 1) await Promise.resolve();
+  });
+}
+
+test("a mark flips the dot at once and stands over reads that have not caught up; once a read holds the item as it left it, a later read, another window's mark, is what is drawn", async () => {
+  const hook = marks([item(X, false)]);
+  hook.mark(item(X, false), true);
+  await settle();
+  assert.deepEqual(hook.dots(), [[X, true]]);
+  // A read from before the mark landed still says read; the mark stands over it.
+  hook.read([item(X, false)]);
+  assert.deepEqual(hook.dots(), [[X, true]]);
+  await hook.sent[0]?.answer();
+  hook.read([item(X, true)]);
+  assert.deepEqual(hook.dots(), [[X, true]]);
+  // Another window marks it read; the reads say so, and the row follows.
+  hook.read([item(X, false)]);
+  assert.deepEqual(hook.dots(), [[X, false]]);
+});
+
+test("marks reach the service one at a time in the order they were made, an item's latest standing for its own still waiting, and Mark all as read waits its turn too", async () => {
+  const hook = marks([item(X, false), item(Y, true)]);
+  hook.mark(item(X, false), true);
+  hook.mark(item(X, true), false);
+  hook.mark(item(X, false), true);
+  hook.markAll([item(X, true), item(Y, true)]);
+  await settle();
+  assert.deepEqual(
+    hook.sent.map((each) => each.words),
+    [`unread:${X}`],
+    "one write is out at a time",
+  );
+  await hook.sent[0]?.answer();
+  await settle();
+  assert.deepEqual(
+    hook.sent.map((each) => each.words),
+    [`unread:${X}`, "all:workspace-acme"],
+    "X's later marks stood for one another, the last already sent, so Mark all as read went next",
+  );
+  assert.equal(hook.rereads(), 0);
+  await hook.sent[1]?.answer();
+  assert.equal(hook.rereads(), 1, "every item marked read asks the reads again once taken");
+});
+
+test("a mark the service refused is let go, and Mark all as read refused asks nothing again", async () => {
+  const hook = marks([item(X, false), item(Y, true)]);
+  hook.mark(item(X, false), true);
+  await settle();
+  await hook.sent[0]?.answer(true);
+  assert.deepEqual(hook.dots(), [
+    [X, false],
+    [Y, true],
+  ]);
+  hook.markAll([item(X, false), item(Y, true)]);
+  await settle();
+  assert.deepEqual(hook.dots(), [
+    [X, false],
+    [Y, false],
+  ]);
+  await hook.sent[1]?.answer(true);
+  assert.deepEqual(hook.dots(), [
+    [X, false],
+    [Y, true],
+  ]);
+  assert.equal(hook.rereads(), 0);
+});
diff --git a/apps/desktop/src/renderer/tasks/use-inbox-read-marks.ts b/apps/desktop/src/renderer/tasks/use-inbox-read-marks.ts
index 22acc45896..9f5f08abfe 100644
--- a/apps/desktop/src/renderer/tasks/use-inbox-read-marks.ts
+++ b/apps/desktop/src/renderer/tasks/use-inbox-read-marks.ts
@@ -2,7 +2,7 @@ import { CODING_AGENT_CALL_FAILURE } from "@luke/features/coding-agent-view";
 import type { InboxItem } from "@luke/features/inbox-wire";
 import { ACT_KIND } from "@luke/host/acts";
 import { APP_COMMAND } from "@luke/settings/shortcuts";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import type { ActHandle } from "../act";
 import { useAppCommand } from "../app-commands";
 import { type InboxGroup, type InboxReadMark, isUnread, withReadMarks } from "./inbox-model";
@@ -10,14 +10,18 @@ import { type InboxGroup, type InboxReadMark, isUnread, withReadMarks } from "./
 /**
  * use-inbox-read-marks.ts -- the Inbox's read and unread marks as one control: an item marked read or unread, or every item marked read, its dot flipping at once.
  *
- * A mark goes to the service as an act, which wakes the held reads of the
- * account on its own, so nothing here reads again; until those reads
- * answer, the mark is laid over what they hold (`inbox-model.ts`'s
- * `withReadMarks`), so the dot flips the moment it is pressed. A mark the
- * service did not take is let go, and the dot stands as the reads hold it.
- * Marking every item read marks only the items the Inbox lists that are
- * unread, in the one workspace it lists, as the service marks them; an item
- * waiting on the developer keeps waiting, since the dots are all it clears.
+ * A mark goes to the service as an act, and is laid over what the reads
+ * hold (`inbox-model.ts`'s `withReadMarks`) so the dot flips the moment it
+ * is pressed, until the reads hold the item as the mark left it; then the
+ * mark is let go, so a later read, another window's mark among them, is
+ * what the row draws. The acts go one at a time, in the order the marks
+ * were made, so a quick read, unread, read reaches the service as the last,
+ * Mark all as read in its turn among them. A mark the service did not take
+ * is let go, and the dot stands as the reads hold it. Marking every item
+ * read marks the items the Inbox lists in the one workspace it lists, as
+ * the service marks them, and asks the reads again once it is taken, since
+ * the write moves nothing main hears of; an item waiting on the developer
+ * keeps waiting, since the dots are all it clears.
  *
  * Opening an item marks it read, once each time it is shown
  * (`useReadOnOpen`), so an item the reader marks unread while it is shown
@@ -27,29 +31,61 @@ import { type InboxGroup, type InboxReadMark, isUnread, withReadMarks } from "./
 
 /** What the Inbox's read marks offer: the reads with the marks laid over them, and the marks themselves. */
 export interface InboxReadMarks {
-  /** The groups as the reads hold them, the marks not yet read back laid over them. */
-  readonly over: (groups: readonly InboxGroup[]) => readonly InboxGroup[];
+  /** The groups as the reads hold them, the marks they have not caught up with laid over them. */
+  readonly groups: readonly InboxGroup[];
   /** Marks one item read or unread. */
   readonly onMark: (item: InboxItem, unread: boolean) => void;
   /** Marks every item given that is unread as read, as the service marks the listed workspace's. */
   readonly onMarkAll: (items: readonly InboxItem[]) => void;
 }
 
+/** No marks, one map so a hook that holds none hands down the same one. */
+const NO_MARKS: ReadonlyMap<string, InboxReadMark> = new Map();
+
 /** What a mark the act channel refused hears, as the service not answering. */
 const UNANSWERED = { failure: CODING_AGENT_CALL_FAILURE.UNANSWERED } as const;
 
-/** No marks, one map so a hook that holds none hands down the same one. */
-const NO_MARKS: ReadonlyMap<string, InboxReadMark> = new Map();
+/** Whether the reads hold an item as a mark left it, or have moved past the item it was made on: either way the mark has nothing left to say. */
+function caughtUp(groups: readonly InboxGroup[], itemId: string, mark: InboxReadMark): boolean {
+  for (const { items } of groups) {
+    const item = items.find((each) => each.id === itemId);
+    if (item !== undefined)
+      return item.updatedAt !== mark.updatedAt || isUnread(item) === mark.unread;
+  }
+  return false;
+}
 
-/** The Inbox's read marks, sent through `act`, every item marked read in `workspaceId` where the Inbox lists one. */
+/**
+ * The Inbox's read marks over `groups`, the reads as they stand, sent
+ * through `act`; every item marked read in `workspaceId` where the Inbox
+ * lists one, and `onMarkedAll` heard once the service took it, so the
+ * reads are asked again.
+ *
+ * A mark stands over the reads until they hold the item as it left it, and
+ * is let go then, so a later read, another window's mark included, is what
+ * the row draws. The marks go to the service one at a time, in the order
+ * they were made, an item's later mark standing for any of its own still
+ * waiting to go, so a quick read, unread, read reaches it as the last.
+ */
 export function useInboxReadMarks({
   act,
   workspaceId,
+  groups,
+  onMarkedAll,
 }: {
   act: ActHandle["act"];
   workspaceId: string | undefined;
+  groups: readonly InboxGroup[];
+  onMarkedAll: () => void;
 }): InboxReadMarks {
   const [marks, setMarks] = useState(NO_MARKS);
+  // The writes, one after another, and each item's latest mark still to go, which its queued write sends.
+  const queue = useRef<Promise<void>>(Promise.resolve());
+  const wanted = useRef(new Map<string, ReadonlyMap<string, InboxReadMark>>());
+  const heard = useRef(onMarkedAll);
+  useLayoutEffect(() => {
+    heard.current = onMarkedAll;
+  });
   // Note that a mark is let go only where it still stands as it was made, so a later mark on the same item outlives an earlier one's refusal.
   const letGo = useCallback((made: ReadonlyMap<string, InboxReadMark>) => {
     setMarks((held) => {
@@ -61,17 +97,34 @@ export function useInboxReadMarks({
   const lay = useCallback((made: ReadonlyMap<string, InboxReadMark>) => {
     setMarks((held) => new Map([...held, ...made]));
   }, []);
+  const send = useCallback((write: () => Promise<void>) => {
+    queue.current = queue.current.then(write);
+  }, []);
+  useEffect(() => {
+    const done = [...marks].filter(([itemId, mark]) => caughtUp(groups, itemId, mark));
+    if (done.length > 0) letGo(new Map(done));
+  });
   const onMark = useCallback(
     (item: InboxItem, unread: boolean) => {
       const made = new Map([[item.id, { unread, updatedAt: item.updatedAt }]]);
       lay(made);
-      void act(ACT_KIND.CODING_AGENTS_INBOX_READ_STATE, { itemId: item.id, unread })
-        .catch(() => UNANSWERED)
-        .then((answer) => {
-          if ("failure" in answer) letGo(made);
-        });
+      wanted.current.set(item.id, made);
+      send(() => {
+        const latest = wanted.current.get(item.id);
+        const mark = latest?.get(item.id);
+        if (latest === undefined || mark === undefined) return Promise.resolve();
+        wanted.current.delete(item.id);
+        return act(ACT_KIND.CODING_AGENTS_INBOX_READ_STATE, {
+          itemId: item.id,
+          unread: mark.unread,
+        })
+          .catch(() => UNANSWERED)
+          .then((answer) => {
+            if ("failure" in answer) letGo(latest);
+          });
+      });
     },
-    [act, lay, letGo],
+    [act, lay, letGo, send],
   );
   const onMarkAll = useCallback(
     (items: readonly InboxItem[]) => {
@@ -82,22 +135,19 @@ export function useInboxReadMarks({
       );
       if (made.size === 0) return;
       lay(made);
-      void act(
-        ACT_KIND.CODING_AGENTS_INBOX_READ_ALL,
-        workspaceId === undefined ? {} : { workspaceId },
-      )
-        .catch(() => UNANSWERED)
-        .then((answer) => {
-          if ("failure" in answer) letGo(made);
-        });
+      send(() =>
+        act(ACT_KIND.CODING_AGENTS_INBOX_READ_ALL, workspaceId === undefined ? {} : { workspaceId })
+          .catch(() => UNANSWERED)
+          .then((answer) => {
+            if ("failure" in answer) letGo(made);
+            else heard.current();
+          }),
+      );
     },
-    [act, workspaceId, lay, letGo],
-  );
-  const over = useCallback(
-    (groups: readonly InboxGroup[]) => withReadMarks(groups, marks),
-    [marks],
+    [act, workspaceId, lay, letGo, send],
   );
-  return { over, onMark, onMarkAll };
+  const marked = useMemo(() => withReadMarks(groups, marks), [groups, marks]);
+  return { groups: marked, onMark, onMarkAll };
 }
 
 /**
diff --git a/apps/desktop/src/renderer/tasks/use-taskless-inbox-items.ts b/apps/desktop/src/renderer/tasks/use-taskless-inbox-items.ts
index 21fa902538..4ba7fb12cf 100644
--- a/apps/desktop/src/renderer/tasks/use-taskless-inbox-items.ts
+++ b/apps/desktop/src/renderer/tasks/use-taskless-inbox-items.ts
@@ -31,6 +31,8 @@ export interface TasklessInboxItems {
   /** The agents whose items are read as of main's latest word of what waits on them, or read and waited on no more, so an item they do not hold is not theirs. */
   readonly current: ReadonlySet<string>;
   readonly onRetry: () => void;
+  /** Reads every agent's items again, as of now, though nothing main hears of moved: what every item marked read needs. */
+  readonly onReread: () => void;
 }
 
 /** One agent's items as last read, and the waiting items that read answered for. */
@@ -123,6 +125,12 @@ export function useTasklessInboxItems(
     setFailed(new Set());
     setAttempt((count) => count + 1);
   }, []);
+  // Note that each agent's last read stays drawn until the new one lands.
+  const onReread = useCallback(() => {
+    readFor.current.clear();
+    asking.current.clear();
+    setAttempt((count) => count + 1);
+  }, []);
   const items = useMemo(
     () => new Map([...reads].map(([agentId, read]) => [agentId, read.items])),
     [reads],
@@ -139,5 +147,6 @@ export function useTasklessInboxItems(
     failed: [...standing.keys()].some((agentId) => failed.has(agentId)),
     current,
     onRetry,
+    onReread,
   };
 }