diff --git a/apps/web/src/components/PhaseGroupedSidebar.tsx b/apps/web/src/components/PhaseGroupedSidebar.tsx
index b5a5c8bb0440d..a184a06a673f3 100644
--- a/apps/web/src/components/PhaseGroupedSidebar.tsx
+++ b/apps/web/src/components/PhaseGroupedSidebar.tsx
@@ -244,6 +244,7 @@ import {
   buildPhaseSidebarSections,
   isPhaseSidebarSectionCollapsed,
   listPhaseSidebarCustomGroups,
+  PHASE_SIDEBAR_RUNNING_SHELF_SECTION,
   PHASE_SIDEBAR_SHELF_SECTIONS,
   PHASE_SIDEBAR_UNGROUPED_ID,
   phaseSidebarCustomGroupIdForRow,
@@ -256,6 +257,7 @@ import {
 } from "@t3tools/client-runtime/state/phase-sidebar-grouping";
 import { usePhaseSidebarGroupingStore } from "../phaseSidebarGroupingStore";
 import { PhaseSidebarGroupByPopover } from "./sidebar/PhaseSidebarGroupByPopover";
+import { PhaseSidebarRunningShelfSwitch } from "./sidebar/PhaseSidebarRunningShelfSwitch";
 import { PhaseSidebarGroupNameDialog } from "./sidebar/PhaseSidebarGroupNameDialog";
 import {
   PHASE_SIDEBAR_SECTION_ACTION_BUTTON_CLASS_NAME,
@@ -2888,7 +2890,7 @@ export function PhaseGroupedSidebar() {
       null,
     [environments],
   );
-  const { sections, forcedExpansionKeys } = useMemo(
+  const { sections, forcedExpansionKeys, runningNodes } = useMemo(
     () =>
       buildPhaseSidebarSections({
         rows: activeRows,
@@ -3040,8 +3042,10 @@ export function PhaseGroupedSidebar() {
       for (const child of node.children) visit(child);
     };
     for (const group of groups) for (const node of group.nodes) visit(node);
+    // T3-CUSTOM(expbkt3): the Running shelf's trees are no longer in a group.
+    for (const node of runningNodes) visit(node);
     return keys;
-  }, [groups]);
+  }, [groups, runningNodes]);
   // T3-CUSTOM(expbkt3): END
   // T3-CUSTOM(expbkt3): Separate idle lifecycle groups from live agent work.
   // Only meaningful when the sections ARE lifecycle phases.
@@ -3114,12 +3118,42 @@ export function PhaseGroupedSidebar() {
       }),
     [routeThreadKey, settledRows, settledShelfCollapsed, settledVisibleCount],
   );
+  // The Running shelf (custom mode, switched on) holds live session trees, so
+  // an open shelf flattens them like any section for traversal.
+  const runningShelfCollapsed = isPhaseSidebarSectionCollapsed(
+    PHASE_SIDEBAR_RUNNING_SHELF_SECTION,
+    collapsedSectionKeys,
+  );
+  const toggleRunningShelf = useCallback(
+    () => toggleSectionCollapsed(PHASE_SIDEBAR_RUNNING_SHELF_SECTION.key),
+    [toggleSectionCollapsed],
+  );
+  const runningShelfRows = useMemo(
+    () =>
+      runningShelfCollapsed
+        ? []
+        : flattenPhaseSidebarTree(runningNodes, isTreeKeyExpanded).map((node) => node.row),
+    [isTreeKeyExpanded, runningNodes, runningShelfCollapsed],
+  );
+  const runningShelfHoldsRoutedThread = useMemo(
+    () =>
+      routeThreadKey !== null &&
+      flattenPhaseSidebarTree(runningNodes, () => true).some(
+        (node) => phaseSidebarRowKey(node.row) === routeThreadKey,
+      ),
+    [routeThreadKey, runningNodes],
+  );
   // T3-CUSTOM(expbkt3): END
   // Traversal, jump labels and shift-range selection operate on what is
   // actually on screen, in screen order: the list, then the docked shelves.
   const visibleRows = useMemo(
-    () => [...activeVisibleRows, ...snoozedShelf.rendered, ...settledShelf.rendered],
-    [activeVisibleRows, snoozedShelf.rendered, settledShelf.rendered],
+    () => [
+      ...activeVisibleRows,
+      ...runningShelfRows,
+      ...snoozedShelf.rendered,
+      ...settledShelf.rendered,
+    ],
+    [activeVisibleRows, runningShelfRows, snoozedShelf.rendered, settledShelf.rendered],
   );
   // T3-CUSTOM(expbkt3): BEGIN — environment markers are conditional on what is
   // actually rendered, not on how many environments are configured. With one
