diff --git a/webviews/src/agent-session/acpmux/App.tsx b/webviews/src/agent-session/acpmux/App.tsx
index 1c64e2833c4f..60dc18a4ba1e 100644
--- a/webviews/src/agent-session/acpmux/App.tsx
+++ b/webviews/src/agent-session/acpmux/App.tsx
@@ -1216,6 +1216,7 @@ const MessageRow = memo(
                   blocker: false,
                   promptIds: [...row.inboxThread.promptIds],
                   ...(row.inboxThread.fromSession ? { fromSession: row.inboxThread.fromSession } : {}),
+                  ...(row.inboxThread.fromHarness ? { fromHarness: row.inboxThread.fromHarness } : {}),
                 },
               ],
             }}
diff --git a/webviews/src/agent-session/acpmux/conversation/InboxNotice.gallery.ts b/webviews/src/agent-session/acpmux/conversation/InboxNotice.gallery.ts
index b23de489422c..d9d93cc95102 100644
--- a/webviews/src/agent-session/acpmux/conversation/InboxNotice.gallery.ts
+++ b/webviews/src/agent-session/acpmux/conversation/InboxNotice.gallery.ts
@@ -8,7 +8,7 @@
 // default are inboxNoticeLook.ts's (`theme.inboxNoticeLook`). Names and messages are made up.
 import { agentPaneEntry } from "../../../gallery/format";
 import type { Play } from "../../../gallery/play";
-import { SESSION_ID, assistant, chat, session, summary, user } from "../../../gallery/fixtures/acpmux";
+import { SESSION_ID, activity, assistant, chat, session, summary, tool, user } from "../../../gallery/fixtures/acpmux";
 import { incomingPrompt } from "./incomingMessage";
 import { inboxText } from "./inboxNotice";
 
@@ -158,6 +158,71 @@ function snapshot(notices: Thread[][], before = false) {
   );
 }
 
+/// A sender no chat here lists, named like another harness (a Codex lane called `claude-…`): its
+/// line draws the neutral agent glyph, never a mark guessed from the name.
+const UNLISTED: Thread = {
+  threadId: "from:claude-mesh-lane/pr:5805",
+  label: "#5805",
+  messages: [{ from: "claude-mesh-lane", text: "HQ#5805 at b070cf5 opened its verification issue." }],
+};
+
+/// Two messages from one session that wait for the agent's turn to end (PendingMessagesCard.tsx):
+/// "2 messages from 1 session", the case Leo named.
+const WAITING = [
+  "Review passed at e34ce27; landing #2210 now.",
+  "Landed #2210; the nightly picks it up in its next run.",
+].map((text, index) => ({
+  id: `w${index + 1}`,
+  prompt: text,
+  message: { name: "grid-lane", sessionId: "s-grid", harness: "claude", text, raw: text },
+}));
+
+/// Inbox rows among tool rows, as a coordinator's chat draws them: a run of commands, one thread's
+/// line, a delivered group of one sender's threads, one of several senders', and the messages that
+/// wait (Leo, 2026-11-01: "i wanted this to be left aligned with the other tool calls" and "let's
+/// just make this look better"). Every group's head is a tool row (MessageGroupHead.tsx).
+/// inbox-row-icon-column.test.ts measures it.
+function amongTools() {
+  const run = (minutes: number) =>
+    activity(
+      [
+        tool("Run", "execute", "completed", {
+          command: "gh pr checks 2210",
+          output: "web / react-apps-base-check pass\n",
+        }),
+        tool("Run", "execute", "completed", { command: "git log --oneline -1", output: "6d9ae71 base autofix\n" }),
+      ],
+      minutes,
+    );
+  return chat(
+    [
+      user("Hand the three polish lanes their briefs and land what comes back reviewed.", 12),
+      run(11),
+      notice([BLOAT], 10),
+      run(9),
+      notice([UNLISTED], 8.5),
+      run(8),
+      notice([GRID, FYI], 7),
+      run(6),
+      notice([PLAN, REVIEW, RAIL], 5),
+      run(4),
+      assistant("Landing #2210 once its review comes back…", 3, { streaming: true }),
+    ],
+    {
+      title: "polish-coordinator",
+      isWorking: true,
+      queue: WAITING,
+      sessions: [
+        session({ sessionId: SESSION_ID, title: "polish-coordinator", name: "polish-coordinator" }),
+        session({ sessionId: "s-log-bloat", title: "ao-log-bloat", name: "ao-log-bloat", harness: "codex" }),
+        session({ sessionId: "s-grid", title: "grid-lane", name: "grid-lane", harness: "claude" }),
+        session({ sessionId: "s-picker", title: "picker-lane", name: "picker-lane", harness: "codex" }),
+        session({ sessionId: "s-review", title: "review-box", name: "review-box", harness: "codex" }),
+      ],
+    },
+  );
+}
+
 const ONE = [[BLOAT]];
 const THREE = [[BLOAT, PLAN, GRID]];
 // Leo's case: notices in a row, each its own prompt; six threads in all.
