diff --git a/AGENTS.md b/AGENTS.md
index fe89e94fa..35decc621 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1457,6 +1457,7 @@ during the wait.
   - Compaction state has one owner at a time. A manual compaction this tab sends holds it until its command settles (`localCompactionsRef`): omp may not have the command yet, so an idle snapshot cannot release it; when it settles during an auto-compaction (`autoCompactingRef`), the control stays with the auto-compaction. Native snapshots (state polls, catch-up, attach, mount) apply only if no compaction started or ended since they were requested (`compactionGenRef`); `setCompacting` keeps `isCompactingRef` and the rendered state together.
 - `useAgentSession` still treats its `session` channel as primary for chat events, but while a run is active it periodically calls `GET /api/agent/[id]` and also reconciles on `visibilitychange`/`online`. This fixes missed `agent_end` events from background tabs or half-open connections.
 - Prompt runs use a monotonic run id; late SSE or slow reconciliation responses from an old run must be ignored so they cannot resurrect stale streaming bubbles.
+- **Needs attention** (`docs/specs/2026-11-13-attention-sidebar-design.md`): a session needs the user while it has an open blocking dialog (`RunningRpcSession.awaitingInput`) or, when not running, while its agent's `request_attention` marker is newer than its newest user message. The tool is part of ompweb's omp build: `runner/src/attention.ts`, which `createHostedAgentSession` (`runner/src/session.ts`) hands every top-level session as an SDK custom tool (`customTools`; `loadMode: "essential"`; omp keeps SDK custom tools active under `--tools <list>` and `--no-tools`, and subagents do not inherit them). It only appends `{"type":"custom","customType":"omp-web-attention","data":{"reason"}}`; the entry type and the 300-character reason cap are a literal on each side (`runner/src/attention.ts`, `ATTENTION_ENTRY_TYPE`/`ATTENTION_REASON_MAX` in `lib/omp/session-files.ts`). `scanTailMessage` (`lib/omp/session-files.ts`) walks the 32 KiB tail back to the newest user message and reports the newest marker before it as `SessionInfo.attention`; the next user message clears it, so nothing ever deletes a marker. `sessionEntry` in `lib/hosts/hub.ts` must keep passing `attention` through from a daemon's list.
 
 ### Composer-attached panels (`components/ComposerPanels.tsx`)
 - The live todo plan (`TodoList`) and the subagent roster live **pinned above
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c2fc2456a..d97323b26 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -32,6 +32,8 @@ All notable changes to **omp-web** (`@kahme247/ompweb`) are documented in this f
 - **Traditional Chinese (`zh-TW`) interface language.** Select Traditional Chinese (繁體中文) in the top-bar language menu. On compact layouts, open **More controls** first. Alternatively, let omp-web pick it automatically when the browser language is `zh-TW`, `zh-HK`, `zh-MO`, or `zh-Hant`. Localized Web Push notifications and a Traditional Chinese README (`README.zh-TW.md`) are included.
 - **Several web apps can share one host daemon and the same live sessions.** Link additional servers with `ompweb host login --add --url <server>` (token from stdin). Prompts, tool progress, results and dialogs stay synchronized, and restarting one web app leaves the other connected to the same omp process. Link protocol v7 moves session startup, idle cleanup and interrupted-run recovery into the host; older links remain supported without sharing their processes. Schedule the first daemon upgrade while its host is quiescent.
 - **Sidebar marks sessions with an unsent draft.** A session whose composer still holds text or attachments shows a small pencil beside its title, so a half-written message is easy to find again. The mark follows this browser tab's drafts.
+- **Needs attention in the sidebar.** A **Needs attention** section above Workspaces lists every session that is waiting for you, on every host, with the same host, workspace and session rows as Workspaces, sorted by name. A session appears there while it has an open question, confirmation or permission prompt, or after its agent called the new `request_attention` tool to say it ends its turn waiting for your instruction, answer, decision or approval; hover the session for the agent's reason. Your next message to the session clears it, and so does the agent carrying on with more tool calls. The section is hidden while nothing needs attention. The tool is part of ompweb's omp build, so every session omp-web starts has it; sessions of a stock omp terminal do not.
+  **Before upgrading:** sessions on a linked host get the `request_attention` tool once that host's ompweb (and its omp runner) is updated; until then only open dialogs mark them.
 - **Sidebar marks sessions waiting for your input.** A session with an open question, confirmation or other blocking dialog shows a small question-bubble icon beside its title, next to the unsent-draft pencil. The mark clears as soon as the dialog is answered, cancelled or expires, in every open browser.
 - **Identify untagged builds from the logo.** Clicking or tapping the ompweb logo still reveals the version; builds made from an untagged Git commit also show its full hash and commit date (`YYYY-MM-DD`). Builds made on a tag keep the version-only display. The metadata is embedded in the browser bundle, so installed packages and binaries do not need Git.
 - **Workspace file APIs run on the owning host.** Directory listings, file metadata and previews, downloads, file search and referenced shell output go through that machine's daemon, including This machine. File downloads stream in bounded chunks rather than being limited by the host link's per-result size. A stopped or older daemon reports unavailable or unsupported instead of reading a path on the web server.
diff --git a/components/AppShell.tsx b/components/AppShell.tsx
index d85afcddc..13b371d2e 100644
--- a/components/AppShell.tsx
+++ b/components/AppShell.tsx
@@ -11,7 +11,7 @@ import { isMacPlatform, navigateShortcutHint, NAVIGATION_HISTORY_MAX_ENTRIES } f
 import { useMobileSidebarGestures } from "@/hooks/useMobileSidebarGestures";
 import { SessionSidebar } from "./SessionSidebar";
 import type { SearchMatchTarget } from "./SessionSearchMatches";
-import type { WorktreeContext } from "./SessionSidebar-helpers";
+import { workspaceLabel, type WorktreeContext } from "./SessionSidebar-helpers";
 import { ToastProvider } from "./ui/toast";
 import { toast } from "./ui/toast";
 import { notificationHistory, useUnreadNotificationCount } from "@/lib/notification-history";