@@ -3257,6 +3291,7 @@ export function PhaseGroupedSidebar() {
     !visibleRowByKey.has(routeThreadKey) &&
     // T3-CUSTOM(expbkt3): a thread folded into a collapsed section or shelf is
     // not hidden by the filters; it is one header click away.
+    !runningShelfHoldsRoutedThread &&
     !snoozedShelf.containsRoutedThread &&
     !settledShelf.containsRoutedThread &&
     !sections.some(
@@ -4024,6 +4059,8 @@ export function PhaseGroupedSidebar() {
     // clean while silently leaving every treeXxx prop undefined, which reads as
     // "the feature is off" rather than as a build error.
     tree?: PhaseThreadRowTreeProps,
+    // T3-CUSTOM(expbkt3): Running shelf rows left their group, so they name it.
+    showGroup = false,
   ) => {
     const key = scopedThreadKey(scopeThreadRef(row.thread.environmentId, row.thread.id));
     const project =
@@ -4078,7 +4115,9 @@ export function PhaseGroupedSidebar() {
         // T3-CUSTOM(expbkt3): custom groups.
         {...(groupActions ? { groupActions } : {})}
         customGroupId={phaseSidebarCustomGroupIdForRow(row)}
-        customGroupLabel={grouping.groupBy === "custom" ? null : (row.customGroup ?? null)}
+        customGroupLabel={
+          grouping.groupBy === "custom" && !showGroup ? null : (row.customGroup ?? null)
+        }
         customGroupColor={customGroupColors.get(phaseSidebarCustomGroupIdForRow(row) ?? "") ?? null}
         linearIssueStatuses={linearStatusesForRow(row)}
         {...(tree ?? {})}
@@ -4088,22 +4127,27 @@ export function PhaseGroupedSidebar() {
 
   // T3-CUSTOM(expbkt3): BEGIN — a session tree renders as nested <ul>s so the
   // list stays a list for assistive tech, and each level animates on its own.
-  const renderTreeNode = (node: PhaseSidebarTreeNode): ReactNode => {
+  const renderTreeNode = (node: PhaseSidebarTreeNode, showGroup = false): ReactNode => {
     const expanded = expandedKeys.has(node.key);
     return (
       <Fragment key={node.key}>
-        {renderThreadRow(node.row, "active", {
-          treeActions,
-          treeDepth: node.depth,
-          treeDescendantCount: node.descendantCount,
-          treeHasBusyDescendant: node.hasBusyDescendant,
-          treeDescendantUnreadCount: node.descendantUnreadCount,
-          treeDescendantRunningCount: node.descendantRunningCount,
-          treeDescendantAttention: node.descendantAttention,
-          treeExpanded: expanded,
-          treeParentKey: node.orphanedFrom?.key ?? null,
-          treeParentTitle: node.orphanedFrom?.title ?? null,
-        })}
+        {renderThreadRow(
+          node.row,
+          "active",
+          {
+            treeActions,
+            treeDepth: node.depth,
+            treeDescendantCount: node.descendantCount,
+            treeHasBusyDescendant: node.hasBusyDescendant,
+            treeDescendantUnreadCount: node.descendantUnreadCount,
+            treeDescendantRunningCount: node.descendantRunningCount,
+            treeDescendantAttention: node.descendantAttention,
+            treeExpanded: expanded,
+            treeParentKey: node.orphanedFrom?.key ?? null,
+            treeParentTitle: node.orphanedFrom?.title ?? null,
+          },
+          showGroup,
+        )}
         {expanded && node.children.length > 0 ? (
           <li>
             <ul
@@ -4158,14 +4202,17 @@ export function PhaseGroupedSidebar() {
         <SidebarGroup className="px-2 pt-1 pb-2">
           <div className="flex items-center justify-between px-1">
             {/* T3-CUSTOM(expbkt3): the caption is the group-by control. */}
-            <PhaseSidebarGroupByPopover
-              groups={customGroupOptions}
-              onCreateGroup={createCustomGroup}
-              onRenameGroup={renameCustomGroup}
-              onDeleteGroup={deleteCustomGroup}
-              onMoveGroup={moveCustomGroup}
-              {...(canRecolorCustomGroups ? { onRecolorGroup: recolorCustomGroup } : {})}
-            />
+            <div className="flex min-w-0 items-center gap-3">
+              <PhaseSidebarGroupByPopover
+                groups={customGroupOptions}
+                onCreateGroup={createCustomGroup}
+                onRenameGroup={renameCustomGroup}
+                onDeleteGroup={deleteCustomGroup}
+                onMoveGroup={moveCustomGroup}
+                {...(canRecolorCustomGroups ? { onRecolorGroup: recolorCustomGroup } : {})}
+              />
+              {grouping.groupBy === "custom" ? <PhaseSidebarRunningShelfSwitch /> : null}
+            </div>
             <PhaseFilterPopover
               repositories={repositoryOptions}
               providers={providerOptions}
@@ -4227,7 +4274,7 @@ export function PhaseGroupedSidebar() {
           {/* T3-CUSTOM(expbkt3): drafts alone are a populated sidebar, even when collapsed. */}
           {sections.every((section) => section.nodes.length === 0) &&
           visibleDraftCount === 0 &&
-          snoozedRows.length + settledRows.length === 0 ? (
+          runningNodes.length + snoozedRows.length + settledRows.length === 0 ? (
             <div className="flex flex-col items-center gap-2 px-4 py-12 text-center">
               <FilterIcon className="size-5 text-muted-foreground/40" />
               <p className="text-xs text-muted-foreground">No threads match these filters</p>
@@ -4244,6 +4291,19 @@ export function PhaseGroupedSidebar() {
           just above the footer, so their headers stay on screen and only the
           list above gives up height when anything else in the sidebar grows. */}
       <PhaseSidebarShelfDock
+        {...(runningNodes.length > 0
+          ? {
+              running: {
+                count: runningNodes.length,
+                collapsed: runningShelfCollapsed,
+                containsRoutedThread: runningShelfHoldsRoutedThread,
+                items: runningShelfCollapsed
+                  ? null
+                  : runningNodes.map((node) => renderTreeNode(node, true)),
+                onToggle: toggleRunningShelf,
+              },
+            }
+          : {})}
         snoozed={{
           count: snoozedRows.length,
           collapsed: snoozedShelfCollapsed,
@@ -4376,11 +4436,37 @@ function PhaseSidebarSectionBlock({
   const manageable =
     onRenameGroup !== undefined || onDeleteGroup !== undefined || onRecolorGroup !== undefined;
   const [colorPickerOpen, setColorPickerOpen] = useState(false);
+  // A custom group says in words what needs you, open or closed, in place of
+  // its session count and the closed-header pills.
+  const summaryWords =
+    section.kind === "custom"
+      ? [
+          {
+            key: "attention",
+            count: summary.attention,
+            label: "asking",
+            className: "text-red-700 dark:text-red-300",
+          },
+          {
+            key: "unread",
+            count: summary.unread,
+            label: "unread",
+            className: "text-emerald-700 dark:text-emerald-300",
+          },
+          {
+            key: "running",
+            count: summary.running,
+            label: "running",
+            className: "text-sky-700 dark:text-sky-300",
+          },
+        ].filter((word) => word.count > 0)
+      : [];
+  const showPills = summaryWords.length === 0;
   const toggle = (
     <button
       type="button"
       aria-expanded={!collapsed}
-      aria-label={`${section.label}, ${section.nodes.length} session${section.nodes.length === 1 ? "" : "s"}${collapsed ? ", collapsed" : ""}`}
+      aria-label={`${section.label}, ${section.nodes.length} session${section.nodes.length === 1 ? "" : "s"}${summaryWords.map((word) => `, ${word.count} ${word.label}`).join("")}${collapsed ? ", collapsed" : ""}`}
       onClick={() => onToggleCollapsed(section.key)}
       className={cn(
         phaseSidebarSectionHeaderClassName(headerPhaseId),
@@ -4405,10 +4491,26 @@ function PhaseSidebarSectionBlock({
       <span className="truncate text-[11px] font-bold uppercase tracking-[0.1em]">
         {section.label}
       </span>
-      <span className="min-w-0 flex-1 truncate text-[9px] text-current/55">
-        {section.helperText}
-      </span>
-      {collapsed && summary.attention > 0 ? (
+      {summaryWords.length > 0 ? (
+        <span
+          className="min-w-0 flex-1 truncate text-[9px] font-semibold"
+          data-testid="phase-sidebar-section-summary-words"
+        >
+          {summaryWords.map((word, index) => (
+            <Fragment key={word.key}>
+              {index > 0 ? <span className="text-current/40"> · </span> : null}
+              <span className={word.className}>
+                {word.count} {word.label}
+              </span>
+            </Fragment>
+          ))}
+        </span>
+      ) : (
+        <span className="min-w-0 flex-1 truncate text-[9px] text-current/55">
+          {section.helperText}
+        </span>
+      )}
+      {showPills && collapsed && summary.attention > 0 ? (
         <span
           className="rounded-full bg-red-500/15 px-1.5 py-0.5 text-[9px] font-semibold tabular-nums text-red-700 dark:text-red-300"
           aria-label={`${summary.attention} waiting on you`}
@@ -4416,7 +4518,7 @@ function PhaseSidebarSectionBlock({
           {summary.attention}
         </span>
       ) : null}
-      {collapsed && summary.running > 0 ? (
+      {showPills && collapsed && summary.running > 0 ? (
         <span
           className="rounded-full bg-sky-500/15 px-1.5 py-0.5 text-[9px] font-semibold tabular-nums text-sky-700 dark:text-sky-300"
           aria-label={`${summary.running} running`}
@@ -4424,7 +4526,7 @@ function PhaseSidebarSectionBlock({
           {summary.running}
         </span>
       ) : null}
-      {collapsed && summary.unread > 0 ? (
+      {showPills && collapsed && summary.unread > 0 ? (
         <span
           className="rounded-full bg-emerald-500/15 px-1.5 py-0.5 text-[9px] font-semibold tabular-nums text-emerald-700 dark:text-emerald-300"
           aria-label={`${summary.unread} unread`}
diff --git a/apps/web/src/components/sidebar/PhaseSidebarRunningShelfSwitch.tsx b/apps/web/src/components/sidebar/PhaseSidebarRunningShelfSwitch.tsx
new file mode 100644
index 0000000000000..250857a56b1f0
--- /dev/null
+++ b/apps/web/src/components/sidebar/PhaseSidebarRunningShelfSwitch.tsx
@@ -0,0 +1,32 @@
+// T3-CUSTOM(expbkt3): the Running shelf switch beside the group-by caption.
+// Custom mode only: when it is on, sessions that run with nothing waiting on a
+// human leave their groups for the Running shelf in the dock.
+import { usePhaseSidebarGroupingStore } from "../../phaseSidebarGroupingStore";
+import { Switch } from "../ui/switch";
+import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
+
+export function PhaseSidebarRunningShelfSwitch() {
+  const enabled = usePhaseSidebarGroupingStore((state) => state.grouping.runningShelf === true);
+  const setRunningShelf = usePhaseSidebarGroupingStore((state) => state.setRunningShelf);
+  return (
+    <Tooltip>
+      <TooltipTrigger
+        render={
+          <label className="flex cursor-pointer items-center gap-1.5 text-[10px] font-medium uppercase tracking-wider text-muted-foreground/70 hover:text-foreground">
+            <Switch
+              size="sm"
+              checked={enabled}
+              onCheckedChange={setRunningShelf}
+              aria-label="Move running sessions to the Running shelf"
+              data-testid="phase-sidebar-running-shelf-switch"
+            />
+            Running
+          </label>
+        }
+      />
+      <TooltipPopup side="bottom">
+        Move running sessions without a question to the Running shelf
+      </TooltipPopup>
+    </Tooltip>
+  );
+}
diff --git a/apps/web/src/components/sidebar/PhaseSidebarShelfDock.expbkt3.test.tsx b/apps/web/src/components/sidebar/PhaseSidebarShelfDock.expbkt3.test.tsx
index fee895f2b2b9e..ebe9641fbe811 100644
--- a/apps/web/src/components/sidebar/PhaseSidebarShelfDock.expbkt3.test.tsx
+++ b/apps/web/src/components/sidebar/PhaseSidebarShelfDock.expbkt3.test.tsx
@@ -34,7 +34,7 @@ const onToggle = vi.fn();
 const onShowMoreSettled = vi.fn();
 let renderer: ReactTestRenderer | null = null;
 
-function mount(props: Pick<PhaseSidebarShelfDockProps, "snoozed" | "settled">) {
+function mount(props: Pick<PhaseSidebarShelfDockProps, "running" | "snoozed" | "settled">) {
   act(() => {
     renderer = create(
       <PhaseSidebarShelfDock
@@ -109,4 +109,41 @@ describe("PhaseSidebarShelfDock", () => {
     act(() => showMore.props.onClick());
     expect(onShowMoreSettled).toHaveBeenCalledTimes(1);
   });
+
+  it("shows the Running shelf on top, open with its rows, and toggles it on its own", () => {
+    const onToggleRunning = vi.fn();
+    mount({
+      running: {
+        count: 1,
+        collapsed: false,
+        containsRoutedThread: false,
+        items: <li data-testid="row-running">r1</li>,
+        onToggle: onToggleRunning,
+      },
+      snoozed: shelf([], { collapsed: true }),
+      settled: shelf([], { collapsed: true }),
+    });
+
+    expect(byTestId("row-running")).toHaveLength(1);
+    act(() => byTestId("phase-sidebar-running-shelf-toggle")[0]!.props.onClick());
+    expect(onToggleRunning).toHaveBeenCalledTimes(1);
+    expect(onToggle).not.toHaveBeenCalled();
+  });
+
+  it("keeps a collapsed Running shelf to its header and marks the open thread", () => {
+    mount({
+      running: {
+        count: 2,
+        collapsed: true,
+        containsRoutedThread: true,
+        items: <li data-testid="row-running">r1</li>,
+        onToggle: vi.fn(),
+      },
+      snoozed: shelf([], { collapsed: true }),
+      settled: shelf([], { collapsed: true }),
+    });
+
+    expect(byTestId("row-running")).toHaveLength(0);
+    expect(byTestId("phase-sidebar-running-shelf-open-thread")).toHaveLength(1);
+  });
 });
diff --git a/apps/web/src/components/sidebar/PhaseSidebarShelfDock.tsx b/apps/web/src/components/sidebar/PhaseSidebarShelfDock.tsx
index 72371866c7592..f4a44469527a1 100644
--- a/apps/web/src/components/sidebar/PhaseSidebarShelfDock.tsx
+++ b/apps/web/src/components/sidebar/PhaseSidebarShelfDock.tsx
@@ -11,8 +11,11 @@
 //
 // Collapse state is the persisted section state the grouping store keeps (see
 // PHASE_SIDEBAR_SHELF_SECTIONS); this component only renders it.
+//
+// The Running shelf sits on top when custom grouping has it switched on: live
+// sessions with nothing waiting on a human, as a flat list. It starts open.
 import type { PhaseSidebarShelfId } from "@t3tools/client-runtime/state/phase-sidebar-grouping";
-import { AlarmClockIcon, CheckIcon, ChevronDownIcon } from "lucide-react";
+import { AlarmClockIcon, CheckIcon, ChevronDownIcon, LoaderCircleIcon } from "lucide-react";
 import type { ReactNode } from "react";
 
 import { cn } from "../../lib/utils";
@@ -25,7 +28,19 @@ export interface PhaseSidebarShelfDockShelf {
   readonly rows: PhaseSidebarShelfRows<PhaseSidebarRow>;
 }
 
+/** The Running shelf: rendered by the caller, since its rows are live session trees. */
+export interface PhaseSidebarShelfDockRunningShelf {
+  readonly count: number;
+  readonly collapsed: boolean;
+  readonly containsRoutedThread: boolean;
+  /** The rows, or null while collapsed. */
+  readonly items: ReactNode;
+  readonly onToggle: () => void;
+}
+
 export interface PhaseSidebarShelfDockProps {
+  /** Absent unless custom grouping has the Running shelf switched on. */
+  readonly running?: PhaseSidebarShelfDockRunningShelf;
   readonly snoozed: PhaseSidebarShelfDockShelf;
   readonly settled: PhaseSidebarShelfDockShelf;
   readonly onToggle: (shelf: PhaseSidebarShelfId) => void;
@@ -36,8 +51,9 @@ export interface PhaseSidebarShelfDockProps {
 }
 
 export function PhaseSidebarShelfDock(props: PhaseSidebarShelfDockProps) {
-  const { snoozed, settled } = props;
-  if (snoozed.count === 0 && settled.count === 0) return null;
+  const { running, snoozed, settled } = props;
+  const runningCount = running?.count ?? 0;
+  if (runningCount === 0 && snoozed.count === 0 && settled.count === 0) return null;
   return (
     <div
       data-testid="phase-sidebar-shelf-dock"
@@ -45,22 +61,29 @@ export function PhaseSidebarShelfDock(props: PhaseSidebarShelfDockProps) {
       // grows, and an open shelf can never push the footer off screen.
       className="flex max-h-[min(45dvh,24rem)] shrink-0 flex-col gap-1 border-t border-sidebar-border px-2 pt-1.5 pb-1"
     >
+      {running !== undefined && running.count > 0 ? (
+        <PhaseSidebarShelf
+          id="running"
+          label="Running"
+          count={running.count}
+          collapsed={running.collapsed}
+          holdsOpenThread={running.collapsed && running.containsRoutedThread}
+          onToggle={running.onToggle}
+          items={running.collapsed ? null : running.items}
+        />
+      ) : null}
       {snoozed.count > 0 ? (
         <PhaseSidebarShelf
           id="snoozed"
           label="Snoozed"
-          shelf={snoozed}
-          onToggle={props.onToggle}
-          renderRow={props.renderRow}
+          {...parkedShelfProps("snoozed", snoozed, props)}
         />
       ) : null}
       {settled.count > 0 ? (
         <PhaseSidebarShelf
           id="settled"
           label="Settled"
-          shelf={settled}
-          onToggle={props.onToggle}
-          renderRow={props.renderRow}
+          {...parkedShelfProps("settled", settled, props)}
           showMore={
             !settled.collapsed && settled.rows.hiddenCount > 0 ? (
               <button
@@ -82,55 +105,71 @@ export function PhaseSidebarShelfDock(props: PhaseSidebarShelfDockProps) {
   );
 }
 
+function parkedShelfProps(
+  id: PhaseSidebarShelfId,
+  shelf: PhaseSidebarShelfDockShelf,
+  props: PhaseSidebarShelfDockProps,
+) {
+  return {
+    count: shelf.count,
+    collapsed: shelf.collapsed,
+    // A collapsed shelf never draws the open thread's row; the header says it
+    // is in here instead, one click away.
+    holdsOpenThread: shelf.collapsed && shelf.rows.containsRoutedThread,
+    onToggle: () => props.onToggle(id),
+    items:
+      shelf.rows.rendered.length > 0
+        ? shelf.rows.rendered.map((row) => props.renderRow(row, id))
+        : null,
+  };
+}
+
+const SHELF_TONE = {
+  running: {
+    icon: LoaderCircleIcon,
+    text: "text-sky-600 dark:text-sky-400",
+    rule: "bg-sky-500/20 dark:bg-sky-400/15",
+  },
+  snoozed: {
+    icon: AlarmClockIcon,
+    text: "text-blue-600 dark:text-blue-400",
+    rule: "bg-blue-500/20 dark:bg-blue-400/15",
+  },
+  settled: { icon: CheckIcon, text: "text-muted-foreground/50", rule: "bg-sidebar-border/60" },
+} as const;
+
 function PhaseSidebarShelf(props: {
-  readonly id: PhaseSidebarShelfId;
+  readonly id: keyof typeof SHELF_TONE;
   readonly label: string;
-  readonly shelf: PhaseSidebarShelfDockShelf;
-  readonly onToggle: (shelf: PhaseSidebarShelfId) => void;
-  readonly renderRow: (row: PhaseSidebarRow, shelf: PhaseSidebarShelfId) => ReactNode;
+  readonly count: number;
+  readonly collapsed: boolean;
+  readonly holdsOpenThread: boolean;
+  readonly onToggle: () => void;
+  readonly items: ReactNode;
   readonly showMore?: ReactNode;
 }) {
-  const { id, label, shelf } = props;
-  const snoozed = id === "snoozed";
-  // A collapsed shelf never draws the open thread's row; the header says it is
-  // in here instead, one click away.
-  const holdsOpenThread = shelf.collapsed && shelf.rows.containsRoutedThread;
-  const hasBody = shelf.rows.rendered.length > 0 || props.showMore != null;
+  const { id, label, count, collapsed, holdsOpenThread } = props;
+  const tone = SHELF_TONE[id];
+  const Icon = tone.icon;
+  const hasBody = props.items != null || props.showMore != null;
   return (
     <section className="flex min-h-0 flex-col" data-testid={`phase-sidebar-${id}-shelf`}>
       <button
         type="button"
-        onClick={() => props.onToggle(id)}
-        aria-expanded={!shelf.collapsed}
-        aria-label={`${label}, ${shelf.count} session${shelf.count === 1 ? "" : "s"}${
-          shelf.collapsed ? ", collapsed" : ""
+        onClick={props.onToggle}
+        aria-expanded={!collapsed}
+        aria-label={`${label}, ${count} session${count === 1 ? "" : "s"}${
+          collapsed ? ", collapsed" : ""
         }${holdsOpenThread ? ", holds the open thread" : ""}`}
         data-testid={`phase-sidebar-${id}-shelf-toggle`}
         data-holds-open-thread={holdsOpenThread ? "" : undefined}
         className="flex w-full shrink-0 cursor-pointer items-center gap-2 rounded-sm px-2 py-0.5 text-left focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
       >
-        {snoozed ? (
-          <AlarmClockIcon
-            aria-hidden
-            className="size-2.5 shrink-0 text-blue-600 dark:text-blue-400"
-          />
-        ) : (
-          <CheckIcon aria-hidden className="size-2.5 shrink-0 text-muted-foreground/50" />
-        )}
-        <span
-          className={cn(
-            "text-[10px] font-semibold uppercase tracking-wider",
-            snoozed ? "text-blue-600 dark:text-blue-400" : "text-muted-foreground/50",
-          )}
-        >
+        <Icon aria-hidden className={cn("size-2.5 shrink-0", tone.text)} />
+        <span className={cn("text-[10px] font-semibold uppercase tracking-wider", tone.text)}>
           {label}
         </span>
-        <span
-          className={cn(
-            "h-px flex-1",
-            snoozed ? "bg-blue-500/20 dark:bg-blue-400/15" : "bg-sidebar-border/60",
-          )}
-        />
+        <span className={cn("h-px flex-1", tone.rule)} />
         {holdsOpenThread ? (
           <span
             aria-hidden
@@ -138,13 +177,13 @@ function PhaseSidebarShelf(props: {
             className="size-1.5 shrink-0 rounded-full bg-primary"
           />
         ) : null}
-        <span className="text-[9px] tabular-nums text-muted-foreground/55">{shelf.count}</span>
+        <span className="text-[9px] tabular-nums text-muted-foreground/55">{count}</span>
         <ChevronDownIcon
           aria-hidden
           className={cn(
             "size-3 shrink-0 transition-transform",
-            snoozed ? "text-blue-600 dark:text-blue-400" : "text-muted-foreground/50",
-            !shelf.collapsed && "rotate-180",
+            tone.text,
+            !collapsed && "rotate-180",
           )}
         />
       </button>
@@ -157,11 +196,7 @@ function PhaseSidebarShelf(props: {
           data-testid={`phase-sidebar-${id}-shelf-rows`}
           className="mt-1 min-h-0 overflow-y-auto overscroll-contain"
         >
-          {shelf.rows.rendered.length > 0 ? (
-            <ul className="space-y-0.5">
-              {shelf.rows.rendered.map((row) => props.renderRow(row, id))}
-            </ul>
-          ) : null}
+          {props.items != null ? <ul className="space-y-0.5">{props.items}</ul> : null}
           {props.showMore}
         </div>
       ) : null}
diff --git a/apps/web/src/phaseSidebarGroupingStore.ts b/apps/web/src/phaseSidebarGroupingStore.ts
index f5ce8d49350ed..759b1a0d73f4a 100644
--- a/apps/web/src/phaseSidebarGroupingStore.ts
+++ b/apps/web/src/phaseSidebarGroupingStore.ts
@@ -19,6 +19,7 @@ import {
   sanitizePhaseSidebarGrouping,
   setPhaseSidebarGroupBy,
   setPhaseSidebarGroupOrder,
+  setPhaseSidebarRunningShelf,
   togglePhaseSidebarSectionCollapsed,
   type PhaseSidebarGroupBy,
   type PhaseSidebarGroupOrder,
@@ -35,6 +36,8 @@ interface PhaseSidebarGroupingStoreState {
   readonly grouping: PhaseSidebarGroupingPreferences;
   setGroupBy: (groupBy: PhaseSidebarGroupBy) => void;
   setGroupOrder: (order: PhaseSidebarGroupOrder) => void;
+  /** Custom mode's Running shelf switch. */
+  setRunningShelf: (enabled: boolean) => void;
   /** Registers an empty placeholder; returns its section id, or null when blank. */
   createGroup: (label: string) => string | null;
   /** Gives a group made in the shared registry this device's next manual-order slot. */
@@ -57,6 +60,8 @@ export const usePhaseSidebarGroupingStore = create<PhaseSidebarGroupingStoreStat
         set((state) => ({ grouping: setPhaseSidebarGroupBy(state.grouping, groupBy) })),
       setGroupOrder: (order) =>
         set((state) => ({ grouping: setPhaseSidebarGroupOrder(state.grouping, order) })),
+      setRunningShelf: (enabled) =>
+        set((state) => ({ grouping: setPhaseSidebarRunningShelf(state.grouping, enabled) })),
       createGroup: (label) => {
         const result = createPhaseSidebarCustomGroup(get().grouping, { label });
         if (result.preferences !== get().grouping) set({ grouping: result.preferences });
diff --git a/packages/client-runtime/src/state/phaseSidebarGrouping.test.ts b/packages/client-runtime/src/state/phaseSidebarGrouping.test.ts
index 428e0632ba6c4..4a92653ac77e4 100644
--- a/packages/client-runtime/src/state/phaseSidebarGrouping.test.ts
+++ b/packages/client-runtime/src/state/phaseSidebarGrouping.test.ts
@@ -30,6 +30,7 @@ import {
   rememberPhaseSidebarCustomGroupOrder,
   renamePhaseSidebarCustomGroup,
   sanitizePhaseSidebarGrouping,
+  setPhaseSidebarRunningShelf,
   togglePhaseSidebarSectionCollapsed,
   type PhaseSidebarGroupingPreferences,
 } from "./phaseSidebarGrouping.ts";
@@ -429,6 +430,73 @@ describe("custom group operations", () => {
   });
 });
 
+describe("Running shelf", () => {
+  const custom = (runningShelf: boolean): PhaseSidebarGroupingPreferences =>
+    setPhaseSidebarRunningShelf(
+      { ...DEFAULT_PHASE_SIDEBAR_GROUPING, groupBy: "custom" },
+      runningShelf,
+    );
+  const build = (rows: ReadonlyArray<PhaseSidebarRow>, grouping: PhaseSidebarGroupingPreferences) =>
+    buildPhaseSidebarSections({
+      rows,
+      filters: EMPTY_PHASE_SIDEBAR_FILTERS,
+      compareSiblings: byId,
+      grouping,
+    });
+  const ids = (nodes: ReadonlyArray<{ readonly row: PhaseSidebarRow }>) =>
+    nodes.map((node) => String(node.row.thread.id)).sort();
+
+  it("is off by default and takes nothing", () => {
+    const result = build(
+      [makeRow("a", { phaseId: "implementing", customGroup: "Week" })],
+      custom(false),
+    );
+    expect(result.runningNodes).toEqual([]);
+    expect(ids(result.sections[0]!.nodes)).toEqual(["a"]);
+  });
+
+  it("takes running sessions out of their groups, but never one that waits on a human", () => {
+    const result = build(
+      [
+        makeRow("run", { phaseId: "implementing", customGroup: "Week" }),
+        makeRow("plan", { phaseId: "planning" }),
+        makeRow("ask", { phaseId: "ask", customGroup: "Week" }),
+        makeRow("input", { phaseId: "needs_input", customGroup: "Week" }),
+        makeRow("idle", { phaseId: "ready", customGroup: "Week", unread: true }),
+        // A running parent whose child is blocked stays where the highlight is.
+        makeRow("parent", { phaseId: "implementing", customGroup: "Week" }),
+        makeRow("child", { parent: "parent", phaseId: "needs_input" }),
+      ],
+      custom(true),
+    );
+    expect(ids(result.runningNodes)).toEqual(["plan", "run"]);
+    const week = result.sections.find((section) => section.label === "Week")!;
+    expect(ids(week.nodes)).toEqual(["ask", "idle", "input", "parent"]);
+    // The header still counts the session the shelf took as running.
+    expect(week.summary).toEqual({ running: 1, attention: 3, unread: 1 });
+    // Ungrouped held only a running session, so it has nothing left to show.
+    expect(result.sections.some((section) => section.isUngrouped)).toBe(false);
+  });
+
+  it("only applies to custom groups", () => {
+    const result = build([makeRow("a", { phaseId: "implementing" })], {
+      ...custom(true),
+      groupBy: "lifecycle",
+    });
+    expect(result.runningNodes).toEqual([]);
+  });
+
+  it("round-trips through the setter and sanitizing", () => {
+    expect(custom(false)).not.toHaveProperty("runningShelf");
+    expect(custom(true).runningShelf).toBe(true);
+    expect(setPhaseSidebarRunningShelf(custom(true), false)).not.toHaveProperty("runningShelf");
+    expect(sanitizePhaseSidebarGrouping(custom(true)).runningShelf).toBe(true);
+    expect(sanitizePhaseSidebarGrouping({ runningShelf: "yes" })).not.toHaveProperty(
+      "runningShelf",
+    );
+  });
+});
+
 describe("sanitizePhaseSidebarGrouping", () => {
   it("falls back to defaults for garbage", () => {
     expect(sanitizePhaseSidebarGrouping(null)).toEqual(DEFAULT_PHASE_SIDEBAR_GROUPING);
diff --git a/packages/client-runtime/src/state/phaseSidebarGrouping.ts b/packages/client-runtime/src/state/phaseSidebarGrouping.ts
index f53569890d62e..403987b4c4c94 100644
--- a/packages/client-runtime/src/state/phaseSidebarGrouping.ts
+++ b/packages/client-runtime/src/state/phaseSidebarGrouping.ts
@@ -99,6 +99,11 @@ export interface PhaseSidebarGroupingPreferences {
   readonly customGroupOrder: ReadonlyArray<string>;
   /** Section keys (see `PhaseSidebarSection.key`) the user closed. */
   readonly collapsedSectionKeys: ReadonlyArray<string>;
+  /**
+   * Custom mode only: sessions that run with nothing waiting on a human leave
+   * their group for the Running shelf. Absent means off.
+   */
+  readonly runningShelf?: boolean;
 }
 
 export const DEFAULT_PHASE_SIDEBAR_GROUPING: PhaseSidebarGroupingPreferences = {
@@ -172,6 +177,7 @@ export function sanitizePhaseSidebarGrouping(value: unknown): PhaseSidebarGroupi
     readonly customGroups?: unknown;
     readonly customGroupOrder?: unknown;
     readonly collapsedSectionKeys?: unknown;
+    readonly runningShelf?: unknown;
   };
   const groupBy = PHASE_SIDEBAR_GROUP_BY_MODES.find((mode) => mode === candidate.groupBy);
   const groupOrder = PHASE_SIDEBAR_GROUP_ORDERS.find((order) => order === candidate.groupOrder);
@@ -183,6 +189,7 @@ export function sanitizePhaseSidebarGrouping(value: unknown): PhaseSidebarGroupi
       (id) => id !== PHASE_SIDEBAR_UNGROUPED_ID,
     ),
     collapsedSectionKeys: sanitizeStringList(candidate.collapsedSectionKeys),
+    ...(candidate.runningShelf === true ? { runningShelf: true } : {}),
   };
 }
 
@@ -206,6 +213,15 @@ export function setPhaseSidebarGroupOrder(
   return preferences.groupOrder === groupOrder ? preferences : { ...preferences, groupOrder };
 }
 
+export function setPhaseSidebarRunningShelf(
+  preferences: PhaseSidebarGroupingPreferences,
+  enabled: boolean,
+): PhaseSidebarGroupingPreferences {
+  if ((preferences.runningShelf === true) === enabled) return preferences;
+  const { runningShelf: _previous, ...rest } = preferences;
+  return enabled ? { ...rest, runningShelf: true } : rest;
+}
+
 /** The section id a legacy local group renders under. */
 function localGroupSectionId(group: PhaseSidebarCustomGroup): string {
   return phaseSidebarCustomGroupId(group.label);
@@ -514,6 +530,24 @@ export interface PhaseSidebarSection {
 export interface PhaseSidebarSectionsResult {
   readonly sections: ReadonlyArray<PhaseSidebarSection>;
   readonly forcedExpansionKeys: ReadonlySet<string>;
+  /**
+   * Top-level sessions on the Running shelf, newest activity first: custom
+   * mode with `runningShelf` on, otherwise always empty. Their groups' headers
+   * still count them as running.
+   */
+  readonly runningNodes: ReadonlyArray<PhaseSidebarTreeNode>;
+}
+
+const NO_RUNNING_NODES: ReadonlyArray<PhaseSidebarTreeNode> = [];
+
+/**
+ * A session the Running shelf takes: its subtree is live agent work and
+ * nothing in it waits on a human. A question, approval or plan anywhere in the
+ * subtree keeps it in its group, where the highlight is.
+ */
+export function isPhaseSidebarRunningShelfNode(node: PhaseSidebarTreeNode): boolean {
+  const phaseId = resolvePhaseSidebarTreePhase(node);
+  return isRunningSessionPhase(phaseId) && !nodeWaitsOnHuman(node, phaseId);
 }
 
 export interface BuildPhaseSidebarSectionsInput {
@@ -636,7 +670,7 @@ export function buildPhaseSidebarSections(
         isUngrouped: false,
         collapsedByDefault: false,
       }));
-      return { sections, forcedExpansionKeys };
+      return { sections, forcedExpansionKeys, runningNodes: NO_RUNNING_NODES };
     }
 
     case "project": {
@@ -674,6 +708,7 @@ export function buildPhaseSidebarSections(
           () => 0,
         ),
         forcedExpansionKeys,
+        runningNodes: NO_RUNNING_NODES,
       };
     }
 
@@ -694,8 +729,28 @@ export function buildPhaseSidebarSections(
         const id = phaseSidebarCustomGroupIdForRow(node.row) ?? PHASE_SIDEBAR_UNGROUPED_ID;
         nodesById.set(id, [...(nodesById.get(id) ?? []), node]);
       }
+      // A header counts what it shows, plus the sessions of its own that the
+      // Running shelf took, so it still says how many of them run.
+      const runningShelf = grouping.runningShelf === true;
+      const runningNodes: PhaseSidebarTreeNode[] = [];
+      const placedNodes = (all: ReadonlyArray<PhaseSidebarTreeNode>) => {
+        if (!runningShelf) return all;
+        const kept: PhaseSidebarTreeNode[] = [];
+        for (const node of all) {
+          (isPhaseSidebarRunningShelfNode(node) ? runningNodes : kept).push(node);
+        }
+        return kept;
+      };
+      const placedSummary = (
+        all: ReadonlyArray<PhaseSidebarTreeNode>,
+        placed: ReadonlyArray<PhaseSidebarTreeNode>,
+      ): PhaseSidebarSectionSummary =>
+        placed === all
+          ? summarizeNodes(all)
+          : { ...summarizeNodes(placed), running: summarizeNodes(all).running };
       const sections: PhaseSidebarSection[] = registry.map((group) => {
-        const nodes = nodesById.get(group.id) ?? [];
+        const allNodes = nodesById.get(group.id) ?? [];
+        const nodes = placedNodes(allNodes);
         return {
           key: phaseSidebarSectionKey("custom", group.id),
           kind: "custom",
@@ -704,7 +759,7 @@ export function buildPhaseSidebarSections(
           helperText: nodes.length === 0 ? "Empty" : pluralSessions(nodes.length),
           phaseId: null,
           nodes,
-          summary: summarizeNodes(nodes),
+          summary: placedSummary(allNodes, nodes),
           isUngrouped: false,
           collapsedByDefault: false,
           ...(group.colorId !== undefined && group.color !== undefined
@@ -712,7 +767,8 @@ export function buildPhaseSidebarSections(
             : {}),
         };
       });
-      const ungrouped = nodesById.get(PHASE_SIDEBAR_UNGROUPED_ID) ?? [];
+      const allUngrouped = nodesById.get(PHASE_SIDEBAR_UNGROUPED_ID) ?? [];
+      const ungrouped = placedNodes(allUngrouped);
       if (ungrouped.length > 0) {
         sections.push({
           key: phaseSidebarSectionKey("custom", PHASE_SIDEBAR_UNGROUPED_ID),
@@ -722,7 +778,7 @@ export function buildPhaseSidebarSections(
           helperText: "Not placed in a group yet",
           phaseId: null,
           nodes: ungrouped,
-          summary: summarizeNodes(ungrouped),
+          summary: placedSummary(allUngrouped, ungrouped),
           isUngrouped: true,
           collapsedByDefault: false,
         });
@@ -735,6 +791,11 @@ export function buildPhaseSidebarSections(
           (section) => manualIndex.get(section.id) ?? Number.MAX_SAFE_INTEGER,
         ),
         forcedExpansionKeys,
+        runningNodes: runningShelf
+          ? runningNodes.sort(
+              (left, right) => latestActivity([right]) - latestActivity([left]) || 0,
+            )
+          : NO_RUNNING_NODES,
       };
     }
   }
@@ -764,6 +825,15 @@ export const PHASE_SIDEBAR_SHELF_SECTIONS: Readonly<
   settled: { key: phaseSidebarSectionKey("lifecycle", "settled"), collapsedByDefault: true },
 };
 
+/**
+ * The Running shelf's collapse identity. It starts open: it holds live work,
+ * not parked history.
+ */
+export const PHASE_SIDEBAR_RUNNING_SHELF_SECTION: Pick<
+  PhaseSidebarSection,
+  "key" | "collapsedByDefault"
+> = { key: "shelf:running", collapsedByDefault: false };
+
 /**
  * The parked shelves under the grouped sections: snoozed and settled sessions,
  * as flat lists in the order the caller partitioned them (wake time, then