@@ -196,10 +261,37 @@ export default agentPaneEntry({
   covers: [
     "agent-session/acpmux/conversation/InboxNoticeCard.tsx",
     "agent-session/acpmux/conversation/InboxNoticeCard.css",
+    "agent-session/acpmux/conversation/MessageGroupHead.tsx",
+    "agent-session/acpmux/conversation/MessageGroupHead.css",
+    "agent-session/acpmux/conversation/LaneNoticeBatch.tsx",
+    "agent-session/acpmux/conversation/PendingMessagesCard.tsx",
     "agent-session/acpmux/conversation/inboxNotice.ts",
     "agent-session/acpmux/conversation/incomingMessage.ts",
   ],
   variants: {
+    "icon-column": {
+      note: "Inbox rows among tool rows: one thread's line, a delivered group of one sender (its harness mark), one of several (the messages glyph), and the messages that wait (\"2 messages from 1 session\"). Every row's glyph sits in the tool rows' icon column, its words start where theirs do, and a group's head is a tool row, their height, gap and type, its chevron shown on hover. A sender no chat lists draws the neutral agent glyph.",
+      snapshot: amongTools(),
+    },
+    "icon-column-look-chevron": {
+      note: "Gallery version (theme inboxNoticeLook group-chevron): the group's chevron always shown.",
+      theme: { inboxNoticeLook: "group-chevron" },
+      snapshot: amongTools(),
+    },
+    "icon-column-look-count": {
+      note: "Gallery version (theme inboxNoticeLook group-count): the count alone; the senders in its tooltip.",
+      theme: { inboxNoticeLook: "group-count" },
+      snapshot: amongTools(),
+    },
+    "icon-column-open": {
+      note: "The same, the group of several opened: its threads' lines under it.",
+      snapshot: amongTools(),
+      play: async (ctx) => {
+        await ctx.waitFor(() => ctx.document.querySelectorAll(".cv-message-group__head").length >= 2);
+        ctx.document.querySelectorAll<HTMLButtonElement>(".cv-message-group__head")[1]?.click();
+        await ctx.waitFor(() => ctx.document.querySelector(".cv-lane-batch__body .cv-received"));
+      },
+    },
     "before-six": {
       note: "Before: three notices in a row, as acpmux wrote them and the pane drew them: each its text for the agent in the person's bubble.",
       snapshot: snapshot(SIX, true),
diff --git a/webviews/src/agent-session/acpmux/conversation/InboxNoticeCard.css b/webviews/src/agent-session/acpmux/conversation/InboxNoticeCard.css
index 534ff08794ef..768cb577f441 100644
--- a/webviews/src/agent-session/acpmux/conversation/InboxNoticeCard.css
+++ b/webviews/src/agent-session/acpmux/conversation/InboxNoticeCard.css
@@ -1,6 +1,6 @@
 /* acpmux's inbox notice (InboxNoticeCard.tsx): each thread a received line (conversation.css
    `.cv-received`), with the thread's label before the preview and "+N more" after it, muted, never cut; the group's head
-   is the waiting messages' (PendingMessagesCard.css). Colours, glass and type are the transcript's. */
+   is a tool row (below). Colours, glass and type are the transcript's. */
 .cv-inbox__label {
   flex: none;
   color: var(--cv-text-muted);
@@ -36,3 +36,12 @@
   border: 1px solid var(--cv-card-ring);
   border-radius: var(--ds-radius-card, 12px);
 }
+/* Two or more threads, folded (InboxNoticeCard.tsx, the `group` look): a tool-row head
+   (MessageGroupHead.css), and opened, the threads' lines start at the tool rows' words. */
+.cv-inbox--group {
+  margin: 0;
+  container-type: inline-size;
+}
+.cv-inbox__body {
+  margin-inline-start: var(--cv-tool-text-inset);
+}
diff --git a/webviews/src/agent-session/acpmux/conversation/InboxNoticeCard.tsx b/webviews/src/agent-session/acpmux/conversation/InboxNoticeCard.tsx
index 580985e2bd78..9222d872454a 100644
--- a/webviews/src/agent-session/acpmux/conversation/InboxNoticeCard.tsx
+++ b/webviews/src/agent-session/acpmux/conversation/InboxNoticeCard.tsx
@@ -8,31 +8,27 @@
 // (`_acpmux/inbox_thread`, through `chat.inbox.thread`) when the line first opens, without marking
 // them read (the person reading is not the agent). Nothing of the notice's text for the agent shows.
 // Two or more threads (a notice of several, or notices next to each other, mergeInboxNotices) draw
-// as one group in the look of the waiting messages' group (PendingMessagesCard.tsx): one line, "N
-// messages from M sessions" and the senders muted, that opens to the threads' lines; the versions
+// as one group: one line, "N messages from M sessions" and the senders muted, a sibling of the tool rows (the tool row's box, its
+// glyph the sender's mark in their icon column), that opens to the threads' lines; the versions
 // beside it are inboxNoticeLook.ts's. Whether a line or the group is open lasts while the page does
 // (incomingOpened.ts), and the row estimator (model.ts) reads it. Everything opens on the click,
 // with no fade in.
 import { useContext, useEffect, useId, useLayoutEffect, useMemo, useState, type ReactNode } from "react";
 import { useT } from "../i18n";
-import { Icon } from "../icons/Icon";
-import { rowIconSize } from "../icons/iconSize";
 import { DisclosureRow } from "../subagents/DisclosureRow";
 import { PromptMarksSession } from "../threadMinimap/promptMarks";
 import { mentionedRepository } from "../../../githubReferences";
 import { CardCopy } from "./CardCopy";
 import { FindReveal, foldFind } from "./chatFind";
 import { SenderName } from "./IncomingMessageCard";
+import { MessageGroupHead } from "./MessageGroupHead";
 import { messageOpened, setMessageOpened } from "./incomingOpened";
 import type { IncomingMessage } from "./incomingMessage";
 import { inboxCounts, inboxThreadKey, type InboxMessage, type InboxNotice, type InboxThread } from "./inboxNotice";
-import { useInboxNoticeLook } from "./inboxNoticeLook";
+import { foldsThreads, useInboxNoticeLook } from "./inboxNoticeLook";
 import { Markdown } from "./Markdown";
-import "./PendingMessagesCard.css";
 import "./InboxNoticeCard.css";
 
-const ROW_ICON = rowIconSize(12);
-
 /// Reads a thread's messages, oldest first (App.tsx `readInboxThread`, `chat.inbox.thread`).
 export type ReadInboxThread = (threadId: string) => Promise<InboxMessage[]>;
 
@@ -96,8 +92,14 @@ function InboxThreadLine({
   }, [open, own, fetched, readFor, readThread, thread]);
   const name = newestSender(thread);
   const sender = useMemo<IncomingMessage>(
-    () => ({ name, text: "", raw: "", ...(thread.fromSession && { sessionId: thread.fromSession }) }),
-    [name, thread.fromSession],
+    () => ({
+      name,
+      text: "",
+      raw: "",
+      ...(thread.fromSession && { sessionId: thread.fromSession }),
+      ...(thread.fromHarness && { harness: thread.fromHarness }),
+    }),
+    [name, thread.fromSession, thread.fromHarness],
   );
   const whole = messages?.map((m) => m.text).join("\n\n") ?? thread.preview;
   const repository = githubRepository ?? mentionedRepository(whole);
@@ -185,7 +187,7 @@ export function InboxNoticeCard({
     setOpen(next);
   };
   const bodyId = useId();
-  const grouped = notice.threads.length > 1 && look === "group";
+  const grouped = notice.threads.length > 1 && foldsThreads(look);
   // Find opens the group for a match in one of its threads; the thread's line opens itself.
   const reveal = useContext(FindReveal);
   const holdsMatch = grouped && Boolean(reveal && reveal.rowId === rowId);
@@ -216,27 +218,33 @@ export function InboxNoticeCard({
     senders.length === 1
       ? t("message.waitingFromOne", { n: messages })
       : t("message.waitingFrom", { n: messages, sessions: senders.length });
+  // One sender: its mark, from its newest thread (its session and bound harness); several: the
+  // messages glyph.
+  const lead = [...notice.threads].reverse().find((thread) => newestSender(thread) === senders[0]);
   return (
-    <div className="cv-pending cv-inbox" data-open={open || undefined}>
+    <div className="cv-inbox cv-inbox--group" data-look={look} data-open={open || undefined}>
       {/* Find counts the messages' words, not the head's names. */}
-      <div className="cv-pending__line" data-find-skip="">
-        <button
-          type="button"
-          className="cv-pending__toggle"
-          aria-expanded={open}
-          aria-controls={open ? bodyId : undefined}
-          title={senders.join(", ")}
-          onClick={() => show(!open)}
-        >
-          <span className="cv-pending__icon">
-            <Icon name={open ? "disclosure.expanded" : "disclosure.collapsed"} size={ROW_ICON} row />
-          </span>
-          <span className="cv-pending__count">{count}</span>
-          <span className="cv-pending__senders">{senders.join(", ")}</span>
-        </button>
-      </div>
+      <MessageGroupHead
+        sender={
+          senders.length === 1 && lead
+            ? {
+                name: senders[0]!,
+                text: "",
+                raw: "",
+                ...(lead.fromSession && { sessionId: lead.fromSession }),
+                ...(lead.fromHarness && { harness: lead.fromHarness }),
+              }
+            : undefined
+        }
+        count={count}
+        senders={senders.join(", ")}
+        open={open}
+        bodyId={bodyId}
+        onToggle={() => show(!open)}
+        className="cv-inbox__head"
+      />
       {open && (
-        <div id={bodyId} className="cv-pending__body">
+        <div id={bodyId} className="cv-inbox__body">
           {lines}
         </div>
       )}
diff --git a/webviews/src/agent-session/acpmux/conversation/IncomingMessageCard.tsx b/webviews/src/agent-session/acpmux/conversation/IncomingMessageCard.tsx
index 82dacf508ae4..f6977f8016a9 100644
--- a/webviews/src/agent-session/acpmux/conversation/IncomingMessageCard.tsx
+++ b/webviews/src/agent-session/acpmux/conversation/IncomingMessageCard.tsx
@@ -18,8 +18,8 @@
 // fuck do you even have this instead of just being able to click on the fucking name of the thing,
 // the open chat? ... Just click the left name thing."). The rest of the line opens the message.
 // The sender's mark is its harness's: the listed chat's, else the one the message names (a peer's
-// relayed message, `fromHarness`), else its name's (agentBrand), and a small bot only when none
-// says (Leo, 2026-10-29: "why are some of these icons still only placeholders?"). Reply, at the line's end,
+// relayed message, `fromHarness`), and a small bot when neither says, never a mark guessed from the
+// sender's name (a Codex lane called `claude-…` drew Claude's; cmux#30247). Reply, at the line's end,
 // answers in place: the answer goes to the sending chat in the message's thread
 // (AcpmuxDirectClient.reply), from an editor in the panel. An open reply and its draft last while
 // the page does; closing the message closes the reply and keeps the draft.
@@ -67,36 +67,24 @@ const RELATION_LABEL: Record<IncomingRelation, StringKey> = {
 /// A harness logo's size in the sender's glyph slot (see SenderName).
 const SENDER_LOGO_SIZE = 12;
 
-/// The sender's mark and name at a received line's start (and a waiting group's sender head,
-/// PendingMessagesCard.tsx): the name opens the sender's chat when there is one to open.
-export function SenderName({ message, onOpen }: { message: IncomingMessage; onOpen(sessionId: string): void }) {
-  const t = useT();
-  // A Chief's message names the Chief and draws its avatar (chiefFace.ts); its turn session is no
-  // chat of the list, so no listed chat with its name stands in for it, and it is no chat to open.
+/// The harness whose mark a sender draws: the listed chat's, else the one the message names (acpmux's
+/// bound `fromHarness`), the first of them with a mark today, else that harness id itself, so a
+/// profile icon that arrives later still replaces the fallback. Never one guessed from the sender's
+/// name: a Codex lane called `claude-…` drew Claude's mark (cmux#30247). With neither, undefined,
+/// and the line draws the neutral agent glyph.
+export function senderHarness(listed: string | undefined, named: string | undefined): string | undefined {
+  return knownMark(listed, named, listed ?? named);
+}
+
+/// The sender's mark alone (a received line's, an inbox group's): its avatar, a Chief's face, else
+/// its harness's mark, else the neutral agent glyph in its own stable tone.
+export function SenderMark({ message }: { message: IncomingMessage }) {
   const chief = useChiefFace(message.chief);
-  const name = (message.chief && chief?.name) || message.name;
   const sender = useSenderChat(message.chief ? "" : message.name, message.sessionId);
-  // Read only (a guest): the sender's chat is not this reader's to open.
-  const readOnly = useTranscriptReadOnly();
-  const sessionId = message.chief || readOnly ? undefined : sender.sessionId;
   const avatar = useAgentAvatar(sender.sessionId);
-  const notice = laneNotice(message);
-  const inboxNames =
-    notice?.kind === "inbox"
-      ? [...new Set((notice.threads ?? []).map(({ sender }) => sender).filter(Boolean))].join(", ")
-      : "";
-  const from = inboxNames || (message.relation ? t(RELATION_LABEL[message.relation], { name }) : name);
-  // The first candidate with a mark today; with none, the sender's own harness id, so a profile icon
-  // that arrives later still replaces the fallback (AgentIdentity stays subscribed to that id).
-  const harness = knownMark(
-    sender.harness,
-    message.harness,
-    message.name,
-    message.name.split("/")[0],
-    sender.harness ?? message.harness,
-  );
+  const harness = senderHarness(sender.harness, message.harness);
   const picture = message.chief ? chief?.src : avatar;
-  const icon = picture ? (
+  return picture ? (
     <img className="cv-agent-avatar" src={picture} alt="" width={16} height={16} />
   ) : message.chief && chief?.text ? (
     <span className="cv-chief-text-avatar" aria-hidden="true">
@@ -114,6 +102,27 @@ export function SenderName({ message, onOpen }: { message: IncomingMessage; onOp
       fallbackNode={<Bot size={16} />}
     />
   );
+}
+
+/// The sender's mark and name at a received line's start (and a waiting group's sender head,
+/// PendingMessagesCard.tsx): the name opens the sender's chat when there is one to open.
+export function SenderName({ message, onOpen }: { message: IncomingMessage; onOpen(sessionId: string): void }) {
+  const t = useT();
+  // A Chief's message names the Chief and draws its avatar (chiefFace.ts); its turn session is no
+  // chat of the list, so no listed chat with its name stands in for it, and it is no chat to open.
+  const chief = useChiefFace(message.chief);
+  const name = (message.chief && chief?.name) || message.name;
+  const sender = useSenderChat(message.chief ? "" : message.name, message.sessionId);
+  // Read only (a guest): the sender's chat is not this reader's to open.
+  const readOnly = useTranscriptReadOnly();
+  const sessionId = message.chief || readOnly ? undefined : sender.sessionId;
+  const notice = laneNotice(message);
+  const inboxNames =
+    notice?.kind === "inbox"
+      ? [...new Set((notice.threads ?? []).map(({ sender }) => sender).filter(Boolean))].join(", ")
+      : "";
+  const from = inboxNames || (message.relation ? t(RELATION_LABEL[message.relation], { name }) : name);
+  const icon = <SenderMark message={message} />;
   // "Open chief-ui (huge-blue)": the chat the name opens, and the other machine it runs on.
   const openTitle = sender.host
     ? t("subagents.openOnHost", { name, host: sender.host })
diff --git a/webviews/src/agent-session/acpmux/conversation/LaneNoticeBatch.css b/webviews/src/agent-session/acpmux/conversation/LaneNoticeBatch.css
index 1c9f8357633d..3653fb853bd0 100644
--- a/webviews/src/agent-session/acpmux/conversation/LaneNoticeBatch.css
+++ b/webviews/src/agent-session/acpmux/conversation/LaneNoticeBatch.css
@@ -6,6 +6,10 @@
   font: inherit;
   color: var(--cv-text);
 }
+/* An inbox batch's head is a tool row (MessageGroupHead.css); the batch is its narrow-pane container. */
+.cv-lane-batch[data-kind="inbox"] {
+  container-type: inline-size;
+}
 .cv-lane-batch__toggle {
   display: flex;
   box-sizing: border-box;
diff --git a/webviews/src/agent-session/acpmux/conversation/LaneNoticeBatch.tsx b/webviews/src/agent-session/acpmux/conversation/LaneNoticeBatch.tsx
index d12eff98f6ea..2694706542e6 100644
--- a/webviews/src/agent-session/acpmux/conversation/LaneNoticeBatch.tsx
+++ b/webviews/src/agent-session/acpmux/conversation/LaneNoticeBatch.tsx
@@ -2,6 +2,7 @@ import { useContext, useId, useLayoutEffect, useState, type ReactNode } from "re
 import type { AcpmuxRow } from "../model";
 import { useT } from "../i18n";
 import { TranscriptActivityRow } from "./TranscriptActivityRow";
+import { groupSender, MessageGroupHead } from "./MessageGroupHead";
 import { Icon } from "../icons/Icon";
 import { PromptMarksSession } from "../threadMinimap/promptMarks";
 import { FindReveal } from "./chatFind";
@@ -43,22 +44,37 @@ export function LaneNoticeBatch({ row, renderMessage }: { row: AcpmuxRow; render
       : t("message.inboxThreads", { n: batch.threads.length || batch.rows.length });
   const detail = batch.kind === "report" ? verdicts : names && t("message.inboxFrom", { names });
   return (
-    <div className="cv-lane-batch" data-open={open || undefined}>
-      <TranscriptActivityRow
-        icon={<Icon name={open ? "disclosure.expanded" : "disclosure.collapsed"} size={12} row />}
-        before={count}
-        name={batch.kind === "inbox" && names ? names : undefined}
-        after={batch.kind === "report" && detail ? ` · ${detail}` : undefined}
-        className="cv-lane-batch__toggle"
-        ariaLabel={[count, detail].filter(Boolean).join(". ")}
-        expanded={open}
-        attributes={{
-          "aria-expanded": String(open),
-          "aria-controls": open ? bodyId : undefined,
-          "data-find-skip": "",
-        }}
-        onClick={() => show(!open)}
-      />
+    <div className="cv-lane-batch" data-kind={batch.kind} data-open={open || undefined}>
+      {batch.kind === "inbox" ? (
+        // Delivered messages from other sessions: a sibling of the tool rows (MessageGroupHead.tsx).
+        <MessageGroupHead
+          sender={groupSender(
+            batch.rows.map((member) => (member.incoming?.kind === "message" ? member.incoming.message : undefined)),
+          )}
+          count={count}
+          senders={names}
+          open={open}
+          bodyId={bodyId}
+          onToggle={() => show(!open)}
+          className="cv-lane-batch__toggle"
+          ariaLabel={[count, detail].filter(Boolean).join(". ")}
+        />
+      ) : (
+        <TranscriptActivityRow
+          icon={<Icon name={open ? "disclosure.expanded" : "disclosure.collapsed"} size={12} row />}
+          before={count}
+          after={batch.kind === "report" && detail ? ` · ${detail}` : undefined}
+          className="cv-lane-batch__toggle"
+          ariaLabel={[count, detail].filter(Boolean).join(". ")}
+          expanded={open}
+          attributes={{
+            "aria-expanded": String(open),
+            "aria-controls": open ? bodyId : undefined,
+            "data-find-skip": "",
+          }}
+          onClick={() => show(!open)}
+        />
+      )}
       {open && (
         <div className="cv-lane-batch__body" id={bodyId}>
           {batch.rows.map((member) => (
diff --git a/webviews/src/agent-session/acpmux/conversation/MessageGroupHead.css b/webviews/src/agent-session/acpmux/conversation/MessageGroupHead.css
new file mode 100644
index 000000000000..9a96874377d0
--- /dev/null
+++ b/webviews/src/agent-session/acpmux/conversation/MessageGroupHead.css
@@ -0,0 +1,81 @@
+/* A folded group of messages (MessageGroupHead.tsx): a sibling of the tool rows (Leo, 2026-11-01:
+   "let's just make this look better"). The head is a tool row (conversation.css .cv-tool: its 22px
+   height, gap and type, its glyph in the one icon column): the sender's harness mark (several
+   senders: the messages glyph), the count as the summary, the senders muted and cut after it, then
+   the chevron, shown and lit only while the row is hovered, focused or open, as an opened group's
+   steps do. Never a bordered box; the group opens on the click, with no fade.
+   design/chat-transcript.md "One icon column". */
+.cv-message-group__head {
+  cursor: default;
+  user-select: none;
+  font-family: var(--cv-font);
+  font-size: var(--cv-font-size);
+  letter-spacing: var(--cv-tracking, 0.045px);
+  -webkit-font-smoothing: antialiased;
+}
+.cv-message-group__head > .cv-tool__icon {
+  color: var(--cv-text-muted);
+}
+.cv-message-group__head > .cv-tool__text {
+  display: flex;
+  align-items: baseline;
+  gap: var(--ds-space-2);
+  min-width: 0;
+}
+.cv-message-group__count {
+  flex: none;
+}
+.cv-message-group__senders {
+  flex: 0 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--cv-text-dim);
+}
+.cv-message-group__head > .cv-tool__chevron {
+  opacity: 0;
+  transition: opacity var(--cv-actions-out) var(--cv-actions-ease);
+}
+.cv-message-group__head:hover,
+.cv-message-group__head:has([data-popup-open]),
+.cv-message-group__head:is(:focus-visible, [aria-expanded="true"]),
+.cv-message-group__head:hover > :is(.cv-tool__icon, .cv-tool__chevron),
+.cv-message-group__head:has([data-popup-open]) > :is(.cv-tool__icon, .cv-tool__chevron),
+.cv-message-group__head:is(:focus-visible, [aria-expanded="true"]) > :is(.cv-tool__icon, .cv-tool__chevron) {
+  color: var(--cv-text);
+}
+.cv-message-group__head:hover > .cv-tool__chevron,
+.cv-message-group__head:has([data-popup-open]) > .cv-tool__chevron,
+.cv-message-group__head:is(:focus-visible, [aria-expanded="true"]) > .cv-tool__chevron {
+  opacity: 1;
+  transition: opacity var(--cv-actions-in) var(--cv-actions-ease) var(--cv-actions-in-delay);
+}
+/* A delivered batch's head keeps LaneNoticeBatch.css's toggle class (its tests and plays find it
+   by it), but not that toggle's inset or hover plate: a tool row's glyph starts at the row's edge,
+   and it lights its words, never a plate behind them. */
+.cv-message-group__head.cv-lane-batch__toggle {
+  padding-inline: 0;
+}
+.cv-message-group__head.cv-lane-batch__toggle:hover {
+  background: none;
+}
+.cv-message-group__head:focus-visible {
+  outline: none;
+  border-radius: 6px;
+  background: color-mix(in srgb, var(--cv-text) 6%, transparent);
+}
+/* Gallery versions (inboxNoticeLook.ts): the chevron always shown; the count alone. */
+.cv-message-group__head[data-look="group-chevron"] > .cv-tool__chevron {
+  opacity: 1;
+}
+.cv-message-group__head[data-look="group-count"] .cv-message-group__senders {
+  display: none;
+}
+/* A narrow pane keeps the count whole: the names, cut to a letter or two, would say nothing. Each
+   group's wrapper is the container. */
+@container (max-width: 480px) {
+  .cv-message-group__senders {
+    display: none;
+  }
+}
diff --git a/webviews/src/agent-session/acpmux/conversation/MessageGroupHead.tsx b/webviews/src/agent-session/acpmux/conversation/MessageGroupHead.tsx
new file mode 100644
index 000000000000..b85b11ec09b6
--- /dev/null
+++ b/webviews/src/agent-session/acpmux/conversation/MessageGroupHead.tsx
@@ -0,0 +1,79 @@
+// The head of a folded group of messages from other sessions: the waiting group
+// (PendingMessagesCard.tsx), a delivered inbox batch (LaneNoticeBatch.tsx) and an inbox notice of
+// several threads (InboxNoticeCard.tsx). It is a sibling of the tool rows (Leo, 2026-11-01, on the
+// old head, a bare chevron on a taller line: "let's just make this look better"): a tool row
+// (conversation.css .cv-tool), its 22px height, gap and type, its glyph in the one icon column (the
+// sender's harness mark, or the messages glyph when several sessions sent), the count as the
+// summary, the senders muted and cut after it, then the chevron, shown and lit only while the row is
+// hovered, focused or open. design/chat-transcript.md "One icon column".
+import { Icon } from "../icons/Icon";
+import { rowIconSize } from "../icons/iconSize";
+import { ChevronRight } from "./icons";
+import { SenderMark } from "./IncomingMessageCard";
+import type { IncomingMessage } from "./incomingMessage";
+import { useInboxNoticeLook } from "./inboxNoticeLook";
+import "./MessageGroupHead.css";
+
+const ROW_ICON = rowIconSize(12);
+
+/// The one sender of a group's messages, the one that best names its session and harness, or
+/// nothing when two or more sessions sent (the head then draws the messages glyph).
+export function groupSender(messages: readonly (IncomingMessage | undefined)[]): IncomingMessage | undefined {
+  const known = messages.filter((message): message is IncomingMessage => Boolean(message));
+  if (new Set(known.map((message) => message.name)).size !== 1) return undefined;
+  return (
+    [...known].reverse().find((message) => message.harness) ??
+    [...known].reverse().find((message) => message.sessionId) ??
+    known.at(-1)
+  );
+}
+
+export function MessageGroupHead({
+  sender,
+  count,
+  senders,
+  open,
+  bodyId,
+  onToggle,
+  className,
+  iconClassName,
+  ariaLabel,
+}: {
+  /// The group's one sender; none when several sessions sent.
+  sender?: IncomingMessage;
+  count: string;
+  /// The senders' names, joined; muted after the count.
+  senders?: string;
+  open: boolean;
+  bodyId: string;
+  onToggle(): void;
+  className?: string;
+  iconClassName?: string;
+  ariaLabel?: string;
+}) {
+  const look = useInboxNoticeLook();
+  return (
+    <button
+      type="button"
+      className={`cv-tool cv-message-group__head${className ? ` ${className}` : ""}`}
+      data-look={look}
+      data-find-skip=""
+      aria-expanded={open}
+      aria-controls={open ? bodyId : undefined}
+      aria-label={ariaLabel}
+      title={senders || undefined}
+      onClick={onToggle}
+    >
+      <span className={`cv-tool__icon${iconClassName ? ` ${iconClassName}` : ""}`} aria-hidden="true">
+        {sender ? <SenderMark message={sender} /> : <Icon name="agent.chat" size={ROW_ICON} row />}
+      </span>
+      <span className="cv-tool__text">
+        <span className="cv-message-group__count">{count}</span>
+        {senders && <span className="cv-message-group__senders">{senders}</span>}
+      </span>
+      <span className="cv-tool__chevron" aria-hidden="true">
+        <ChevronRight size={12} strokeWidth={1.4} className={`cv-rotor${open ? " is-open" : ""}`} />
+      </span>
+    </button>
+  );
+}
diff --git a/webviews/src/agent-session/acpmux/conversation/PendingMessagesCard.css b/webviews/src/agent-session/acpmux/conversation/PendingMessagesCard.css
index 0073c9ec4c32..9f5b1eb078fb 100644
--- a/webviews/src/agent-session/acpmux/conversation/PendingMessagesCard.css
+++ b/webviews/src/agent-session/acpmux/conversation/PendingMessagesCard.css
@@ -1,6 +1,6 @@
 /* The messages that wait for the agent, as one group (PendingMessagesCard.tsx): its head is one
-   line on the tool rows' line, no margins of its own (its row's frame gives the room; model.ts
-   estimates that): the chevron in the icon column, the count, the
+   tool row on the tool rows' line (MessageGroupHead.css), no margins of its own (its row's frame
+   gives the room; model.ts estimates that): the sender's mark in the icon column, the count, the
    senders muted and cut to the line (none in a narrow pane). Open, each sender's 22px head (its
    mark and name, which opens its chat, and how many it sent), then its messages, each its own
    received line; a line in the group leaves out the sender the head names. Never an opaque or
@@ -16,57 +16,9 @@
 .cv-pending__line {
   display: flex;
   align-items: center;
-  height: var(--cv-message-line);
   min-width: 0;
   container-type: inline-size;
   white-space: nowrap;
-  user-select: none;
-}
-.cv-pending__toggle {
-  all: unset;
-  display: flex;
-  align-items: center;
-  flex: 0 1 auto;
-  min-width: 0;
-  height: var(--cv-message-line);
-  box-sizing: border-box;
-  /* The words start where every iconed row's do (conversation.css `--cv-row-icon-gap`). */
-  gap: var(--cv-row-icon-gap);
-  /* The trailing room keeps the count clear of the plate's edge; none before the chevron, which
-     sits in the tool rows' glyph slot at the row's left edge (design/chat-transcript.md "One icon
-     column"). */
-  padding: 0 var(--ds-space-1) 0 0;
-  border-radius: 6px;
-  cursor: default;
-}
-.cv-pending__toggle:hover,
-.cv-pending__toggle:focus-visible {
-  background: color-mix(in srgb, var(--cv-text) 6%, transparent);
-}
-.cv-pending__icon {
-  display: flex;
-  flex: none;
-  align-items: center;
-  justify-content: center;
-  width: var(--cv-glyph-slot);
-  color: var(--cv-text-muted);
-}
-.cv-pending__count {
-  flex: none;
-  color: var(--cv-text);
-}
-.cv-pending__senders {
-  flex: 0 1 auto;
-  min-width: 0;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  color: var(--cv-text-dim);
-}
-/* A narrow pane keeps the count whole: the names, cut to a letter or two, would say nothing. */
-@container (max-width: 480px) {
-  .cv-pending__senders {
-    display: none;
-  }
 }
 .cv-pending__body {
   margin-inline-start: 24px;
diff --git a/webviews/src/agent-session/acpmux/conversation/PendingMessagesCard.tsx b/webviews/src/agent-session/acpmux/conversation/PendingMessagesCard.tsx
index c728c8c3aace..475e162a369a 100644
--- a/webviews/src/agent-session/acpmux/conversation/PendingMessagesCard.tsx
+++ b/webviews/src/agent-session/acpmux/conversation/PendingMessagesCard.tsx
@@ -1,6 +1,7 @@
 // The messages other sessions sent that the agent has not read yet, as one collapsed group at the
-// transcript's end (pendingMessages.ts). Closed, it is one line: a chevron, how many messages from
-// how many sessions, and the senders, muted and cut to the line. Opened, its messages sit under it
+// transcript's end (pendingMessages.ts). Closed, it is one tool row (MessageGroupHead.tsx): the
+// sender's harness mark (several sessions: the messages glyph), how many messages from how many
+// sessions, the senders muted and cut to the line, and the chevron on hover. Opened, its messages sit under it
 // grouped by sender: the sender's mark and name (a click opens its chat), then each of its messages
 // as its own received line, whole when opened, with its actions. Whether the group is open lasts
 // while the page does (incomingOpened.ts), so it survives the virtualized list and new arrivals,
@@ -11,15 +12,12 @@ import { useT } from "../i18n";
 import type { AcpmuxRow } from "../model";
 import { PromptMarksSession } from "../threadMinimap/promptMarks";
 import { FindReveal } from "./chatFind";
-import { Icon } from "../icons/Icon";
-import { rowIconSize } from "../icons/iconSize";
 import { messageOpened, setMessageOpened } from "./incomingOpened";
 import { bySender } from "./pendingMessages";
 import { SenderName } from "./IncomingMessageCard";
+import { groupSender, MessageGroupHead } from "./MessageGroupHead";
 import "./PendingMessagesCard.css";
 
-const ROW_ICON = rowIconSize(12);
-
 export function PendingMessagesCard({
   row,
   onOpen,
@@ -72,20 +70,21 @@ export function PendingMessagesCard({
     <div className="cv-pending" data-open={open || undefined}>
       {/* Find counts the messages' words, not the head's names. */}
       <div className="cv-pending__line" data-find-skip="">
-        <button
-          type="button"
+        <MessageGroupHead
+          sender={groupSender(
+            countSources.map((group) => {
+              const first = group.rows.at(-1);
+              return first?.incoming?.kind === "message" ? first.incoming.message : undefined;
+            }),
+          )}
+          count={count}
+          senders={names.join(", ")}
+          open={open}
+          bodyId={bodyId}
+          onToggle={() => show(!open)}
           className="cv-pending__toggle"
-          aria-expanded={open}
-          aria-controls={open ? bodyId : undefined}
-          title={names.join(", ")}
-          onClick={() => show(!open)}
-        >
-          <span className="cv-pending__icon">
-            <Icon name={open ? "disclosure.expanded" : "disclosure.collapsed"} size={ROW_ICON} row />
-          </span>
-          <span className="cv-pending__count">{count}</span>
-          <span className="cv-pending__senders">{names.join(", ")}</span>
-        </button>
+          iconClassName="cv-pending__icon"
+        />
       </div>
       {open && (
         <div id={bodyId} className="cv-pending__body">
diff --git a/webviews/src/agent-session/acpmux/conversation/inboxNotice.ts b/webviews/src/agent-session/acpmux/conversation/inboxNotice.ts
index 9f6a468a6cea..f56316ac7755 100644
--- a/webviews/src/agent-session/acpmux/conversation/inboxNotice.ts
+++ b/webviews/src/agent-session/acpmux/conversation/inboxNotice.ts
@@ -22,6 +22,9 @@ export type InboxThread = {
   from: string[];
   /// The newest message's sender's session, when it is a chat here.
   fromSession?: string;
+  /// The newest message's sender's harness family (`claude`, `codex`, ...), when acpmux bound it
+  /// (prompt_provenance.rs `fromHarness`; cmux#30247): its line draws that harness's mark.
+  fromHarness?: string;
   /// The new messages the notice brought.
   count: number;
   /// The newest one's first line.
@@ -102,6 +105,7 @@ export function inboxNotice(notice: string, provenance: Record<string, unknown>)
       label: shownLabel(text(p.label), threadId),
       from: strings(p.from),
       ...(text(p.fromSession) && { fromSession: text(p.fromSession) }),
+      ...(text(p.fromHarness) && { fromHarness: text(p.fromHarness) }),
       count,
       preview: text(p.preview).trim() || previewFromText(notice, threadId) || firstLine(newest ?? ""),
       blocker: p.blocker === true || previewLineBlocks(notice, threadId),
diff --git a/webviews/src/agent-session/acpmux/conversation/inboxNoticeLook.ts b/webviews/src/agent-session/acpmux/conversation/inboxNoticeLook.ts
index 603919a11335..35f5e6284585 100644
--- a/webviews/src/agent-session/acpmux/conversation/inboxNoticeLook.ts
+++ b/webviews/src/agent-session/acpmux/conversation/inboxNoticeLook.ts
@@ -1,14 +1,19 @@
 import { useSyncExternalStore } from "react";
 
 /// How an inbox notice of two or more threads draws (InboxNoticeCard.tsx). `group`, the default: one
-/// line, "N messages from M sessions" and the senders, that opens to a received line per thread, as
-/// the waiting messages' group draws (PendingMessagesCard.tsx). The others are gallery versions kept
-/// beside it (InboxNotice.gallery.ts): `lines`, a received line per thread with no head; `card`, the
-/// threads' lines always shown in one quiet bordered card. A notice of one thread is its line alone
+/// tool row, the sender's mark, "N messages from M sessions" and the senders muted, its chevron shown
+/// on hover, that opens to a received line per thread. The others are gallery versions kept beside
+/// it (InboxNotice.gallery.ts): `group-chevron`, the same row with its chevron always shown;
+/// `group-count`, the same row with the count alone (the senders in its tooltip); `lines`, a
+/// received line per thread with no head; `card`, the threads' lines always shown in one quiet
+/// bordered card. A notice of one thread is its line alone
 /// in every look. The native host sends no value, so the default holds there.
-export type InboxNoticeLook = "group" | "lines" | "card";
+export type InboxNoticeLook = "group" | "group-chevron" | "group-count" | "lines" | "card";
 
-const LOOKS: readonly InboxNoticeLook[] = ["group", "lines", "card"];
+const LOOKS: readonly InboxNoticeLook[] = ["group", "group-chevron", "group-count", "lines", "card"];
+
+/// Whether a look folds the threads under one head row.
+export const foldsThreads = (look: InboxNoticeLook): boolean => look.startsWith("group");
 let current: InboxNoticeLook = "group";
 const listeners = new Set<() => void>();
 
diff --git a/webviews/src/agent-session/acpmux/conversation/laneNoticeBatches.ts b/webviews/src/agent-session/acpmux/conversation/laneNoticeBatches.ts
index 36db0a1e6c86..425e100b5617 100644
--- a/webviews/src/agent-session/acpmux/conversation/laneNoticeBatches.ts
+++ b/webviews/src/agent-session/acpmux/conversation/laneNoticeBatches.ts
@@ -24,6 +24,7 @@ const inboxLaneNotice = (notice: InboxNotice): LaneNotice => {
       ...(thread.label ? { label: thread.label } : {}),
       ...(thread.promptIds.length ? { promptIds: thread.promptIds } : {}),
       ...(thread.fromSession ? { fromSession: thread.fromSession } : {}),
+      ...(thread.fromHarness ? { fromHarness: thread.fromHarness } : {}),
       count: thread.count,
     };
   });
@@ -140,6 +141,7 @@ function inboxChildren(row: AcpmuxRow, notice: LaneNotice): readonly AcpmuxRow[]
                 count: thread.count ?? 1,
                 promptIds: thread.promptIds ?? [],
                 ...(thread.fromSession ? { fromSession: thread.fromSession } : {}),
+                ...(thread.fromHarness ? { fromHarness: thread.fromHarness } : {}),
               },
             }
           : {}),
@@ -152,6 +154,7 @@ function inboxChildren(row: AcpmuxRow, notice: LaneNotice): readonly AcpmuxRow[]
             threadId: thread.id,
             ...(delivery.promptId ? { msgId: delivery.promptId } : {}),
             ...(thread.fromSession && delivery.sender === thread.sender ? { sessionId: thread.fromSession } : {}),
+            ...(thread.fromHarness && delivery.sender === thread.sender ? { harness: thread.fromHarness } : {}),
           },
         },
       });
diff --git a/webviews/src/agent-session/acpmux/conversation/laneReport.ts b/webviews/src/agent-session/acpmux/conversation/laneReport.ts
index de3a7fb64fd5..e9ec37f53bdc 100644
--- a/webviews/src/agent-session/acpmux/conversation/laneReport.ts
+++ b/webviews/src/agent-session/acpmux/conversation/laneReport.ts
@@ -22,6 +22,7 @@ export type LaneNoticeThread = {
   readonly label?: string;
   readonly promptIds?: readonly string[];
   readonly fromSession?: string;
+  readonly fromHarness?: string;
   readonly count?: number;
 };
 
diff --git a/webviews/src/agent-session/acpmux/model.ts b/webviews/src/agent-session/acpmux/model.ts
index 11ea8f5a4efc..864b704bfa24 100644
--- a/webviews/src/agent-session/acpmux/model.ts
+++ b/webviews/src/agent-session/acpmux/model.ts
@@ -458,6 +458,7 @@ export type AcpmuxRow = {
     count: number;
     promptIds: readonly string[];
     fromSession?: string;
+    fromHarness?: string;
   };
   laneNoticeBatch?: {
     kind: "report" | "inbox";
@@ -1785,11 +1786,13 @@ function measuredRowHeight(
     // an opened message does, its text read from the notice (else its preview).
     const { threads } = row.incoming.notice;
     const line = TOOL_ROW_HEIGHT;
-    const grouped = threads.length > 1 && inboxNoticeLook() === "group";
-    if (grouped && !messageOpened(sessionId, row.id)) return finish(line + LINE_FRAME);
+    // The group's head is a tool row (MessageGroupHead.tsx) on the one-line rows' line.
+    const head = TOOL_ROW_HEIGHT;
+    const grouped = threads.length > 1 && foldsThreads(inboxNoticeLook());
+    if (grouped && !messageOpened(sessionId, row.id)) return finish(head + LINE_FRAME);
     const { lineHeight } = metrics();
     if (receivedPrepared.size > 256) receivedPrepared.clear();
-    let height = (grouped ? line : 0) + (threads.length > 1 && inboxNoticeLook() === "card" ? 6 : 0);
+    let height = (grouped ? head : 0) + (threads.length > 1 && inboxNoticeLook() === "card" ? 6 : 0);
     for (const thread of threads) {
       height += line;
       if (!messageOpened(sessionId, inboxThreadKey(row.id, thread.threadId))) continue;
@@ -2092,7 +2095,7 @@ import { chatColumn, type ChatColumn } from "./chatWidth";
 import { currentChatMetrics } from "./chatDisplay";
 import { messageOpened } from "./conversation/incomingOpened";
 import { inboxThreadKey } from "./conversation/inboxNotice";
-import { inboxNoticeLook } from "./conversation/inboxNoticeLook";
+import { foldsThreads, inboxNoticeLook } from "./conversation/inboxNoticeLook";
 import { isDiagram, isUnlabeledLang } from "./conversation/codeShape";
 
 /// The pane's fallback accessible name and problem-only header status. A handshake that is
diff --git a/webviews/test/inbox-row-icon-column.test.ts b/webviews/test/inbox-row-icon-column.test.ts
new file mode 100644
index 000000000000..a2bb37c426f5
--- /dev/null
+++ b/webviews/test/inbox-row-icon-column.test.ts
@@ -0,0 +1,221 @@
+// Inbox rows among tool rows share the tool rows' icon column (Leo, 2026-11-01, on an inbox line
+// whose glyph sat right of the tool rows': "i wanted this to be left aligned with the other tool
+// calls"), and a folded group of threads is a sibling of the tool rows (Leo, 2026-11-01, on its
+// bare chevron indented past that column on a taller line: "let's just make this look better").
+// Measured in the page, never from each row's own box, so a row-level inset counts: every inbox
+// line's glyph center and first word's x equal a tool row's; a group's head also has a tool row's
+// height, icon-to-word gap and type size; its chevron is hidden at rest and shown on hover.
+// design/chat-transcript.md "One icon column".
+//
+// CMUX_INBOX_ROW_ARTIFACT_DIR=DIR also writes each theme's 2x still and measurements to DIR.
+import { afterAll, beforeAll, describe, expect, setDefaultTimeout, test } from "bun:test";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { chromium, type Browser, type Page } from "playwright";
+import { galleryFrame, warmGalleryFrame } from "./support/galleryFrame";
+import { requireBrowserLane } from "./support/requireBrowserLane";
+
+await requireBrowserLane("inbox-row-icon-column.test.ts", async () => {
+  setDefaultTimeout(240_000);
+  const ENTRY = "agent-pane.inbox-notice";
+  const VARIANT = "icon-column";
+  const THEMES = [
+    { name: "Apple System Colors Light", file: "light" },
+    { name: "Catppuccin Mocha", file: "dark" },
+  ];
+  /** How far apart two edges or centers may be, in CSS px. */
+  const TOLERANCE = 0.5;
+
+  try {
+    await (await chromium.launch({ headless: true })).close();
+  } catch {
+    describe.skip("inbox row icon column", () => test("browser", () => {}));
+    return;
+  }
+  const { createServer } = await import("vite");
+  const webviews = path.resolve(import.meta.dir, "..");
+  let vite: Awaited<ReturnType<typeof createServer>> | undefined;
+  let browser: Browser;
+
+  beforeAll(async () => {
+    vite = await createServer({
+      configFile: path.join(webviews, "vite.config.gallery-dev.ts"),
+      server: { port: 0, host: "127.0.0.1", strictPort: false },
+      logLevel: "error",
+    });
+    await vite.listen();
+    browser = await chromium.launch({ headless: true });
+    await warmGalleryFrame(vite, ENTRY, { browser, params: { variant: VARIANT } });
+  });
+  afterAll(async () => {
+    await browser?.close();
+    await vite?.close();
+  });
+
+  type Row = {
+    kind: "tool" | "line" | "group";
+    label: string;
+    glyphCenter: number;
+    textLeft: number;
+    /** From the icon slot's right edge to the first word. */
+    gap: number;
+    height: number;
+    fontSize: number;
+  };
+
+  /** Every top-level tool row, inbox line and inbox group head, in page px. */
+  const measure = (page: Page): Promise<Row[]> =>
+    page.evaluate(() => {
+      const visible = (element: Element) => {
+        const box = element.getBoundingClientRect();
+        return box.width > 0 && box.height > 0 && getComputedStyle(element).visibility !== "hidden";
+      };
+      // A group's head (MessageGroupHead.tsx; before it, the waiting group's and the delivered batch's
+      // chevron lines).
+      const GROUP = ".cv-message-group__head, .cv-pending__line, .cv-lane-batch__toggle";
+      const LINE = ".cv-received > .cv-disclosure__line";
+      const TOOL = ".cv-tools .cv-tool";
+      const rows = [...document.querySelectorAll<HTMLElement>(`${TOOL}, ${LINE}, ${GROUP}`)].filter(
+        (row) =>
+          visible(row) &&
+          // Top level only: not a step of an opened tool group or a line inside an opened inbox group.
+          !row.closest(".cv-steps, .cv-inbox__body, .cv-pending__body, .cv-lane-batch__body, .cv-disclosure__panel") &&
+          !(row.matches(TOOL) && !row.matches(GROUP) && row.closest(".cv-inbox")) &&
+          // A head inside a waiting group's line is that group's row; measure the head.
+          !(row.matches(".cv-pending__line") && row.querySelector(".cv-message-group__head")),
+      );
+      return rows.map((row) => {
+        const kind = row.matches(GROUP) ? "group" : row.matches(LINE) ? "line" : "tool";
+        const slot = row.querySelector<HTMLElement>(":scope > .cv-tool__icon, .cv-received__mark, .cv-pending__icon");
+        if (!slot) throw new Error(`a row with no icon slot: ${row.className}`);
+        const glyph =
+          [...slot.querySelectorAll<Element>("svg, img")].find(visible) ??
+          [...slot.querySelectorAll<Element>("span")].find(visible) ??
+          slot;
+        const glyphBox = glyph.getBoundingClientRect();
+        const walker = document.createTreeWalker(row, NodeFilter.SHOW_TEXT);
+        let textLeft = Number.NaN;
+        let fontSize = Number.NaN;
+        for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+          if (slot.contains(node) || !node.textContent?.trim()) continue;
+          const range = document.createRange();
+          range.selectNodeContents(node);
+          const first = [...range.getClientRects()].find((rect) => rect.width > 0);
+          if (!first) continue;
+          textLeft = first.left;
+          fontSize = Number.parseFloat(getComputedStyle(node.parentElement!).fontSize);
+          break;
+        }
+        return {
+          kind,
+          label: row.textContent?.trim().slice(0, 40) ?? "",
+          glyphCenter: (glyphBox.left + glyphBox.right) / 2,
+          textLeft,
+          gap: textLeft - slot.getBoundingClientRect().right,
+          height: row.getBoundingClientRect().height,
+          fontSize,
+        };
+      });
+    });
+
+  const px = (value: number) => `${Math.round(value * 100) / 100}px`;
+  const near = (a: number, b: number) => Math.abs(a - b) <= TOLERANCE;
+
+  /** What breaks the shared column, as sentences; empty when every inbox row keeps it. */
+  const problems = (rows: Row[]) => {
+    const found: string[] = [];
+    const tool = rows.find((row) => row.kind === "tool");
+    if (!tool) return ["no tool row drew"];
+    for (const row of rows) {
+      if (row.kind === "tool") continue;
+      const name = `the inbox ${row.kind} "${row.label}"`;
+      if (!near(row.glyphCenter, tool.glyphCenter))
+        found.push(`${name}'s glyph centers at x ${px(row.glyphCenter)}, the tool row's at ${px(tool.glyphCenter)}`);
+      if (!near(row.textLeft, tool.textLeft))
+        found.push(`${name}'s title starts at x ${px(row.textLeft)}, the tool row's at ${px(tool.textLeft)}`);
+      if (row.kind !== "group") continue;
+      if (!near(row.height, tool.height))
+        found.push(`${name} is ${px(row.height)} tall, the tool row ${px(tool.height)}`);
+      if (!near(row.gap, tool.gap))
+        found.push(`${name}'s words start ${px(row.gap)} after its icon slot, the tool row's ${px(tool.gap)}`);
+      if (!near(row.fontSize, tool.fontSize))
+        found.push(`${name}'s type is ${px(row.fontSize)}, the tool row's ${px(tool.fontSize)}`);
+    }
+    return found;
+  };
+
+  for (const theme of THEMES)
+    test(`inbox lines and groups share the tool rows' icon column, and a group is a tool row (${theme.name})`, async () => {
+      const artifacts = process.env.CMUX_INBOX_ROW_ARTIFACT_DIR;
+      const page = await browser.newPage({ viewport: { width: 760, height: 620 }, deviceScaleFactor: 2 });
+      try {
+        const port = (vite!.httpServer!.address() as { port: number }).port;
+        await page.goto(
+          `http://127.0.0.1:${port}${galleryFrame(ENTRY, { variant: VARIANT, width: 560, theme: theme.name })}`,
+        );
+        await page.waitForFunction(() => document.documentElement.dataset.galleryReady === "1", undefined, {
+          timeout: 120_000,
+        });
+        await page.evaluate(() => document.fonts.ready);
+        await page.locator(".cv-received").first().waitFor();
+        await page.locator(".cv-pending").first().waitFor();
+        await page.mouse.move(0, 0);
+        const rows = await measure(page);
+        console.log(
+          `${theme.name}:\n${rows
+            .map(
+              (row) =>
+                `  ${row.kind.padEnd(6)} glyph ${px(row.glyphCenter)} text ${px(row.textLeft)} gap ${px(row.gap)} h ${px(row.height)} type ${px(row.fontSize)} "${row.label}"`,
+            )
+            .join("\n")}`,
+        );
+        const found = problems(rows);
+
+        // The group's chevron: hidden at rest, shown on hover.
+        const head = page.locator(".cv-message-group__head").first();
+        const chevron = head.locator(".cv-tool__chevron");
+        const shown = async () =>
+          chevron.evaluate((element) => {
+            const style = getComputedStyle(element);
+            return style.visibility !== "hidden" && Number(style.opacity) > 0.5;
+          });
+        const hasHead = (await head.count()) > 0;
+        const atRest = hasHead ? await shown() : undefined;
+        let hovered: boolean | undefined;
+        if (hasHead) {
+          await head.hover();
+          // The reveal fades in after its delay; wait for it rather than a fixed time.
+          hovered = await page
+            .waitForFunction(
+              () => {
+                const element = document.querySelector(".cv-message-group__head .cv-tool__chevron");
+                return !!element && Number(getComputedStyle(element).opacity) > 0.5;
+              },
+              undefined,
+              { timeout: 5_000 },
+            )
+            .then(
+              () => true,
+              () => false,
+            );
+        }
+        if (artifacts) {
+          await mkdir(artifacts, { recursive: true });
+          await writeFile(
+            path.join(artifacts, `inbox-row-${theme.file}.json`),
+            JSON.stringify({ theme: theme.name, rows, problems: found, chevron: { atRest, hovered } }, null, 2),
+          );
+          await page.mouse.move(0, 0);
+          await page.screenshot({ path: path.join(artifacts, `inbox-row-${theme.file}.png`), fullPage: true });
+        }
+        expect(rows.filter((row) => row.kind === "line").length).toBeGreaterThanOrEqual(2);
+        // A delivered group of one sender, one of several, and the waiting group.
+        expect(rows.filter((row) => row.kind === "group").length).toBe(3);
+        expect(found).toEqual([]);
+        expect(hasHead).toBe(true);
+        expect({ atRest, hovered }).toEqual({ atRest: false, hovered: true });
+      } finally {
+        await page.close();
+      }
+    });
+});
diff --git a/webviews/test/inbox-sender-mark.test.tsx b/webviews/test/inbox-sender-mark.test.tsx
new file mode 100644
index 000000000000..6fdae943159d
--- /dev/null
+++ b/webviews/test/inbox-sender-mark.test.tsx
@@ -0,0 +1,141 @@
+// l10n-allow-file: test fixtures.
+// An inbox line's sender mark (conversation/InboxNoticeCard.tsx through IncomingMessageCard.tsx
+// SenderMark) is the sender's real harness: the listed chat's, else the one acpmux bound on the
+// notice (`fromHarness`), else the neutral agent glyph. Never a mark guessed from the sender's name:
+// a Codex lane called `claude-sr2-fleet-mesh-2` drew a mark from its name (cmux#30247). A folded
+// group of one sender draws that sender's mark in the tool rows' icon slot; of several, the messages
+// glyph. Leo, 2026-11-01: "i wanted this to be left aligned with the other tool calls".
+import { afterAll, afterEach, expect, test } from "bun:test";
+import { JSDOM, VirtualConsole } from "jsdom";
+import { act } from "react";
+import type { Root } from "react-dom/client";
+import type { AcpmuxSessionEntry } from "../src/agent-session/acpmux/sessionList";
+import type { InboxNotice, InboxThread } from "../src/agent-session/acpmux/conversation/inboxNotice";
+
+const dom = new JSDOM("<!doctype html><div id=root></div>", {
+  url: "http://localhost/",
+  pretendToBeVisual: true,
+  virtualConsole: new VirtualConsole(),
+});
+const scope = globalThis as Record<string, unknown>;
+const replacements: Record<string, unknown> = {
+  window: dom.window,
+  document: dom.window.document,
+  navigator: dom.window.navigator,
+  HTMLElement: dom.window.HTMLElement,
+  Element: dom.window.Element,
+  Node: dom.window.Node,
+  Range: dom.window.Range,
+  localStorage: dom.window.localStorage,
+  customElements: dom.window.customElements,
+  MutationObserver: dom.window.MutationObserver,
+  ResizeObserver: class {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  },
+  getComputedStyle: dom.window.getComputedStyle.bind(dom.window),
+  requestAnimationFrame: dom.window.requestAnimationFrame.bind(dom.window),
+  cancelAnimationFrame: dom.window.cancelAnimationFrame.bind(dom.window),
+  IS_REACT_ACT_ENVIRONMENT: true,
+};
+for (const key of Object.getOwnPropertyNames(dom.window))
+  if (/^(HTML|SVG|CSS|Shadow|Document|Mutation|KeyboardEvent)/.test(key) && !(key in scope))
+    replacements[key] = (dom.window as unknown as Record<string, unknown>)[key];
+const saved = Object.keys(replacements).map((key) => [key, key in scope, scope[key]] as const);
+Object.assign(scope, replacements);
+const host = dom.window.document.getElementById("root")!;
+let root: Root | undefined;
+
+afterEach(() => {
+  act(() => root?.unmount());
+  root = undefined;
+});
+afterAll(() => {
+  for (const [key, had, value] of saved) {
+    if (had) scope[key] = value;
+    else delete scope[key];
+  }
+});
+
+const { createRoot } = await import("react-dom/client");
+const { InboxNoticeCard } = await import("../src/agent-session/acpmux/conversation/InboxNoticeCard");
+const { senderHarness } = await import("../src/agent-session/acpmux/conversation/IncomingMessageCard");
+const { SubsessionContext, SubsessionStore } = await import("../src/agent-session/acpmux/subagents/subsessions");
+
+const entry = (fields: Partial<AcpmuxSessionEntry> & { sessionId: string }) =>
+  ({ displayTitle: fields.name ?? "", pendingPermissions: 0, ...fields }) as AcpmuxSessionEntry;
+const sessions = [
+  entry({ sessionId: "s-claude", name: "grid-lane", harness: "claude" }),
+  // A Codex chat whose name starts with another harness's.
+  entry({ sessionId: "s-mesh", name: "claude-sr2-fleet-mesh-2", harness: "codex" }),
+];
+
+const thread = (from: string, fields: Partial<InboxThread> = {}): InboxThread => ({
+  threadId: `from:${from}/pr:9`,
+  label: "#9",
+  from: [from],
+  count: 1,
+  preview: "Review passed; landing it now.",
+  blocker: false,
+  promptIds: [`p-${from}`],
+  ...fields,
+});
+
+async function render(notice: InboxNotice) {
+  const store = new SubsessionStore();
+  store.set(sessions);
+  root = createRoot(host);
+  await act(async () =>
+    root!.render(
+      <SubsessionContext.Provider value={{ store, open: () => undefined }}>
+        <InboxNoticeCard rowId="row-1" notice={notice} onOpen={() => undefined} />
+      </SubsessionContext.Provider>,
+    ),
+  );
+}
+
+/// The brand each line's mark draws (`data-agent` of AgentMark's svg), or "neutral" for the agent glyph.
+const marks = (selector: string) =>
+  [...host.querySelectorAll<HTMLElement>(selector)].map((slot) => {
+    const brand = slot.querySelector<SVGElement>("svg.agent-mark");
+    if (brand) return brand.getAttribute("data-agent");
+    return slot.querySelector("svg") ? "neutral" : "none";
+  });
+
+test("a Claude sender draws the Claude mark", async () => {
+  await render({ threads: [thread("grid-lane", { fromSession: "s-claude" })] });
+  expect(marks(".cv-received__mark")).toEqual(["claude"]);
+});
+
+test("a Claude sender acpmux bound, listed nowhere here, draws the Claude mark", async () => {
+  await render({ threads: [thread("far-lane", { fromHarness: "claude" })] });
+  expect(marks(".cv-received__mark")).toEqual(["claude"]);
+});
+
+test("a Codex chat named claude-… draws its own harness's mark, not Claude's", async () => {
+  await render({ threads: [thread("claude-sr2-fleet-mesh-2")] });
+  expect(marks(".cv-received__mark")).toEqual(["openai"]);
+});
+
+test("an unknown sender named claude-… draws the neutral agent glyph, never a guessed vendor", async () => {
+  await render({ threads: [thread("claude-x")] });
+  expect(marks(".cv-received__mark")).toEqual(["neutral"]);
+  expect(senderHarness(undefined, undefined)).toBeUndefined();
+});
+
+test("a folded group of one sender draws its mark in the tool rows' icon slot; of several, the messages glyph", async () => {
+  await render({
+    threads: [
+      thread("grid-lane", { threadId: "pr:1", fromSession: "s-claude" }),
+      thread("grid-lane", { threadId: "pr:2", fromSession: "s-claude" }),
+    ],
+  });
+  expect(marks(".cv-inbox__head > .cv-tool__icon")).toEqual(["claude"]);
+  act(() => root?.unmount());
+  root = undefined;
+  await render({
+    threads: [thread("grid-lane", { fromSession: "s-claude" }), thread("claude-x", { threadId: "pr:3" })],
+  });
+  expect(marks(".cv-inbox__head > .cv-tool__icon")).toEqual(["neutral"]);
+});