@@ -2604,7 +2604,7 @@ export function AppShell({ appName }: { appName: string }) {
                         <option value={newSessionWorkspaceValue}>{projectLabel(effectiveNewSessionCwd)}</option>
                       )}
                       {hostProjects.map((project) => {
-                        const name = project.alias ?? project.name ?? projectLabel(project.path);
+                        const name = workspaceLabel(project);
                         // A member's pinned project: its option names the node.
                         const node = !project.poolId && projectTargetId(project, pools) !== (project.hostId ?? LOCAL_HOST_ID) ? hosts?.find((host) => host.id === (project.hostId ?? LOCAL_HOST_ID)) : undefined;
                         return (
diff --git a/components/SessionSidebar-helpers.test.mjs b/components/SessionSidebar-helpers.test.mjs
index 2e9af6752..8790b05c8 100644
--- a/components/SessionSidebar-helpers.test.mjs
+++ b/components/SessionSidebar-helpers.test.mjs
@@ -65,3 +65,62 @@ test("sessions on different workers share one logical project while a same-path
     ["pool:workers:other", { running: 0, unread: 0, exited: 0 }],
   ]);
 });
+
+test("attention: an open dialog counts even while running; the agent's marker only while the session is not running", async () => {
+  const { attentionSessionIds } = await import("./SessionSidebar-helpers.ts");
+  const marker = { reason: "Pick one", at: "2026-11-13T10:00:00.000Z" };
+  const sessions = [
+    { id: "marker-idle", attention: marker },
+    { id: "marker-running", attention: marker },
+    { id: "dialog-running" },
+    { id: "plain" },
+  ];
+  const running = new Set(["marker-running", "dialog-running", "new"]);
+  assert.deepEqual([...attentionSessionIds(sessions, running, new Set(["dialog-running"]))].sort(), ["dialog-running", "marker-idle"]);
+  // A dialog on a session the list does not have yet counts too (its row is a live placeholder).
+  assert.deepEqual([...attentionSessionIds([], running, new Set(["new"]))], ["new"]);
+});
+
+test("attention entries: only attention sessions, workspaces by label and sessions by title A→Z, workspaces without one dropped", async () => {
+  const { attentionProjectEntries } = await import("./SessionSidebar-helpers.ts");
+  const session = (id, cwd, extra) => ({ id, cwd, path: `${cwd}/${id}.jsonl`, created: "", modified: "2026-11-13T10:00:00.000Z", messageCount: 1, firstMessage: "", ...extra });
+  // The manual order (sortOrder) and pins do not apply.
+  const projects = [
+    { path: "/srv/zeta", sortOrder: 0 },
+    { path: "/srv/quiet", sortOrder: 1 },
+    { path: "/srv/Beta", sortOrder: 2, pinOrder: 0 },
+    { path: "/srv/x", alias: "alpha", sortOrder: 3 },
+  ];
+  const sessions = [
+    session("z1", "/srv/zeta", { name: "fix tests" }),
+    session("q1", "/srv/quiet", { name: "idle" }),
+    session("b2", "/srv/Beta", { name: "Zebra" }),
+    session("b1", "/srv/Beta", { firstMessage: "apple pie" }),
+    session("b3", "/srv/Beta", { name: "item 10", parentSessionId: "b2" }),
+    session("b4", "/srv/Beta", { name: "Item 9" }),
+    session("bx", "/srv/Beta", { name: "Aardvark" }),
+    session("x1", "/srv/x", { name: "deploy" }),
+  ];
+  const byProject = groupSessionsByProject(projects, sessions);
+  const entries = attentionProjectEntries(projects, byProject, new Set(["z1", "b2", "b1", "b3", "b4", "x1"]));
+  assert.deepEqual(entries.map(({ project, hostId, tree }) => [project.path, hostId, tree.map((node) => node.session.id)]), [
+    ["/srv/x", "local", ["x1"]],
+    ["/srv/Beta", "local", ["b1", "b4", "b3", "b2"]],
+    ["/srv/zeta", "local", ["z1"]],
+  ]);
+  assert.ok(entries.every(({ tree }) => tree.every((node) => node.children.length === 0)), "a fork does not nest under its parent");
+  assert.deepEqual(attentionProjectEntries(projects, byProject, new Set()), []);
+});
+
+test("attention host groups: only hosts with an entry, A→Z by shown name with this machine not pinned first", async () => {
+  const { attentionHostGroups } = await import("./SessionSidebar-helpers.ts");
+  const hostList = [{ id: "local", label: "" }, { id: "h1", label: "build box" }, { id: "h2", label: "Zed" }, { id: "h3", label: "Empty" }];
+  const names = { local: "This machine", h1: "build box", h2: "Zed", h3: "Empty", "pool:cluster": "Cluster" };
+  const nameOf = (host) => names[host.id];
+  const entries = [{ hostId: "h2", name: "z" }, { hostId: "local", name: "l" }, { hostId: "h1", name: "b2" }, { hostId: "h1", name: "b1" }];
+  const shape = (groups) => groups.map(({ host, projects }) => [host.id, projects.map((entry) => entry.name)]);
+  assert.deepEqual(shape(attentionHostGroups(entries, hostList, undefined, nameOf)), [["h1", ["b2", "b1"]], ["local", ["l"]], ["h2", ["z"]]]);
+  // A cluster member's workspaces list under the cluster, as in Workspaces.
+  const pools = [{ id: "cluster", members: [{ hostId: "h2" }] }];
+  assert.deepEqual(shape(attentionHostGroups(entries, [...hostList, { id: "pool:cluster", label: "Cluster" }], pools, nameOf)), [["h1", ["b2", "b1"]], ["pool:cluster", ["z"]], ["local", ["l"]]]);
+});
diff --git a/components/SessionSidebar-helpers.ts b/components/SessionSidebar-helpers.ts
index 2c1e91bd2..fbe8c2188 100644
--- a/components/SessionSidebar-helpers.ts
+++ b/components/SessionSidebar-helpers.ts
@@ -1,6 +1,6 @@
 import { isLinkUp, type HostStatus } from "@/lib/hosts/host";
-import type { SessionInfo } from "@/lib/types";
-import { LOCAL_HOST_ID, type ProjectSortMode } from "@/lib/project-ordering";
+import type { ManagedProject, SessionInfo } from "@/lib/types";
+import { LOCAL_HOST_ID, groupProjectsByHost, projectIdentity, projectTargetId, type PoolMembers, type ProjectSortMode } from "@/lib/project-ordering";
 import { comparableProjectPath } from "@/lib/comparable-path";
 interface WorktreeEntry {
   path: string;
@@ -140,6 +140,21 @@ function projectLabel(projectPath: string): string {
   const index = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
   return index >= 0 ? trimmed.slice(index + 1) : trimmed;
 }
+
+/** The name a workspace row shows: its alias, else its name, else its folder. */
+function workspaceLabel(project: ManagedProject): string {
+  return project.alias ?? project.name ?? projectLabel(project.path);
+}
+
+/** The title a session row shows. */
+function sessionTitle(session: SessionInfo): string {
+  return session.name || session.firstMessage.slice(0, 50) || session.id.slice(0, 12);
+}
+
+/** A→Z as the user reads it: case-insensitive, digits numerically. */
+function compareLabels(a: string, b: string): number {
+  return a.localeCompare(b, undefined, { sensitivity: "base", numeric: true });
+}
 function formatRelativeTime(value: string, _locale: string, now: number): string | null {
   const timestamp = new Date(value).getTime();
   if (!Number.isFinite(timestamp)) return null;
@@ -242,6 +257,62 @@ function hostsCameOnline(
   const wasUp = new Set(prev.filter((host) => isLinkUp(host.status)).map((host) => host.id));
   return next.some((host) => isLinkUp(host.status) && !wasUp.has(host.id));
 }
+
+/** Sessions blocked on the user: an open blocking dialog (`awaitingInputIds`,
+ *  running by definition), or the agent's `request_attention` marker on a
+ *  session that is not running (a run in progress is not waiting). */
+function attentionSessionIds(
+  sessions: readonly SessionInfo[],
+  runningSessionIds: ReadonlySet<string>,
+  awaitingInputIds: ReadonlySet<string>,
+): Set<string> {
+  const ids = new Set(awaitingInputIds);
+  for (const session of sessions) {
+    if (session.attention && !runningSessionIds.has(session.id)) ids.add(session.id);
+  }
+  return ids;
+}
+
+interface AttentionEntry {
+  project: ManagedProject;
+  /** The host group the workspace lists under (`projectTargetId`). */
+  hostId: string;
+  tree: SessionTreeNode[];
+}
+
+/** The Needs attention section's workspaces: each with only its attention
+ *  sessions, workspaces without one dropped. Workspaces A→Z by label and
+ *  sessions A→Z by title, whatever the Workspaces sort. Every session is its
+ *  own root (forks do not nest), so the order holds. */
+function attentionProjectEntries(
+  projects: readonly ManagedProject[],
+  sessionsByProject: ReadonlyMap<string, readonly SessionInfo[]>,
+  ids: ReadonlySet<string>,
+): AttentionEntry[] {
+  if (ids.size === 0) return [];
+  const entries: AttentionEntry[] = [];
+  for (const project of projects) {
+    const sessions = (sessionsByProject.get(projectIdentity(project)) ?? []).filter((session) => ids.has(session.id));
+    if (sessions.length === 0) continue;
+    sessions.sort((a, b) => compareLabels(sessionTitle(a), sessionTitle(b)));
+    entries.push({ project, hostId: projectTargetId(project), tree: sessions.map((session) => ({ session, children: [] })) });
+  }
+  return entries.sort((a, b) => compareLabels(workspaceLabel(a.project), workspaceLabel(b.project)));
+}
+
+/** The Needs attention section's host groups: only hosts with an entry, A→Z by
+ *  the name the group shows (this machine is not pinned first). Entries keep
+ *  their order inside a group. */
+function attentionHostGroups<T extends { hostId?: string; poolId?: string }>(
+  entries: T[],
+  hosts: { id: string; label: string }[],
+  pools: PoolMembers | undefined,
+  nameOf: (host: { id: string; label: string }) => string,
+): { host: { id: string; label: string }; projects: T[] }[] {
+  return groupProjectsByHost(entries, hosts, pools)
+    .filter((group) => group.projects.length > 0)
+    .sort((a, b) => compareLabels(nameOf(a.host), nameOf(b.host)));
+}
 const MAX_PROJECT_SESSIONS = 5;
 export {
   EMPTY_PROJECT_SET,
@@ -250,6 +321,9 @@ export {
   INITIAL_RESTORE_RETRY_MS,
   MAX_PROJECT_SESSIONS,
   UNREAD_SESSIONS_STORAGE_KEY,
+  attentionHostGroups,
+  attentionProjectEntries,
+  attentionSessionIds,
   buildSessionTree,
   displayCwd,
   formatRelativeTime,
@@ -263,6 +337,8 @@ export {
   saveExpandedProjects,
   saveProjectSortMode,
   saveUnreadSessionIds,
+  sessionTitle,
+  workspaceLabel,
   type LivePlace,
   type SessionTreeNode,
   type WorktreeContext,
diff --git a/components/SessionSidebar-rows.tsx b/components/SessionSidebar-rows.tsx
index 6b14c3ebd..aa18fa6ea 100644
--- a/components/SessionSidebar-rows.tsx
+++ b/components/SessionSidebar-rows.tsx
@@ -14,7 +14,8 @@ import { hasDraft, subscribeDrafts } from "@/lib/draft-store";
 import {
   MAX_PROJECT_SESSIONS,
   formatRelativeTime,
-  projectLabel,
+  sessionTitle,
+  workspaceLabel,
   type SessionTreeNode,
 } from "./SessionSidebar-helpers";
 import {
@@ -117,6 +118,8 @@ interface ProjectRowProps {
   /** A sort is active: show the pin toggle; only pinned rows reorder by hand. */
   pinnable: boolean;
   onTogglePin: (project: ManagedProject) => Promise<void>;
+  /** False where the list has a fixed order (Needs attention): no drag, no Move up/down. */
+  reorderable?: boolean;
   isDragTarget: boolean;
   removeBusy: boolean;
   onSelectSession: (s: SessionInfo) => void;
@@ -156,6 +159,7 @@ function ProjectRow({
   onMoveProject,
   pinnable,
   onTogglePin,
+  reorderable = true,
   isDragTarget,
   removeBusy,
   onSelectSession,
@@ -196,9 +200,9 @@ function ProjectRow({
     // The sidebar already reports failed presentation writes in a toast.
     void onUpdatePresentation(project, { alias }).catch(() => {});
   }, [aliasValue, project, onUpdatePresentation]);
-  const label = project.alias ?? project.name ?? projectLabel(project.path);
+  const label = workspaceLabel(project);
   const pinned = pinnable && project.pinOrder !== undefined;
-  const canReorder = !pinnable || pinned;
+  const canReorder = reorderable && (!pinnable || pinned);
   const hasActivity = Boolean(activity && (activity.running > 0 || activity.unread > 0 || activity.exited > 0));
   const visibleRoots = hiddenCount > 0 && !showAllSessions
     ? tree.slice(0, MAX_PROJECT_SESSIONS)
@@ -743,7 +747,9 @@ const SessionItem = memo(function SessionItem({
   const inputRef = useRef<HTMLInputElement>(null);
   const contentButtonRef = useRef<HTMLButtonElement>(null);
   const menuButtonRef = useRef<HTMLButtonElement>(null);
-  const title = session.name || session.firstMessage.slice(0, 50) || session.id.slice(0, 12);
+  const title = sessionTitle(session);
+  // The agent's request_attention reason; a running session is not waiting on it.
+  const attentionReason = isRunning ? undefined : session.attention?.reason;
   // A session's composer draft is keyed by its id (ChatWindow's `draftKey`).
   const hasUnsentDraft = useSyncExternalStore(subscribeDrafts, () => hasDraft(session.id), () => false);
   const relativeTime = formatRelativeTime(session.modified, locale, relativeTimeNow);
@@ -893,7 +899,7 @@ const SessionItem = memo(function SessionItem({
         <>
           {depth > 0 && <GitBranch size={11} strokeWidth={2} style={{ flexShrink: 0, color: "var(--text-dim)" }} aria-hidden="true" />}
           <button ref={contentButtonRef} type="button" className="session-item-button" aria-current={isSelected ? "true" : undefined} onKeyDown={(event) => { if (event.key === "Delete" && !deleting) { event.preventDefault(); setConfirmDelete(true); } }} style={{ display: "flex", alignItems: "center", flex: 1, minWidth: 0 }}>
-            <span title={title} style={{ minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap", color: "var(--text)", fontSize: 12.5, fontWeight: isSelected ? 600 : 500, lineHeight: 1.35, letterSpacing: "-0.005em" }}>
+            <span title={attentionReason ? `${title}\n${t("sessionSidebar.attentionReason", { reason: attentionReason })}` : title} style={{ minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap", color: "var(--text)", fontSize: 12.5, fontWeight: isSelected ? 600 : 500, lineHeight: 1.35, letterSpacing: "-0.005em" }}>
               {title}
             </span>
             {isAwaitingInput && (
diff --git a/components/SessionSidebar.presentation.test.mjs b/components/SessionSidebar.presentation.test.mjs
index a0664fae5..c69fe00c9 100644
--- a/components/SessionSidebar.presentation.test.mjs
+++ b/components/SessionSidebar.presentation.test.mjs
@@ -222,3 +222,110 @@ test("the sidebar refetches its projects and sessions when the loaded pools chan
     window.matchMedia = original.matchMedia;
   }
 });
+
+test("Needs attention lists a waiting session under its workspace above Workspaces, without pin or reordering, and goes away when nothing waits", async () => {
+  const original = { fetch: globalThis.fetch, Worker: globalThis.Worker, SharedWorker: globalThis.SharedWorker, matchMedia: window.matchMedia };
+  globalThis.Worker = FakeWorker;
+  globalThis.SharedWorker = undefined;
+  window.matchMedia = () => ({ matches: false, addEventListener() {}, removeEventListener() {} });
+  // A sort is active and the workspace is pinned: in Workspaces its row has a pin and reorders.
+  localStorage.setItem("omp-web:project-sort", "alphabetical");
+  const session = (id, name, extra) => ({ id, path: `/l/${id}.jsonl`, cwd: "/l", created: "2026-11-13T09:00:00.000Z", modified: "2026-11-13T09:00:00.000Z", messageCount: 2, firstMessage: "hi", name, ...extra });
+  const reason = "Postgres or SQLite?";
+  let sessions = [session("idle", "Quiet chat"), session("wait", "Choose a database", { attention: { reason, at: "2026-11-13T09:00:00.000Z" } })];
+  globalThis.fetch = async (input) => {
+    const url = new URL(String(input), "http://localhost");
+    if (url.pathname === "/api/projects") return Response.json({ projects: [{ path: "/l", pinOrder: 0 }] });
+    if (url.pathname === "/api/sessions") return Response.json({ sessions });
+    return Response.json({});
+  };
+  const props = { selectedSessionId: null, skipInitialProjectSelection: true, onSelectSession() {}, addProjectOpen: false, setAddProjectOpen() {}, usageVisible: false };
+  const findSection = () => document.querySelector(`section[aria-label="${translate("sessionSidebar.needsAttention")}"]`);
+  try {
+    const { rerender } = render(React.createElement(SessionSidebar, props));
+    await waitFor(() => assert.ok(findSection()));
+    const section = findSection();
+    assert.ok(section.compareDocumentPosition(screen.getByText(translate("projects.heading"))) & Node.DOCUMENT_POSITION_FOLLOWING, "the section sits above Workspaces");
+    assert.deepEqual([...section.querySelectorAll(".sidebar-project-identity")].map((row) => row.textContent), ["l"]);
+    assert.deepEqual([...section.querySelectorAll(".session-item-button")].map((row) => row.textContent), ["Choose a database"]);
+    assert.equal(section.querySelector("[title^='Choose a database']").getAttribute("title"), `Choose a database\n${translate("sessionSidebar.attentionReason", { reason })}`);
+    const pin = translate("projects.pin", { name: "l" });
+    await waitFor(() => assert.ok(document.querySelector(`[aria-label="${pin}"]`), "the Workspaces row has its pin"));
+    assert.equal(section.querySelector(`[aria-label="${pin}"]`), null, "no pin in Needs attention");
+    assert.equal(section.querySelector(".sidebar-project-header").getAttribute("draggable"), "false");
+    fireEvent.click(section.querySelector(`[aria-label="${translate("commandPalette.actions")}"]`));
+    await screen.findByText(translate("projects.nameAlias"));
+    assert.equal(screen.queryByText(translate("projects.moveUp")), null, "no Move up in Needs attention");
+    fireEvent.keyDown(section.querySelector(".sidebar-project-header"), { key: "Escape" });
+
+    sessions = [session("idle", "Quiet chat")];
+    // The refresh refetches the sessions; let it land inside act.
+    await act(async () => { rerender(React.createElement(SessionSidebar, { ...props, refreshKey: 1 })); });
+    await waitFor(() => assert.equal(findSection(), null));
+    assert.ok(screen.getByText(translate("projects.heading")), "Workspaces stays");
+  } finally {
+    cleanup();
+    localStorage.removeItem("omp-web:project-sort");
+    globalThis.fetch = original.fetch;
+    globalThis.Worker = original.Worker;
+    globalThis.SharedWorker = original.SharedWorker;
+    window.matchMedia = original.matchMedia;
+  }
+});
+
+// One workspace "/l"; `running`/`runningSessions` feed the running channel the way /api/sessions does.
+async function attentionScenario(body, { sessions = [], running = [], runningSessions = [] }) {
+  const original = { fetch: globalThis.fetch, Worker: globalThis.Worker, SharedWorker: globalThis.SharedWorker, matchMedia: window.matchMedia };
+  globalThis.Worker = FakeWorker;
+  globalThis.SharedWorker = undefined;
+  window.matchMedia = () => ({ matches: false, addEventListener() {}, removeEventListener() {} });
+  globalThis.fetch = async (input) => {
+    const url = new URL(String(input), "http://localhost");
+    if (url.pathname === "/api/projects") return Response.json({ projects: [{ path: "/l" }] });
+    if (url.pathname === "/api/sessions") return Response.json({ sessions, runningSessionIds: running, runningSessions });
+    return Response.json({});
+  };
+  const props = { selectedSessionId: null, skipInitialProjectSelection: true, onSelectSession() {}, addProjectOpen: false, setAddProjectOpen() {}, usageVisible: false };
+  try {
+    render(React.createElement(SessionSidebar, props));
+    await body();
+  } finally {
+    cleanup();
+    localStorage.removeItem("omp-web:expanded-projects");
+    globalThis.fetch = original.fetch;
+    globalThis.Worker = original.Worker;
+    globalThis.SharedWorker = original.SharedWorker;
+    window.matchMedia = original.matchMedia;
+  }
+}
+const attentionSection = () => document.querySelector(`section[aria-label="${translate("sessionSidebar.needsAttention")}"]`);
+const attentionSession = (id, name, extra) => ({ id, path: `/l/${id}.jsonl`, cwd: "/l", created: "2026-11-13T09:00:00.000Z", modified: "2026-11-13T09:00:00.000Z", messageCount: 2, firstMessage: "hi", name, ...extra });
+const attentionMarker = { reason: "Pick one", at: "2026-11-13T09:00:00.000Z" };
+
+test("Needs attention lists a running session with an open dialog and no marker", async () => {
+  await attentionScenario(async () => {
+    await waitFor(() => assert.ok(attentionSection()));
+    assert.deepEqual([...attentionSection().querySelectorAll(".session-item-button")].map((row) => row.textContent), ["Asking"]);
+  }, { sessions: [attentionSession("dlg", "Asking")], running: ["dlg"], runningSessions: [{ id: "dlg", cwd: "/l", awaitingInput: true }] });
+});
+
+test("Needs attention leaves out a running session's marker, and its row shows no reason", async () => {
+  await attentionScenario(async () => {
+    const expand = await screen.findByLabelText(translate("projects.expandProject", { name: "l" }));
+    fireEvent.click(expand);
+    await waitFor(() => assert.ok(document.querySelector("[title^='Marked']")));
+    assert.equal(attentionSection(), null);
+    assert.equal(document.querySelector("[title^='Marked']").getAttribute("title"), "Marked");
+  }, { sessions: [attentionSession("m", "Marked", { attention: attentionMarker })], running: ["m"], runningSessions: [{ id: "m", cwd: "/l" }] });
+});
+
+test("Needs attention lists every waiting session of a workspace without a show-more button", async () => {
+  const names = Array.from({ length: 7 }, (_, i) => `Chat ${i}`);
+  await attentionScenario(async () => {
+    await waitFor(() => assert.ok(attentionSection()));
+    const rows = [...attentionSection().querySelectorAll(".session-item-button")].map((row) => row.textContent);
+    assert.deepEqual(rows.toSorted(), names);
+    const showMore = names.map((_, i) => translate("projects.showMoreSessions", { count: i + 1 }));
+    assert.equal([...attentionSection().querySelectorAll("button")].some((button) => showMore.includes(button.textContent)), false);
+  }, { sessions: names.map((name, i) => attentionSession(`s${i}`, name, { attention: attentionMarker })) });
+});
diff --git a/components/SessionSidebar.tsx b/components/SessionSidebar.tsx
index f7e67aeff..2e779dbf2 100644
--- a/components/SessionSidebar.tsx
+++ b/components/SessionSidebar.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { memo, useEffect, useLayoutEffect, useState, useCallback, useRef, useMemo, useDeferredValue } from "react";
+import { memo, useEffect, useLayoutEffect, useState, useCallback, useRef, useMemo, useDeferredValue, type CSSProperties } from "react";
 import type { ExitedRpcSession, ManagedProject, ProjectLaunchConfig, SessionInfo } from "@/lib/types";
 import { useI18n } from "@/lib/i18n";
 import { formatApiError } from "@/lib/i18n/api-error";
@@ -34,6 +34,9 @@ import {
   INITIAL_RESTORE_MAX_ATTEMPTS,
   INITIAL_RESTORE_RETRY_MS,
   MAX_PROJECT_SESSIONS,
+  attentionHostGroups,
+  attentionProjectEntries,
+  attentionSessionIds,
   buildSessionTree,
   livePlace,
   loadExpandedProjects,
@@ -44,6 +47,7 @@ import {
   saveExpandedProjects,
   saveProjectSortMode,
   saveUnreadSessionIds,
+  workspaceLabel,
   type LivePlace,
   type WorktreeContext,
   type WorktreeEntry,
@@ -51,7 +55,7 @@ import {
   hostsCameOnline,
 } from "./SessionSidebar-helpers";
 import { OmpWebTitle, SIDEBAR_BUTTON_TRANSITION, SidebarIconButton, SidebarPortalMenu } from "./SessionSidebar-chrome";
-import { HostGroup, ProjectRow } from "./SessionSidebar-rows";
+import { HostGroup, ProjectRow, type ProjectRowProps } from "./SessionSidebar-rows";
 
 /** Deadline for one /api/sessions fetch. A wedged-but-listening server never
  * answers; without this the initial spinner would pend forever. */
@@ -131,6 +135,15 @@ const projectRequestTarget = (project: ManagedProject) => project.poolId && proj
   : { cwd: project.path, hostId: remoteHostId(project.hostId) };
 const THIS_MACHINE = { id: LOCAL_HOST_ID, label: "" };
 const COLLAPSED_HOSTS_STORAGE_KEY = "omp-web:collapsed-hosts";
+/** The section headings (Needs attention, Workspaces). */
+const SECTION_HEADING_STYLE: CSSProperties = {
+  flex: 1,
+  color: "var(--text-muted)",
+  fontSize: 11,
+  fontWeight: 600,
+  letterSpacing: "0.08em",
+  textTransform: "uppercase",
+};
 
 function loadCollapsedHosts(): Set<string> {
   try {
@@ -176,6 +189,25 @@ export const SessionSidebar = memo(function SessionSidebar({ selectedSessionId,
       return next;
     });
   }, []);
+  // Needs attention keeps its own collapse state, expanded by default and not
+  // stored: collapsing there leaves Workspaces as it is.
+  const [attentionCollapsedHosts, setAttentionCollapsedHosts] = useState<ReadonlySet<string>>(() => new Set());
+  const [attentionCollapsedProjects, setAttentionCollapsedProjects] = useState<ReadonlySet<string>>(() => new Set());
+  const toggleAttentionHostCollapsed = useCallback((hostId: string) => {
+    setAttentionCollapsedHosts((prev) => {
+      const next = new Set(prev);
+      if (!next.delete(hostId)) next.add(hostId);
+      return next;
+    });
+  }, []);
+  const toggleAttentionProjectCollapsed = useCallback((project: ManagedProject) => {
+    const key = projectIdentity(project);
+    setAttentionCollapsedProjects((prev) => {
+      const next = new Set(prev);
+      if (!next.delete(key)) next.add(key);
+      return next;
+    });
+  }, []);
   // Why a host's sessions cannot be opened or started right now (null when they can).
   const hostUnavailableReason = useCallback((hostId: string): string | null => {
     const row = hosts?.find((host) => host.id === hostId);
@@ -831,7 +863,7 @@ export const SessionSidebar = memo(function SessionSidebar({ selectedSessionId,
   // Only "Last updated" reads sessions; other modes must not re-sort on every session refresh.
   const orderingSessions = projectSortMode === "updated" ? visibleSessions : NO_SESSIONS;
   const sortedProjectsBase = useMemo(
-    () => orderProjects(visibleProjects, projectSortMode, orderingSessions, (project) => project.alias ?? project.name ?? projectLabel(project.path)),
+    () => orderProjects(visibleProjects, projectSortMode, orderingSessions, workspaceLabel),
     [visibleProjects, projectSortMode, orderingSessions],
   );
   const orderingKey = useMemo(
@@ -868,6 +900,16 @@ export const SessionSidebar = memo(function SessionSidebar({ selectedSessionId,
     () => projectActivityCounts(visibleSessions, runningSessionIds, unreadSessionIds, exitedSessions.keys()),
     [visibleSessions, runningSessionIds, unreadSessionIds, exitedSessions],
   );
+  // Needs attention lists every blocked session; the Workspaces search and
+  // running filter do not apply to it.
+  const attentionIds = useMemo(
+    () => attentionSessionIds(allSessions, runningSessionIds, awaitingInputIds),
+    [allSessions, runningSessionIds, awaitingInputIds],
+  );
+  const attentionEntries = useMemo(
+    () => attentionProjectEntries(sortedProjects, sessionsByProject, attentionIds),
+    [sortedProjects, sessionsByProject, attentionIds],
+  );
 
   // Client-side filtering (Workspaces header: search + "running only").
   // While a filter is active, workspaces with no matching sessions are hidden
@@ -1460,6 +1502,55 @@ export const SessionSidebar = memo(function SessionSidebar({ selectedSessionId,
     if (selected) setLastOpenSession(hostProjectKey(selected.hostId, workspaceKeyOf(selected)), selected.id);
   }, [allSessions, selectedSessionId]);
 
+  // A host group's header (name, link state), the same in both sections.
+  const hostGroupHeader = (host: { id: string; label: string }) => {
+    const row = hosts?.find((candidate) => candidate.id === host.id);
+    return {
+      name: row ? hostName(t, row) : host.label,
+      color: row ? HOST_STATUS_COLOR[row.status] : undefined,
+      statusText: row && row.status !== "online" ? hostStatusText(t, row) : null,
+      unavailableReason: hostUnavailableReason(host.id),
+    };
+  };
+  // What a workspace row shows and does in either section; each section adds
+  // its session tree, expansion and ordering controls.
+  const projectRowProps = (project: ManagedProject, groupHostId: string) => {
+    const projectKey = projectIdentity(project);
+    // A member's own project listed in the cluster group: name its node.
+    const node = project.poolId || groupHostId === hostOf(project) ? undefined : hosts?.find((candidate) => candidate.id === hostOf(project));
+    const unavailable = node ? hostUnavailableReason(node.id) : null;
+    return {
+      project,
+      node: node ? { label: hostName(t, node), statusText: unavailable ? hostStatusText(t, node) : null, unavailableReason: unavailable } : undefined,
+      // Sessions group under a project through the case-folded comparable
+      // form (see groupSessionsByProject), so the active highlight must
+      // use the same comparison: a session whose cwd/projectRoot spells
+      // the project folder with different casing (Windows/NTFS) lands in
+      // this row — the row must light up for it too.
+      isActive: selectedProject !== null && (project.poolId ? selectedProject === projectKey : !selectedPoolKey && selectedHostId === hostOf(project) && comparableProjectPath(selectedProject) === comparableProjectPath(project.path)),
+      activity: projectActivity.get(foldedHostProjectKey(project.hostId, workspaceKeyOf(project))),
+      selectedSessionId,
+      runningSessionIds,
+      awaitingInputIds,
+      unreadSessionIds,
+      exitedSessions,
+      recentlyCompletedIds: effectiveRecentCompletedSet,
+      relativeTimeNow,
+      onActivate: activateProject,
+      onRemoveProject: handleRemoveProject,
+      onEditLaunchConfig: setLaunchConfigProject,
+      onUpdatePresentation: handleUpdateProjectPresentation,
+      onDragProjectChange: setDraggedProject,
+      onDropProject: (target: ManagedProject) => void handleProjectDrop(target),
+      onMoveProject: (target: ManagedProject, delta: -1 | 1) => void handleMoveProject(target, delta),
+      onTogglePin: handleTogglePin,
+      removeBusy: removeProjectKey === projectKey,
+      onSelectSession: handleSelectSessionFromList,
+      onRenamed: loadSessions,
+      onSessionDeleted: handleSessionDeleted,
+    } satisfies Partial<ProjectRowProps>;
+  };
+
   return (
     <div className="sidebar-shell" style={{ display: "flex", flexDirection: "column", height: "100%", overflow: "hidden", paddingBottom: "env(safe-area-inset-bottom)" }}>
       {addProjectOpen && (
@@ -1626,18 +1717,47 @@ export const SessionSidebar = memo(function SessionSidebar({ selectedSessionId,
         </button>
       </div>
 
+      {/* Needs attention: every session blocked on the user, A→Z; scrolls on its own so Workspaces stays reachable */}
+      {attentionEntries.length > 0 && (
+        <section aria-label={t("sessionSidebar.needsAttention")} style={{ flexShrink: 0, maxHeight: "40%", display: "flex", flexDirection: "column", paddingBottom: 4, borderBottom: "1px solid var(--border)" }}>
+          <div style={{ flexShrink: 0, minHeight: 32, boxSizing: "border-box", padding: "4px 10px 2px", display: "flex", alignItems: "center" }}>
+            <span style={SECTION_HEADING_STYLE}>{t("sessionSidebar.needsAttention")}</span>
+          </div>
+          <div style={{ minHeight: 0, overflowY: "auto", padding: "2px 10px 0" }}>
+            {attentionHostGroups(attentionEntries, hostList, pools, (host) => hostGroupHeader(host).name).map(({ host, projects: entries }) => {
+              const rows = entries.map(({ project, tree }) => (
+                <ProjectRow
+                  key={projectIdentity(project)}
+                  {...projectRowProps(project, host.id)}
+                  tree={tree}
+                  isExpanded={!attentionCollapsedProjects.has(projectIdentity(project))}
+                  hiddenCount={0}
+                  onToggleExpand={toggleAttentionProjectCollapsed}
+                  pinnable={false}
+                  reorderable={false}
+                  isDragTarget={false}
+                />
+              ));
+              if (!showHostGroups) return rows;
+              return (
+                <HostGroup
+                  key={host.id}
+                  {...hostGroupHeader(host)}
+                  collapsed={attentionCollapsedHosts.has(host.id)}
+                  onToggle={() => toggleAttentionHostCollapsed(host.id)}
+                  empty={null}
+                >
+                  {rows}
+                </HostGroup>
+              );
+            })}
+          </div>
+        </section>
+      )}
+
       {/* Workspaces section header: label + search / sort / filter / add */}
       <div style={{ flexShrink: 0, padding: "4px 10px 2px", display: "flex", alignItems: "center", gap: 2 }}>
-        <span
-          style={{
-            flex: 1,
-            color: "var(--text-muted)",
-            fontSize: 11,
-            fontWeight: 600,
-            letterSpacing: "0.08em",
-            textTransform: "uppercase",
-          }}
-        >
+        <span style={SECTION_HEADING_STYLE}>
           {t("projects.heading")}
         </span>
         <SidebarIconButton
@@ -1803,65 +1923,30 @@ export const SessionSidebar = memo(function SessionSidebar({ selectedSessionId,
             if (showHostGroups && filtersActive && entries.length === 0) return null;
             const rows = entries.map(({ project, sessions }) => {
               const projectKey = projectIdentity(project);
-              // A member's own project listed in the cluster group: name its node.
-              const node = project.poolId || host.id === hostOf(project) ? undefined : hosts?.find((candidate) => candidate.id === hostOf(project));
-              const unavailable = node ? hostUnavailableReason(node.id) : null;
               const tree = treesByProject.get(projectKey) ?? buildSessionTree(sessions);
-              // Sessions group under a project through the case-folded comparable
-              // form (see groupSessionsByProject), so the active highlight must
-              // use the same comparison: a session whose cwd/projectRoot spells
-              // the project folder with different casing (Windows/NTFS) lands in
-              // this row — the row must light up for it too.
-              const isActive = selectedProject !== null && (project.poolId ? selectedProject === projectKey : !selectedPoolKey && selectedHostId === hostOf(project) && comparableProjectPath(selectedProject) === comparableProjectPath(project.path));
               return (
                 <ProjectRow
                   key={projectKey}
-                  project={project}
-                  node={node ? { label: hostName(t, node), statusText: unavailable ? hostStatusText(t, node) : null, unavailableReason: unavailable } : undefined}
-                  isActive={isActive}
-                  activity={projectActivity.get(foldedHostProjectKey(project.hostId, workspaceKeyOf(project)))}
+                  {...projectRowProps(project, host.id)}
                   tree={tree}
                   isExpanded={expandedProjectKeys.has(foldedHostProjectKey(project.hostId, workspaceKeyOf(project)))}
                   hiddenCount={filtersActive ? 0 : Math.max(0, tree.length - MAX_PROJECT_SESSIONS)}
-                  selectedSessionId={selectedSessionId}
-                  runningSessionIds={runningSessionIds}
-                  awaitingInputIds={awaitingInputIds}
-                  unreadSessionIds={unreadSessionIds}
-                  exitedSessions={exitedSessions}
-                  recentlyCompletedIds={effectiveRecentCompletedSet}
-                  relativeTimeNow={relativeTimeNow}
-                  onActivate={activateProject}
                   onToggleExpand={toggleProjectExpanded}
-                  onRemoveProject={handleRemoveProject}
-                  onEditLaunchConfig={setLaunchConfigProject}
-                  onUpdatePresentation={handleUpdateProjectPresentation}
-                  onDragProjectChange={setDraggedProject}
-                  onDropProject={(target) => void handleProjectDrop(target)}
-                  onMoveProject={(target, delta) => void handleMoveProject(target, delta)}
                   pinnable={pinsActive}
-                  onTogglePin={handleTogglePin}
                   isDragTarget={draggedProject !== null && projectTargetId(draggedProject, pools) === projectTargetId(project, pools) && projectIdentity(draggedProject) !== projectKey && (!pinsActive || project.pinOrder !== undefined)}
-                  removeBusy={removeProjectKey === projectKey}
-                  onSelectSession={handleSelectSessionFromList}
                   searchQuery={trimmedSearchQuery || undefined}
                   onOpenSearchMatch={onOpenSearchMatch ? handleOpenSearchMatch : undefined}
-                  onRenamed={loadSessions}
-                  onSessionDeleted={handleSessionDeleted}
                 />
               );
             });
             if (!showHostGroups) return rows;
-            const row = hosts?.find((candidate) => candidate.id === host.id);
             const member = pools.some((pool) => pool.members.some((member) => member.hostId === host.id));
             if (member && entries.length === 0) return null;
             const canAdd = host.id.startsWith("pool:") || (!member && (host.id === LOCAL_HOST_ID || poolsLoaded));
             return (
               <HostGroup
                 key={host.id}
-                name={row ? hostName(t, row) : host.label}
-                color={row ? HOST_STATUS_COLOR[row.status] : undefined}
-                statusText={row && row.status !== "online" ? hostStatusText(t, row) : null}
-                unavailableReason={hostUnavailableReason(host.id)}
+                {...hostGroupHeader(host)}
                 collapsed={collapsedHosts.has(host.id)}
                 onToggle={() => toggleHostCollapsed(host.id)}
                 onAdd={canAdd ? () => {
diff --git a/docs/specs/2026-11-13-attention-sidebar-design.md b/docs/specs/2026-11-13-attention-sidebar-design.md
new file mode 100644
index 000000000..dd311beb7
--- /dev/null
+++ b/docs/specs/2026-11-13-attention-sidebar-design.md
@@ -0,0 +1,111 @@
+# Needs attention: sidebar section and agent attention signal
+
+## Intent
+
+A user running many sessions across hosts must see at a glance which ones are
+blocked on them. Today a blocked session is marked inside its workspace (#461,
+the "Waiting for your input" icon), but finding it means scanning every
+expanded workspace. A **Needs attention** section above Workspaces lists exactly
+those sessions, and nothing else.
+
+## What counts as needing attention
+
+A session needs attention while either holds:
+
+1. **An open blocking dialog** waits for the user: `ask`, `confirm`, `select`,
+   `input`, `editor` or `open_url` (`BLOCKING_UI_METHODS`). This covers tool
+   permission prompts ("Allow tool: …", unless auto-approved) and omp-web's own
+   confirmations (`confirmFromServer`, used by `send_to_session` and
+   `new_session`). The server already reports this per running session as
+   `RunningRpcSession.awaitingInput` (#461).
+2. **The agent said it waits for the user.** The model calls the
+   `request_attention` tool when it ends its turn waiting for an instruction,
+   an answer, a decision or an approval. The tool persists a marker entry. The
+   session needs attention while that marker is newer than the session's newest
+   user message **and** the session is not running. The next user message
+   clears it, so the agent never has to withdraw it.
+
+The second signal lives in the session file, so it survives idle reaping (the
+omp process is gone), web server restarts and daemon restarts.
+
+## Agent tool: `request_attention`
+
+- Part of ompweb's omp build: `runner/src/attention.ts` defines it as an SDK
+  custom tool, and `createHostedAgentSession` (`runner/src/session.ts`) passes
+  it in `customTools` to every session the runner creates, headless or TUI, so
+  every omp-web session on every host gets it. Subagents do not (omp builds
+  them with its own factory and none of their parent's custom tools), nor do
+  sessions of a stock omp.
+- `loadMode: "essential"`, so it is always in the model's tool list; omp keeps
+  SDK custom tools active under `--tools <list>` and `--no-tools`.
+- Parameters: `{ reason: string }`, a short sentence on what the agent needs.
+  The runner collapses whitespace, trims it and keeps at most 300 characters.
+- Effect: `session.sessionManager.appendCustomEntry("omp-web-attention",
+  { reason })` on the session that runs it, persisted as
+  `{"type":"custom","customType":"omp-web-attention","data":{"reason":…},…}`.
+  It does not change the session title.
+- The tool description tells the model when to call it: at the end of a turn
+  that waits on the user. Not for progress updates, not mid-task.
+- The entry type and the 300-character cap are a literal on each side, as for
+  `omp-web-history-navigation`: `runner/src/attention.ts` and
+  `lib/omp/session-files.ts`.
+
+## Detection on disk
+
+`scanTailMessage` (`lib/omp/session-files.ts`) already walks the tail window
+backwards to the newest message entry. It continues backwards until the newest
+real `role: "user"` message; an `omp-web-attention` custom entry found before
+that sets `attention: { reason, at }` (`at` is the entry's timestamp, `""` when
+missing). User-role messages omp marks `synthetic: true` do not count as the
+user answering, so they neither stop the walk nor clear the marker. An
+assistant message with a tool call newer than the marker means the agent kept
+working, so the marker is ignored; the call that requested attention is older
+than its marker and does not cancel it. Only the
+32 KiB tail window is scanned; a marker followed by more than 32 KiB of later
+entries without a user message is not found (accepted: the agent calls the tool
+as its last act).
+
+`SessionInfo.attention?: { reason: string; at: string }` carries it to the
+client through the existing per-host session lists. The session list refreshes
+on `agent_end` already, so a marker written during a run appears when the run
+ends.
+
+## Sidebar
+
+- A **Needs attention** section above the Workspaces header. Hidden while no
+  session needs attention.
+- The set: `awaitingInput` sessions from the `running` channel, plus sessions
+  whose `attention` is set and that are not running.
+- Same structure, rows and badges as Workspaces: host group (when host groups
+  show), then workspace row, then session rows, rendered with the same
+  components. Sessions stay in Workspaces too.
+- Always alphabetical: hosts by name, workspaces by label, sessions by display
+  title. The user's sort mode, pins and manual order do not apply.
+- No pin control, no drag or move, no sort/filter/add buttons in the section
+  header. Search and the running filter do not filter it.
+- Workspace rows in the section start expanded and show every attention
+  session (no "show more"). Collapsing a host or workspace there does not
+  affect Workspaces.
+- A session row's tooltip carries the reason when the attention comes from
+  the tool.
+- The section scrolls on its own and takes at most about 40% of the sidebar
+  height, so Workspaces stays reachable.
+
+## Approaches considered
+
+1. **Title emoji convention** (`⏸️`, `❓`, `🚧` from a personal
+   `session_phase` extension). Rejected: omp-web would hardcode one user's
+   convention.
+2. **Live extension status** (`ctx.ui.setStatus`). Rejected: in-memory only;
+   the session would leave the section when its idle process is reaped while
+   still waiting.
+3. **Bundled tool writing a session entry** (chosen). Works for every agent of
+   every omp-web session, persists, needs no omp change.
+4. **Native omp attention API**. Cleanest, but needs an upstream oh-my-pi
+   change; can replace 3 later.
+
+## Non-goals
+
+- Notifications: the existing `input` notification is unchanged.
+- Inferring attention from free text ("Should I…?").
+- Showing attention for terminal-only omp sessions.
diff --git a/lib/hosts/hub.test.mjs b/lib/hosts/hub.test.mjs
index 3be65b2c0..2e34067d0 100644
--- a/lib/hosts/hub.test.mjs
+++ b/lib/hosts/hub.test.mjs
@@ -1052,6 +1052,25 @@ test("a restarted daemon (hello ack 0) starts a fresh uplink sequence", async ()
   await restarted.down.cancel();
 });
 
+test("a session's attention marker passes the link's list validation; a malformed one drops only the marker", async () => {
+  const link = await linkedHost("Attentive");
+  const session = (n, extra) => ({
+    path: `/s/${n}.jsonl`, id: `11111111-2222-4333-8444-${String(n).padStart(12, "0")}`, cwd: "/w", created: "c", modified: "m", messageCount: 0, firstMessage: "", ...extra,
+  });
+  const valid = session(1, { attention: { reason: "Pick a color", at: "2026-11-13T00:00:00.000Z" } });
+  const malformed = [null, "waiting", { reason: 5, at: "t" }, { reason: "r" }].map((attention, i) => session(i + 2, { attention }));
+  const long = session(9, { attention: { reason: "x".repeat(500), at: "t" } });
+  const listing = link.remote.sessionOps.listSessions();
+  const req = await link.down.nextReal();
+  await linkPost(link, [{ type: "res", seq: 1, id: req.id, ok: true, result: [valid, ...malformed, long] }], req.seq);
+  assert.deepEqual(JSON.parse(JSON.stringify(await listing)), [
+    valid,
+    ...malformed.map((_, i) => session(i + 2)),
+    { ...long, attention: { reason: "x".repeat(300), at: "t" } },
+  ]);
+  await link.down.cancel();
+});
+
 test("binary frames carry a large result ahead of its res, joined in order; an unknown id is ignored, too many bytes fail the op", async () => {
   const link = await linkedHost("Blobby");
   const { socket } = link.down;
diff --git a/lib/hosts/hub.ts b/lib/hosts/hub.ts
index 2088ad045..4affe670d 100644
--- a/lib/hosts/hub.ts
+++ b/lib/hosts/hub.ts
@@ -5,6 +5,7 @@
 import { randomUUID } from "node:crypto";
 import { posix, win32 } from "node:path";
 import { readBodyWithinLimit } from "../bounded-form-data";
+import { ATTENTION_REASON_MAX } from "../omp/session-files";
 import type { RpcTransport } from "../omp/rpc-transport";
 import type { ProjectRegistryEntry } from "../project-registry";
 import { isValidSessionId } from "../session-file-references-core";
@@ -1071,14 +1072,21 @@ const nullableString = (value: unknown) => value === null || typeof value === "s
 /** A daemon's session-list entry reduced to SessionInfo's fields; null when one has the wrong type. */
 function sessionEntry(value: unknown): SessionInfo | null {
   if (!isRecord(value)) return null;
-  const { path, id, cwd, name, created, modified, lastMessageAt, messageCount, firstMessage, parentSessionId, projectRoot, projectKey, worktreeBranch } = value;
+  const { path, id, cwd, name, created, modified, lastMessageAt, messageCount, firstMessage, parentSessionId, projectRoot, projectKey, worktreeBranch, attention } = value;
+  // Optional: a malformed marker drops only the marker, never the session.
+  const mark = isRecord(attention) && typeof attention.reason === "string" && typeof attention.at === "string"
+    ? { reason: attention.reason.slice(0, ATTENTION_REASON_MAX), at: attention.at }
+    : undefined;
   if (
     typeof path !== "string" || typeof id !== "string" || !isValidSessionId(id) || typeof cwd !== "string"
     || typeof created !== "string" || typeof modified !== "string" || typeof firstMessage !== "string"
     || typeof messageCount !== "number" || !Number.isFinite(messageCount)
     || ![name, lastMessageAt, parentSessionId, projectRoot, projectKey, worktreeBranch].every(optionalString)
   ) return null;
-  return { path, id, cwd, name, created, modified, lastMessageAt, messageCount, firstMessage, parentSessionId, projectRoot, projectKey, worktreeBranch } as SessionInfo;
+  return {
+    path, id, cwd, name, created, modified, lastMessageAt, messageCount, firstMessage, parentSessionId, projectRoot, projectKey, worktreeBranch,
+    ...(mark ? { attention: mark } : {}),
+  } as SessionInfo;
 }
 
 /** A daemon's project-registry entry reduced to its known fields; null when one has the wrong type. */
diff --git a/lib/i18n/locales/en.json b/lib/i18n/locales/en.json
index 8d89c7cb4..792746ba9 100644
--- a/lib/i18n/locales/en.json
+++ b/lib/i18n/locales/en.json
@@ -1246,6 +1246,8 @@
   "sessionSidebar.copyTranscriptFailed": "Could not copy the transcript",
   "sessionSidebar.unsentDraft": "Unsent draft",
   "sessionSidebar.awaitingInput": "Waiting for your input",
+  "sessionSidebar.needsAttention": "Needs attention",
+  "sessionSidebar.attentionReason": "Needs attention: {reason}",
   "sessionSidebar.selectProjectFirst": "Select a project first",
   "sessionSidebar.switchWorktree": "Switch worktree",
   "sessionSidebar.launchConfigDirectory": "Directory",
diff --git a/lib/i18n/locales/ja.json b/lib/i18n/locales/ja.json
index 9d924608c..dcd0ea520 100644
--- a/lib/i18n/locales/ja.json
+++ b/lib/i18n/locales/ja.json
@@ -1203,6 +1203,8 @@
   "sessionSidebar.copyTranscriptFailed": "トランスクリプトをコピーできませんでした",
   "sessionSidebar.unsentDraft": "未送信の下書き",
   "sessionSidebar.awaitingInput": "入力を待っています",
+  "sessionSidebar.needsAttention": "要対応",
+  "sessionSidebar.attentionReason": "要対応: {reason}",
   "sessionSidebar.selectProjectFirst": "先にプロジェクトを選択してください",
   "sessionSidebar.switchWorktree": "ワークツリーを切り替え",
   "sessionSidebar.launchConfigDirectory": "ディレクトリ",
diff --git a/lib/i18n/locales/zh-CN.json b/lib/i18n/locales/zh-CN.json
index 57541240a..b5141c578 100644
--- a/lib/i18n/locales/zh-CN.json
+++ b/lib/i18n/locales/zh-CN.json
@@ -1203,6 +1203,8 @@
   "sessionSidebar.copyTranscriptFailed": "无法复制对话记录",
   "sessionSidebar.unsentDraft": "未发送的草稿",
   "sessionSidebar.awaitingInput": "等待你的输入",
+  "sessionSidebar.needsAttention": "需要处理",
+  "sessionSidebar.attentionReason": "需要处理：{reason}",
   "sessionSidebar.selectProjectFirst": "请先选择一个项目",
   "sessionSidebar.switchWorktree": "切换工作树",
   "sessionSidebar.launchConfigDirectory": "目录",
diff --git a/lib/i18n/locales/zh-TW.json b/lib/i18n/locales/zh-TW.json
index 27644a4fd..d8084305e 100644
--- a/lib/i18n/locales/zh-TW.json
+++ b/lib/i18n/locales/zh-TW.json
@@ -1246,6 +1246,8 @@
   "sessionSidebar.copyTranscriptFailed": "無法複製逐字稿",
   "sessionSidebar.unsentDraft": "未傳送的草稿",
   "sessionSidebar.awaitingInput": "等待您的輸入",
+  "sessionSidebar.needsAttention": "需要處理",
+  "sessionSidebar.attentionReason": "需要處理：{reason}",
   "sessionSidebar.selectProjectFirst": "請先選取專案",
   "sessionSidebar.switchWorktree": "切換工作樹",
   "sessionSidebar.launchConfigDirectory": "目錄",
diff --git a/lib/omp/session-files.ts b/lib/omp/session-files.ts
index 2524beccb..d7c9bd5a1 100644
--- a/lib/omp/session-files.ts
+++ b/lib/omp/session-files.ts
@@ -660,6 +660,14 @@ export interface OmpSessionInfo {
   status?: SessionStatus;
   /** Timestamp of the last message entry in the tail window (when scanned with status). */
   lastMessageAt?: Date;
+  /** The agent's request_attention marker newer than the newest user message (when scanned with status). */
+  attention?: SessionAttention;
+}
+
+export interface SessionAttention {
+  reason: string;
+  /** The marker entry's timestamp (ISO). */
+  at: string;
 }
 
 const SESSION_LIST_PREFIX_BYTES = 4096;
@@ -797,8 +805,11 @@ interface TailMessage {
   role?: string;
   stopReason?: string;
   content?: unknown;
+  synthetic?: unknown;
 }
 
+const hasToolCall = (content: unknown) => Array.isArray(content) && content.some((block) => isRecord(block) && block.type === "toolCall");
+
 function statusFromTailMessage(message: TailMessage): SessionStatus {
   switch (message.role) {
     case "assistant": {
@@ -810,10 +821,7 @@ function statusFromTailMessage(message: TailMessage): SessionStatus {
         case "length":
           return "interrupted";
       }
-      const content = message.content;
-      if (Array.isArray(content) && content.some((block) => isRecord(block) && block.type === "toolCall")) {
-        return "interrupted";
-      }
+      if (hasToolCall(message.content)) return "interrupted";
       return "complete";
     }
     case "toolResult":
@@ -825,27 +833,61 @@ function statusFromTailMessage(message: TailMessage): SessionStatus {
   }
 }
 
-/** The tail window's last message entry: lifecycle status plus its timestamp. */
-function scanTailMessage(suffix: string): { status: SessionStatus; lastMessageAt?: Date } {
-  if (!suffix) return { status: "unknown" };
+/** The `customType` of the agent's `request_attention` marker; ompweb's omp build writes it (`runner/src/attention.ts`). */
+export const ATTENTION_ENTRY_TYPE = "omp-web-attention";
+/** The longest attention reason kept; `runner/src/attention.ts` caps the reason it writes at the same length. */
+export const ATTENTION_REASON_MAX = 300;
+
+interface TailScan {
+  status: SessionStatus;
+  lastMessageAt?: Date;
+  attention?: SessionAttention;
+}
+
+/** The tail window's last message entry (lifecycle status plus its timestamp), and the newest attention marker
+ * written after the newest real user message with no assistant tool call after it. Entries are appended in time order,
+ * so a marker in the window with no user message after it is newer than every user message, including those before
+ * the window. A tool call after the marker means the agent kept working, so no marker counts. */
+function scanTailMessage(suffix: string): TailScan {
+  const result: TailScan = { status: "unknown" };
+  if (!suffix) return result;
   const lines = suffix.split("\n");
+  let sawMessage = false;
   for (let i = lines.length - 1; i >= 0; i--) {
     const line = lines[i];
     // Every persisted entry starts with "{" — cheaply skips blank lines and
     // the leading partial fragment of the tail window.
     if (line.charCodeAt(0) !== 123) continue;
-    let entry: { type?: string; timestamp?: unknown; message?: TailMessage };
+    let entry: { type?: string; customType?: unknown; data?: { reason?: unknown }; timestamp?: unknown; message?: TailMessage };
     try {
       entry = JSON.parse(line);
     } catch {
       continue;
     }
     if (entry.type === "message" && entry.message) {
-      const at = typeof entry.timestamp === "string" ? new Date(entry.timestamp) : undefined;
-      return { status: statusFromTailMessage(entry.message), lastMessageAt: at && !Number.isNaN(at.getTime()) ? at : undefined };
+      const message = entry.message;
+      if (!sawMessage) {
+        sawMessage = true;
+        const at = typeof entry.timestamp === "string" ? new Date(entry.timestamp) : undefined;
+        result.status = statusFromTailMessage(message);
+        result.lastMessageAt = at && !Number.isNaN(at.getTime()) ? at : undefined;
+      }
+      // A real user message clears every older marker; omp's synthetic user-role messages do not.
+      if (message.role === "user" && message.synthetic !== true) break;
+      // An assistant tool call settles the walk: newer than any marker still ahead (the agent kept working, so none
+      // counts), or older than the marker already found (the call that requested attention), which it leaves alone.
+      if (message.role === "assistant" && hasToolCall(message.content)) break;
+    } else if (entry.type === "custom" && entry.customType === ATTENTION_ENTRY_TYPE && !result.attention) {
+      const reason = entry.data?.reason;
+      result.attention = {
+        reason: typeof reason === "string" ? reason.slice(0, ATTENTION_REASON_MAX) : "",
+        at: typeof entry.timestamp === "string" ? entry.timestamp : "",
+      };
     }
+    // The newest marker is found and the status is known: nothing older changes either.
+    if (sawMessage && result.attention) break;
   }
-  return { status: "unknown" };
+  return result;
 }
 
 interface SessionListHeader {
@@ -1004,6 +1046,7 @@ export function scanSessionInfo(
       firstMessage: firstMessage || "(no messages)",
       status: tail?.status,
       lastMessageAt: tail?.lastMessageAt,
+      attention: tail?.attention,
     };
   } catch {
     return undefined;
diff --git a/lib/session-reader.test.mjs b/lib/session-reader.test.mjs
index c3c448cd1..c223bc1cb 100644
--- a/lib/session-reader.test.mjs
+++ b/lib/session-reader.test.mjs
@@ -524,6 +524,103 @@ test("lists each session's last message time from the tail, not the file mtime",
   });
 });
 
+// request_attention (runner/src/attention.ts) persists a marker; the next user message clears it.
+test("lists the agent's attention marker until the next user message", async () => {
+  await withAgentDir(async (dir) => {
+    const cwd = join(tmpdir(), "omp-web-missing-project");
+    const marker = (id, parentId, reason, timestamp) => ({ type: "custom", customType: "omp-web-attention", data: { reason }, id, parentId, timestamp });
+    const toolResult = (id, parentId, timestamp) => ({
+      type: "message", id, parentId, timestamp,
+      message: { role: "toolResult", toolCallId: "c1", toolName: "request_attention", content: [{ type: "text", text: "ok" }] },
+    });
+    const waitingPath = writeSessionFile(dir, "2026-01-01_waiting.jsonl", { id: "waiting", cwd, timestamp: "2026-01-01T00:00:00.000Z" }, [
+      userEntry("u1", null, "plan it", "2026-01-01T00:00:01.000Z"),
+      marker("m1", "u1", "An older ask", "2026-01-01T00:00:02.000Z"),
+      assistantEntry("a1", "m1", "Which color?", "2026-01-01T00:00:03.000Z"),
+      marker("m2", "a1", "Pick a color", "2026-01-01T00:00:04.000Z"),
+      toolResult("r1", "m2", "2026-01-01T00:00:05.000Z"),
+      assistantEntry("a2", "r1", "Waiting for you.", "2026-01-01T00:00:06.000Z"),
+    ]);
+    writeSessionFile(dir, "2026-01-02_answered.jsonl", { id: "answered", cwd, timestamp: "2026-01-02T00:00:00.000Z" }, [
+      userEntry("u1", null, "plan it", "2026-01-02T00:00:01.000Z"),
+      marker("m1", "u1", "Pick a color", "2026-01-02T00:00:02.000Z"),
+      userEntry("u2", "m1", "blue", "2026-01-02T00:00:03.000Z"),
+      assistantEntry("a1", "u2", "Done.", "2026-01-02T00:00:04.000Z"),
+    ]);
+    writeSessionFile(dir, "2026-01-03_plain.jsonl", { id: "plain", cwd, timestamp: "2026-01-03T00:00:00.000Z" }, [
+      userEntry("u1", null, "hi", "2026-01-03T00:00:01.000Z"),
+      assistantEntry("a1", "u1", "Hello.", "2026-01-03T00:00:02.000Z"),
+    ]);
+    let byId = new Map((await listAllSessions()).map((s) => [s.id, s]));
+    assert.deepEqual(byId.get("waiting")?.attention, { reason: "Pick a color", at: "2026-01-01T00:00:04.000Z" });
+    // The marker walk leaves the newest message's time alone.
+    assert.equal(byId.get("waiting")?.lastMessageAt, "2026-01-01T00:00:06.000Z");
+    assert.equal(byId.get("answered")?.attention, undefined);
+    assert.equal(byId.get("plain")?.attention, undefined);
+
+    // The user's answer clears it: the append changes size and mtime, so the per-file scan memo rescans.
+    appendFileSync(waitingPath, `${JSON.stringify(userEntry("u2", "a2", "blue", "2026-01-01T00:00:07.000Z"))}\n`);
+    invalidateSessionListCache();
+    byId = new Map((await listAllSessions()).map((s) => [s.id, s]));
+    assert.equal(byId.get("waiting")?.attention, undefined);
+    assert.equal(byId.get("waiting")?.lastMessageAt, "2026-01-01T00:00:07.000Z");
+  });
+});
+
+test("drops the attention marker once the agent kept working, and keeps it past synthetic user messages", async () => {
+  await withAgentDir(async (dir) => {
+    const cwd = join(tmpdir(), "omp-web-missing-project");
+    const marker = (id, parentId, reason, timestamp) => ({ type: "custom", customType: "omp-web-attention", data: { reason }, id, parentId, ...(timestamp ? { timestamp } : {}) });
+    const toolCall = (id, parentId, name, timestamp) => ({
+      type: "message", id, parentId, timestamp,
+      message: { role: "assistant", stopReason: "toolUse", content: [{ type: "toolCall", id: `c-${id}`, name, arguments: {} }] },
+    });
+    const toolResult = (id, parentId, name, timestamp) => ({
+      type: "message", id, parentId, timestamp,
+      message: { role: "toolResult", toolCallId: `c-${parentId}`, toolName: name, content: [{ type: "text", text: "ok" }] },
+    });
+    // The request_attention call precedes its own marker; later bash/edit calls mean the agent moved on.
+    writeSessionFile(dir, "2026-01-01_moved-on.jsonl", { id: "moved-on", cwd, timestamp: "2026-01-01T00:00:00.000Z" }, [
+      userEntry("u1", null, "fix it", "2026-01-01T00:00:01.000Z"),
+      toolCall("a1", "u1", "request_attention", "2026-01-01T00:00:02.000Z"),
+      marker("m1", "a1", "Need approval", "2026-01-01T00:00:03.000Z"),
+      toolResult("r1", "m1", "request_attention", "2026-01-01T00:00:04.000Z"),
+      toolCall("a2", "r1", "bash", "2026-01-01T00:00:05.000Z"),
+      toolResult("r2", "a2", "bash", "2026-01-01T00:00:06.000Z"),
+      toolCall("a3", "r2", "edit", "2026-01-01T00:00:07.000Z"),
+      toolResult("r3", "a3", "edit", "2026-01-01T00:00:08.000Z"),
+      assistantEntry("a4", "r3", "All done, nothing needed from you.", "2026-01-01T00:00:09.000Z"),
+    ]);
+    // The marker's own call stays older than it, so it still counts; a synthetic user-role message does not clear it.
+    writeSessionFile(dir, "2026-01-02_synthetic.jsonl", { id: "synthetic", cwd, timestamp: "2026-01-02T00:00:00.000Z" }, [
+      userEntry("u1", null, "fix it", "2026-01-02T00:00:01.000Z"),
+      toolCall("a1", "u1", "request_attention", "2026-01-02T00:00:02.000Z"),
+      marker("m1", "a1", "Need approval", "2026-01-02T00:00:03.000Z"),
+      toolResult("r1", "m1", "request_attention", "2026-01-02T00:00:04.000Z"),
+      {
+        type: "message", id: "s1", parentId: "r1", timestamp: "2026-01-02T00:00:05.000Z",
+        message: { role: "user", synthetic: true, attribution: "agent", content: [{ type: "text", text: "reminder" }] },
+      },
+      assistantEntry("a2", "s1", "Waiting for you.", "2026-01-02T00:00:06.000Z"),
+    ]);
+    writeSessionFile(dir, "2026-01-03_untimed.jsonl", { id: "untimed", cwd, timestamp: "2026-01-03T00:00:00.000Z" }, [
+      userEntry("u1", null, "plan it", "2026-01-03T00:00:01.000Z"),
+      marker("m1", "u1", "OLDER", "2026-01-03T00:00:02.000Z"),
+      marker("m2", "m1", "NEWER"),
+      assistantEntry("a1", "m2", "Waiting for you.", "2026-01-03T00:00:03.000Z"),
+    ]);
+    writeSessionFile(dir, "2026-01-04_long.jsonl", { id: "long", cwd, timestamp: "2026-01-04T00:00:00.000Z" }, [
+      userEntry("u1", null, "plan it", "2026-01-04T00:00:01.000Z"),
+      marker("m1", "u1", "x".repeat(500), "2026-01-04T00:00:02.000Z"),
+    ]);
+    const byId = new Map((await listAllSessions()).map((s) => [s.id, s]));
+    assert.equal(byId.get("moved-on")?.attention, undefined);
+    assert.deepEqual(byId.get("synthetic")?.attention, { reason: "Need approval", at: "2026-01-02T00:00:03.000Z" });
+    assert.deepEqual(byId.get("untimed")?.attention, { reason: "NEWER", at: "" });
+    assert.equal(byId.get("long")?.attention?.reason, "x".repeat(300));
+  });
+});
+
 // Rules/skills/memory injections land before the first user message and can
 // exceed the 4 KiB list-scan prefix; the sidebar and auto-name need that text.
 test("lists the first user message even when injected context precedes it beyond the scan prefix", async () => {
diff --git a/lib/session-reader.ts b/lib/session-reader.ts
index 363e62559..427ffee65 100644
--- a/lib/session-reader.ts
+++ b/lib/session-reader.ts
@@ -97,6 +97,7 @@ async function loadAllSessions(): Promise<SessionInfo[]> {
       projectRoot: project?.projectRoot ?? s.cwd,
       projectKey: projectIdentityKey(project?.projectRoot ?? s.cwd),
       ...(project?.isWorktree && project.branch ? { worktreeBranch: project.branch } : {}),
+      ...(s.attention ? { attention: s.attention } : {}),
     };
   });
 }
diff --git a/lib/types.ts b/lib/types.ts
index c1e728eb5..b9c8a637f 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -449,6 +449,8 @@ export interface SessionInfo {
   /** Registered logical identity; physical owner/cwd/projectRoot remain unchanged. */
   poolId?: string;
   projectId?: string;
+  /** The agent asked for the user (`request_attention`) after the newest user message. */
+  attention?: { reason: string; at: string };
 }
 
 /** Metadata for a gzip-compressed session in OMP's archive tree. */
diff --git a/runner/src/attention.ts b/runner/src/attention.ts
new file mode 100644
index 000000000..b07750c0b
--- /dev/null
+++ b/runner/src/attention.ts
@@ -0,0 +1,53 @@
+/**
+ * The agent's `request_attention` tool. It only appends an `omp-web-attention` custom entry to its session: ompweb's
+ * session list (`lib/omp/session-files.ts`) shows a session under Needs attention while that marker is newer than its
+ * newest user message and the session is not running.
+ */
+import { type } from "@oh-my-pi/omptype";
+import type { CustomTool } from "@oh-my-pi/pi-coding-agent/extensibility/custom-tools/types";
+import type { AgentSession } from "@oh-my-pi/pi-coding-agent/session/agent-session";
+
+/** The marker's `customType`; ompweb's session list reads the same literal (`lib/omp/session-files.ts`). */
+export const ATTENTION_ENTRY_TYPE = "omp-web-attention";
+/** The longest reason written; `lib/omp/session-files.ts` caps the reason it reads at the same length. */
+export const ATTENTION_REASON_MAX = 300;
+
+const parameters = type({
+	reason: type("string").describe('One short sentence on what you need from the user, e.g. "Approve the migration plan".'),
+});
+
+/**
+ * `request_attention` for the session `session()` returns. A session's tools are built before the session, so the
+ * factory hands in a getter it fills once the session exists; no turn, and so no tool call, runs before that.
+ */
+export function createAttentionTool(
+	session: () => AgentSession | undefined,
+): CustomTool<typeof parameters, { reason: string }> {
+	return {
+		name: "request_attention",
+		label: "Request Attention",
+		// Always in the model's tool list: SDK custom tools otherwise default to "discoverable", behind a discovery
+		// step, and a tool the model must look up first is one it forgets to call at the end of a turn.
+		loadMode: "essential",
+		description: [
+			"Mark this session as waiting for the user, so it shows under Needs attention in omp-web.",
+			"Call it as the last action of a turn that ends waiting on the user: for an instruction, an answer, a decision or an approval.",
+			"Do not call it for progress updates or mid-task.",
+			"The user's next message clears it; never withdraw it yourself.",
+		].join(" "),
+		parameters,
+		async execute(_toolCallId, params) {
+			const target = session();
+			if (!target) throw new Error("request_attention ran before its session existed");
+			const reason = String(params.reason ?? "")
+				.replace(/\s+/g, " ")
+				.trim()
+				.slice(0, ATTENTION_REASON_MAX);
+			target.sessionManager.appendCustomEntry(ATTENTION_ENTRY_TYPE, { reason });
+			return {
+				content: [{ type: "text", text: "The session is marked as waiting for the user. End the turn now." }],
+				details: { reason },
+			};
+		},
+	};
+}
diff --git a/runner/src/session.ts b/runner/src/session.ts
index 1e6a49209..cd0221739 100644
--- a/runner/src/session.ts
+++ b/runner/src/session.ts
@@ -3,6 +3,8 @@ import {
 	type CreateAgentSessionResult,
 	createAgentSession,
 } from "@oh-my-pi/pi-coding-agent/sdk";
+import type { AgentSession } from "@oh-my-pi/pi-coding-agent/session/agent-session";
+import { createAttentionTool } from "./attention";
 import { HostChannel } from "./channel";
 import { isHeadless } from "./headless";
 
@@ -10,12 +12,21 @@ import { isHeadless } from "./headless";
  * omp's session factory, plus the `ompweb host` channel: the host receives the session's events
  * and drives it through the same `AgentSession` the TUI uses, and dialogs open on both sides.
  * A headless omp serves the host on stdio instead, from `headless.ts`.
+ * Every session it makes gets the `request_attention` tool (`attention.ts`). Subagents do not: omp builds
+ * them with its own factory and hands them none of their parent's custom tools.
  */
 export async function createHostedAgentSession(options: CreateAgentSessionOptions = {}): Promise<CreateAgentSessionResult> {
+	let session: AgentSession | undefined;
+	const customTools = [...(options.customTools ?? []), createAttentionTool(() => session)];
 	// A non-interactive launch throws when a resumed session's model cannot be restored; ompweb instead
 	// opens it on the default model, or none, so a logged-out user can still open old sessions and log in from them.
-	if (isHeadless()) return createAgentSession({ ...options, allowSessionModelFallback: true });
-	const result = await createAgentSession(options);
+	if (isHeadless()) {
+		const result = await createAgentSession({ ...options, customTools, allowSessionModelFallback: true });
+		session = result.session;
+		return result;
+	}
+	const result = await createAgentSession({ ...options, customTools });
+	session = result.session;
 	// Only the TUI is a session the web may drive; `-p`, json and acp runs leave `hasUI` unset (rpc modes never reach here).
 	if (!options.hasUI) return result;
 	const channel = await HostChannel.connect(result.session, result.subagentEventBus);
diff --git a/runner/test/attention.test.ts b/runner/test/attention.test.ts
new file mode 100644
index 000000000..198131794
--- /dev/null
+++ b/runner/test/attention.test.ts
@@ -0,0 +1,44 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import * as os from "node:os";
+import * as path from "node:path";
+import { ATTENTION_ENTRY_TYPE, ATTENTION_REASON_MAX } from "../src/attention";
+import { createTestSession, type TestSession } from "./harness";
+
+let test: TestSession | undefined;
+
+afterEach(async () => {
+	await test?.dispose();
+	test = undefined;
+});
+
+const toolCall = { type: "toolCall" as const, name: "request_attention" };
+
+describe("request_attention", () => {
+	it("is in the model's tool list and appends the trimmed, capped reason as the marker entry", async () => {
+		// No host listens here: the session's channel stays closed.
+		process.env.OMPWEB_HOST_SOCKET = path.join(os.tmpdir(), `ompweb-attention-test-${process.pid}.sock`);
+		test = await createTestSession({
+			responses: [
+				{ content: [{ ...toolCall, arguments: { reason: "  Pick\n a   color  " } }] },
+				{ content: ["waiting"] },
+				{ content: [{ ...toolCall, arguments: { reason: "x".repeat(ATTENTION_REASON_MAX + 50) } }] },
+				{ content: ["waiting again"] },
+			],
+		});
+		const { session, mock } = test;
+		const markers = () =>
+			session.sessionManager
+				.getEntries()
+				.flatMap(entry => (entry.type === "custom" && entry.customType === ATTENTION_ENTRY_TYPE ? [entry.data] : []));
+
+		await session.prompt("pick one");
+		await session.waitForIdle();
+		// The harness passes an explicit (empty) tool list, as `--tools`/`--no-tools` do: the tool still reaches the model.
+		expect(mock.calls[0]?.context.tools?.map(tool => tool.name)).toContain("request_attention");
+		expect(markers()).toEqual([{ reason: "Pick a color" }]);
+
+		await session.prompt("and again");
+		await session.waitForIdle();
+		expect(markers()).toEqual([{ reason: "Pick a color" }, { reason: "x".repeat(ATTENTION_REASON_MAX) }]);
+	});
+});